Professional C++ (2014)

Part IIntroduction to Professional C++

· CHAPTER 1: A Crash Course in C++ and the STL

· CHAPTER 2: Working with Strings

· CHAPTER 3: Coding with Style

Chapter 1A Crash Course in C++ and the STL

WHAT’S IN THIS CHAPTER?

· A brief overview of the most important parts and syntax of the C++ language and the Standard Template Library (STL)

· The basics of smart pointers

WROX.COM DOWNLOADS FOR THIS CHAPTER

Please note that all the code examples for this chapter are available as a part of this chapter’s code download on the book’s website at www.wrox.com/go/proc++3e on the Download Code tab.

The goal of this chapter is to cover briefly the most important parts of C++ so that you have a base of knowledge before embarking on the rest of the book. This chapter is not a comprehensive lesson in the C++ programming language nor the STL. The basic points, such as what a program is and the difference between = and ==, are not covered. The esoteric points, such as the definition of a union, or the volatile keyword, are also omitted. Certain parts of the C language that are less relevant in C++ are also left out, as are parts of C++ that get in-depth coverage in later chapters.

This chapter aims to cover the parts of C++ that programmers encounter every day. For example, if you’ve been away from C++ for a while and you’ve forgotten the syntax of a for loop, you’ll find that syntax in this chapter. Also, if you’re fairly new to C++ and don’t understand what a reference variable is, you’ll learn about that kind of variable here, as well. You’ll also learn the basics on how to use the functionality available in the STL, such as vector containers, string objects, and smart pointers.

If you already have significant experience with C++, skim this chapter to make sure that there aren’t any fundamental parts of the language on which you need to brush up. If you’re new to C++, read this chapter carefully and make sure you understand the examples. If you need additional introductory information, consult the titles listed in Appendix B.

THE BASICS OF C++

The C++ language is often viewed as a “better C” or a “superset of C.” Many of the annoyances or rough edges of the C language were addressed when C++ was designed. Because C++ is based on C, much of the syntax you’ll see in this section will look familiar to you if you are an experienced C programmer. The two languages certainly have their differences, though. As evidence, The C++ Programming Language by C++ creator Bjarne Stroustrup (Fourth Edition; Addison-Wesley Professional, 2013), weighs in at 1,368 pages, while Kernighan and Ritchie’s The C Programming Language (Second Edition; Prentice Hall, 1988) is a scant 274 pages. So if you’re a C programmer, be on the look out for new or unfamiliar syntax!

The Obligatory Hello, World

In all its glory, the following code is the simplest C++ program you’re likely to encounter:

// helloworld.cpp

#include <iostream>

int main()

{

std::cout << "Hello, World!" << std::endl;

return 0;

}

This code, as you might expect, prints the message “Hello, World!” on the screen. It is a simple program and unlikely to win any awards, but it does exhibit the following important concepts about the format of a C++ program.

· Comments

· Preprocessor Directives

· The main() Function

· I/O Streams

These concepts are briefly explained in the next sections.

Comments

The first line of the program is a comment, a message that exists for the programmer only and is ignored by the compiler. In C++, there are two ways to delineate a comment. In the preceding and following examples, two slashes indicate that whatever follows on that line is a comment.

// helloworld.cpp

The same behavior (this is to say, none) would be achieved by using a multiline comment. Multiline comments start with /* and end with */. The following code shows a multiline comment in action (or, more appropriately, inaction).

/* This is a multiline comment.

The compiler will ignore it.

*/

Comments are covered in detail in Chapter 3.

Preprocessor Directives

Building a C++ program is a three-step process. First, the code is run through a preprocessor, which recognizes meta-information about the code. Next, the code is compiled, or translated into machine-readable object files. Finally, the individual object files arelinked together into a single application. Directives aimed at the preprocessor start with the # character, as in the line #include <iostream> in the previous example. In this case, an include directive tells the preprocessor to take everything from the <iostream> header file and make it available to the current file. The most common use of header files is to declare functions that will be defined elsewhere. A function declaration tells the compiler how a function is called, declaring the number and types of parameters, and the function return type. A definition contains the actual code for the function. In C++, declarations usually go into files with extension .h, known as header files, while definitions usually go into files with extension .cpp, known as source files. A lot of other programming languages do not separate declarations and definitions into separate files, for example C# and Java.

The <iostream> header declares the input and output mechanisms provided by C++. If the program did not include it, it would be unable to perform its only task of outputting text.

NOTE In C, header files usually end in .h, such as <stdio.h>. In C++, the suffix is omitted for standard library headers, such as <iostream>. Standard headers from C still exist in C++, but with new names. For example, you can access the functionality from <stdio.h> by including <cstdio>.

The following table shows some of the most common preprocessor directives.

One example of using preprocessor directives is to avoid multiple includes. For example:

#ifndef MYHEADER_H

#define MYHEADER_H

// ... the contents of this header file

#endif

If your compiler supports the #pragma once directive, and most modern compilers do, this can be rewritten as follows:

#pragma once

// ... the contents of this header file

Chapter 10 discusses this in more details.

The main() Function

main() is, of course, where the program starts. An int is returned from main(), indicating the result status of the program. The main() function either takes no parameters, or takes two parameters as follows:

int main(int argc, char* argv[])

argc gives the number of arguments passed to the program, and argv contains those arguments. Note that argv[0] might be the program name, but you should not rely on it, and you should never use it.

I/O Streams

I/O streams are covered in depth in Chapter 12, but the basics of output are very simple. Think of an output stream as a laundry chute for data. Anything you toss into it will be output appropriately. std::cout is the chute corresponding to the user console, orstandard out. There are other chutes, including std::cerr, which outputs to the error console. The << operator tosses data down the chute. In the preceding example, a quoted string of text is sent to standard out. Output streams allow multiple data of varying types to be sent down the stream sequentially on a single line of code. The following code outputs text, followed by a number, followed by more text.

std::cout << "There are " << 219 << " ways I love you." << std::endl;

std::endl represents an end-of-line sequence. When the output stream encounters std::endl, it will output everything that has been sent down the chute so far and move to the next line. An alternate way of representing the end of a line is by using the \n character. The \n character is an escape character, which refers to a new-line character. Escape characters can be used within any quoted string of text. The following table shows the most common escape characters:

Streams can also be used to accept input from the user. The simplest way to do this is to use the >> operator with an input stream. The std::cin input stream accepts keyboard input from the user. User input can be tricky because you can never know what kind of data the user will enter. See Chapter 12 for a full explanation of how to use input streams.

If you’re new to C++ and coming from a C background, you’re probably wondering what has been done with trusty old printf(). While printf() can still be used in C++, it’s recommended to use the streams library.

Namespaces

Namespaces address the problem of naming conflicts between different pieces of code. For example, you might be writing some code that has a function called foo(). One day, you decide to start using a third-party library, which also has a foo() function. The compiler has no way of knowing which version of foo() you are referring to within your code. You can’t change the library’s function name, and it would be a big pain to change your own.

Namespaces come to the rescue in such scenarios because you can define the context in which names are defined. To place code in a namespace, enclose it within a namespace block. Suppose the following is in a file called namespaces.h:

namespace mycode {

void foo();

}

The implementation of a method or function can also be handled in a namespace:

#include <iostream>

#include "namespaces.h"

namespace mycode {

void foo() {

std::cout << "foo() called in the mycode namespace" << std::endl;

}

}

By placing your version of foo() in the namespace “mycode,” it is isolated from the foo() function provided by the third-party library. To call the namespace-enabled version of foo(), prepend the namespace onto the function name by using ::, also called the scope resolution operator, as follows.

mycode::foo(); // Calls the "foo" function in the "mycode" namespace

Any code that falls within a “mycode” namespace block can call other code within the same namespace without explicitly prepending the namespace. This implicit namespace is useful in making the code more readable. You can also avoid prepending of namespaces with the using directive. This directive tells the compiler that the subsequent code is making use of names in the specified namespace. The namespace is thus implied for the code that follows:

#include "namespaces.h"

using namespace mycode;

int main()

{

foo(); // Implies mycode::foo();

return 0;

}

A single source file can contain multiple using directives, but beware of overusing this shortcut. In the extreme case, if you declare that you’re using every namespace known to humanity, you’re effectively eliminating namespaces entirely! Name conflicts will again result if you are using two namespaces that contain the same names. It is also important to know in which namespace your code is operating so that you don’t end up accidentally calling the wrong version of a function.

You’ve seen the namespace syntax before — you used it in the Hello, World program, where cout and endl are actually names defined in the std namespace. You could have written Hello, World with the using directive as shown here:

#include <iostream>

using namespace std;

int main()

{

cout << "Hello, World!" << endl;

return 0;

}

A using declaration can be used to refer to a particular item within a namespace. For example, if the only part of the std namespace that you intend to use is cout, you can refer to it as follows:

using std::cout;

Subsequent code can refer to cout without prepending the namespace, but other items in the std namespace will still need to be explicit:

using std::cout;

cout << "Hello, World!" << std::endl;

WARNING Never put a using directive or using declaration in a header file, otherwise you force it on everyone that is including your header.

Variables

In C++, variables can be declared just about anywhere in your code and can be used anywhere in the current block below the line where they are declared. Variables can be declared without being given a value. These uninitialized variables generally end up with a semi-random value based on whatever is in memory at the time and are the source of countless bugs. Variables in C++ can alternatively be assigned an initial value when they are declared. The code that follows shows both flavors of variable declaration, both usingints, which represent integer values.

int uninitializedInt;

int initializedInt = 7;

cout << uninitializedInt << " is a random value" << endl;

cout << initializedInt << " was assigned an initial value" << endl;

NOTE Most compilers will issue a warning or an error when code is using uninitialized variables. Some compilers will generate code that will report an error at run time.

The table that follows shows the most common types used in C++.

NOTE C++ does not provide a basic string type. However, a standard implementation of a string is provided as part of the standard library as described later in this chapter and in more detail in Chapter 2.

Variables can be converted to other types by casting them. For example, a float can be cast to an int. C++ provides three ways of explicitly changing the type of a variable. The first method is a holdover from C, and unfortunately is still commonly used. The second method seems more natural at first but is rarely seen. The third is the most verbose, but the cleanest and recommended method.

float myFloat = 3.14f;

int i1 = (int)myFloat; // method 1

int i2 = int(myFloat); // method 2

int i3 = static_cast<int>(myFloat); // method 3

The resulting integer will be the value of the floating point number with the fractional part truncated. Chapter 10 describes the different casting methods in more detail. In some contexts, variables can be automatically cast, or coerced. For example, a short can be automatically converted into a long because a long represents the same type of data with at least the same precision.

long someLong = someShort; // no explicit cast needed

When automatically casting variables, you need to be aware of the potential loss of data. For example, casting a float to an int throws away information (the fractional part of the number). Most compilers will issue a warning if you assign a float to an int without an explicit cast. If you are certain that the left-hand side type is fully compatible with the right-hand side type, it’s okay to cast implicitly.

Literals

Literals are used to write numbers or strings in your code. C++ supports a number of standard literals. Numbers can be specified with the following literals. All four examples represent the same number.

· Decimal literal, for example: 123

· Octal literal, for example: 0173

· Hexadecimal literal, for example: 0x7B

· Binary literal, for example: 0b1111011

Other examples of literals in C++:

· A floating point value: 3.14f

· A double floating point value: 3.14

· A single character: ‘a’

· A zero-terminated array of characters: “character array”

It’s also possible to define your own type of literals, which is an advanced feature explained in Chapter 10.

C++14 allows the use of digits separators in numeric literals. A digits separator is a single quote character. For example:

int number1 = 23'456'789; // The number 23456789

float number2 = 0.123'456f; // The number 0.123456

Operators

What good is a variable if you don’t have a way to change it? The following table shows the most common operators used in C++ and sample code that makes use of them. Note that operators in C++ can be binary (operate on two expressions), unary (operate on a single expression), or even ternary (operate on three expressions). There is only one ternary operator in C++ and it is covered in the section “Conditionals.”

The following program shows the most common variable types and operators in action. If you’re unsure about how variables and operators work, try to figure out what the output of this program will be, and then run it to confirm your answer.

int someInteger = 256;

short someShort;

long someLong;

float someFloat;

double someDouble;

someInteger++;

someInteger *= 2;

someShort = static_cast<short>(someInteger);

someLong = someShort * 10000;

someFloat = someLong + 0.785f;

someDouble = static_cast<double>(someFloat) / 100000;

cout << someDouble << endl;

The C++ compiler has a recipe for the order in which expressions are evaluated. If you have a complicated line of code with many operators, the order of execution may not be obvious. For that reason, it’s probably better to break up a complicated statement into several smaller statements or explicitly group expressions by using parentheses. For example, the following line of code is confusing unless you happen to know the C++ operator precedence table by heart:

int i = 34 + 8 * 2 + 21 / 7 % 2;

Adding parentheses makes it clear which operations are happening first:

int i = 34 + (8 * 2) + ( (21 / 7) % 2 );

For those of you playing along at home, both approaches are equivalent and end up with i equal to 51. If you assumed that C++ evaluated expressions from left to right, your answer would have been 1. C++ evaluates /, *, and % first (in left-to-right order), followed by addition and subtraction, then bitwise operators. Parentheses let you explicitly tell the compiler that a certain operation should be evaluated separately.

Types

In C++, you can use the basic types (int, bool, etc.) to build more complex types of your own design. Once you are an experienced C++ programmer, you will rarely use the following techniques, which are features brought in from C, because classes are far more powerful. Still, it is important to know about the following ways of building types so that you will recognize the syntax.

Enumerated Types

An integer really represents a value within a sequence — the sequence of numbers. Enumerated types let you define your own sequences so that you can declare variables with values in that sequence. For example, in a chess program, you could represent each piece as an int, with constants for the piece types, as shown in the following code. The integers representing the types are marked const to indicate that they can never change.

const int PieceTypeKing = 0;

const int PieceTypeQueen = 1;

const int PieceTypeRook = 2;

const int PieceTypePawn = 3;

//etc.

int myPiece = PieceTypeKing;

This representation is fine, but it can become dangerous. Since a piece is just an int, what would happen if another programmer added code to increment the value of a piece? By adding one, a king becomes a queen, which really makes no sense. Worse still, someone could come in and give a piece a value of -1, which has no corresponding constant.

Enumerated types solve these problems by tightly defining the range of values for a variable. The following code declares a new type, PieceType, which has four possible values, representing four of the chess pieces.

enum PieceType { PieceTypeKing, PieceTypeQueen, PieceTypeRook, PieceTypePawn };

Behind the scenes, an enumerated type is just an integer value. The real value of PieceTypeKing is zero. However, by defining the possible values for variables of type PieceType, your compiler can give you a warning or error if you attempt to perform arithmetic onPieceType variables or treat them as integers. The following code, which declares a PieceType variable, and then attempts to use it as an integer, results in a warning or error on most compilers.

PieceType myPiece;

myPiece = 0;

It’s also possible to specify the integer values for members of an enumeration. The syntax is as follows.

enum PieceType { PieceTypeKing = 1, PieceTypeQueen, PieceTypeRook = 10, PieceTypePawn };

In this example, PieceTypeKing has the integer value 1, PieceTypeQueen has the value 2 assigned by the compiler, PieceTypeRook has the value 10, and PieceTypePawn has the value 11 assigned automatically by the compiler.

The compiler assigns a value to an enumeration member that is the value of the previous enumeration member incremented by one. If you don’t assign a value to the first enumeration member yourself, the compiler assigns it the value 0.

Strongly Typed Enumerations

Enumerations as explained above are not strongly typed, meaning they are not type-safe. They are always interpreted as integers, and thus you can compare enumeration values from completely different enumeration types. The enum class solves these problems. For example:

enum class MyEnum

{

EnumValue1,

EnumValue2 = 10,

EnumValue3

};

This is a type-safe enumeration called MyEnum. These enumeration value names are not automatically exported to the enclosing scope, which means you always have to use the scope resolution operator:

MyEnum value1 = MyEnum::EnumValue1;

The enumeration values are not automatically converted to integers, which means the following is illegal:

if (MyEnum::EnumValue3 == 11) {...}

By default, the underlying type of an enumeration value is an integer, but this can be changed as follows:

enum class MyEnumLong : unsigned long

{

EnumValueLong1,

EnumValueLong2 = 10,

EnumValueLong3

};

Structs

Structs let you encapsulate one or more existing types into a new type. The classic example of a struct is a database record. If you are building a personnel system to keep track of employee information, you will need to store the first initial, last initial, employee number, and salary for each employee. A struct that contains all of this information is shown in the employeestruct.h header file that follows:

struct Employee {

char firstInitial;

char lastInitial;

int employeeNumber;

int salary;

};

A variable declared with type Employee will have all of these fields built-in. The individual fields of a struct can be accessed by using the “.” operator. The example that follows creates and then outputs the record for an employee:

#include <iostream>

#include "employeestruct.h"

using namespace std;

int main()

