Exercise 0-7

Is this a valid program? why or why not?

#include <iostream>
int main{}
{
    /* This is a comment that extends over several lines
       because it uses /* and */ as its starting and ending delimiters */
       std::cout << "Does this work?" << std::endl;
       return 0;
}

Solution

No. This is not a valid C++ Program.

The issue is the way the code treats comment. A correct block-comment looks like this.

/* this is a comment */

i.e. a correctly written comment is surround by the /* and */. Anything in between is a comment. Anything outside is not a comment.

In this case, the actual comment part is highlighted in blue below (and the remaining red part is not qualified as a comment)

/* This is a comment that extends over several lines
because it uses /* and */ as its starting and ending delimiters */

I would correct the comment to something like this (using the line comment //), should we wish to keep the comments.

// This is a comment that extends over several lines
// because it uses /* and */ as its starting and ending delimiters

Reference

Exercise 0-6

Is this a valid program? Why or why not?

#include <iostream>
int main() {{{{{{std::cout << "Hello World!" << std::endl;}}}}}}

Solution

Yes. This is a valid C++ program.

In C++ curly braces tell the implementation to treat whatever (statement) appears between them as a unit.

It is okay to have nested curly braces, as long as all the curly braces are balanced out. i.e. for every single open/left brace it is matched by a close/right brace.

Let’s run the program and see what we get?

Result

The program compiles okay. And gives us the following result in the console output window.

Hello World!

Process returned 0 (0x0)   execution time : 0.187 s
Press any key to continue.

Experiment – Nested Curly Braces

Let us, for curiosity sake to see if nested curly braces actually work? Here is a very simple program that I write for this experiment.

// Experiment with nested curly braces
#include <iostream>
int main()
{
    std::cout << "I am block 1" << std::endl;
    {
        std::cout << "I am block 1-1, son of block 1" << std::endl;
        {
            std::cout << "I am block 1-1-1, son of block 1-1, grandson of block 1." << std::endl;
            std::cout << "I am block 1-1-2, son of block 1-1, grandson of block 1." << std::endl;
        }
    }
    {
        std::cout << "I am block 1-2, son of block 1" << std::endl;
    }
}

The program compiles okay and gives us the followings in the console output window as expected.

I am block 1
I am block 1-1, son of block 1
I am block 1-1-1, son of block 1-1, grandson of block 1.
I am block 1-1-2, son of block 1-1, grandson of block 1.
I am block 1-2, son of block 1

Process returned 0 (0x0)   execution time : 0.187 s
Press any key to continue.

This experiment has demonstrated that nested curly braces essentially provides a way to group blocks of statements together, which I think is a very cool feature as it allows us breakdown tons of statements into smaller blocks. This is very handy if we are to define a chunky function.

Reference

Exercise 0-4

Write a program that, when run, writes the Hello World program as its output.

Solution

Using the skills picked up from the previous exercises, this should be quite a straight forward exercise. There is nothing new here. Below is my code (of course, there are many ways to do this.)

#include <iostream>
int main()
{
    std::cout << "#include <iostream>" << std::endl;
    std::cout << "int main()" << std::endl;
    std::cout << "{" << std::endl;
    std::cout << "  std::cout << \"Hello World!\" << std::endl;" << std::endl;
    std::cout << "  return 0;" << std::endl;
    std::cout << "}" << std::endl;
    return 0;
}

Result

Submitting the program produces the Hello World code in the console output window.

#include <iostream>
int main()
{
  std::cout << "Hello World!" << std::endl;
  return 0;
}

Process returned 0 (0x0)   execution time : 0.179 s
Press any key to continue.

# Reference

Koenig, Andrew & Moo, Barbara E., Accelerated C++, Addison-Wesley, 2000

Exercise 0-3

The string literal “\t” represents a tab character; different C++ implementations display tabs in different ways. Experiment with your implementation to learn how it treats tabs.

Experiments

I shall be running a number of experiment C++ programs to test out the tab behaviour. I am running this using the Code::Block IDE (Integrated Development Environment) on Window Vista platform. (According to a number of online forums the tab property differs depending on the platform (e.g. tab length).

Experiment 1

In this experiment I will add various number of tabs at the start of a line.

<h1>include <iostream></h1>

<p>int main()
{
    std::cout << "Start the following line with tabs" << std::endl;
    std::cout << "\tStart this line with 1 tab." << std::endl;
    std::cout << "\t\tStart this line with 2 tabs." << std::endl;
    std::cout << "\t\t\tStart this line with 3 tabs." << std::endl;
    return 0;
}

Result (experiment 1)

Submitting the program produces the following in the console output window.

Start the following line with tabs
         Start this line with 1 tab.
                 Start this line with 2 tabs.
                         Start this line with 3 tabs.

Process returned 0 (0x0)   execution time : 0.235 s
Press any key to continue.

Observations:

• Should the line begins with 1 tab, the tab length is 8 spaces.
• With 2 (consecutive) tabs, the second tab adds 8 spaces. i.e. total indentation is 8 + 8 = 16 spaces.
• With 3 (consecutive) tabs, the third tab is adds spaces. i.e. total indentation is 8 + 8 + 8 = 24 spaces.

From this it appears that each tab corresponds to 8 spaces.

Experiment 2

In this experiment I will add various number of tabs within a line.

#include <iostream>
int main()
{
    std::cout << "Add tabs within the line" << std::endl;
    std::cout << "I will add 1 tabs\twithin this line line." << std::endl;
    std::cout << "I will add 2 tabs\t\twithin this line." << std::endl;
    std::cout << "I will add 3 tabs\t\t\twithin this line." << std::endl;
    return 0;
}

Result

Submitting the program produces the following in the console output window.

Add tabs within the line
I will add 1 tabs       within this line line.
I will add 2 tabs               within this line.
I will add 3 tabs                       within this line.

Process returned 0 (0x0)   execution time : 0.159 s
Press any key to continue.

Observations:

• Should the line contains 1 tab, the tab length is 7 spaces.
• With 2 (consecutive) tabs, the second tab adds 8 spaces. i.e. total tab length is 7 + 8 = 15 spaces.
• With 3 (consecutive) tabs, the third tab is 8 spaces. i.e. total indentation is 7 + 8 + 8 = 23 spaces.

From this it appears that each tab is of 8 spaces, except the first tab which is of 7. (I’m not entirely sure why though.)

Conclusion

Merging experiment 1 and 2, it appears that each tab in general takes up a fix length of 8 spaces. The only exception is the first tab that is placed within a line (as seen in experiment 2), which takes up only 7 spaces (i.e. 1 space less). I am not entirely sure why at this stage.

This reminds of a message that the authors mention in chapter 0:

… string literal, … a mysterious type that we shall not even discuss until section 10.2 / page 176…

So is it something that is hidden that require deeper understanding?I hope to find out more in later chapter(s).

Reference

Exercise 0-0

Compile and run the Hello World program.

Solution

The classic Hello World code looks like this.

// a small C++ program</p>

#include <iostream>

int main()
{
    ( (std::cout << "Hello, world!") << std::endl);
    return 0;
}

In detail

// a small C++ program

• The double forward slashes indicates comment. Comments are ignored by the program during implementation.

<br />#include <iostream>

• The #include directive ensures the <iostream> (input-output stream) facility is made available to the program.

int main()
{
}

• We declare that the main function would yield an integer (int) type result. (i.e. result = 0 if success. Otherwise non-zero). The main function is the first function that is run when we implement a C++ program – so we must define one.
• We define the main function within the two curly braces { }.

    ( (std::cout << "Hello, world!") << std::endl);

• The expression statement create a result of type std::ostream (standard output stream), defined by its first operand std::cout (standard console output). The utility cout (console output) is in the (namespace) scope std (standard library).
• The first (left associative) output operator << writes the string literal “Hello, world” to the std::cout. This causes a side-effect of displaying the string literal on the console command window.
• The second (left associative) output operator << allows the manipulator std::endl (standard end line) to manipulate the standard output stream, which in this case, ends the current line of output.
• Note that the brackets are not strictly required. I’ve included the brackets here purely to help visualising the logics associating with the left-associative output operator << .
• The entire expression statement yields std::cout as a value (a result) which is of type std::ostream (standard output stream), and as a side effect writes the string literal (Hello, World!) onto this standard output stream (as displayed in the output command window). The std::endl manipulator ends the output line. Once it’s displayed (which is what we wanted), the semi-colon at the end of the expression statement discards the std::cout value (which is appropriate as we don’t need to keep hold of this value any more).

    return 0;

• The return statement explicitly return an integer (int) value of 0 at the end of the main function to imply job run success. The semi-colon explicitly states that this is the end of this return statement.

Result

Once submitted the program, the following text appears in command window as expected.

Hello, world! 

Process returned 0 (0x0) execution time : 0.268 s 
Press any key to continue.

Reference

Chapter 0 of the Accelerated C++ book (by Koenig and Moo, reference at bottom) has provided me with an in-depth introduction of the classic Hello World C++ program in just 6 pages. As I see that there is an end of chapter exercise section and the book does not come with a solution (for good reason I guess!), I’ve decided to have a go doing these exercises and post my solutions in separate posts. Despite the book pretty much has covered it all, I would aim to include my own version of explanation for the benefit of learning and understanding. (My solution/explanation is subject to error as it’s just a scientific programming sketchbook after all!)

Although the (Hello World) program we’ve written is simple, we’ve covered a lot of ground in this chapter.

Key concepts learnt from this chapter: Hello World program; comment; #include directive; standard library vs core language; input-output stream (iostream); standard header; angle brackets; the main function; curly braces; operand type (int and std::iostream); output operator (<<); namespace (std); standard output stream (std::cout); stream manipulator (std::endl); the return statement; expression; result; side effects; operator vs operand; left-associative operator; scope; qualified name (std::cout); scope operator (::); free and non-free form structure; special string literals; escape using backslash; semicolons; expression statement; null statement.

References