C++ Programming related.
Rewrite the framing program (Exercise 2-0) to ask the user to supply the amount of spacing to leave between the frame and the greeting.
Turns out that in my solution to Exercise 2-2 I already have covered this. i.e. to ask user to supply the horizontal and vertical padding separately. Please see my solution to Exercise 2-2 for details.
Change the framing program (Exercise 2-0) so that it uses a different amount of space to separate the sides from the greeting than it uses to separate the top and bottom borders from the greeting.
The original framing program in Exercise 2-0 “hard-codes” the const int pad which forces both vertical and horizontal paddings to be identical. The question asks for a capability to assign the vertical padding and horizontal padding separately.
To do this I am going to adjust the original framing program taking into account of the followings:
The modified program looks like this:
#include <iostream>
#include <string>
// say what standard-library names we use
using std::cin;
using std::endl;
using std::cout;
using std::string;
int main()
{
// ask for the person's name
cout << "Please enter your first name: ";
// read the name
string name;
cin >> name;
// ask user to provide the vertical padding
cout << "Please provide integer padY (vertical padding): ";
int inPadY;
cin >> inPadY;
// ask user to provide the horizontal padding
cout << "Please provide integer padX (horizontal padding): ";
int inPadX;
cin >> inPadX;
// build the message that we intend to write
const string greeting = "Hello, " + name + "!";
// build the constant padding parameters
const int padY = inPadY; // vertical padding
const int padX = inPadX; // horizontal padding
// the number of rows to write
const int rows = ( padY * 2 ) + 3;
// the number of columns to write
const string::size_type cols = greeting.size() + ( padX * 2 ) + 2;
// write a blank line to separate the output from the input
cout << endl;
// write 'rows' rows of output
// invariant: we have written r rows so far
for ( int r = 0; r != rows ; ++r )
{
string::size_type c = 0;
// invariant: we have written c characters so far in the current row
while ( c != cols)
{
// is it time to write the greeting?
if ( ( r == padY+ 1 ) && ( c == padX + 1 ) )
{
cout << greeting;
c += greeting.size();
}
else
{
// are we on the border?
if (
( r == 0 ) // top row
|| ( r == rows - 1 ) // or bottom row
|| ( c == 0 ) // or left-most column
|| ( c == cols - 1 ) // or right-most column
)
{
cout << "*";
}
else
{
cout << " ";
}
++c;
}
}
cout << endl;
}
return 0;
}
Case 1: padY = 1; padX = 10
Please enter your first name: Johnny Please provide integer padY (vertical padding): 1 Please provide integer padX (horizontal padding): 10 ************************************ * * * Hello, Johnny! * * * ************************************
Case 2: padY = 5; pad X = 5
Please enter your first name: Johnny Please provide integer padY (vertical padding): 1 Please provide integer padX (horizontal padding): 10 ************************************ * * * Hello, Johnny! * * * ************************************
Case 3: padY = 10 padX = 1
Please enter your first name: Johnny Please provide integer padY (vertical padding): 5 Please provide integer padX (horizontal padding): 5 ************************** * * * * * * * * * * * Hello, Johnny! * * * * * * * * * * * **************************
So far, so good!
Change the framing program (Exercise 2-0) so that it writes its greeting with no separation from the frame.
The sort of output that we are after looks like this:
</p> <hr /> <p><em>Hello, Johnny!</em></p> <hr /> <p>
i.e. We can just simply re-use the same program that we wrote in Exercise 2-0, except this time we change the padding of 1 (space character) to 0 (space characters). In other word, no padding round the greeting message.
For completeness sake, I have copied and pasted the code from Exercise 2-0 here. Note that this time I change the const int pad value to 0. (See line 23 below!)
</p>
<h1>include <iostream></h1>
<h1>include <string></h1>
<p>// say what standard-library names we use
using std::cin;
using std::endl;
using std::cout;
using std::string;</p>
<p>int main()
{
// ask for the person's name
cout << "Please enter your first name: ";</p>
<pre><code>// read the name
string name;
cin &gt;&gt; name;
// build the message that we intend to write
const string greeting = &quot;Hello, &quot; + name + &quot;!&quot;;
// the number of blanks surrounding the greeting
const int pad = 0; // no padding this time
// the number of rows and columns to write
const int rows = ( pad * 2 ) + 3;
const string::size_type cols = greeting.size() + ( pad * 2 ) + 2;
// write a blank line to separate the output from the input
cout &lt;&lt; endl;
// write 'rows' rows of output
// invariant: we have written r rows so far
for ( int r = 0; r != rows ; ++r )
{
string::size_type c = 0;
// invariant: we have written c characters so far in the current row
while ( c != cols)
{
// is it time to write the greeting?
if ( ( r == pad + 1 ) &amp;&amp; ( c == pad + 1 ) )
{
cout &lt;&lt; greeting;
c += greeting.size();
}
else
{
// are we on the border?
if (
( r == 0 ) // top row
|| ( r == rows - 1 ) // or bottom row
|| ( c == 0 ) // or left-most column
|| ( c == cols - 1 ) // or right-most column
)
{
cout &lt;&lt; &quot;*&quot;;
}
else
{
cout &lt;&lt; &quot; &quot;;
}
++c;
}
}
cout &lt;&lt; endl;
}
return 0;
</code></pre>
<p>}</p>
<p>
The program compiles successfully and produce the following output in the standard console output window.
Please enter your first name: Johnny</p> <hr /> <p><em>Hello, Johnny!</em></p> <hr /> <p>Process returned 0 (0x0) execution time : 2.905 s Press any key to continue.
Compile and run the program presented in this chapter.
Note: The comprehensive program and explanation are documented very clearly in chapter 2 of the book. Refer to the chapter for details.
This is what the program does:
****************** * * * Hello, Johnny! * * * ******************
Specification as follows:
This is the full code as described in the chapter. I have added some extra brackets for clarity purpose.
#include <iostream>
#include <string>
// say what standard-library names we use
using std::cin;
using std::endl;
using std::cout;
using std::string;
int main()
{
// ask for the person's name
cout << "Please enter your first name: ";
// read the name
string name;
cin >> name;
// build the message that we intend to write
const string greeting = "Hello, " + name + "!";
// the number of blanks surrounding the greeting
const int pad = 1;
// the number of rows and columns to write
const int rows = ( pad * 2 ) + 3;
const string::size_type cols = greeting.size() + ( pad * 2 ) + 2;
// write a blank line to separate the output from the input
cout << endl;
// write 'rows' rows of output
// invariant: we have written r rows so far
for ( int r = 0; r != rows ; ++r )
{
string::size_type c = 0;
// invariant: we have written c characters so far in the current row
while ( c != cols)
{
// is it time to write the greeting?
if ( ( r == pad + 1 ) && ( c == pad + 1 ) )
{
cout << greeting;
c += greeting.size();
}
else
{
// are we on the border?
if (
( r == 0 ) // top row
|| ( r == rows - 1 ) // or bottom row
|| ( c == 0 ) // or left-most column
|| ( c == cols - 1 ) // or right-most column
)
{
cout << "*";
}
else
{
cout << " ";
}
++c;
}
}
cout << endl;
}
return 0;
}
The program compiles successfully and produce the following output in the standard console output window.
Please enter your first name: Johnny ****************** * * * Hello, Johnny! * * * ****************** Process returned 0 (0x0) execution time : 2.699 s Press any key to continue.
What does the following program do it, when it asks you for input, you type two names (for example, Samuel Beckett)? Predict the behaviour before running the program, then try it.
#include <iostream>
#include <string>
int main()
{
std::cout << "What is your name? ";
std::string name;
std::cin >> name; // frist std::cin step
std::cout << " Hello, " << name
<< std::endl << "And what is yours?";
std::cin >> name; // second std::cin step
std::cout << "Hello, " << name
<< "; nice to meet you too!" << std::endl;
return 0;
}
At the first std::cin phase we type in two words, “Samuel Beckett”, followed by hitting the enter key. The following happens:
(1) the two words initially get stored in the buffer (corresponding to std::string variable name)
Samuel Beckett
Note that the buffer automatically discard the leading and trailing blanks. Each word is separated by a space character.
(2) the std::cin cuases the buffer the flush out the first word “Samuel” to the std::string variable assignment. The std::string name has now a value of “Samuel”.
Because the first word has now been flushed out from the buffer, the buffer for name now looks like this:
Beckett
Note that the first word Samuel is now gone. It has been flushed away from the buffer.
At the second std::cin phase, becuase there is already a word in the buffer, it just simply asks the buffer to flush out that value and assign that to the std::string variable name. The std::string name has now a value of “Beckett” (and replace the old value “Samuel”)
Because the first word has now been flushed out from the buffer, the buffer for name now looks like this:
The buffer s now empty!
If there turn out to be a third std::cin step, the user will be asked to supply some values to the buffer, so that the std::cin facility may read from it. (But in this case, the program only has two std::cin steps).
In summary, the std::cin checks the buffer corresponding to the std::string variable.
This question appears to be quite simple at first sight, and after going through such detail investigation, it has revealed so much “hidden scene” behind the std::cin and buffer operations. The above summarises my own humble understanding – this is the most logical visualisation I could come up with. (and I hope it is correct!)
For completeness, let us run the program and confirm our understanding.
What is your name? Samuel Beckett Hello, Samuel And what is yours?Hello, Beckett; nice to meet you too! Process returned 0 (0x0) execution time : 21.496 s Press any key to continue.
To confirm the hypothesis stated in the summary section above, let’s do three more experiments. Knowing that there are two std::cin steps in the program, we can try the followings:
At the first std::cin phase, I provide 0 words and hit enter.
Because the buffer for the std::string variable is empty, hitting the enter button does not get us anywhere – the program insists us to provide at least 1 word to the buffer.
At the first std::cin phase, I provide 1 word and hit enter.
This satisfies the first std::cin phase – it reads the word that I provide and use it for the first std::cout phase. Buffer is empty as a consequence. When it reaches the second std::cin phase however, because the buffer is empty it pauses and asks me to provide some words in order to proceed.
At the first std::cin phase, I provide 3 words and hit enter.
Result:
(note: we the program contains a 3rd std::cin step, it would just read that remaining 1 word from the buffer).
Part 1: Is this program valid? If so, what does it do? If not, say why not, and rewrite it to be valid.
#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 and require correction.
Like the previous exercises (1-3 / 1-4), the key to this question is to understanding the term scope. One scope may not “see” what’s inside the other scope(s).
For clarity let me add some comments to the code to visualise these scopes.
// original program with comments added to visualise scope
#include <iostream>
#include <string>
int main()
{ // scope main starts
{ // scope main-1 starts
std::string s = "a string";
{ // scope main-1-1 starts
std::string x = s + ", really";
std::cout << s << std::endl;
} //scope main-1-1 ends
std::cout << x << std::endl;
} // scope main-1 ends
return 0;
} // scope main ends
} // scope main ends
[/code]
Let me start off by stating the following facts (in general)
To apply these facts to our case:
To prove the point if we run the program as it is, we expect to see a compilation error
line (19): error: ‘x’ was not declared in this scope
To make the std::string x visible to the scope main-1, simply move the scope main-1-1 up 1 level by removing the curly braces. Like this:
// corrected - likely to work
#include <iostream>
#include <string>
int main()
{ // scope main starts
{ // scope main-1 starts
std::string s = "a string";
std::string x = s + ", really";
std::cout << s << std::endl;
std::cout << x << std::endl;
} // scope main-1 ends
return 0;
} // scope main ends
Running this corrected version program gives us the desirable result, as expected.
a string a string, really Process returned 0 (0x0) execution time : 0.245 s Press any key to continue.
Part 1: Is the following program valid? if so what does it do? If not, why not?
Part 2: What if we add a semi-colon between the second-last and third-last (right) curly braces?
#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;
}
}
}
Yes. The program is valid.
Like the previous exercise (1-3), the key to this question is to understanding the term scope. Each pair of curly braces {} form a scope. It is okay to have scopes nested within a scope.
For clarity let me add some comments to the code to visualise these scopes.
#include <iostream>
#include <string>
int main()
{//scope main starts
{ //scope main-1 start
const std::string s = "a string";
std::cout << s << std::endl;
{ //scope main-1-1 starts
const std::string s = "another string";
std::cout << s << std::endl;
} //scope main-1-1 ends
} //scope main-1 ends
} //scope main ends
The const std::string variable s in scope main-1 is not the same const std::string variable s in scope main-1-1 (which is nested inside scope main-1). Even though scope main-1-1 is nested inside scope main-1, all local variables inside scope main-1-1 is hidden from view of main-1.
For completeness, let’s run the program at the top to confirm it runs okay.
a string another string Process returned 0 (0x0) execution time : 0.317 s Press any key to continue.
The program runs okay as expected.
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, we expect to see the followings memory allocations / de-allocations.
Notice how this differs to the case in exercise 1.3?
Adding a semi-colon (;) between the second last and third last right curly braces will still constitute a valid program. For clarity, this is what the program would look like with that semi-colon.
#include <iostream>
#include <string>
int main()
{//scope main starts
{ //scope main-1 start
const std::string s = "a string";
std::cout << s << std::endl;
{ //scope main-1-1 starts
const std::string s = "another string";
std::cout << s << std::endl;
} //scope main-1-1 ends
; // the additional semi-colon
} //scope main-1 ends
} //scope main ends
The additional semi-colon essentially creates a null-statement within the main-1 scope. i.e. it has no effect to the code. I think the reason the authors ask this question is to solidify our understanding on scope. i.e. which scope does that semi-colon belong to? Writing a C++ code in the above manner helps us visualise this easier.
Submitting the program with this semi-colon would yield the same output.
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;
}
}
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.
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.
Are the following definitions valid? Why or why not?
const std::string exclam = "!"; const std::string message = "Hello " + ", world" + exclam;
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 +.
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;
}
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.
Are the following definitions valid? Why or why not?
const std::string hello = "Hello"; const std::string message = hello + ", world" + "!";
Yes. These definitions are valid.
The key in answering this question is to acknowledge the use of the string concatenation operator +.
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;
}
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.