Chapter 9: Understanding C++ Quirks and Oddities

Search in book...
Toggle Font Controls
Create new playlist

Name your new playlist

Playlist description (optional)
Sign In

Email address

Password

Forgot Password?

or

Continue with Facebook

Continue with Google
Sign Up

Full Name

Email address

Confirm Email Address

Password

or

Continue with Facebook

Continue with Google

Chapter 9

Understanding C++ Quirks and Oddities

WHAT’S IN THIS CHAPTER?

What the different use-cases are for references
Keyword confusion
How to use typedefs and type aliases
What scope resolution is
Details of new C++11 features that do not fit elsewhere in this book

Many parts of the C++ language have tricky syntax or quirky semantics. As a C++ programmer, you grow accustomed to most of this idiosyncratic behavior; it starts to feel natural. However, some aspects of C++ are a source of perennial confusion. Either books never explain them thoroughly enough, or you forget how they work and continually look them up, or both. This chapter addresses this gap by providing clear explanations for some of C++’s most niggling quirks and oddities.

Many language idiosyncrasies are covered in various chapters throughout this book. This chapter tries not to repeat those topics, by limiting itself to subjects that are not covered in detail elsewhere in the book. There is a bit of redundancy with other chapters, but the material is “sliced” in a different way in order to provide you with a new perspective.

The topics of this chapter include references, const, constexpr, static, extern, typedefs, type aliases, casts, scope resolution, uniform initialization, alternative function syntax, null pointer constant, angle brackets, initializer lists, explicit conversion operators, attributes, user-defined literals, header files, variable-length argument lists, and preprocessor macros. Although this list might appear to be a hodgepodge of topics, it is a carefully selected collection of some of the most confusing, but commonly used, aspects of the language, and of new C++11 features.

REFERENCES

Professional C++ code, including much of the code in this book, uses references extensively. It is helpful to step back and think about what exactly references are, and how they behave.

A reference in C++ is an alias for another variable. All modifications to the reference change the value of the variable to which it refers. You can think of references as implicit pointers that save you the trouble of taking the address of variables and dereferencing the pointer. Alternatively, you can think of references as just another name for the original variable. You can create stand-alone reference variables, use reference data members in classes, accept references as parameters to functions and methods and return references from functions and methods.

Reference Variables

Reference variables must be initialized as soon as they are created, like this:

int x = 3;
int& xRef = x;

Code snippet from ReferencesReferenceVariables.cpp

Subsequent to this assignment, xRef is another name for x. Any use of xRef uses the current value of x. Any assignment to xRef changes the value of x. For example, the following code sets x to 10 through xRef:

xRef = 10;

Code snippet from ReferencesReferenceVariables.cpp

You cannot declare a reference variable outside of a class without initializing it:

int& emptyRef; // DOES NOT COMPILE!

Code snippet from ReferencesReferenceVariables.cpp

You must always initialize a reference when it is created. Usually, references are created when they are declared, but reference data members need to be initialized in the constructor initializer for the containing class.

You cannot create a reference to an unnamed value such as an integer literal, unless the reference is to a const value. In the following example, unnamedRef1 will not compile because it is a non-const reference to a constant. That would mean you could change the value of the constant, 5, which doesn’t make sense. unnamedRef2 works because it’s a const reference, so you cannot write “unnamedRef2 = 7”.

int& unnamedRef1 = 5; // DOES NOT COMPILE
const int& unnamedRef2 = 5; // Works

Code snippet from ReferencesReferenceVariables.cpp

Modifying References

A reference always refers to the same variable to which it is initialized; references cannot be changed once they are created. This rule leads to some confusing syntax. If you “assign” a variable to a reference when the reference is declared, the reference refers to that variable. However, if you assign a variable to a reference after that, the variable to which the reference refers is changed to the value of the variable being assigned. The reference is not updated to refer to that variable. Here is a code example:

int x = 3, y = 4;
int& xRef = x;
xRef = y; // Changes value of x to 4. Doesn't make xRef refer to y.

Code snippet from ReferencesReferenceVariables.cpp

You might try to circumvent this restriction by taking the address of y when you assign it:

int x = 3, y = 4;
int& xRef = x;
xRef = &y; // DOES NOT COMPILE!

This code does not compile. The address of y is a pointer, but xRef is declared as a reference to an int, not a reference to a pointer.

Some programmers go even further in attempts to circumvent the intended semantics of references. What if you assign a reference to a reference? Won’t that make the first reference refer to the variable to which the second reference refers? You might be tempted to try this code:

int x = 3, z = 5;
int& xRef = x;
int& zRef = z;
zRef = xRef; // Assigns values, not references

Code snippet from ReferencesReferenceVariables.cpp

The final line does not change zRef. Instead, it sets the value of z to 3, because xRef refers to x, which is 3.

You cannot change the variable to which a reference refers after it is initialized; you can only change the value of that variable.

References to Pointers and Pointers to References

You can create references to any type, including pointer types. Here is an example of a reference to a pointer to int:

int* intP;
int*& ptrRef = intP;
ptrRef = new int;
*ptrRef = 5;

Code snippet from ReferencesReferenceVariables.cpp

The syntax is a little strange: You might not be accustomed to seeing * and & right next to each other. However, the semantics are straightforward: ptrRef is a reference to intP, which is a pointer to int. Modifying ptrRef changes intP. References to pointers are rare, but can occasionally be useful, as discussed in the “Reference Parameters” section later in this chapter.

Note that taking the address of a reference gives the same result as taking the address of the variable to which the reference refers. For example:

int x = 3;
int& xRef = x;
int* xPtr = &xRef; // Address of a reference is pointer to value
*xPtr = 100;

Code snippet from ReferencesReferenceVariables.cpp

This code sets xPtr to point to x by taking the address of a reference to x. Assigning 100 to *xPtr changes the value of x to 100. Writing a comparison “xPtr == xRef” will not compile because of a type mismatch; xPtr is a pointer to an int while xRef is a reference to an int. The comparisons “xPtr == &xRef” and “xPtr == &x” both compile without errors and are both true.

Finally, note that you cannot declare a reference to a reference or a pointer to a reference:

int x = 3;
int& xRef = x;
int&& xDoubleRef = xRef; // DOES NOT COMPILE!
int&* refPtr = &xRef; // DOES NOT COMPILE!

Code snippet from ReferencesReferenceVariables.cpp

In this example && is used in an attempt to declare a reference to a reference which is not possible. However, the C++11 standard assigns a new meaning to &&. It now means rvalue reference and is discussed later in this chapter.

Reference Data Members

As Chapter 7 explains, data members of classes can be references. A reference cannot exist without referring to some other variable. Thus, you must initialize reference data members in the constructor initializer, not in the body of the constructor. The following is a quick example:

class MyClass
{
    public:
        MyClass(int& ref) : mRef(ref) {}
    protected:
        int& mRef;
};
int main()
{
    int i = 123;
    MyClass m(i);
    return 0;
}

Code snippet from ReferencesReferenceDataMembers.cpp

Consult Chapter 7 for details.

Reference Parameters

C++ programmers do not often use stand-alone reference variables or reference data members. The most common use of references is for parameters to functions and methods. Recall that the default parameter-passing semantics are pass-by-value: Functions receive copies of their arguments. When those parameters are modified, the original arguments remain unchanged. References allow you to specify alternative pass-by-reference semantics for arguments passed to the function. When you use reference parameters, the function receives references to the function arguments. If those references are modified, the changes are reflected in the original argument variables. For example, here is a simple swap function to swap the values of two ints:

void swap(int& first, int& second)
{
    int temp = first;
    first = second;
    second = temp;
}

Code snippet from ReferencesReferenceParameters.cpp

You can call it like this:

int x = 5, y = 6;
swap(x, y);

Code snippet from ReferencesReferenceParameters.cpp

When the function swap() is called with the arguments x and y, the first parameter is initialized to refer to x, and the second parameter is initialized to refer to y. When swap() modifies first and second, x and y are actually changed.

Just as you can’t initialize normal reference variables with constants, you can’t pass constants as arguments to functions that employ pass-by-reference:

swap(3, 4); // DOES NOT COMPILE

Code snippet from ReferencesReferenceParameters.cpp

Using rvalue references from C++11, it is possible to pass constants as arguments to functions that employ pass-by-rvalue-reference. Rvalue references are discussed later in this chapter.

References from Pointers

A common quandary arises when you have a pointer to something that you need to pass to a function or method that takes a reference. You can “convert” a pointer to a reference in this case simply by dereferencing the pointer. This action gives you the value to which the pointer points, which the compiler then uses to initialize the reference parameter. For example, you can call swap() like this:

int x = 5, y = 6;
int *xp = &x, *yp = &y;
swap(*xp, *yp);

Code snippet from ReferencesReferenceParameters.cpp

Pass-By-Reference versus Pass-By-Value