{

// Create and populate an employee.

Employee anEmployee;

anEmployee.firstInitial = 'M';

anEmployee.lastInitial = 'G';

anEmployee.employeeNumber = 42;

anEmployee.salary = 80000;

// Output the values of an employee.

cout << "Employee: " << anEmployee.firstInitial <<

anEmployee.lastInitial << endl;

cout << "Number: " << anEmployee.employeeNumber << endl;

cout << "Salary: $" << anEmployee.salary << endl;

return 0;

}

Conditionals

Conditionals let you execute code based on whether or not something is true. As shown in the following sections, there are three main types of conditionals in C++.

if/else Statements

The most common conditional is the if statement, which can be accompanied by else. If the condition given inside the if statement is true, the line or block of code is executed. If not, execution continues to the else case if present, or to the code following the conditional. The following pseudocode shows a cascading if statement, a fancy way of saying that the if statement has an else statement that in turn has another if statement, and so on.

if (i > 4) {

// Do something.

} else if (i > 2) {

// Do something else.

} else {

// Do something else.

}

The expression between the parentheses of an if statement must be a Boolean value or evaluate to a Boolean value. Logical evaluation operators, described later, provide ways of evaluating expressions to result in a true or false Boolean value.

switch Statements

The switch statement is an alternate syntax for performing actions based on the value of an expression. In C++ switch statements, the expression must be of an integral type or of a type convertible to an integral type, and must be compared to constants. Each constant value represents a “case.” If the expression matches the case, the subsequent lines of code are executed until a break statement is reached. You can also provide a default case, which is matched if none of the other cases match. The following pseudocode shows a common use of the switch statement.

switch (menuItem) {

case OpenMenuItem:

// Code to open a file

break;

case SaveMenuItem:

// Code to save a file

break;

default:

// Code to give an error message

break;

}

A switch statement can always be converted into if/else statements. The previous switch statement can be converted as follows:

if (menuItem == OpenMenuItem) {

// Code to open a file

} else if (menuItem == SaveMenuItem) {

// Code to save a file

} else {

// Code to give an error message

}

If a case section omits the break statement, the code for that case section is executed first, followed by a fallthrough, executing the code for the next case section whether or not that case matches. This can be a source of bugs, but is sometimes useful. One example is to have a single case section that is executed for several different cases. For example,

switch (backgroundColor) {

case ColorDarkBlue:

case ColorBlack:

// Code to execute for both a dark blue or black background color

break;

case ColorRed:

// Code to execute for a red background color

break;

}

switch statements are generally used when you want to do something based on the specific value of an expression, as opposed to some test on the expression.

The Conditional Operator

C++ has one operator that takes three arguments, known as a ternary operator. It is used as a shorthand conditional expression of the form “if [something] then [perform action], otherwise [perform some other action].” The conditional operator is represented by a? and a :. The following code will output “yes” if the variable i is greater than 2, and “no” otherwise.

std::cout << ((i > 2) ? "yes" : "no");

The advantage of the conditional operator is that it can occur within almost any context. In the preceding example, the conditional operator is used within code that performs output. A convenient way to remember how the syntax is used is to treat the question mark as though the statement that comes before it really is a question. For example, “Is i greater than 2? If so, the result is ‘yes’: if not, the result is ‘no.’”

Unlike an if statement or a switch statement, the conditional operator doesn’t execute code blocks based on the result. Instead, it is used within code, as shown in the preceding example. In this way, it really is an operator (like + and -) as opposed to a true conditional, such as if and switch.

Logical Evaluation Operators

You have already seen a logical evaluation operator without a formal definition. The > operator compares two values. The result is “true” if the value on the left is greater than the value on the right. All logical evaluation operators follow this pattern — they all result in a true or false.

The following table shows common logical evaluation operators (op):

C++ uses short-circuit logic when evaluating logical expressions. That means that once the final result is certain, the rest of the expression won’t be evaluated. For example, if you are performing a logical OR operation of several Boolean expressions, as shown below, the result is known to be true as soon as one of them is found to be true. The rest won’t even be checked.

bool result = bool1 || bool2 || (i > 7) || (27 / 13 % i + 1) < 2;

In this example, if bool1 is found to be true, the entire expression must be true, so the other parts aren’t evaluated. In this way, the language saves your code from doing unnecessary work. It can, however, be a source of hard-to-find bugs if the later expressions in some way influence the state of the program (for example, by calling a separate function). The following code shows a statement using && that will short-circuit after the second term because 0 always evaluates to false:

bool result = bool1 && 0 && (i > 7) && !done;

Arrays

Arrays hold a series of values, all of the same type, each of which can be accessed by its position in the array. In C++, you must provide the size of the array when the array is declared. You cannot give a variable as the size — it must be a constant, or a constant expression (constexpr), discussed in Chapter 10. The code that follows shows the declaration of an array of three integers followed by three lines to initialize the elements to 0:

int myArray[3];

myArray[0] = 0;

myArray[1] = 0;

myArray[2] = 0;

The next section discusses loops which you can use to initialize each element. However, instead of using loops, or using the previous initialization mechanism, you can also accomplish the zero-initialization with the following one-liner:

int myArray[3] = {0};

Note that this is only possible if you want to initialize all values to zero. For example, the following line fills only the first element in the array with the value 2 and fills all the other elements in the array with the value 0:

int myArray[3] = {2};

An array can also be initialized with an initializer list, in which case the compiler can deduce the size of the array automatically. For example:

int arr[] = {1, 2, 3, 4}; // The compiler creates an array of 4 elements.

The preceding examples show a one-dimensional array, which you can think of as a line of integers, each with its own numbered compartment. C++ allows multi-dimensional arrays. You might think of a two-dimensional array as a checkerboard, where each location has a position along the x-axis and a position along the y-axis. Three-dimensional and higher arrays are harder to picture and are rarely used. The following code shows the syntax for allocating a two-dimensional array of characters for a Tic-Tac-Toe board and then putting an “o” in the center square:

char ticTacToeBoard[3][3];

ticTacToeBoard[1][1] = 'o';

Figure 1-1 shows a visual representation of this board with the position of each square.

FIGURE 1-1

WARNING In C++, the first element of an array is always at position 0, not position 1! The last position of the array is always the size of the array minus 1!

std::array

The arrays discussed in the previous section come from C, and still work in C++. However, C++ has a special type of fixed-size container called std::array, defined in the <array> header file. It’s basically a thin wrapper around C-style arrays.

There are a number of advantages in using std::arrays instead of C-style arrays. They always know their own size, do not automatically get cast to a pointer to avoid certain types of bugs, and have iterators to easily loop over the elements. Iterators are briefly discussed later in this chapter and are discussed in detail in Chapter 16.

The following example demonstrates how to use the array container. The angle brackets after array, as in array<int, 3>, will become clear during the discussion of templates in Chapter 11. For its use with array, it suffices to remember that you have to specify 2 parameters between the angle brackets. The first represents the type of the elements in the array, and the second represents the size of the array.

#include <iostream>

#include <array>

using namespace std;

int main()

{

array<int, 3> arr = {9, 8, 7};

cout << "Array size = " << arr.size() << endl;

cout << "Element 2 = " << arr[1] << endl;

return 0;

}

NOTE Both the C-style arrays and the std::arrays have a fixed size, which should be known at compile time. They cannot grow or shrink at run time.

If you want an array with a dynamic size, it’s recommended to use std::vector, explained later in this chapter. A vector automatically grows in size when you add new elements to it.

Loops

Computers are great for doing the same thing over and over. C++ provides four looping mechanisms: the while loop, do/while loop, for loop, and range-based for loop.

The while Loop

The while loop lets you perform a block of code repeatedly as long as an expression evaluates to true. For example, the following completely silly code will output “This is silly.” five times:

int i = 0;

while (i < 5) {

std::cout << "This is silly." << std::endl;

++i;

}

The keyword break can be used within a loop to immediately get out of the loop and continue execution of the program. The keyword continue can be used to return to the top of the loop and reevaluate the while expression. Both are often considered poor style because they cause the execution of a program to jump around somewhat haphazardly, so they should be used sparingly. The only place where you have to use break is in the context of the switch statement, as seen earlier.

The do/while Loop

C++ also has a variation on the while loop called do/while. It works similarly to the while loop, except that the code to be executed comes first, and the conditional check for whether or not to continue happens at the end. In this way, you can use a loop when you want a block of code to always be executed at least once and possibly additional times based on some condition. The example that follows will output “This is silly.” once even though the condition will end up being false:

int i = 100;

do {

std::cout << "This is silly." << std::endl;

++i;

} while (i < 5);

The for Loop

