Exercise 1-3

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

#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;
    }

}

Solution

Yes. The program is valid.

The key to this question is to understanding the term scope. Each pair of curly braces form a scope.

Within the main function (scope), we have two sub-scopes, as defined by the two pairs of curly braces. Visualise these as block 1 and block 2. Block 1 corresponds to line 6 to 9. Block 2 corresponds to line 10 to 13.

Each block constitute its own scope – all local variables and statements within each scope are independent to each other. The const std::string variable s in block 1 is not the same as the const std::string variable s in block 2.

Because of this, even though there is a const std::string variable s in block 1, it is okay to define another constd std::string variable s in block 2 – due to the fact the two variables are in different scope.

It is however not possible to re-define a const std::string variable s within the same block (scope). For instance, the following would not be valid:

    {
        const std::string s = "a string";
        const std::string s = "another string"; // this is not valid.
        std::cout << s << std::endl;
    }

For completeness, let’s run that program at the top to confirm it compiles and runs okay.

a string
another string

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

The program runs okay as expected.

Memory Treatment

Another thing to bear in mind is the fact that all local variables within a scope only has a life time within the scope. i.e. once the implementation reaches the closing curly brace, }, (in other words, the end of the scope) the local variables of that scope are destroyed. The memory that was taken up by the local variables are now freed up and returned back to the system.

In this case, as the two blocks of scopes are implemented in a sequential manner, we expect to see the followings memory allocations / de-allocations.

• Line 7: memory allocated for the std::string s variable of scope block 1.
• Line 9: The std::string s variable of scope block 1 is destroyed. Memory is freed up and returned to the system.
• Line 11: memory allocated for the std::string s variable of scope block 2.
• Line 13: The std::string s variable of scope block 2 is destroyed. Memory is freed up and returned to the system.

Reference

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

Exercise 1-2

Are the following definitions valid? Why or why not?

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

Solution

No. The use of the concatenation operator is not valid. i.e. we bump into a “taboo” scenario: string literal + string literal. This is not valid.

The key in answering this question is to acknowledge the use of the string concatenation operator +.

• It is left associative.
• We can use + to concatenate a string and a string literal (and vice versa), or a string and a string, but not a string with a string literal (nor vice versa).

Line 1 defines a string variable exclam. This line is valid.

Line 2 defines a string variable message with the concatenation operator. The logic looks like this:

message = ( ( "Hello " + ", world" ) + exclam) 
        = ( ( a string literal + a string literal ) + a string )
        = ( ( compilation error! ) + a string)

i.e. We expect to encounter the invalid string literal + string literal scenario. This will likely cause compilation error.

Let’s test running the following program to prove the invalidity of the program.

#include <iostream>
#include <string>
int main()
{
    const std::string exclam = "!";
    const std::string message = "Hello  + ", world" + exclam;
    std::cout << message << std::endl;
    return 0;
}

Result

As expected, we get a compilation error.

error: invalid operands of types 'const char [6]' and 'const char [8]' to binary 'operator+'|

The const char [6] corresponds to the string literal “Hello”.

The const char [8] corresponds to the string literal “, world”.

(Note: I recall from reading another C++ book that the length of a string is usually the number of character plus one – that plus one is for reserving a space for a backslash, \ , character at the end)

We can easily fix this by avoiding the string literal + string literal scenario. For instance, we may imply merge the two string literal together upfront. (Keep it simple and stupid!)

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

For completeness sake, let’s run the following corrected program – we should expect to avoid that compilation error.

#include <iostream>
#include <string>
int main()
{
    const std::string exclam = "!";
    const std::string message = "Hello, world" + exclam;
    std::cout << message << std::endl;
    return 0;
}

Running this program produces the output as expected.

Hello, world!

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

Reference

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

Exercise 1-1

Are the following definitions valid? Why or why not?

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

Solution

Yes. These definitions are valid.

The key in answering this question is to acknowledge the use of the string concatenation operator +.