Pass-by-reference is required when you want to modify the parameter and see those changes reflected in the variable argument to the function or method. However, you should not limit your use of pass-by-reference to only those cases. Pass-by-reference avoids copying the arguments to the function, providing two additional benefits in some cases:

1. Efficiency: Large objects and structs could take a long time to copy. Pass-by-reference passes only a pointer to the object or struct into the function.

2. Correctness: Not all objects allow pass-by-value. Even those that do allow it might not support deep copying correctly. As Chapter 7 explains, objects with dynamically allocated memory must provide a custom copy constructor in order to support deep copying.

If you want to leverage these benefits, but do not want to allow the original objects to be modified, you can mark the parameters const, giving you pass-by-const-reference. This topic is covered in detail later in this chapter.

These benefits to pass-by-reference imply that you should use pass-by-value only for simple built-in types like int and double for which you don’t need to modify the arguments. Use pass-by-reference in all other cases.

Reference Return Values

You can also return a reference from a function or method. The main reason to do so is efficiency. Instead of returning a whole object, return a reference to the object to avoid copying it unnecessarily. Of course, you can only use this technique if the object in question will continue to exist following the function termination.

From a function or method, never return a reference to a variable that is locally scoped to that function or method, such as an automatically allocated variable on the stack that will be destroyed when the function ends.

A second reason to return a reference is if you want to be able to assign to the return value directly as an lvalue (the left-hand side of an assignment statement).

Several overloaded operators commonly return references. Chapter 7 shows some examples, and you can read about more applications of this technique in Chapter 18.

Deciding between References and Pointers

References in C++ could be considered redundant: almost everything you can do with references, you can accomplish with pointers. For example, you could write the previously shown swap() function like this:

void swap(int* first, int* second)
{
    int temp = *first;
    *first = *second;
    *second = temp;
}

However, this code is more cluttered than the version with references: References make your programs cleaner and easier to understand. References are also safer than pointers: It’s impossible to have an invalid reference, and you don’t explicitly dereference references, so you can’t encounter any of the dereferencing errors associated with pointers. These arguments, saying that references are safer, are only valid in the absence of any pointers. For example, take the following function which accepts a reference to an int:

void refcall(int& t) { ++t; }

You could declare a pointer and initialize it to the null pointer. Then you could dereference this pointer and pass it as the reference argument to refcall() as in the following code. This code will compile but will crash when trying to execute it.

int main()
{
    int* ptr = nullptr;
    refcall(*ptr);
    return 0;
}

Most of the time, you can use references instead of pointers. References to objects even support polymorphism in the same way as pointers to objects. The only case in which you need to use a pointer is when you need to change the location to which it points. Recall that you cannot change the variable to which references refer. For example, when you dynamically allocate memory, you need to store a pointer to the result in a pointer rather than a reference.

Another way to distinguish between appropriate use of pointers and references in parameters and return types is to consider who owns the memory. If the code receiving the variable is responsible for releasing the memory associated with an object, it must receive a pointer to the object. If the code receiving the variable should not free the memory, it should receive a reference.

Use references instead of pointers unless you need to change to where the reference refers to.

Strict application of this rule can lead to some unfamiliar syntax. Consider a function that splits an array of ints into two arrays: one of even numbers and one of odd numbers. The function doesn’t know how many numbers in the source array will be even or odd, so it should dynamically allocate the memory for the destination arrays after examining the source array. It should also return the sizes of the two new arrays. Altogether, there are four items to return: pointers to the two new arrays and the sizes of the two new arrays. Obviously, you must use pass-by-reference. The canonical C way to write the function looks like this:

void separateOddsAndEvens(const int arr[], int size, int** odds,
    int* numOdds, int** evens, int* numEvens)
{
    // First pass to determine array sizes
    *numOdds = *numEvens = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] % 2 == 1) {
            (*numOdds)++;
        } else {
            (*numEvens)++;
        }
    }
    // Allocate two new arrays of the appropriate size.
    *odds = new int[*numOdds];
    *evens = new int[*numEvens];
    // Copy the odds and evens to the new arrays
    int oddsPos = 0, evensPos = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] % 2 == 1) {
            (*odds)[oddsPos++] = arr[i];
        } else {
            (*evens)[evensPos++] = arr[i];
        }
    }
}

Code snippet from ReferencesOddsEvensPtrs.cpp

The final four parameters to the function are the “reference” parameters. In order to change the values to which they refer, separateOddsAndEvens() must dereference them, leading to some ugly syntax in the function body.

