Chapter 1

[KTC]

Exercise 1-1

Are the following definitions valid? Why or why not?

Code:

const std::string hello = "Hello";
const std::string message = hello + ", world" + "!";

Yes, the definitions are valid.

They are the same as the example given earlier in the chapter except a string literal (", world") is concatenate onto the end of a string (hello), rather than the other way round.

[KTC]

Exercise 1-2

Are the following definitions valid? Why or why not?

Code:

const std::string exclam = "!";
const std::string message = "Hello" + ", world" + exclam;

No, the definitions are not valid.

"Hello" and ", world" are both string literal. Two string literal may not be concatenated using the + operator as stated earlier in the chapter.

[KTC]

Exercise 1-3

Is the following program valid? If so, what does it do? If not, why not?

Code:

#include <iostream>
#include <string>

int main()
{
    { const std::string s = "a string";
      std::cout << s << std::endl; }
   
    { const std::string s = "another string";
      std::cout << s << std::endl; }
    return 0;
}

Yes, the program is valid.

A string variable s is initialized with a string literal and then outputted. This happenes twice.

C++ have what's call the One Definition Rule (ODR). What it basically means is that a variable may only be defined once. Also, no two variables may share the same name within the same scope. The ODR is not violated here because the two string initialization happens within completely separate scope, namely they are contained within separate block ({ ... }).

[KTC]

Exercise 1-4

What about this one? What if we change }} to };} in the third line from the end?

Code:

#include <iostream>
#include <string>

int main()
{
    { const std::string s = "a string";
      std::cout << s << std::endl;
    { const std::string s = "another string";
      std::cout << s << std::endl; }}
    return 0;
}

Yes, the program is valid.

In this case, the ODR is not violated because the second string s is defined within a nested block to the first, meaning again different scope. In this case, the second string s hides the first one, and hence the second output statement will output another string and not a string.

It is possible to access hidden named variable using the scope resolution operator :: if they are either in global scope, or in a named namespace. It is not possible to access a hidden named variable otherwise, e.g. it is not possible to access the first string s within the scope where the second string s is after it has been defined.

Changing }} to };} have no effect as the ; is simply an empty statement and have no effect on scope resolution.

Note: A variable is only hidden in any particular scope if there exist a variable with the same name in that scope. See the next exercise for when a variable is not hidden.

[KTC]

Exercise 1-5

Is this program valid? If so, what does it do? If not, say why not, and rewrite it to be valid.

Code:

#include <iostream>
#include <string>

int main()
{
    { std::string s = "a string";
    { std::string x = s + ", really";
    std::cout << s << std::endl; }
    std::cout << x << std::endl;
    }
    return 0;
}

No, the program is not valid.

At the end of the first }, the string x have come to the end of the scope where it is defined and is hence then destroyed. One may then no longer access the string x as it no longer exist.

There are a number of different way to rewrite this program to be valid. Two methods are shown below.

Code

GeSHi (cpp):
#include <iostream>
#include <string>
 
int main()
{
    { std::string s = "a string";
    std::string x = s + ", really";
    std::cout << s << std::endl;
    std::cout << x << std::endl;
    }
    return 0;
}
Created by GeSHI 1.0.7.18

This one remove the most nested block ({ ... }) making the string x still valid when we get to the output statement.

Code

GeSHi (cpp):
#include <iostream>
#include <string>
 
int main()
{
    { std::string s = "a string";
    std::string x;
    { x = s + ", really";
    std::cout << s << std::endl; }
    std::cout << x << std::endl;
    }
    return 0;
}
Created by GeSHI 1.0.7.18

This one move the definition of the string x to the outer scope to which the output statement is at. The effect is the same as the first solution above.

[KTC]

Exercise 1-6

What does the following program do if, when it asks you for input, you type two names (for example, Samuel Beckett)? Predict the behavior before running the program, then try it.

Code:

#include <iostream>
#include <string>

int main()
{
    std::cout << "What is your name? ";
    std::string name;
    std::cin >> name;
    std::cout << "Hello, " << name
              << std::endl << "And what is yours? ";
    std::cin >> name;
    std::cout << "Hello, " << name
              << "; nice to meet you too!" << std::endl;
    return 0;
}

As explained earlier in the book, the >> operator will only read in one word. Hence, during the first input statement, the name Samuel is read in, and subsequently outputted. It should be noted here the greetings outputted is on a newline from the question and user input due to the user having press the Return key to signal the end of user input*. During the second input statement, there is still text in the input stream buffer ( Beckett). This mean the program doesn't wait for user input, instead reading in this second word as the second name (ignoring initial whitespace) and outputting it. It is to be noted the second greetings outputted is not on a new line from the question as program have not been told to start on a newline either by the code, or from user input*.

Nitpicker's corner
* : Standard interactive terminal behaviour considered.