Line 6 will create a C-string variable to store the string “cString” followed by automatically adding the null character ‘\0’ located at index 7. The string characters are stored at indexes from 0 up to 6. When running the code, the while loop will print the cStringVar contents up to the null character when the loop terminates, avoiding reading the rest of the array that includes uninitialized array locations.

Let us now experiment with what would happen if we accidentally lose ‘\0’.

Experiment 1: Add the below line of code just below line 6 to replace ‘\0’ with any other character like ‘a’ and run the code again. Explain what happens.

cStringVar[7] = ‘a’;

The exact behavior will depend on the specific compiler you are using. Running this code on Visual Studio on a Windows system, the code still printed the string correctly, followed by the added ‘a’ character without any complications. This happened because the compiler’s automated operation happened behind the scenes. The array will be automatically initialized to its base type at the time of declaration. This means that although the code did not explicitly initialize the memory locations at indexes [8] and [9], the system automatically initialized them for us based on the array base type, which is the null character ‘\0’.

Experiment 2: Now let us examine another scenario. Change the size of the string to 8 instead of 10. In this case, the ‘\0’ character will be the last character in the array. Therefore, when you replace the null character with any other character, the array will no longer behave as a C-string array. Run the code and explain the results.

The code now will print all characters stored in the array in addition to undefined contents from outside the array boundary. To avoid reading and writing to memory locations outside of the array boundary, we can add additional protection to the while loop condition like this:

const int SIZE = 8;
while (cStringVar[index] != ‘\0’ &&  (index < SIZE) ) {  …..  

This change guarantees that the loop terminates at either reaching the null character or reaching the end of the array.

Run the code and explain the results. The main purpose of this example is to illustrate the usage of some of the C-string functions. In lines 7 to 10, we declare and populate C-string variables. As always, we have a concern about overflowing C-string variables; it is a good idea to check their sizes using the strlen function from the <cstring> library, lines 13 and 14.  strlen function returns the number of characters saved in a C-string variable – excluding the null character – not the declared size. That is, if a C-string variable is declared to have the size of 10 and then used to save 5 characters value, strlen will return 5.

Because the full name variable was declared to be of a specific size, we want to check if the combined first and last names will fit. If not, we must warn the user utilizing the if … else statement in line 17. If the size of both first and last names + one space between them + the null character ‘\0’ fit the fullName variable size, then we can run the else block. Firstly, we copy the firstName variable into the fullName using the strcpy_s function. The ‘_s’ part denotes the safe version of this function introduced in C++ 11 in comparison with the older version. Many of the <cstring> functions have been modified and have the ‘_s” part to signify this fact. strcpy_s function takes three arguments: the destination variable, the size of the destination variable, and the source variable, respectively. Again, it is critical to check that the destination variable size is large enough to hold the source variable contents. Line 23 adds a space to separate the two names, and line 24 adds the lastName contents into the fullName variable using the strcat_s. The cat part of this function name denotes the concatenate action, which means adding the second string to the end of the first string. This is in contrast to the strcpy_s function behavior, in which the contents of the source string overwrite the contents of the destination variable. Finally, line 26 prints out the fullName contents to the console.

It is very important to remember that all of the mentioned functions must handle the null character appropriately for every operation. That is, strlen returns the size of the string, excluding the null character. Both the strcpy_s and strcat_s will ensure that the destination variable is always delimited with the null character appropriately.

To better understand how to work with C-strings, let us do a couple of tests on example 02 code. The exact behavior depends on your compiler and system. To run all the code in this book, I used Visual Studio IDE and Windows 11.

Test 1: Change the firstNameSize to 4 and enter a large first name like John, which will not leave a space for the null character. When running the code, an exception is thrown saying, “Stack around the variable ‘firstName’ was corrupted,” which prevents running the remaining of the code. Similar results will occur if the lastNamesize is changed in the same manner.

Test 2: Change firstNameSize, lastNameSize, and fullNameSize back to 10. This time, be sure the first and last names you entered fit within the allowed limit; however, the combined names will not fit the full name size allowance, such as John Smith. Of course, in this case, the if-statement will detect the problem and terminate the execution safely.

Test 3: Keep all changes in test 2 and change the if-condition to become if (strlen(firstName) + strlen(lastName) + 2 > 20) . We do this only to trick the if-condition and allow the else block to execute. This time, by using the same example, ‘John Smith,’ the if-statement will fail to detect the problem, and the code will continue executing the else block. Lines 22 and 23 will execute normally as the size of the lastName will fit both the first name and the additional space. However, line 24 will generate the exception again because it causes a memory overflow.

Run the code and explain the results. In this example, we are testing how the strncpy_s and strncat_s functions can provide additional safety when working with C-Strings. The constants in lines 7 to 10 provide reasonable string sizes to run the code without issues. However, we are going to modify these sizes to test the behavior of both strncpy_s and strncat_s functions. Note that we used the getline member function of the input stream cin to read an entire line of text.

Test 1: change the constant MAX_LABEL_LENGTH size to 5 and provide a large first name like ‘Smith’. When you run the code, the strncpy_s function at line 24 will cause the run-time error “Debug Assertion Failed!” to terminate the execution gracefully after failing to assert that the source size fits the destination size.

Test 2: keep the same MAX_LABEL_LENGTH size and enter a four-character first name like ‘John’. This time the strncpy_s function at line 24 will run correctly, however, the function strncat_s at line 27 will now complain about the source size – which is only 1 character – being larger than the destination size.

Test 3: as an exercise, make similar changes to test functions at lines 30, 33, and 36. Comment on the results.

In this example, we will test what values are returned by the strcmp for various scenarios. For clarity, first, test the code using single-character strings. Then, you can use larger strings. Compare and explain the results.

Test 1: str1 = a        str2 = b
Test 2: str1 = b        str2 = a
Test 3: str1 = a        str2 = A
Test 4: str1 = B        str2 = b
Test 5: str1 = a        str2 = a
Test 6: str1 = A        str2 = A
Test 7: str1 = abc      str2 = abc
Test 8: str1 = abca     str2 = abcb
Test 9: str1 = abcb     str2 = abca
Test 10: str1 = abca    str2 = abcA

In the provided code, line 16, we are only interested to know whether the entered command starts with the word help or not. This can be part of a larger system where users can enter a large number of commands and this information can be useful to optimize the system performance. To test this functionality, you can enter something like help ls, help /s/d, clear dir, hellp/ cd/, or anything else.

Similarly, in line 28, we want to know the type of username entered, assuming there are many different types of usernames. For testing the code, you can enter something like admin_master, admin level 1, user_1, admn-user, or anything else.

Run the attached code and comment on the results. This example shows how easy to declare, initialize, and concatenate strings. You might want to compare how you did these operations with CStrings. In line 7, we declared four string variables in one line, initializing the first variable and leaving others without initialization. After reading two strings from the console in line 9, line 10 concatenates them together using the + operator. Compilers are smart enough to tell what needs to be done in this statement. If you are using the + operator between two numerical values, it will be understood that the required operation is to add the two numerical values and return their addition. However, if the + operator happens to be placed between two strings, it will be understood that the required operation is to concatenate the two strings into one string. If you try to place the + operator between a string and a numerical value, you will get an error as this operator is not defined. Line 11 shows how easy it is to print out string variables contents in any desired format.

This example code tests whether a given text can be read exactly the same in the reversed direction. For example, the text racecar can be read the same from right to left. Similarly, the sentence “No lemon, no melon.” This wordplay is called Palindrome. To simplify the code, the given text must be stripped of all punctuation, including spaces. Additionally, upper-case letters need to be converted to lowercase.

The provided code has two functions: cleanString and isPalindrome. The program starts execution from line 27 in the main function when a user is prompted to enter a sentence and save it into the sentence variable. Then, the isPalindrome function is called in line 30, where it returns either true or false. The isPalindrome function takes the entered text as a parameter passed by reference to make the parameter accessible to all functions. The const modifier is used to protect this parameter from being changed unintentionally. The first line in the isPalindrome function calls the cleanString function, line18. As the name suggests, cleanString function job is to remove all punctuations and convert upper-case characters to lower-case. The first task can be achieved by calling the predefined isalnum function, line 10. This function returns true for only letters and numbers. The tolower function converts upper-case letters to lower-case. cleanString function uses the for-each loop in line 9 that reads the text saved in the str variable character by character and saves it in the c variable.

When the cleanString function returns the cleaned string to the isPalindrome function in line 18, a for loop is used to reverse it. Note how the for loop is written to loop backward from the end of the string to its beginning. Although the length() function returns values in size_t type, which is an unsigned integer type, we used int instead. The reason is in this implementation i, must become negative to terminate the loop, which is not possible with size_t type. Additionally, although string variables can be used as whole objects, it is allowable to access particular characters using the square brackets syntax resembling arrays’ indexes, line 21. Line 23 tests whether the actual entered text by the user cleanStr equals the reversed text. Thus, isPalindrome returns either true or false.

Run the attached code and comment on the results. In this example, we use the find member function that searches a string for a specific character. If the character is found, find returns its integer position starting from 0. If not, find returns a special constant defined in the string class called npos, which means ‘no position’.

The code counts how many vowels are there in any given text. This is done by the countVowels function that takes the entered text by a user as a parameter. Then, it compares every character with a predefined list of vowels, including both upper and lower case characters, as in line 8.

The for-each loop is used to iterate over all characters stored in the str variable one by one. The if-statement condition returns true only if the character is found in the vowels list. Otherwise, it returns npos constant where the condition returns false, skipping counting that particular character.

We use the referencing operator  ::  when we need to tell the compiler where to find a specific definition, thus we wrote string::npos to say that the constant npos is defined in the string class.

To clarify how the find function works, add the below line inside the if-statement block. This line prints what find function returns for every found character c .

cout << “The character (” << c << “) position is ” << vowels.find(c) << endl;

Run the provided code several times with different input texts, then comment on the results.

In this example, we want to create two copies of the user input text, vowelGroup and consonantGroup. The first loop modifies the vowelGroup by replacing every consonant letter with  _  ignoring punctuation and numbers. The member function replace – line 17 – takes three arguments: the index of the character in the string, the number of characters to replace starting at the first argument index, and the characters to replace the existing characters in the string. The first part of the if condition checks whether a given character exists in the vowels variable defined in line 10. As explained in example 09, the find member function returns npos constant if a character is not found. This means the condition vowels.find(vowelGroup.at(i)) == string::npos returns true for all non-vowel characters. The second part checks whether the character is alpha to ignore punctuation and numbers. isalpha member function defined in the <cctype> library returns true only for upper and lower case letters.

Note in this example, we used the string class member function at( ) to read a specific character in the string rather than using square bracket syntax. Both notations return the same result; however, using at( ) is safer because it checks whether the provided index is a legal index or not. If not, at( ) returns an exception. Using square brackets does not perform this check. Risking reading areas out of the string boundaries. Both notations are popular when working with strings.

The second loop works with similar logic. However, the if condition does not call isalpha because once we know that a character is a vowel, it is certainly an alpha character.

Run the provided code and comment on the results. This is a simple word battle game where two players are prompted to enter a single word of their choice. Then, inside the for-loop, the two words will be compared, and the user who chooses a word that comes before the opponent word will be the winner. Of course, to make the game interesting, you can request that only real words be used.

Run the attached code and comment on the results. The code will first ask users to enter a monetary value. Because we do not know how the value will be entered, the entered value is initially saved as a string. Then, the for loop will remove all non-digit characters from the entered value. Note how the erase member function of the string class is used to achieve this goal. Lastly, the stod is used to convert the string to double and makes it ready to be included in any desired calculations. stod function throws an exception if its argument contains non-digit characters. There are other similar functions that convert strings to numerical types like stoi (string to integer) , stof (string to float), and others.

The second part of the code is about handling dates. To avoid confusion caused by which delimiter users might use, like / or \ or – , the code will focus on reading the numerical values for month, day, and year, ignoring any other non-digit characters. for-each loop is used to iterate over all characters stored in the string input. Each character is tested, whether being a digit or not, utilizing the isdigit function. Note how the part variable is utilized to separate month, day, and year values. The += operator is overloaded to work with both strings and characters by concatenating the character at the left side to the end of the string at the right side. If month, day, and year strings need to be further processed to check if they fit within a plausible range, they must be converted to integers first. See exercise 10.

Run the given code and test it with these numbers: 100999.87888, 123888456, -129900.654, etc. Comment on the results.

The provided code formates the entered numbers by adding a comma after every three digits, rounding decimal numbers to only two decimal places, and adding a \$ sign. The code works by first asking a user to enter any number to format; then, it calls the formatNumber function. The first thing this function does is round numbers to two decimal places, line 34. If a user enters an integer, this line adds two zeros decimal places to format all numbers consistently. To simplify the code, line 35 converts negative numbers to positive numbers using the absolute value fabs function from <cmath> library. The to_string from <string> library converts numbers to strings. to_string function returns numbers with six decimal places. For example, if you entered 123 or 123.45, to_string returns 123.000000 or 123.450000. Therefore, the rounded number stored in the number variable will have four extra 0s added to it.  Line 36 trims those extra four 0s utilizing subStr member function of the string class. This function returns part of a string by specifying the start and the end of the returned sub-string.

Now, we are ready to add commas to make reading large numbers easier. The insertCommas function called in line 38 takes the numStr formatted so far as an argument. To add commas at the correct places, a for-loop is used to iterate through the entire numStr string in reverse order. The idea here is to read characters in the numStr from right to left and to save them into a new string variable formattedNumber using the insert member function of the string class. This function takes two arguments: the position where we want to insert a string and the contents of this string. In line 15, we read characters one by one, starting at the end of the numStr and adding them at the beginning of the formattedNumber variable. Thus, although we are reading the numStr reversely, the formattedNumber will be in the correct order at the end of the for-loop.

To accomplish our goal, we have to add commas after detecting the decimal point and reading each digit from right to left in sets of three. To understand how the code works, let’s trace through an example, like 1234567.89. At the very first iteration of the for-loop, the if-statement returns false. Then, the else if part returns false as well, allowing moving forward and reading the second character, which will have the same result. The third read character will be detected as the decimal point character by the if-statement setting pastDecimal to true and count to 0. At the following iteration, the else if block will be selected, incrementing the count variable and testing whether its value equals 3, which is not at this point. After two more iterations and when count equals 3, a comma is inserted at the beginning of the formattedNumber variable. This process repeats until reading the entire numStr string.

Run the given code and comment on the results. After declaring the vector called temperatures, the vector member function push_back() is used to initialize it. In the for loop, the vector elements are accessed using a syntax similar to the array syntax, temperatures[i].  The vector member function size() returns the number of elements currently stored in the vector, NOT the amount of space that has been allocated for the vector, which can be larger than the number of elements it currently holds. Note that the for loop variant is declared as size_t type, which is unsigned int to match the returned type by size(). The type casting (char)248 is used to print the degree symbol ° in the results. On my system, the ASCII code for this symbol is 248.

The attached code has 6 tests to help you understand the behavior of vectors. At the beginning, all code lines are commented out. Then, you will need to comment and uncomment portions of the code to run each test separately. Visual Studio and other similar IDEs provide buttons and keyboard shortcuts to do this easily.

Test 1: Uncomment lines 7 and 8 and run the code. aVector.size() function returns 0 as the size of a declared but not initialized vector.

Test 2: Comment out the previous lines and uncomment lines 11 to 14. After declaring the aVector and initializing the first 10 locations, the aVector.size() function returns 10 as the current size of the vector. Now, it is permissible to use the [ ] notation to read only the initialized locations. Notice that all values stored in the vector are 0s, which are the default values for the type int.

Test 3: Comment out the previous lines and uncomment lines 17 to 20. In this test, we set the for loop condition as aVector.size() + 1 to try accessing a location outside the initialized range. As you expected, an error message will pop up.

Test 4: Comment out the previous lines and uncomment lines 23 to 29. This test shows that after declaring a vector, we can use the square brackets [ ] notation to write to any of the initialized locations.

Test 5: Comment out the previous lines and uncomment lines 32 to 38. Similar to test 3, we try to write outside the initialized range of the vector. Of course, an error message will pop up.

Test 6: Comment out the previous lines and uncomment lines 41 to 49. In this test, we use the if .. else statement to check whether we are writing within the initialized range of the vector locations. If it is true, we can use the square brackets [ ] notation to add values, otherwise, we must use the push_back() function to do so.

In this example, we will examine vectors’ behavior as they are designed to grow dynamically to meat programs needs. The code has 3 tests. You will need to comment out and comment on portions of the code as instructed.

Test 1: Uncomment lines 11 to 17 and run the code. From the results, we can notice that the capacity increases in a nonlinear manner. In the beginning, it grows slowly by adding a few locations. But later, it grows much faster to meet the program demands.

Test 2: Comment out the previous lines and uncomment lines 20 to 23. In the case that you know the needed vector size, you can reserve a specific amount using the reserve() member function. Using reserve() function can enhance the program performance by avoiding the excessive vector dynamic growing overhead. What happens behind the scenes is that every time the vector becomes full, a new vector is created with a larger capacity. Then, all stored data are copied from the old vector to the new vector. Lastly, the old vector is destroyed. These operations can affect the overall performance of programs.

Although executing line 20 will reserve 100 locations in the vector, line 21 shows that the current size is 0 because reserve() function does not actually initialize the reserved locations. Therefore, if line 23 is executed, an error message will pop up on the screen.

Test 3: Comment out the previous lines and uncomment lines 26 to 47. resize() is similar to size() in that it initializes the number of locations equal to the passed argument. However, resize() can set a new size to the vector either by increasing or decreasing its original size.

Running lines 26 to 31, resize the vector to 10. Then, it is ok to use the [ ] notation to add values to these locations because they are already initialized. Lines 34 to 37 resize the vector to a new size of 20 and print the contents of the entire vector. You will notice that after printing the first 10 values added in the previous step, 10 zeros are printed out as well. Those zeros are the default values added to the initialized locations in the vector after increasing its size from 10 to 20. Lines 41 to 45 replace zeros with values and then print the entire vector contents.

Test 4: Keep the commented-out lines from test 3 unchanged and uncomment lines 49 to 53. When you run these lines, an error message will pop up on the screen. The reason is that after resizing the vector down to 15, the last 5 locations were lost and cannot be accessed anymore.