Additionally, when you want to call separateOddsAndEvens(), you must pass the address of two pointers so that the function can change the actual pointers, and the address of two ints so that the function can change the actual ints:

int unSplit[10] = {1, 2, 3, 4, 5, 6, 6, 8, 9, 10};
int *oddNums, *evenNums;
int numOdds, numEvens;
separateOddsAndEvens(unSplit, 10, &oddNums, &numOdds, &evenNums, &numEvens);

Code snippet from ReferencesOddsEvensPtrs.cpp

If such syntax annoys you (which it should), you can write the same function by using references to obtain true pass-by-reference semantics:

void separateOddsAndEvens(const int arr[], int size, int*& odds,
    int& numOdds, int*& evens, int& numEvens)
{
    numOdds = numEvens = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] % 2 == 1) {
            numOdds++;
        } else {
            numEvens++;
        }
    }
    odds = new int[numOdds];
    evens = new int[numEvens];
    int oddsPos = 0, evensPos = 0;
    for (int i = 0; i < size; i++) {
        if (arr[i] % 2 == 1) {
            odds[oddsPos++] = arr[i];
        } else {
            evens[evensPos++] = arr[i];
        }
    }
}

Code snippet from ReferencesOddsEvensRefs.cpp

In this case, the odds and evens parameters are references to int*s. separateOddsAndEvens() can modify the int*s that are used as arguments to the function (through the reference), without any explicit dereferencing. The same logic applies to numOdds and numEvens, which are references to ints.

With this version of the function, you no longer need to pass the addresses of the pointers or ints. The reference parameters handle it for you automatically:

int unSplit[10] = {1, 2, 3, 4, 5, 6, 6, 8, 9, 10};
int *oddNums, *evenNums;
int numOdds, numEvens;
separateOddsAndEvens(unSplit, 10, oddNums, numOdds, evenNums, numEvens);

Code snippet from ReferencesOddsEvensRefs.cpp

It’s recommended to avoid dynamically allocated arrays as much as possible to make your life easier. For example, by using the STL vector container, the previous separateOddsAndEvens() can be rewritten much more compactly and elegantly, because all memory allocation and deallocation happens automatically.

void separateOddsAndEvens(const vector<int>& arr,
    vector<int>& odds, vector<int>& evens)
{
    for (auto& i : arr) {
        if (i % 2 == 1)
            odds.push_back(i);
        else
            evens.push_back(i);
    }
}

Code snippet from ReferencesOddsEvensVector.cpp

This version can be used as follows:

vector<int> vecUnSplit = {1, 2, 3, 4, 5, 6, 6, 8, 9, 10};
vector<int> odds, evens;
separateOddsAndEvens(vecUnSplit, odds, evens);

Code snippet from ReferencesOddsEvensVector.cpp

The STL vector container is discussed in more detail in Chapter 12.

Rvalue References

In C++, an lvalue is something of which you can take an address, a named variable for example. The name comes from the fact that they normally appear on the left-hand side of an assignment. An rvalue on the other hand is anything that is not an lvalue, a constant value for example or a temporary object or value. Typically an rvalue is on the right-hand side of an assignment operator.

C++11 introduces a new concept, an rvalue reference, which is a reference to an rvalue. In particular, it is a concept that is applied when the rvalue is a temporary object. The purpose of an rvalue reference is to allow methods (most particularly, but not restricted to, copy constructors and operator=) so that a particular method can be chosen when a temporary object is involved. The consequence of this is that certain operations which normally involve copying large values can be implemented by simply copying pointers to those values, knowing the temporary object will be destroyed.

A method can specify an rvalue reference parameter by using && as part of the parameter specification, e.g., type&& name. Normally, a temporary object will be seen as a const type&, but when there is a method that uses an rvalue reference, a temporary object can be resolved to this overload.

However, rvalue references are not limited to parameters of functions. You can declare a variable of type rvalue reference, and assign to it, although this usage is uncommon. Consider the following code, which is illegal in C++:

int& i = 2;       // Invalid: reference to a constant
int a = 2, b = 3;
int& j = a + b;   // Invalid: reference to a temporary

Using rvalue references, the following is perfectly legal:

int&& i = 2;
int a = 2, b = 3;
int&& j = a + b;

Standalone rvalue references as in the preceding example are rarely used as such. However, they can be useful as parameters to functions or methods as the following example demonstrates. The code first defines two incr() functions, one accepting an lvalue reference and one accepting an rvalue reference.

