Experience has shown that the best way to develop and maintain a large program is to construct it from small, simple pieces, or components. This technique is called divide and conquer (p. 212).

C++ programs are typically written by combining new functions and classes you write with “prepackaged” functions and classes available in the C++ Standard Library.

Functions allow you to modularize a program by separating its tasks into self-contained units.

The statements in the function bodies are written only once, are reused from perhaps several locations in a program and are hidden from other functions.

Sometimes functions are not members of a class. These are called global functions (p. 214).

The prototypes for global functions are often placed in headers, so that they can be reused in any program that includes the header and that can link to the function’s object code.

For a function that’s not defined in a class, you must either define the function before using it or you must declare that the function exists by using a function prototype.

A function prototype (p. 217) is a declaration of a function that tells the compiler the function’s name, its return type and the types of its parameters

A function prototype ends with a required semicolon.

Parameter names in function prototypes are optional (they’re ignored by the compiler), but many programmers use these names for documentation purposes.

The compiler uses the prototype to ensure that the function header matches the function prototype; to check that each function call contains the correct number and types of arguments and that the types of the arguments are in the correct order; to ensure that the value returned by the function can be used correctly in the calling expression; and to ensure that each argument is consistent with the type of the corresponding parameter.

In a function with a void return type, control returns to the caller when the program reaches the function-ending right brace or by executing the statement

return;

The portion of a function prototype that includes the name of the function and the types of its arguments is called the function signature (p. 219) or simply the signature.

An important feature of function prototypes is argument coercion (p. 219)—i.e., forcing arguments to the appropriate types specified by the parameter declarations.

Arguments can be converted by the compiler to the parameter types as specified by C++’s promotion rules (p. 219). The promotion rules indicate the implicit conversions that the compiler can perform between fundamental types.

The C++ Standard Library is divided into many portions, each with its own header. The headers also contain definitions of various class types, functions and constants.

A header “instructs” the compiler on how to interface with library components.

Calling rand (p. 222) repeatedly produces a sequence of pseudorandom numbers (p. 226). The sequence repeats itself each time the program executes.

To make numeric literals more readable, C++14 allows you to insert between groups of digits in numeric literals the digit separator ' (p. 225; a single-quote character).

To randomize the numbers produced by rand, pass an unsigned integer argument (typically from function time; p. 227) to function srand (p. 226), which seeds the rand function.

Random numbers in a range can be generated with

type variableName{shiftingValue + rand() % scalingFactor};

where shiftingValue (p. 227) is equal to the first number in the desired range of consecutive integers and scalingFactor (p. 227) is equal to the width of the desired range of consecutive integers.

A scoped enumeration (p. 230)—introduced by the keywords enum class followed by a type name—is a set of named integer constants that start at 0, unless specified otherwise, and increment by 1.

To reference a scoped enum constant, you must qualify the constant with the scoped enum’s type name and the scope resolution operator (::). If another scoped enum contains the same identifier for one of its constants, it’s always clear which version of the constant is being used.

A scoped enum’s underlying integral type is int by default.

C++11 allows you to specify an enum’s underlying integral type by following the enum’s type name with a colon (:) and the integral type.

A compilation error occurs if an enum constant’s value is outside the range that can be represented by the enum’s underlying type.

Unscoped enums can lead to naming collisions and logic errors.

An unscoped enum’s underlying integral type depends on its constants’ values—the type is guaranteed to be large enough to store the constant values specified.

According to CERT, function rand does not have “good statistical properties” and can be predictable, which makes programs that use rand less secure.

C++11 provides a new, more secure library of random-number capabilities that can produce nondeterministic random numbers for simulations and security scenarios where predictability is undesirable. These new capabilities are located in the C++ Standard Library’s <random> header.

For flexibility based on how random numbers are used in programs, C++11 provides many classes that represent various random-number generation engines and distributions. An engine implements a random-number generation algorithm that produces pseudorandom numbers. A distribution controls the range of values produced by an engine, the types of those values and the statistical properties of the values.

A default_random_engine (p. 232) represents the default random-number generation engine.

The uniform_int_distribution (p. 232) evenly distributes pseudorandom integers over a specified range of values. The default range is from 0 to the maximum value of an int on your platform.

An identifier declared outside any function or class has global namespace scope (p. 233).

Global variable (p. 234) declarations are placed outside any class or function definition. Global variables retain their values throughout the program’s execution. Global variables and functions can be referenced by any function that follows their declarations or definitions.

Identifiers declared inside a block have block scope (p. 233), which begins at the identifier’s declaration and ends at the terminating right brace (}) of the block in which the identifier is declared.

static (p. 234) local variables also have block scope, but retain their values when the function in which they’re declared returns to its caller.

An identifier declared outside any function or class has global namespace scope. Such an identifier is “known” in all functions from the point at which it’s declared until the end of the file.

Iteration and recursion are similar: both are based on a control statement, involve iteration, involve a termination test, gradually approach termination and can occur infinitely.

Recursion repeatedly invokes the mechanism, and overhead, of function calls. This can be expensive in both processor time and memory space. Each recursive call (p. 254) causes another copy of the function’s variables to be created; this can consume considerable memory.