The for loop provides another syntax for looping. Any for loop can be converted to a while loop and vice versa. However, the for loop syntax is often more convenient because it looks at a loop in terms of a starting expression, an ending condition, and a statement to execute at the end of every iteration. In the following code, i is initialized to 0; the loop will continue as long as i is less than 5; and at the end of every iteration, i is incremented by 1. This code does the same thing as the while loop example, but is more readable because the starting value, ending condition, and per-iteration statement are all visible on one line.

for (int i = 0; i < 5; ++i) {

std::cout << "This is silly." << std::endl;

}

The Range-Based for Loop

The range-based for loop is a fourth looping mechanism. It allows for easy iteration over elements of a container. This type of loop works for C-style arrays, initializer lists (discussed in Chapter 10), and any type that has a begin() and end() method returning iterators, such as std::array and all other STL containers discussed in Chapter 16.

The following example first defines an array of four integers. The range-based for loop then iterates over a copy of every element in this array and prints each value. To iterate over the elements themselves without making copies, use a reference variable, discussed later in this chapter.

std::array<int, 4> arr = {1, 2, 3, 4};

for (int i : arr) {

std::cout << i << std::endl;

}

Functions

For programs of any significant size, placing all the code inside of main() is unmanageable. To make programs easy to understand, you need to break up, or decompose, code into concise functions.

In C++, you first declare a function to make it available for other code to use. If the function is used inside only a particular file, you generally declare and define the function in the source file. If the function is for use by other modules or files, you generally put the declaration in a header file and the definition in a source file.

NOTE Function declarations are often called “function prototypes” or “signatures” to emphasize that they represent how the function can be accessed, but not the code behind it.

A function declaration is shown below. This example has a return type of void, indicating that the function does not provide a result to the caller. The caller must provide two arguments for the function to work with — an integer and a character.

void myFunction(int i, char c);

Without an actual definition to match this function declaration, the link stage of the compilation process will fail because code that makes use of the function will be calling nonexistent code. The following definition prints the values of the two parameters:

void myFunction(int i, char c)

{

std::cout << "the value of i is " << i << std::endl;

std::cout << "the value of c is " << c << std::endl;

}

Elsewhere in the program, you can make calls to myFunction() and pass in arguments for the two parameters. Some sample function calls are shown here:

myFunction(8, 'a');

myFunction(someInt, 'b');

myFunction(5, someChar);

NOTE In C++, unlike C, a function that takes no parameters just has an empty parameter list. It is not necessary to use void to indicate that no parameters are taken. However, you must still use void to indicate when no value is returned.

C++ functions can also return a value to the caller. The following function adds two numbers and returns the result:

int addNumbers(int number1, int number2)

{

return number1 + number2;

}

This function can be called as follows:

int sum = addNumbers(5, 3);

Every function has a local predefined variable __func__ that looks as follows:

static const char __func__[] = "function-name";

This variable can for example be used for logging purposes:

int addNumbers(int number1, int number2)

{

std::cout << "Entering function " << __func__ << std::endl;

return number1 + number2;

}

Alternative Function Syntax

C++ is still using the function syntax as it was designed for C. In the meantime, C++ has been extended with quite a lot of new functionality and this exposed a number of problems with the old function syntax. Since C++11, an alternative function syntax is supported with a trailing return type. This new syntax is not of much use for ordinary functions, but is very useful in the context of specifying the return type of template functions. Templates are studied in detail in Chapters 11 and 21.

The following example demonstrates the alternative function syntax. The auto keyword in this context has the meaning of starting a function prototype using the alternative function syntax.

auto func(int i) -> int

{

return i + 2;

}

The return type of the function is no longer at the beginning, but placed at the end of the line after the arrow, ->. The following code demonstrates that calling func() remains exactly the same and shows that the main() function can also use this alternative syntax:

auto main() -> int

{

cout << func(3) << endl;

return 0;

}

Function Return Type Deduction

C++14 allows you to ask the compiler to figure out the return type of a function automatically. To make use of this functionality, you need to specify auto as the return type and omit any trailing return type:

auto divideNumbers(double numerator, double denominator)

{

if (denominator == 0) { /* ... */ }

return numerator / denominator;

}

The compiler deduces the return type based on the expressions used for the return statements. There can be multiple return statements in the function, but they should all resolve to the same type. Such a function can even include recursive calls (calls to itself), but the first return statement in the function must be a non-recursive call.

Type Inference Part 1

Type inference allows the compiler to automatically deduce the type of an expression. There are two keywords for type inference: auto and decltype, which are discussed in the next two sections.

C++14 adds decltype(auto) to the mix, discussed in the section “Type Inference Part 2” later in the chapter because you need to learn about references first before you can understand decltype(auto).

The auto Keyword

The auto keyword has four completely different meanings. The first meaning is to tell the compiler to automatically deduce the type of a variable at compile time. The following line shows the simplest use of the auto keyword in that context:

auto x = 123; // x will be of type int

In this example you don’t win much by typing auto instead of int; however, it becomes useful for more complicated types. Suppose you have a function called getFoo() that has a complicated return type. If you want to assign the result of the call to a variable, you can spell out the complicated type, or you can simply use auto and let the compiler figure it out:

auto result = getFoo();

More concrete examples of the auto keyword will pop up throughout the book.

The second use of the auto keyword is for the alternative function syntax, explained earlier.

The third use of the auto keyword is for function return type deduction, also discussed earlier. Lastly, a fourth use of auto is for generic lambda expressions, discussed in Chapter 17.

The decltype Keyword

The decltype keyword takes an expression as argument, and computes the type of that expression. For example:

int x = 123;

decltype(x) y = 456;

In this example, the compiler deduces the type of y to be int because that’s the type of x. Like the auto keyword for the alternative function syntax, the decltype keyword doesn’t seem to add much value on first sight. However, in the context of templates, discussed in Chapter 11 and 21, auto and decltype become pretty powerful.

Those Are the Basics

At this point, you have reviewed the basic essentials of C++ programming. If this section was a breeze, skim the next section to make sure that you’re up to speed on the more-advanced material. If you struggled with this section, you may want to obtain one of the fine introductory C++ books mentioned in Appendix B before continuing.

DIVING DEEPER INTO C++

Loops, variables, and conditionals are terrific building blocks, but there is much more to learn. The topics covered next include many features designed to help C++ programmers with their code as well as a few features that are often more confusing than helpful. If you are a C programmer with little C++ experience, you should read this section carefully.

Pointers and Dynamic Memory

Dynamic memory allows you to build programs with data that is not of fixed size at compile time. Most nontrivial programs make use of dynamic memory in some form.

The Stack and the Heap

Memory in your C++ application is divided into two parts — the stack and the heap. One way to visualize the stack is as a deck of cards. The current top card represents the current scope of the program, usually the function that is currently being executed. All variables declared inside the current function will take up memory in the top stack frame, the top card of the deck. If the current function, which I’ll call foo() calls another function bar(), a new card is put on the deck so that bar() has its own stack frame to work with. Any parameters passed from foo() to bar() are copied from the foo() stack frame into the bar() stack frame. Figure 1-2 shows what the stack might look like during the execution of a hypothetical function foo() that has declared two integer values.

FIGURE 1-2

Stack frames are nice because they provide an isolated memory workspace for each function. If a variable is declared inside the foo() stack frame, calling the bar() function won’t change it unless you specifically tell it to. Also, when the foo() function is done running, the stack frame goes away, and all of the variables declared within the function no longer take up memory. Variables that are stack-allocated do not need to be deallocated (deleted) by the programmer; it happens automatically.

The heap is an area of memory that is completely independent of the current function or stack frame. You can put variables on the heap if you want them to exist even when the function in which they were created has completed. The heap is less structured than the stack. You can think of it as just a pile of bits. Your program can add new bits to the pile at any time or modify bits that are already in the pile. You have to make sure that you deallocate (delete) any memory that you allocated on the heap. This does not happen automatically, unless you use smart pointers, discussed in a next section.

Working with Pointers

You can put anything on the heap by explicitly allocating memory for it. For example, to put an integer on the heap, you need to allocate memory for it, but first you need to declare a pointer:

int* myIntegerPointer;

The * after the int type indicates that the variable you are declaring refers/points to some integer memory. Think of the pointer as an arrow that points at the dynamically allocated heap memory. It does not yet point to anything specific because you haven’t assigned it to anything; it is an uninitialized variable. Uninitialized variables should be avoided at all times, and especially uninitialized pointers because they point to some random place in memory. Working with such pointers most likely will make your program crash. That’s why you should always declare and initialize your pointers at the same time. You can initialize them to a null pointer (nullptr) if you don’t want to allocate memory right away:

int* myIntegerPointer = nullptr;

You use the new operator to allocate the memory:

myIntegerPointer = new int;

In this case, the pointer points to the address of just a single integer value. To access this value, you need to dereference the pointer. Think of dereferencing as following the pointer’s arrow to the actual value in the heap. To set the value of the newly allocated heap integer, you would use code like the following:

*myIntegerPointer = 8;

Notice that this is not the same as setting myIntegerPointer to the value 8. You are not changing the pointer; you are changing the memory that it points to. If you were to reassign the pointer value, it would point to the memory address 8, which is probably random garbage that will eventually make your program crash.

After you are finished with your dynamically allocated memory, you need to deallocate the memory using the delete operator. To prevent the pointer from being used after having deallocated the memory it points to, it’s recommended to set your pointer to nullptr:

delete myIntegerPointer;

myIntegerPointer = nullptr;

WARNING A pointer must be valid before dereferencing it. A null or uninitialized pointer will cause a crash if dereferenced.

Pointers don’t always point to heap memory. You can declare a pointer that points to a variable on the stack, even another pointer. To get a pointer to a variable, you use the & “address of” operator:

int i = 8;

int* myIntegerPointer = &i; // Points to the variable with the value 8

C++ has a special syntax for dealing with pointers to structures. Technically, if you have a pointer to a structure, you can access its fields by first dereferencing it with *, then using the normal . syntax, as in the code that follows, which assumes the existence of a function called getEmployee().

Employee* anEmployee = getEmployee();

cout << (*anEmployee).salary << endl;

This syntax is a little messy. The -> (arrow) operator lets you perform both the dereference and the field access in one step. The following code is equivalent to the preceding code, but is easier to read:

Employee* anEmployee = getEmployee();

cout << anEmployee->salary << endl;

Normally, when you pass a variable into a function, you are passing by value. If a function takes an integer parameter, it is really a copy of the integer that you pass in. Pointers to stack variables are often used in C to allow functions to modify variables in other stack frames, essentially passing by reference. By dereferencing the pointer, the function can change the memory that represents the variable even though that variable isn’t in the current stack frame. This is less common in C++, because C++ has a better mechanism, called references, which is covered later in this chapter.

Dynamically Allocated Arrays

The heap can also be used to dynamically allocate arrays. You use the new[] operator to allocate memory for an array:

int arraySize = 8;

int* myVariableSizedArray = new int[arraySize];

This allocates memory for enough integers to satisfy the arraySize variable. Figure 1-3 shows what the stack and the heap both look like after this code is executed. As you can see, the pointer variable still resides on the stack, but the array that was dynamically created lives on the heap.

FIGURE 1-3

Now that the memory has been allocated, you can work with myVariableSizedArray as though it were a regular stack-based array:

myVariableSizedArray[3] = 2;

When your code is done with the array, it should remove it from the heap so that other variables can use the memory. In C++, you use the delete[] operator to do this.

delete[] myVariableSizedArray;

The brackets after delete indicate that you are deleting an array!

NOTE Avoid using malloc() and free() from C. Instead, use new and delete, or new[] and delete[].

WARNING To prevent memory leaks, every call to new should be paired with a call to delete, and every call to new[] should be paired with a call to delete[]. Pairing a new[] with a delete also causes a memory leak. Memory leaks are discussed in Chapter 22.

Null Pointer Constant

Before C++11, the constant 0 was used to define either the number 0 or a null pointer. This can cause some problems. Take the following example:

void func(char* str) {cout << "char* version" << endl;}

void func(int i) {cout << "int version" << endl;}

int main()

{

func(NULL);

return 0;

}

The main() function is calling func() with parameter NULL, which is supposed to be a null pointer constant. In other words, you are expecting the char* version of func() to be called with a null pointer as argument. However, since NULL is not a pointer, but identical to the integer 0, the integer version of func() is called.

This problem is solved with the introduction of a real null pointer constant, nullptr. The following code calls the char* version.

func(nullptr);

Smart Pointers

To avoid common memory problems, you should use smart pointers instead of normal “naked” C-style pointers. Smart pointers automatically deallocate memory when the smart pointer object goes out of scope, for example when the function has finished executing.

There are three smart pointer types in C++: std::unique_ptr, std::shared_ptr and std::weak_ptr, all defined in the <memory> header. The unique_ptr is analogous to an ordinary pointer, except that it will automatically free the memory or resource when the unique_ptrgoes out of scope or is deleted. A unique_ptr has sole ownership of the object pointed to. One advantage of the unique_ptr is that it simplifies coding where storage must be freed when an exceptional situation occurs. When the smart pointer variable leaves its scope, the storage is automatically freed. You can also store a C-style array in a unique_ptr. Use std::make_unique<>() to create a unique_ptr.

For example, instead of writing the following:

Employee* anEmployee = new Employee;

You should write:

auto anEmployee = std::make_unique<Employee>();

make_unique() is available since C++14. If your compiler is not yet C++14 compliant you can make your unique_ptr as follows. Note that you now have to specify the type, Employee, twice:

std::unique_ptr<Employee> anEmployee(new Employee);

You can use the anEmployee smart pointer the same way as a normal pointer.

unique_ptr is a generic smart pointer that can point to any kind of memory. That’s why it is a template. Templates require the angle brackets to specify the template parameters. Between the brackets you have to specify the type of memory you want your unique_ptr to point to. Templates are discussed in detail in Chapters 11 and 21, but the smart pointers are introduced in the beginning of the book so that they can be used throughout the book, and as you can see, they are easy to use.

shared_ptr allows for distributed “ownership” of the data. Each time a shared_ptr is assigned, a reference count is incremented indicating there is one more “owner” of the data. When a shared_ptr goes out of scope, the reference count is decremented. When the reference count goes to zero it means there is no longer any owner of the data, and the object referenced by the pointer is freed. You cannot store an array in a shared_ptr. Use std::make_shared<>() to create a shared_ptr.

You can use weak_ptr to observe a shared_ptr without incrementing or decrementing the reference count of the linked shared_ptr.

Chapter 22 discusses these smart pointers in detail, but because the basic use is straightforward, they are already used throughout examples in the book.

NOTE Naked, plain old pointers are only allowed if there is no ownership involved. Otherwise, use unique_ptr by default, and shared_ptr if you need shared ownership. If you know about auto_ptr, forget it because the C++ standard has deprecated it.

References

The pattern for most functions is that they take in zero or more parameters, do some calculations, and return a single result. Sometimes, however, that pattern is broken. You may be tempted to return two values, or you may want the function to be able to change the value of one of the variables that were passed in.

In C, the primary way to accomplish such behavior is to pass in a pointer to the variable instead of the variable itself. The only problem with this approach is that it brings the messiness of pointer syntax into what is really a simple task. In C++, there is an explicit mechanism for “pass-by-reference.” Attaching & to a type indicates that the variable is a reference. It is still used as though it was a normal variable, but behind the scenes, it is really a pointer to the original variable. Below are two implementations of an addOne()function. The first will have no effect on the variable that is passed in because it is passed by value. The second uses a reference and thus changes the original variable.

void addOne(int i)

{

i++; // Has no real effect because this is a copy of the original

}

void addOne(int& i)

{

i++; // Actually changes the original variable

}

The syntax for the call to the addOne() function with an integer reference is no different than if the function just took an integer.

int myInt = 7;

addOne(myInt);

NOTE There is a subtle difference between the two addOne() implementations. The version using pass-by-value will accept constants without a problem; for example “addOne(3);” is legal. However, doing the same with the pass-by-reference version ofaddOne() will result in a compiler error. This can be solved by using rvalue references, which is an advanced C++ feature explained in Chapter 10.

Strings in C++

There are three ways to work with strings of text in C++: the C-style, which represents strings as arrays of characters; the C++ style, which wraps that representation in an easier-to-use string type; and the general class of nonstandard approaches. Chapter 2 provides a detailed discussion.

For now, the only thing you need to know is that the C++ string type is defined in the <string> header file, and that you can use a C++ string almost like a basic type. Just like I/O streams, the string type lives in the std namespace. The example that follows shows how strings can be used just like character arrays.

std::string myString = "Hello, World";

cout << "The value of myString is " << myString << endl;

Exceptions

C++ is a very flexible language, but not a particularly safe one. The compiler will let you write code that scribbles on random memory addresses or tries to divide by zero (computers don’t deal well with infinity). One of the language features that attempts to add a degree of safety back to the language is exceptions.