// Increment value using lvalue reference parameter.
void incr(int& value)
{
    cout << "increment with lvalue reference" << endl;
    ++value;
}
// Increment value using rvalue reference parameter.
void incr(int&& value)
{
    cout << "increment with rvalue reference" << endl;
    ++value;
}

Code snippet from ReferencesRvalueReferences.cpp

You can call the incr() function with a named variable as argument as follows. Because a is a named variable, the incr() function accepting an lvalue reference is called. After the call to incr(), the value of a will be 11.

int a = 10, b = 20;
incr(a);            // Will call incr(int& value)

Code snippet from ReferencesRvalueReferences.cpp

You can also call the incr() function with an expression as argument as follows. The incr() function accepting an lvalue reference cannot be used, because the expression a + b results in a temporary, which is not an lvalue. In this case the rvalue reference version is called. Since the argument is a temporary, the incremented value is actually lost after the call to incr().

incr(a + b);        // Will call incr(int&& value)

Code snippet from ReferencesRvalueReferences.cpp

A literal can also be used as argument to the incr() call. This will also trigger a call to the rvalue reference version because a literal cannot be an lvalue.

incr(3);            // Will call incr(int&& value)

Code snippet from ReferencesRvalueReferences.cpp

If you remove the definition accepting an lvalue reference, incr(int& value), calling incr() with a named variable like incr(b) will result in a compiler error, because the C++ standard says that an rvalue reference parameter (int&& value) will never be bound to an lvalue (b). You can force the compiler to call the rvalue reference version of incr() by using std::move() which converts an lvalue into an rvalue as follows. After the incr() call, the value of b will be 21.

incr(std::move(b)); // Will call incr(int&& value)

Code snippet from ReferencesRvalueReferences.cpp

Move Semantics

C++11 adds the concept of move semantics to objects by implementing a move constructor and a move assignment operator. These will be used by the compiler on places where the second object is a temporary object that will be destroyed after the copy or assignment. Both the move constructor and the move assignment operator copy the member variables from the source object to the new object and then reset the variables of the source object to null values. By doing this, they are actually moving ownership of the memory from one object to another object. They basically do a shallow copy of the member variables and switch ownership of allocated memory to prevent dangling pointers or memory leaks.

Move semantics is implemented by using rvalue references. To add move semantics to a class, a move constructor and a move assignment operator need to be implemented. Following is the Spreadsheet class definition from Chapter 7, which now includes a move constructor and a move assignment operator.

class Spreadsheet
{
    public:
        Spreadsheet(Spreadsheet&& src); // Move constructor
        Spreadsheet& operator=(Spreadsheet&& rhs);  // Move assignment
        // Remaining code omitted for brevity
};

Code snippet from SpreadsheetMoveSemanticsSpreadsheet.h

The implementation is as follows.

// Move constructor
Spreadsheet::Spreadsheet(Spreadsheet&& src)
{
    // Shallow copy of data
    mWidth = src.mWidth;
    mHeight = src.mHeight;
    mCells = src.mCells;
    // Reset the source object
    src.mWidth = 0;
    src.mHeight = 0;
    src.mCells = nullptr;
}
// Move assignment operator
Spreadsheet& Spreadsheet::operator=(Spreadsheet&& rhs)
{
    // check for self-assignment
    if (this == &rhs) {
        return *this;
    }
    // free the old memory
    for (int i = 0; i < mWidth; i++) {
        delete [] mCells[i];
    }
    delete [] mCells;
    mCells = nullptr;
    // Shallow copy of data
    mWidth = rhs.mWidth;
    mHeight = rhs.mHeight;
    mCells = rhs.mCells;
    // Reset the source object
    rhs.mWidth = 0;
    rhs.mHeight = 0;
    rhs.mCells = nullptr;
    return *this;
}

Code snippet from SpreadsheetMoveSemanticsSpreadsheet.cpp

Both the move constructor and the move assignment operator are moving ownership of the memory for mCells from the source object to the new object. They reset the mCells pointer of the source object to a null pointer to prevent the destructor of the source object to deallocate that memory, because now the new object is the owner of that memory.

The preceding move constructor and move assignment operator can be tested with the following code:

Spreadsheet CreateObject()
{
    return Spreadsheet(3, 2);
}
int main()
{
    vector<Spreadsheet> vec;
    for (int i = 0; i < 2; ++i) {
        cout << "Iteration " << i << endl;
        vec.push_back(Spreadsheet(100, 100));
        cout << endl;
    }
    Spreadsheet s(2,3);
    s = CreateObject();
    Spreadsheet s2(5,6);
    s2 = s;
    return 0;
}