• It is left associative.
• We can use + to concatenate a string and a string literal (and vice versa), or a string and a string, but not a string with a string literal (nor vice versa).

Line 1 defines a string variable hello with length of 5 characters (which is Hello). This line is valid.

Line 2 defines a string variable message with the concatenation operator. The logic looks like this:

message = ( ( hello + ", world" ) + "!") 
        = ( ( a string + a string literal ) + a string literal )
        = ( ( a string ) + a string literal )
        = ( a string + a string literal )
        = ( a string )

i.e. at every single stage, we have not encountered any invalid string literal + string literal scenario. The concatenation is therefore valid.

Let’s test running the following program to prove the validity of the program.

#include <iostream>
#include <string>
int main()
{
    const std::string hello = "Hello";
    const std::string message = hello + ", world" + "!";
    std::cout << message << std::endl;
    return 0;
}

Result

As expected, the program compiled okay and produce the expected output.

Hello, world!

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

Reference

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

Exercise 1-0

Compile, execute, and test the programs in this chapter.

Solution

I will be taking the programs directly from the book (chapter 1 – Working with Strings), test run them, and see what we get. This exercise is purely to get our hands dirty right away on writing a submitting very simple programs on handling strings. Nothing too clever.

Test (Program 1)

The goal of this program is to

• ask for a person’s name,
• read the name in as a string variable, and
• output a greeting message.

// ask for a person's name, and greet the person
#include <iostream>
#include <string>

int main()
{
    // ask for the person's name
    std::cout << "Please enter your first name: ";

    // read the name
    std::string name;   //define name
    std::cin >> name;   //read into name

    // write a greeting
    std::cout << "Hello, " << name << "!" << std::endl;
    return 0;
}

Result (Program 1)

Run the program. The followings are produced in the console output window:

Please enter your first name:

Type in some texts (my name) on the keyboard

Please enter your first name: Johnny

Hit enter key and it gives:

Please enter your first name: Johnny
Hello, Johnny!

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

Test (Program 2)

The goal of program 2 is to read in a person’s name, and generate a framed greeting like this:

******************
*                *
* Hello, Johnny! *
*                *
******************

To do this the following C++ program is taken directly from the book.

// ask for a person's name, and generate a framed greeting
#include <iostream>
#include <string>

int main()
{
    std::cout << "Please enter your first name: ";  //ask for the person's name
    std::string name;   //define name
    std::cin >> name;   //read into name

    // build the message that we intend to write
    const std::string greeting = "Hello, " + name + "!";

    // build the second and forth lines of the output
    const std::string spaces(greeting.size(),' ');
    const std::string second = "* " + spaces + " *";
    const std::string first(second.size(),'*');

    // write it all
    std::cout << std::endl;
    std::cout << first << std::endl;
    std::cout << second << std::endl;
    std::cout << "* " << greeting << " *" << std::endl;
    std::cout << second << std::endl;
    std::cout << first << std::endl;
    return 0;
}

Result (Program 2)

Run the program. The followings are produced in the console output window:

Please enter your first name:

Type in some texts (my name) on the keyboard

Please enter your first name: Johnny

Hit enter key and it gives:

Please enter your first name: Johnny

******************
*                *
* Hello, Johnny! *
*                *
******************

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

Some core learning:

• Use double quote “ to define string literal. Use single quote ‘ to define character (char) literal.
• We can use + to concatenate a string and a string literal (and vice versa), or a string and a string, but not a string with a string literal (nor vice versa). i.e.
  • string + string is okay.
  • string literal + string is okay.
  • string + string literal is okay.
  • string literal + string literal is NOT okay.
• Use the object component size() , which is a function, to determine the length (number of characters) of a string (the object itself). e.g. greeting.size gives the length of the string greeting.
• Refer to the book to see the various ways to define a string variables, including the use of overload.
• Keep It Simple and Stupid (KISS) – write the code in a way that is easy to write and understand. Nothing too clever.

Reference

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