An exception is an unexpected situation. For example, if you are writing a function that retrieves a web page, several things could go wrong. The Internet host that contains the page might be down, the page might come back blank, or the connection could be lost. One way you could handle this situation is by returning a special value from the function, such as nullptr or an error code. Exceptions provide a much better mechanism for dealing with problems.

Exceptions come with some new terminology. When a piece of code detects an exceptional situation, it throws an exception. Another piece of code catches the exception and takes appropriate action. The following example shows a function, divideNumbers(), that throws an exception if the caller passes in a denominator of zero:

#include <stdexcept>

double divideNumbers(double numerator, double denominator)

{

if (denominator == 0) {

throw std::invalid_argument("Denominator cannot be 0.");

}

return numerator / denominator;

}

When the throw line is executed, the function immediately ends without returning a value. If the caller surrounds the function call with a try/catch block, as shown in the following code, it receives the exception and is able to handle it.

#include <iostream>

#include <exception>

int main()

{

try {

std::cout << divideNumbers(2.5, 0.5) << std::endl;

std::cout << divideNumbers(2.3, 0) << std::endl;

std::cout << divideNumbers(4.5, 2.5) << std::endl;

} catch (const std::exception& exception) {

std::cout << "Exception caught: " << exception.what() << std::endl;

}

return 0;

}

The first call to divideNumbers() executes successfully, and the result is output to the user. The second call throws an exception. No value is returned, and the only output is the error message that is printed when the exception is caught. The third call is never executed because the second call throws an exception causing the program to jump to the catch block. The output for the preceding block of code is:

5

An exception was caught: Denominator cannot be 0.

Exceptions can get tricky in C++. To use exceptions properly, you need to understand what happens to the stack variables when an exception is thrown, and you have to be careful to properly catch and handle the necessary exceptions. The preceding example used the built-in std::invalid_argument type, but it is preferable to write your own exception types that are more specific to the error being thrown. Unlike the Java language, the C++ compiler doesn’t force you to catch every exception that might occur. If your code never catches any exceptions but an exception is thrown, it will be caught by the program itself, which will be terminated. These trickier aspects of exceptions are covered in much more detail in Chapter 13.

The Many Uses of const

The keyword const can be used in several different ways in C++. All of its uses are related, but there are subtle differences. The subtleties of const make for excellent interview questions! Chapter 10 explains in detail all the ways that const can be used. The following sections outline the most frequent uses.

const Constants

If you assumed that the keyword const has something to do with constants, you have correctly uncovered one of its uses. In the C language, programmers often use the preprocessor #define mechanism to declare symbolic names for values that won’t change during the execution of the program, such as the version number. In C++, programmers are encouraged to avoid #define in favor of using const to define constants. Defining a constant with const is just like defining a variable, except that the compiler guarantees that code cannot change the value.

const float versionNumber = 2.0f;

const std::string productName = "Super Hyper Net Modulator";

const to Protect Parameters

In C++, you can cast a non-const variable to a const variable. Why would you want to do this? It offers some degree of protection from other code changing the variable. If you are calling a function that a coworker of yours is writing, and you want to ensure that the function doesn’t change the value of a parameter you pass in, you can tell your coworker to have the function take a const parameter. If the function attempts to change the value of the parameter, it will not compile.

In the following code, a string* is automatically cast to a const string* in the call to mysteryFunction(). If the author of mysteryFunction() attempts to change the value of the passed string, the code will not compile. There are ways around this restriction, but using them requires conscious effort. C++ only protects against accidentally changing const variables.

void mysteryFunction(const std::string* someString)

{

*someString = "Test"; // Will not compile.

}

int main()

{

std::string myString = "The string";

mysteryFunction(&myString);

return 0;

}

const References

You will often find code that uses const reference parameters. At first, that seems like a contradiction. Reference parameters allow you to change the value of a variable from within another context. const seems to prevent such changes.

The main value in const reference parameters is efficiency. When you pass a value into a function, an entire copy is made. When you pass a reference, you are really just passing a pointer to the original so the computer doesn’t need to make the copy. By passing aconst reference, you get the best of both worlds — no copy is made but the original variable cannot be changed.

const references become more important when you are dealing with objects because they can be large and making copies of them can have unwanted side effects. Subtle issues like this are covered in Chapter 10. The following example shows how to pass a std::stringto a function as a const reference:

void printString(const std::string& myString)

{

std::cout << myString << std::endl;

}

int main()

{

std::string someString = "Hello World";

printString(someString);

return 0;

}

Type Inference Part 2

Now that you know about references, const, and std::string, it’s time to revisit type inference with a discussion of decltype(auto).

decltype(auto)

Using auto to deduce the type of an expression strips away reference qualifiers and const qualifiers. decltype does not strip those but might cause code duplication. C++14 solves this by introducing decltype(auto).

For example, suppose you have the following function:

const string message = "Test";

const string& foo()

{

return message;

}

You can call foo() and store the result in a variable with the type specified as auto as follows:

auto f1 = foo();

Because auto strips reference and const qualifiers, f1 is of type string, and thus a copy is made. If you want f1 to be a const reference, you can explicitly make it a reference and mark it const as follows:

const auto& f1 = foo();

An alternative solution is to use decltype, which does not strip anything:

decltype(foo()) f2 = foo();

In this case, f2 is of type const string&; however, there is code duplication because you need to specify foo() twice, which can be cumbersome when foo() is a more complicated expression.

The solution in C++14 is as follows:

decltype(auto) f3 = foo();

f3 is also of type const string&.

C++ AS AN OBJECT-ORIENTED LANGUAGE

If you are a C programmer, you may have viewed the features covered so far in this chapter as convenient additions to the C language. As the name C++ implies, in many ways the language is just a “better C.” There is one major point that this view overlooks. Unlike C, C++ is an object-oriented language.

Object-oriented programming (OOP) is a very different, arguably more natural, way to write code. If you are used to procedural languages such as C or Pascal, don’t worry. Chapter 5 covers all the background information you need to know to shift your mindset to the object-oriented paradigm. If you already know the theory of OOP, the rest of this section will get you up to speed (or refresh your memory) on basic C++ object syntax.

Defining a Class

A class defines the characteristics of an object. In C++, classes are usually defined in a header file (.h), while the definitions of its non-inline methods and of any static data members is in a corresponding source file (.cpp).

A basic class definition for an airline ticket class is shown below. The class can calculate the price of the ticket based on the number of miles in the flight and whether or not the customer is a member of the “Elite Super Rewards Program.” The definition begins by declaring the class name. Inside a set of curly braces, the data members (properties) of the class and its methods (behaviors) are declared. Each data member and method is associated with a particular access level: public, protected, or private. These labels can occur in any order and can be repeated. Members that are public can be accessed from outside the class, while members that are private cannot be accessed from outside the class. It’s recommended to make all your data members private, and if needed, give access to them with public getters and setters. This way you can easily change the representation of your data while keeping the public interface the same.

#include <string>

class AirlineTicket

{

public:

AirlineTicket();

~AirlineTicket();

int calculatePriceInDollars() const;

const std::string& getPassengerName() const;

void setPassengerName(const std::string& name);

int getNumberOfMiles() const;

void setNumberOfMiles(int miles);

bool getHasEliteSuperRewardsStatus() const;

void setHasEliteSuperRewardsStatus(bool status);

private:

std::string mPassengerName;

int mNumberOfMiles;

bool mHasEliteSuperRewardsStatus;

};

The method that has the same name as the class with no return type is a constructor. It is automatically called when an object of the class is created. The method with a tilde (~) character followed by the class name is a destructor. It is automatically called when the object is destroyed.

NOTE To follow the const-correctness principle, it’s always a good idea to declare member functions that do not change any data member of the object as being const. These member functions are also called “inspectors,” compared to “mutators” for non-const member functions.

The definitions of some of the AirlineTicket class methods are shown below.

AirlineTicket::AirlineTicket()

{

// Initialize data members

mHasEliteSuperRewardsStatus = false;

mPassengerName = "Unknown Passenger";

mNumberOfMiles = 0;

}

AirlineTicket::~AirlineTicket()

{

// Nothing much to do in terms of cleanup

}

int AirlineTicket::calculatePriceInDollars() const

{

if (getHasEliteSuperRewardsStatus()) {

// Elite Super Rewards customers fly for free!

return 0;

}

// The cost of the ticket is the number of miles times

// 0.1. Real airlines probably have a more complicated formula!

return static_cast<int>(getNumberOfMiles() * 0.1);

}

const string& AirlineTicket::getPassengerName() const

{

return mPassengerName;

}

void AirlineTicket::setPassengerName(const string& name)

{

mPassengerName = name;

}