Code snippet from SpreadsheetMoveSemanticsSpreadsheetTest.cpp

Chapter 1 introduces the vector. A vector grows dynamically in size to accommodate new objects. This is done by allocating a bigger chunk of memory and then copying or moving the objects from the old vector to the new and bigger vector. If the compiler finds a move constructor, the objects will be moved instead of copied. By moving them there is no need for any deep copying making it much more efficient.

When you add output statements to all constructors and assignment operators of the Spreadsheet class, the output of the preceding test program will be as follows:

Iteration 0
Normal constructor        (1)
Move constructor          (2)
 
Iteration 1
Normal constructor        (3)
Move constructor          (4)
Move constructor          (5)
 
Normal constructor        (6)
Normal constructor        (7)
Move assignment operator  (8)
Normal constructor        (9)
Assignment operator       (10)

On the first iteration of the loop, the vector is still empty. Take the following line of code from the loop:

vec.push_back(Spreadsheet(100, 100));

With this line, a new Spreadsheet object is created which will invoke the normal constructor (1). The vector will resize itself to make space for the new object being pushed in. The created Spreadsheet object is then moved into the vector, invoking the move constructor (2).

On the second iteration of the loop, a second Spreadsheet object is created with the normal constructor (3). At this point, the vector can hold one element, so it’s again resized to make space for a second object. By resizing the vector, the previously added elements need to be moved from the old vector to the new and bigger vector, so this will trigger a call to the move constructor for each previously added element (4). Then, the new Spreadsheet object is moved into the vector with its move constructor (5).

The CreateObject function creates a temporary Spreadsheet object with its normal constructor (7), which is then returned from the function and move-assigned to the variable s (8). Because the temporary object will cease to exist after the assignment, the compiler will invoke the move assignment operator instead of the normal copy assignment operator. On the other hand, the assignment s2 = s will invoke the copy assignment operator (10) because the right-hand side object is not a temporary object, but a named object.

If the Spreadsheet class did not include a move constructor and move assignment operator, the above output would look as follows:

Iteration 0
Normal constructor
Copy constructor
 
Iteration 1
Normal constructor
Copy constructor
Copy constructor
 
Normal constructor
Normal constructor
Assignment operator
Normal constructor
Assignment operator

As you can see, copy constructors are called instead of move constructors and copy assignment operators are called instead of move assignment operators. In the previous example, the Spreadsheet objects have 10.000 (100 x 100) elements. The implementation of the Spreadsheet move constructor and move assignment operator don’t require any memory allocation, while the copy constructor and copy assignment operator require 101 allocations. So, using move semantics can increase performance a lot in certain situations.

Move constructors and move assignment operators can also be explicitly deleted or defaulted, just like normal constructors and normal copy assignment operators, as explained in Chapter 6.

As another example where move semantics increases performance, take a swap() function that swaps two objects. Before C++11, a swap() function could be implemented as follows. This example uses templates, which are discussed in detail in Chapter 19.

template<typename T>
void swapCopy(T& a, T& b)
{
    T temp(a);
    a = b;
    b = temp;
}

This implementation first copies a to temp, then copies b to a and then copies temp to b. If type T is expensive to copy, this swap implementation will hurt performance. With move semantics the swap() function can avoid all copying:

template<typename T>
void swapMove(T& a, T& b)
{
    T temp(std::move(a));
    a = std::move(b);
    b = std::move(temp);
}

Obviously, move semantics is useful only when you know that the source object will be destroyed.

KEYWORD CONFUSION

Two keywords in C++ appear to cause more confusion than any others: const and static. Both of these keywords have several different meanings, and each of their uses presents subtleties that are important to understand.

The const Keyword

The keyword const is short for “constant” and specifies that something remains unchanged. The compiler will enforce this requirement by marking any attempt to change it as an error. Furthermore, when optimizations are enabled, the compiler can take advantage of this knowledge to produce better code.

The keyword const has two related roles. It can mark variables or parameters, and it can mark methods. This section provides a definitive discussion of these two meanings.

const Variables and Parameters

You can use const to “protect” variables by specifying that they cannot be modified. As Chapters 1 and 5 explain, one important use of this keyword is as a replacement for #define to declare constants. This use of const is its most straightforward application. For example, you could declare the constant PI like this:

const double PI = 3.14159;