// Other get and set methods omitted for brevity.

The sample program that follows makes use of the AirlineTicket class. This example shows the creation of a stack-based AirlineTicket object as well as a heap-based object.

AirlineTicket myTicket; // Stack-based AirlineTicket

myTicket.setPassengerName("Sherman T. Socketwrench");

myTicket.setNumberOfMiles(700);

int cost = myTicket.calculatePriceInDollars();

cout << "This ticket will cost $" << cost << endl;

// Heap-based AirlineTicket with smart pointer

auto myTicket2 = make_unique<AirlineTicket>();

myTicket2->setPassengerName("Laudimore M. Hallidue");

myTicket2->setNumberOfMiles(2000);

myTicket2->setHasEliteSuperRewardsStatus(true);

int cost2 = myTicket2->calculatePriceInDollars();

cout << "This other ticket will cost $" << cost2 << endl;

// No need to delete myTicket2, happens automatically

// Heap-based AirlineTicket without smart pointer (not recommended)

AirlineTicket* myTicket3 = new AirlineTicket();

// ... Use ticket 3

delete myTicket3; // delete the heap object!

The preceding example exposes you to the general syntax for creating and using classes. Of course, there is much more to learn. Chapters 7, 8, and 9 go into more depth about the specific C++ mechanisms for defining classes.

THE STANDARD LIBRARY

C++ comes with a standard library, which contains a lot of useful classes that can easily be used in your code. The benefit of using classes from the standard library is that you don’t need to reinvent certain classes and you don’t need to waste time on implementing things that have already been implemented for you. Another benefit is that the classes available in the standard library are heavily tested and verified for correctness by thousands of users. The standard library classes are also tuned for high performance, so using them will most likely result in better performance compared to making your own implementation.

The amount of functionality available to you in the standard library is pretty big. Chapter 15 and later chapters provide more details about the standard library. When you start working with C++ it is a good idea to understand what the standard library can do for you from the very beginning. This is especially important if you are a C programmer. As a C programmer, you might try to solve problems in C++ the same way you would solve them in C. However, in C++ there is probably an easier and safer solution to the problem by using standard library classes.

You already saw some standard library classes earlier in this chapter; for example, std::string, std::array, and the std::unique_ptr smart pointer.

std::vector

Another example of functionality provided by the standard library is the concept of containers, which is used further in this chapter. Take std::vector as an example, declared in <vector>. The vector replaces the concept of C arrays with a much more flexible and safer mechanism. As a user, you need not worry about memory management, as the vector will automatically allocate enough memory to hold its elements. A vector is dynamic, meaning that elements can be added and removed at run time. To make it easy to loop over the contents of containers, the standard library provides a concept called iterators. Chapter 16 goes into more detail regarding containers and iterators, but the basic use is straightforward, which is why it’s introduced in the beginning of the book so that it can be used in examples. The following example demonstrates the basic functionality of the std::vector class and the concept of iterators.

#include <string>

#include <vector>

#include <iostream>

#include <iterator>

using namespace std;

int main()

{

// Create a vector of strings, using uniform initialization

vector<string> myVector = {"A first string", "A second string"};

// Add some strings to the vector using push_back

myVector.push_back("A third string");

myVector.push_back("The last string in the vector");

// Print the elements using a range-based for loop

for (const auto& str : myVector)

cout << str << endl;

// Iterate over the elements in the vector and print them once more

for (auto iterator = cbegin(myVector);

iterator != cend(myVector); ++iterator) {

cout << *iterator << endl;

}

return 0;

}

myVector is declared as vector<string>. The angle brackets are required to specify the template parameters, just as with std::unique_ptr earlier in this chapter. A vector is a generic container. It can contain almost any kind of object; that’s why you have to specify the type of object you want in your vector between those brackets. Templates are discussed in detail in Chapters 11 and 21.

To add elements to the vector, you can use uniform initialization, discussed in detail in Chapter 10, or the push_back() method. Because the type of the iterator variable is auto and because cbegin() is used to initialize the iterator, the compiler automatically deduces its type as vector<string>::const_iterator.

YOUR FIRST USEFUL C++ PROGRAM

The following program builds on the employee database example used earlier when discussing structs. This time, you will end up with a fully functional C++ program that uses many of the features discussed in this chapter. This real-world example includes the use of classes, exceptions, streams, vectors, iterators, namespaces, references, and other language features.

An Employee Records System

A program to manage a company’s employee records needs to be flexible and have useful features. The feature set for this program includes the following:

· The ability to add an employee

· The ability to fire an employee

· The ability to promote an employee

· The ability to view all employees, past and present

· The ability to view all current employees

· The ability to view all former employees

The design for this program divides the code into three parts. The Employee class encapsulates the information describing a single employee. The Database class manages all the employees of the company. A separate UserInterface file provides the interactivity of the program.

The Employee Class

The Employee class maintains all the information about an employee. Its methods provide a way to query and change that information. Employees also know how to display themselves on the console. Methods also exist to adjust the employee’s salary and employment status.

Employee.h

The Employee.h file defines the Employee class. The sections of this file are described individually in the material that follows.

The first line contains a #pragma once to prevent the file from being included multiple times, followed by the inclusion of the string functionality.

This code also declares that the subsequent code, contained within the curly braces, lives in the Records namespace. Records is the namespace that is used throughout this program for application-specific code.

#pragma once

#include <string>

namespace Records {

The following constant, representing the default starting salary for new employees, lives in the Records namespace. Other code that lives in Records can access this constant as kDefaultStartingSalary. Elsewhere, it must be referenced as Records::kDefaultStartingSalary.

const int kDefaultStartingSalary = 30000;

The Employee class is defined, along with its public methods. The promote() and demote() methods both have integer parameters that are specified with a default value. In this way, other code can omit the integer parameters and the default will automatically be used.

A number of setters and getters provide mechanisms to change the information about an employee or to query the current information about an employee.

class Employee

{

public:

Employee();

void promote(int raiseAmount = 1000);

void demote(int demeritAmount = 1000);

void hire(); // Hires or rehires the employee

void fire(); // Dismisses the employee

void display() const;// Outputs employee info to console

// Getters and setters

void setFirstName(const std::string& firstName);

const std::string& getFirstName() const;

void setLastName(const std::string& lastName);

const std::string& getLastName() const;

void setEmployeeNumber(int employeeNumber);

int getEmployeeNumber() const;

void setSalary(int newSalary);

int getSalary() const;

bool getIsHired() const;

Finally, the data members are declared as private so that other parts of the code cannot modify them directly. The setters and getters provide the only public way of modifying or querying these values.

private:

std::string mFirstName;

std::string mLastName;

int mEmployeeNumber;

int mSalary;

bool mHired;

};

}

Employee.cpp

This section discusses the implementations for the Employee member functions. The Employee constructor sets the initial values for the Employee’s data members. By default, new employees have no name, an employee number of -1, the default starting salary, and a status of not hired. This constructor implementation shows a second mechanism to initialize class member variables. You can either put the initialization between the curly braces in the body of the constructor, or you can use a constructor initializer, which follows a colon after the constructor name.

#include <iostream>

#include "Employee.h"

using namespace std;

namespace Records {

Employee::Employee()

: mFirstName("")

, mLastName("")

, mEmployeeNumber(-1)

, mSalary(kDefaultStartingSalary)

, mHired(false)

{

}

The promote() and demote() methods simply call the setSalary() method with a new value. Note that the default values for the integer parameters do not appear in the source file; they are only allowed in a function declaration, not in a definition.

void Employee::promote(int raiseAmount)

{

setSalary(getSalary() + raiseAmount);

}

void Employee::demote(int demeritAmount)

{

setSalary(getSalary() - demeritAmount);

}

The hire() and fire() methods just set the mHired data member appropriately.

void Employee::hire()

{

mHired = true;

}

void Employee::fire()

{

mHired = false;

}

The display() method uses the console output stream to display information about the current employee. Because this code is part of the Employee class, it could access data members, such as mSalary, directly instead of using getSalary(). However, it is considered good style to make use of getters and setters when they exist, even within the class.

void Employee::display() const

{

cout << "Employee: " << getLastName() << ", " << getFirstName() << endl;

cout << "-------------------------" << endl;

cout << (mHired ? "Current Employee" : "Former Employee") << endl;

cout << "Employee Number: " << getEmployeeNumber() << endl;

cout << "Salary: $" << getSalary() << endl;

cout << endl;

}

A number of getters and setters perform the task of getting and setting values. Even though these methods seem trivial, it’s better to have trivial getters and setters than to make your data members public. In the future, you may want to perform bounds checking in the setSalary() method, for example. Getters and setters also make debugging easier because you can put a breakpoint in them to inspect values when they are retrieved or set. Another reason is that when you decide to change how you are storing the data in your class, you would only need to modify these getters and setters.

// Getters and setters

void Employee::setFirstName(const string& firstName)

{

mFirstName = firstName;

}

const string& Employee::getFirstName() const

{

return mFirstName;

}

// ... other getters and setters omitted for brevity

}

EmployeeTest.cpp

As you write individual classes, it is often useful to test them in isolation. The following code includes a main() function that performs some simple operations using the Employee class. Once you are confident that the Employee class works, you should remove or comment-out this file so that you don’t attempt to compile your code with multiple main() functions.

#include <iostream>

#include "Employee.h"

using namespace std;

using namespace Records;

int main()

{

cout << "Testing the Employee class." << endl;

Employee emp;

emp.setFirstName("John");

emp.setLastName("Doe");

emp.setEmployeeNumber(71);

emp.setSalary(50000);

emp.promote();

emp.promote(50);

emp.hire();

emp.display();

return 0;

}

The Database Class

The Database class uses the std::vector class from the standard library to store Employee objects.

Database.h

Because the database will take care of automatically assigning an employee number to a new employee, a constant defines where the numbering begins.

#pragma once

#include <iostream>

#include <vector>

#include "Employee.h"

namespace Records {

const int kFirstEmployeeNumber = 1000;

The database provides an easy way to add a new employee by providing a first and last name. For convenience, this method returns a reference to the new employee. External code can also get an employee reference by calling the getEmployee() method. Two versions of this method are declared. One allows retrieval by employee number. The other requires a first and last name.

class Database

{

public:

Database();

Employee& addEmployee(const std::string& firstName,

const std::string& lastName);

Employee& getEmployee(int employeeNumber);

Employee& getEmployee(const std::string& firstName,

const std::string& lastName);

Because the database is the central repository for all employee records, it has methods that output all employees, the employees who are currently hired, and the employees who are no longer hired.

void displayAll() const;

void displayCurrent() const;

void displayFormer() const;

mEmployees contains the Employee objects. The mNextEmployeeNumber data member keeps track of what employee number is assigned to a new employee.

private:

std::vector<Employee> mEmployees;

int mNextEmployeeNumber;

};

}

Database.cpp

The Database constructor takes care of initializing the next employee number data member to its starting value.

#include <iostream>

#include <stdexcept>

#include "Database.h"

using namespace std;

namespace Records {

Database::Database() : mNextEmployeeNumber(kFirstEmployeeNumber)

{

}

The addEmployee() method creates a new Employee object, fills in its information and adds it to the vector. Note that the mNextEmployeeNumber data member is incremented after its use so that the next employee will get a new number.

Employee& Database::addEmployee(const string& firstName,

const string& lastName)

{

Employee theEmployee;

theEmployee.setFirstName(firstName);

theEmployee.setLastName(lastName);

theEmployee.setEmployeeNumber(mNextEmployeeNumber++);

theEmployee.hire();

mEmployees.push_back(theEmployee);

return mEmployees[mEmployees.size() - 1];

}

Only one version of getEmployee() is shown. Both versions work in similar ways. The methods loop over all employees in mEmployees using range-based for loops, and check to see if each Employee is a match for the information passed to the method. An exception is thrown if no match is found.

Employee& Database::getEmployee(int employeeNumber)

{

for (auto& employee : mEmployees) {

if (employee.getEmployeeNumber() == employeeNumber) {

return employee;

}

}

throw runtime_error("No employee found.");

}

The display methods all use a similar algorithm. They loop through all employees and tell each employee to display itself to the console if the criterion for display matches. displayFormer() is similar to displayCurrent().

void Database::displayAll() const

{

for (const auto& employee : mEmployees) {

employee.display();

}

}

void Database::displayCurrent() const

{

for (const auto& employee : mEmployees) {

if (employee.getIsHired())

employee.display();

}

}

}

DatabaseTest.cpp

A simple test for the basic functionality of the database follows:

#include <iostream>

#include "Database.h"

using namespace std;

using namespace Records;

int main()

{

Database myDB;

Employee& emp1 = myDB.addEmployee("Greg", "Wallis");

emp1.fire();

Employee& emp2 = myDB.addEmployee("Marc", "Gregoire");

emp2.setSalary(100000);

Employee& emp3 = myDB.addEmployee("John", "Doe");

emp3.setSalary(10000);

emp3.promote();

cout << "all employees: " << endl << endl;

myDB.displayAll();

cout << endl << "current employees: " << endl << endl;

myDB.displayCurrent();

cout << endl << "former employees: " << endl << endl;

myDB.displayFormer();

return 0;

}

The User Interface

The final part of the program is a menu-based user interface that makes it easy for users to work with the employee database.

UserInterface.cpp

The main() function is a loop that displays the menu, performs the selected action, then does it all again. For most actions, separate functions are defined. For simpler actions, like displaying employees, the actual code is put in the appropriate case.

#include <iostream>

#include <stdexcept>

#include <exception>

#include "Database.h"

using namespace std;

using namespace Records;

int displayMenu();

void doHire(Database& db);

void doFire(Database& db);

void doPromote(Database& db);

void doDemote(Database& db);

int main()

{

Database employeeDB;

bool done = false;

while (!done) {

int selection = displayMenu();

switch (selection) {

case 1:

doHire(employeeDB);

break;

case 2:

doFire(employeeDB);

break;

case 3:

doPromote(employeeDB);

break;

case 4:

employeeDB.displayAll();

break;

case 5:

employeeDB.displayCurrent();

break;

case 6:

employeeDB.displayFormer();

break;

case 0:

done = true;

break;

default:

cerr << "Unknown command." << endl;

break;

}

}

return 0;

}

The displayMenu() function outputs the menu and gets input from the user. One important note is that this code assumes that the user will “play nice” and type a number when a number is requested. When you read about I/O in Chapter 12, you will learn how to protect against bad input.

int displayMenu()

{

int selection;

cout << endl;

cout << "Employee Database" << endl;

cout << "-----------------" << endl;

cout << "1) Hire a new employee" << endl;

cout << "2) Fire an employee" << endl;

cout << "3) Promote an employee" << endl;

cout << "4) List all employees" << endl;

cout << "5) List all current employees" << endl;

cout << "6) List all former employees" << endl;

cout << "0) Quit" << endl;

cout << endl;

cout << "---> ";

cin >> selection;

return selection;

}

The doHire() function gets the new employee’s name from the user and tells the database to add the employee. It handles errors somewhat gracefully by outputting a message and continuing.

void doHire(Database& db)

{

string firstName;

string lastName;

cout << "First name? ";

cin >> firstName;

cout << "Last name? ";

cin >> lastName;

try {

db.addEmployee(firstName, lastName);

} catch (const std::exception& exception) {

cerr << "Unable to add new employee: " << exception.what() << endl;

}

}

doFire() and doPromote() both ask the database for an employee by their employee number and then use the public methods of the Employee object to make changes.

void doFire(Database& db)

{

int employeeNumber;

cout << "Employee number? ";

cin >> employeeNumber;

try {

Employee& emp = db.getEmployee(employeeNumber);

emp.fire();

cout << "Employee " << employeeNumber << " terminated." << endl;

} catch (const std::exception& exception) {

cerr << "Unable to terminate employee: " << exception.what() << endl;

}

}

void doPromote(Database& db)

{

int employeeNumber;

int raiseAmount;

cout << "Employee number? ";

cin >> employeeNumber;

cout << "How much of a raise? ";

cin >> raiseAmount;

try {

Employee& emp = db.getEmployee(employeeNumber);

emp.promote(raiseAmount);

} catch (const std::exception& exception) {

cerr << "Unable to promote employee: " << exception.what() << endl;

}

}

Evaluating the Program

The preceding program covers a number of topics from the very simple to the more complex. There are a number of ways that you could extend this program. For example, the user interface does not expose all of the functionality of the Database or Employee classes. You could modify the UI to include those features. You could also change the Database class to remove fired employees from mEmployees.

If there are parts of this program that don’t make sense, consult the preceding sections to review those topics. If something is still unclear, the best way to learn is to play with the code and try things out. For example, if you’re not sure how to use the conditional operator, write a short main() function that tries it out.

SUMMARY

Now that you know the fundamentals of C++, you are ready to become a professional C++ programmer. When you start getting deeper into the C++ language farther in the book, refer to this chapter to brush up on parts of the language you may need to review. Going back to some of the sample code in this chapter may be all you need to see to bring a forgotten concept back to the forefront of your mind.