Source Files and Header Files

The file depicted in Figure 1-1, Ex1_01.cpp, is in the code download for the book. The file extension, .cpp, indicates that this is a C++ source file. Source files contain functions and thus all the executable code in a program. The names of source files usually have the extension .cpp, although other extensions such as .cc, .cxx, or .c++ are sometimes used to identify a C++ source file.

C++ code is actually stored in two kinds of files. Next to source files, there’re also so-called header files. Header files contain, among other things, function prototypes and definitions for classes and templates that are used by the executable code in a .cpp file. The names of header files usually have the extension .h, although other extensions such as .hpp are also used. You’ll create your first very own header files in Chapter 10; until then all your programs will be small enough to be defined in a single source file.

Comments and Whitespace

The first two lines in Figure 1-1 are comments. You add comments that document your program code to make it easier to understand how it works. The compiler ignores everything that follows two successive forward slashes on a line, so this kind of comment can follow code on a line. In our example, the first line is a comment that indicates the name of the file containing this code. We'll identify the file for each working example in the same way.

There’s another form of comment that you can use when you need to spread a comment over several lines. Here’s an example:

Everything between /* and */ will be ignored by the compiler. You can embellish this sort of comment to make it stand out. For instance:

Whitespace is any sequence of spaces, tabs, newlines, or form feed characters. Whitespace is generally ignored by the compiler, except when it is necessary for syntactic reasons to distinguish one element from another.

Preprocessing Directives and Standard Library Headers

The third line in Figure 1-1 is a preprocessing directive. Preprocessing directives cause the source code to be modified in some way before it is compiled to executable form. This preprocessing directive adds the contents of the Standard Library header file with the name iostream to this source file, Ex1_01.cpp. The header file contents are inserted in place of the #include directive.

Header files , which are sometimes referred to just as headers, contain definitions to be used in a source file. iostream contains definitions that are needed to perform input from the keyboard and text output to the screen using Standard Library routines. In particular, it defines std::cout and std::endl among many other things. If the preprocessing directive to include the iostream header was omitted from Ex1_01.cpp, the source file wouldn’t compile because the compiler would not know what std::cout or std::endl is. The contents of header files are included into a source file before it is compiled. You’ll be including the contents of one or more Standard Library header files into nearly every program, and you’ll also be creating and using your own header files that contain definitions that you construct later in the book.

Functions

The program in Figure 1-1 consists of just the function main(). The first line of the function is as follows:

This is called the function header , which identifies the function. Here, int is a type name that defines the type of value that the main() function returns when it finishes execution—an integer. An integer is a number without a fractional component; that is, 23 and -2048 are integers, while 3.1415 and ¼ are not. In general, the parentheses following a name in a function definition enclose the specification for information to be passed to the function when you call it. There’s nothing between the parentheses in this instance, but there could be. You’ll learn how you specify the type of information to be passed to a function when it is executed in Chapter 8. We’ll always put parentheses after a function name in the text—like we did with main()—to distinguish it from other things that are code.

The executable code for a function is always enclosed between curly braces. The opening brace follows the function header.

Statements

A statement is a basic unit in a C++ program. A statement always ends with a semicolon, and it’s the semicolon that marks the end of a statement, not the end of the line. A statement defines something, such as a computation, or an action that is to be performed. Everything a program does is specified by statements. Statements are executed in sequence until there is a statement that causes the sequence to be altered. You’ll learn about statements that can change the execution sequence in Chapter 4. There are three statements in main() in Figure 1-1. The first defines a variable, which is a named bit of memory for storing data of some kind. In this case, the variable has the name answer and can store integer values:

The type, int, appears first, preceding the name. This specifies the kind of data that can be stored—integers. Note the space between int and answer. One or more whitespace characters is essential here to separate the type name from the variable name; without the space, the compiler would see the name intanswer, which it would not understand. An initial value for answer appears between the braces following the variable name, so it starts out storing 42. There’s a space between answer and {42}, but it’s not essential. Any of the following definitions are valid as well:

The compiler mostly ignores superfluous whitespace. However, you should use whitespace in a consistent fashion to make your code more readable.

There’s a somewhat redundant comment at the end of the first statement explaining what we just described, but it does demonstrate that you can add a comment to a statement. The whitespace preceding the // is also not mandatory, but it is desirable.

You can enclose several statements between a pair of curly braces, { }, in which case they’re referred to as a statement block . The body of a function is an example of a block, as you saw in Figure 1-1 where the statements in the main() function appear between curly braces. A statement block is also referred to as a compound statement because in most circumstances it can be considered as a single statement , as you’ll see when we look at decision-making capabilities in Chapter 4, and loops in Chapter 5. Wherever you can put a single statement, you can equally well put a block of statements between braces. As a consequence, blocks can be placed inside other blocks—this concept is called nesting . Blocks can be nested, one within another, to any depth.

Data Input and Output

Input and output are performed using streams in C++. To output something, you write it to an output stream, and to input data, you read it from an input stream. A stream is an abstract representation of a source of data or a data sink. When your program executes, each stream is tied to a specific device that is the source of data in the case of an input stream and the destination for data in the case of an output stream. The advantage of having an abstract representation of a source or sink for data is that the programming is then the same regardless of the device the stream represents. You can read a disk file in essentially the same way as you read from the keyboard. The standard output and input streams in C++ are called cout and cin, respectively, and by default they correspond to your computer’s screen and keyboard. You’ll be reading input from cin in Chapter 2.

The next statement in main() in Figure 1-1 outputs text to the screen:

The statement is spread over three lines, just to show that it’s possible. The names cout and endl are defined in the iostream header file. We’ll explain about the std:: prefix a little later in this chapter. << is the insertion operator that transfers data to a stream. In Chapter 2 you’ll meet the extraction operator, >>, that reads data from a stream. Whatever appears to the right of each << is transferred to cout. Inserting endl to std::cout causes a new line to be written to the stream and the output buffer to be flushed. Flushing the output buffer ensures that the output appears immediately. The statement will produce the following output:

You can add comments to each line of a statement. Here’s an example:

You don’t have to align the double slashes , but it’s common to do so because it looks tidier and makes the code easier to read. Of course, you should not start writing comments just to write them. A comment normally contains useful information that is not immediately obvious from the code.

return Statements

The last statement in main() is a return statement. A return statement ends a function and returns control to where the function was called. In this case, it ends the function and returns control to the operating system. A return statement may or may not return a value. This particular return statement returns 0 to the operating system. Returning 0 to the operating system indicates that the program ended normally. You can return nonzero values such as 1, 2, etc., to indicate different abnormal end conditions. The return statement in Ex1_01.cpp is optional, so you could omit it. This is because if execution runs past the last statement in main(), it is equivalent to executing return 0.

Namespaces

A large project will involve several programmers working concurrently. This potentially creates a problem with names. The same name might be used by different programmers for different things, which could at least cause some confusion and may cause things to go wrong. The Standard Library defines a lot of names, more than you can possibly remember. Accidental use of Standard Library names could also cause problems. Namespaces are designed to overcome this difficulty.

A namespace is a sort of family name that prefixes all the names declared within the namespace. The names in the Standard Library are all defined within a namespace that has the name std. cout and endl are names from the Standard Library, so the full names are std::cout and std::endl. Those two colons together, ::, have a fancy title: the scope resolution operator. We’ll have more to say about it later. Here, it serves to separate the namespace name, std, from the names in the Standard Library such as cout and endl. Almost all names from the Standard Library are prefixed with std.

The code for a namespace looks like this:

Everything between the braces is within the my_space namespace. You’ll find out more about defining your own namespaces in Chapter 10.

Names and Keywords

The C++ standard allows names to be of any length, but typically a particular compiler will impose some sort of limit. However, this is normally sufficiently large that it doesn’t represent a serious constraint. Most of the time you won’t need to use names of more than 12 to 15 characters.

Here are some valid C++ names:

Uppercase and lowercase are differentiated, so democrat is not the same name as Democrat. You can see a couple examples of conventions for writing names that consist of two or more words; you can capitalize the second and subsequent words or just separate them with underscores.

While compilers often won’t really complain if you use these, the problem is that such names might clash either with those that are generated by the compiler or with names that are used internally by your Standard Library implementation. Notice that the common denominator with these reserved names is that they all start with an underscore. Thus, our advice is this:

Binary Numbers

Using the first seven bits , you can represent positive numbers from 0 to 127, which is a total of 128 different numbers. Using all eight bits, you get 256, or 2⁸, numbers. In general, if you have n bits available, you can represent 2ⁿ integers, with positive values from 0 to 2ⁿ – 1.

Adding binary numbers inside your computer is a piece of cake because the “carry” from adding corresponding digits can be only 0 or 1. This means that very simple—and thus excruciatingly fast—circuitry can handle the process. Figure 1-3 shows how the addition of two 8-bit binary values would work.

The addition operation adds corresponding bits in the operands, starting with the rightmost. Figure 1-3 shows that there is a “carry” of 1 to the next bit position for each of the first six bit positions. This is because each digit can be only 0 or 1. When you add 1 + 1, the result cannot be stored in the current bit position and is equivalent to adding 1 in the next bit position to the left.

Hexadecimal Numbers

Binary notation here starts to be more than a little cumbersome for practical use, particularly when you consider that this in decimal is only 16,103,905—a miserable eight decimal digits. You can sit more angels on the head of a pin than that! Clearly you need a more economical way of writing this, but decimal isn’t always appropriate. You might want to specify that the 10th and 24th bits from the right in a number are 1, for example. Figuring out the decimal integer for this is hard work, and there’s a good chance you’ll get it wrong anyway. An easier solution is to use hexadecimal notation, in which the numbers are represented using base 16.

Thankfully, this adds up to the same number you got when converting the equivalent binary number to a decimal value: 16,103,905. In C++, hexadecimal values are written with 0x or 0X as a prefix, so in code the value would be written as 0xF5B9E1. Obviously, this means that 99 is not at all the same as 0x99.

The other handy coincidence with hexadecimal numbers is that modern computers store integers in words that are an even number of bytes, typically 2, 4, 8, or 16 so-called bytes. A byte is 8 bits, which is exactly two hexadecimal digits, so any binary integer word in memory always corresponds to an exact number of hexadecimal digits.

Negative Binary Numbers

There’s another aspect to binary arithmetic that you need to understand: negative numbers. So far, we’ve assumed that everything is positive—the optimist’s view—and so the glass is still half-full. But you can’t avoid the negative side of life—the pessimist’s perspective—that the glass is already half-empty. But how is a negative number represented in a modern computer? You’ll see shortly that the answer to this seemingly easy question is actually far from obvious….

Integers that can be both positive and negative are referred to as signed integers . Naturally, you only have binary digits at your disposal to represent numbers. At the end of the day, any language your computer speaks shall consist solely of bits and bytes. As you know, your computer’s memory is generally composed of 8-bit bytes, so all binary numbers are going to be stored in some multiple (usually a power of 2) of 8 bits. Thus, you can also only have signed integers with 8 bits, 16 bits, 32 bits, or whatever.

A straightforward representation of signed integers therefore consists of a fixed number of binary digits, where one of these bits is designated as a so-called sign bit. In practice, the sign bit is always chosen to be the leftmost bit. Say we fix the size of all our signed integers to 8 bits; then the number 6 could be represented as 00000110, and -6 could be represented as 10000110. Changing +6 to –6 just involves flipping the sign bit from 0 to 1. This is called a signed magnitude representation: each number consists of a sign bit that is 0 for positive values and 1 for negative values, plus a given number of other bits that specify the magnitude or absolute value of the number (the value without the sign in other words).

While signed magnitude representations are easy to work with for humans, they have one unfortunate downside: they are not at all easy to work with for computers! More specifically, they carry a lot of overhead in terms of the complexity of the circuits that are needed to perform arithmetic. When two signed integers are added, for instance, you don’t want the computer to be messing about, checking whether either or both of the numbers are negative. What you really want is to use the same simple and very fast “add” circuitry regardless of the signs of the operands.

This seems to give –20, which of course isn’t what you wanted at all. It’s definitely not +4, which you know is 00000100. “Ah,” we hear you say, “you can’t treat a sign just like another digit.” But that is just what you do want to do to speed up binary computations!

Note that this works both ways. To convert the 2’s complement representation of a negative number back into the corresponding positive binary number, you again flip all bits and add one. For our example, flipping 11111000 gives 00000111, adding one to this gives 00001000, or +8 in decimal. Magic!

The answer is 4—it works! The “carry” propagates through all the leftmost 1s, setting them back to 0. One fell off the end, but you shouldn’t worry about that—it’s probably compensating for the one you borrowed from the end in the subtraction you did to get –8. In fact, what’s happening is that you’re implicitly assuming that the sign bit, 1 or 0, repeats forever to the left. Try a few examples of your own; you’ll find it always works, like magic. The great thing about the 2’s complement representation of negative numbers is that it makes arithmetic—and not just addition, by the way—very easy for your computer. And that accounts for one of the reasons computers are so good at crunching numbers.

Octal Values

Octal integers are numbers expressed with base 8. Digits in an octal value can only be from 0 to 7. Octal is used rarely these days. It was useful in the days when computer memory was measured in terms of 36-bit words because you could specify a 36-bit binary value by 12 octal digits. Those days are long gone, so why are we introducing it? The answer is the potential confusion it can cause. You can still write octal constants in C++. Octal values are written with a leading zero, so while 76 is a decimal value, 076 is an octal value that corresponds to 62 in decimal. So, here’s a golden rule:

Bi-Endian and Little-Endian Systems

Integers are stored in memory as binary values in a contiguous sequence of bytes, commonly groups of 2, 4, 8, or 16 bytes. The question of the sequence in which the bytes appear can be important—it’s one of those things that doesn’t matter until it matters, and then it really matters.

As you can see, the most significant eight bits of the value—the one that’s all 0s—are stored in the byte with the highest address (last, in other words), and the least significant eight bits are stored in the byte with the lowest address, which is the leftmost byte. This arrangement is described as little-endian. Why on earth, you wonder, would a computer reverse the order of these bytes? The motivation, as always, is rooted in the fact that it allows for more efficient calculations and simpler hardware. The details don’t matter much; the main thing is that you’re aware that most modern computers these days use this counterintuitive encoding.

Now the bytes are in reverse sequence with the most significant eight bits stored in the leftmost byte, which is the one with the lowest address. This arrangement is described as bi-endian. Some processors such as PowerPC and all recent ARM processors are bi-endian, which means that the byte order for data is switchable between bi-endian and little-endian.

This is all very interesting, you may say, but when does it matter? Most of the time, it doesn’t. More often than not, you can happily write a program without knowing whether the computer on which the code will execute is bi-endian or little-endian. It does matter, however, when you’re processing binary data that comes from another machine. You need to know the endianness. Binary data is written to a file or transmitted over a network as a sequence of bytes. It’s up to you how you interpret it. If the source of the data is a machine with a different endianness from the machine on which your code is running, you must reverse the order of the bytes in each binary value. If you don’t, you have garbage.

For those who collect curious background information, the terms bi-endian and little-endian are drawn from the book Gulliver’s Travels by Jonathan Swift. In the story, the emperor of Lilliput commanded all his subjects to always crack their eggs at the smaller end. This was a consequence of the emperor’s son having cut his finger following the traditional approach of cracking his egg at the big end. Ordinary, law-abiding Lilliputian subjects who cracked their eggs at the smaller end were described as Little Endians. The Big Endians were a rebellious group of traditionalists in the Lilliputian kingdom who insisted on continuing to crack their eggs at the big end. Many were put to death as a result.

Floating-Point Numbers

All integers are numbers, but of course not all numbers are integers: 3.1415 is no integer, and neither is -0.00001. Many applications will have to deal with fractional numbers at one point or another. So clearly you need a way to represent such numbers on your computer as well, complemented with the ability to efficiently perform computations with them. The mechanism nearly all computers support for handling fractional numbers, as you may have guessed from the section title, is called floating-point numbers.

Floating-point numbers do not just represent fractional numbers, though. As an added bonus, they are able to deal with very large numbers as well. They allow you to represent, for instance, the number of protons in the universe, which needs around 79 decimal digits (though of course not accurate within one particle, but that’s OK—who has the time to count them all anyway?). Granted, the latter is perhaps somewhat extreme, but clearly there are situations in which you’ll need more than the ten decimal digits you get from a 32-bit binary integer, or even more than the 19 you can get from a 64-bit integer. Equally, there are lots of very small numbers, for example, the amount of time in minutes it takes the typical car salesperson to accept your generous offer on a 2001 Honda (and it’s covered only 480,000 miles…). Floating-point numbers are a mechanism that can represent both these classes of numbers quite effectively.

We’ll first explain the basic principles using decimal floating-point numbers. Of course, your computer will again use a binary representation instead, but things are just so much easier to understand for us humans when we use decimal numbers. A so-called normalized number consists of two parts: a mantissa or fraction and an exponent. Both can be either positive or negative. The magnitude of the number is the mantissa multiplied by 10 to the power of the exponent. In analogy with the binary floating-point number representations of your computer, we’ll moreover fix the number of decimal digits of both the mantissa and the exponent.

It’s easier to demonstrate this than to describe it, so let’s look at some examples. The number 365 could be written in a floating-point form, as follows:

The mantissa here has seven decimal digits, the exponent two. The E stands for “exponent” and precedes the power of 10 that the 3.650000 (the mantissa) part is multiplied by to get the required value. That is, to get back to the regular decimal notation, you simply have to compute the following product: 3.650000 × 10². This is clearly 365.

Now let’s look at a small number:

This is evaluated as -3.65 × 10^-3, which is -0.00365. They’re called floating-point numbers for the fairly obvious reason that the decimal point “floats” and its position depends on the exponent value.

Now suppose you have a larger number such as 2,134,311,179. Using the same amount of digits, this number looks like this:

It’s not quite the same. You’ve lost three low-order digits, and you’ve approximated your original value as 2,134,311,000. This is the price to pay for being able to handle such a vast range of numbers: not all these numbers can be represented with full precision; floating-point numbers in general are only approximate representations of the exact number.

Aside from the fixed-precision limitation in terms of accuracy, there’s another aspect you may need to be conscious of. You need to take great care when adding or subtracting numbers of significantly different magnitudes. A simple example will demonstrate the problem. Consider adding 1.23E-4 to 3.65E+6. The exact result, of course, is 3,650,000 + 0.000123, or 3,650,000.000123. But when converted to floating-point with seven digits of precision, this becomes the following:

Adding the latter, smaller number to the former has had no effect whatsoever, so you might as well not have bothered. The problem lies directly with the fact that you carry only seven digits of precision. The digits of the larger number aren’t affected by any of the digits of the smaller number because they’re all further to the right.

Funnily enough, you must also take care when the numbers are nearly equal. If you compute the difference between such numbers, most numbers may cancel each other out, and you may end up with a result that has only one or two digits of precision. This is referred to as catastrophic cancellation, and it’s quite easy in such circumstances to end up computing with numbers that are totally garbage.

While floating-point numbers enable you to carry out calculations that would be impossible without them, you must always keep their limitations in mind if you want to be sure your results are valid. This means considering the range of values that you are likely to be working with and their relative values. The field that deals with analyzing and maximizing the precision—or numerical stability—of mathematical computations and algorithms is called numerical analysis. This is an advanced topic, though, and well outside the scope of this book. Suffice to say that the precision of floating-point numbers is limited and that the order and nature of arithmetic operations you perform with them can have a significant impact on the accuracy of your results.

Your computer, of course, again does not work with decimal numbers; rather, it works with binary floating-point representations. Bits and bytes, remember? Concretely, nearly all computers today use the encoding and computation rules specified by the IEEE 754 standard. Left to right, each floating-point number then consists of a single sign bit, followed by a fixed number of bits for the exponent, and finally another series of bits that encode the mantissa. The most common floating-point numbers representations are the so-called single precision (1 sign bit, 8 bits for the exponent, and 23 for the mantissa, adding up to 32 bits in total) and double precision (1 + 11 + 52 = 64 bits) floating-point numbers.

Floating-point numbers can represent huge ranges of numbers. A single-precision floating-point number, for instance, can already represent numbers ranging from 10^-38 to 10⁺³⁸. Of course, there’s a price to pay for this flexibility: the number of digits of precision is limited. You know this already from before, and it’s also only logical; of course not all 38 digits of all numbers in the order of 10⁺³⁸ can be represented exactly using 32 bits. After all, the largest signed integer a 32-bit binary integer can represent exactly is only 2³¹ - 1, which is about 2 × 10⁺⁹. The number of decimal digits of precision in a floating-point number depends on how much memory is allocated for its mantissa. A single-precision floating-point value, for instance, provides approximately seven decimal digits accuracy. We say “approximately” because a binary fraction with 23 bits doesn’t exactly correspond to a decimal fraction with seven decimal digits. A double-precision floating-point value corresponds to around 16 decimal digits accuracy.

ASCII Codes

Way back in the 1960s, the American Standard Code for Information Interchange (ASCII) was defined for representing characters. This is a 7-bit code, so there are 128 different code values. ASCII values 0 to 31 represent various nonprinting control characters such as carriage return (code 15) and line feed (code 12). Code values 65 to 90 inclusive are the uppercase letters A to Z, and 97 to 122 correspond to lowercase a to z. If you look at the binary values corresponding to the code values for letters, you’ll see that the codes for lowercase and uppercase letters differ only in the sixth bit; lowercase letters have the sixth bit as 0, and uppercase letters have the sixth bit as 1. Other codes represent digits 0 to 9, punctuation, and other characters.

The original 7-bit ASCII is fine if you are American or British, but if you are French or German, you need things like accents and umlauts in text, which are not included in the 128 characters that 7-bit ASCII encodes. To overcome the limitations imposed by a 7-bit code, extended versions of ASCII were defined with 8-bit codes. Values from 0 to 127 represent the same characters as 7-bit ASCII, and values from 128 to 255 are variable. One variant of 8-bit ASCII that you have probably met is called Latin-1, which provides characters for most European languages, but there are others for languages such as Russian.

If you speak Korean, Japanese, Chinese, or Arabic, an 8-bit coding is totally inadequate. To give you an idea, modern encodings of Chinese, Japanese, and Korean scripts (which share a common background) cover nearly 88,000 characters—a tiny bit more than the 256 characters you’re able to get out of 8 bits! To overcome the limitations of extended ASCII, the Universal Character Set (UCS) emerged in the 1990s. UCS is defined by the standard ISO 10646 and has codes with up to 32 bits. This provides the potential for hundreds of millions of unique code values.

UCS and Unicode

UCS defines a mapping between characters and integer code values, called code points. It is important to realize that a code point is not the same as an encoding. A code point is an integer; an encoding specifies a way of representing a given code point as a series of bytes or words. Code values of less than 256 are popular and can be represented in one byte. It would be inefficient to use four bytes to store code values that require just one byte just because there are other codes that require several bytes. Encodings are ways of representing code points that allow them to be stored more efficiently.

Unicode is a standard that defines a set of characters and their code points identical to those in UCS. Unicode also defines several different encodings for these code points and includes additional mechanisms for dealing with such things as right-to-left languages such as Arabic. The range of code points is more than enough to accommodate the character sets for all the languages in the world, as well as many different sets of graphical characters such as mathematical symbols, or even emoticons and emojis. Regardless, the codes are arranged such that strings in the majority of languages can be represented as a sequence of single 16-bit codes.

You have four integer types that store Unicode characters. These are types char, wchar_t, char16_t, and char32_t. You’ll learn more about these in Chapter 2.

Escape Sequences

Because the backslash signals the start of an escape sequence, the only way to enter a backslash as a character constant is by using two successive backslashes (\\).

This program that uses escape sequences outputs a message to the screen. To see it, you’ll need to enter, compile, link, and execute the code:

When you manage to compile, link, and run this program, you should see the following output displayed:

The output is determined by what’s between the outermost double quotes in the following statement:

In principle, everything between the outer double quotes in the preceding statement gets sent to cout. A string of characters between a pair of double quotes is called a string literal . The double quote characters are delimiters that identify the beginning and end of the string literal; they aren’t part of the string. Each escape sequence in the string literal will be converted to the character it represents by the compiler, so the character will be sent to cout, not the escape sequence itself. A backslash in a string literal always indicates the start of an escape sequence, so the first character that’s sent to cout is a double quote character.

Least followed by a space is output next. This is followed by a single quote character, then said, followed by another single quote. Next is a space, followed by the backslash specified by \\. Then a newline character corresponding to \n is written to the stream so the cursor moves to the beginning of the next line. You then send two tab characters to cout with \t\t, so the cursor will be moved two tab positions to the right. The word soonest is output next followed by a space and then mended between single quotes. Finally, a period is output followed by a double quote.

The truth is, in our enthusiasm for showcasing character escaping, we may have gone a bit overboard in Ex1_02.cpp. You actually do not have to escape the single quote character, ', inside string literals ; there’s already no possibility for confusion. So, the following statement would have worked just fine already:

It’s only when within a character literal of the form '\'' that a single quote really needs escaping. Conversely, double quotes, of course, won’t need a backslash then; your compiler will happily accept both '\"' and '"'. But we’re getting ahead of ourselves: character literals are more a topic of the next chapter.

Defining Integer Variables

Here’s a statement that defines an integer variable:

This defines a variable of type int with the name apple_count. The variable will contain some arbitrary junk value. You can and should specify an initial value when you define the variable, like this:

The initial value for apple_count appears between the braces following the name so it has the value 15. The braces enclosing the initial value are called a braced initializer . You’ll meet situations later in the book where a braced initializer will have several values between the braces. You don’t have to initialize variables when you define them, but it’s a good idea to do so. Ensuring variables start out with known values makes it easier to work out what is wrong when the code doesn’t work as you expect.

The size of variables of type int is typically 4 bytes, so they can store integers from -2,147,483,648 to +2,147,483,647. This covers most situations, which is why int is the integer type that is used most frequently.

Here are definitions for three variables of type int :

The initial value for total_fruit is the sum of the values of two variables defined previously. This demonstrates that the initial value for a variable can be an expression. The statements that define the two variables in the expression for the initial value for total_fruit must appear earlier in the source file; otherwise, the definition for total_fruit won’t compile.

The initial value between the braces should be of the same type as the variable you are defining. If it isn’t, the compiler will try to convert it to the required type. If the conversion is to a type with a more limited range of values, the conversion has the potential to lose information. An example would be if you specified the initial value for an integer variable that is not an integer—1.5, for example. A conversion to a type with a more limited range of values is called a narrowing conversion. If you use curly braces to initialize your variables, the compiler will always issue either a warning or an error whenever it detects a narrowing conversion .

There are two other ways for initializing a variable. Functional notation looks like this:

A second alternative is the so-called assignment notation:

Both these possibilities are equally valid as the braced initializer form and mostly completely equivalent. Both are therefore used extensively in existing code as well. In this book, however, we’ll adopt the braced initializer syntax. This is the most recent syntax that was introduced in C++11 specifically to standardize initialization. Its main advantage is that it enables you to initialize just about everything in the same way—which is why it is also commonly referred to as uniform initialization . Another advantage is that the braced initializer form is slightly safer when it comes to narrowing conversions:

All three definitions clearly contain a narrowing conversion. We’ll have more to say about floating-point to integer conversions later, but for now believe us when we say that after these variable definitions banana_count will contain the integer value 7, coconut_count will initialize to 5, and papaya_count will initialize to 0—provided compilation does not fail with an error because of the third statement, of course. It’s unlikely that this is what the author had in mind. Definitions with narrowing conversions such as these are therefore almost always mistakes.

Nevertheless, as far as the C++ standard is concerned, our first two definitions are perfectly legal C++. They are allowed to compile without even the slightest warning. While some compilers do issue a warning about such flagrant narrowing conversions, definitely not all of them do. If you use the braced initializer form, however, a conforming compiler is required to at least issue a diagnostic message. Some compilers will even issue an error and refuse to compile such definitions altogether. We believe inadvertent narrowing conversions do not deserve to go unnoticed, which is why we favor the braced initializer form.

Prior to C++17, there was one relatively common case where uniform initialization could not be used. We’ll return to this exception near the end of this chapter when we discuss the auto keyword. But since this quirk will soon be nothing more than a bad memory, we believe there’s little objective reason left not to embrace the new syntax. Uniformity and predictability, on the other hand, are desirable traits—especially for you, someone who’s taking the first steps in C++. In this book, we’ll therefore consistently use braced initializers.

You can define and initialize more than one variable of a given type in a single statement. Here’s an example:

While this is legal, it’s often considered best to define each variable in a separate statement. This makes the code more readable, and you can explain the purpose of each variable in a comment.

You can write the value of any variable of a fundamental type to the standard output stream. Here’s a program that does that with a couple of integers:

If you compile and execute this, you’ll see that it outputs the values of the three variables following some text explaining what they are. The integer values are automatically converted to a character representation for output by the insertion operator, <<. This works for values of any of the fundamental types.

Zero Initialization

The following statement defines an integer variable with an initial value equal to zero:

You could omit the 0 in the braced initializer here, and the effect would be the same. The statement that defines counter could thus be written like this:

The empty curly braces somewhat resemble the number zero, which makes this syntax easy to remember. Zero initialization works for any fundamental type. For all fundamental numeric types, for instance, an empty braced initializer is always assumed to contain the number zero.

Defining Variables with Fixed Values

Sometimes you’ll want to define variables with values that are fixed and must not be changed. You use the const keyword in the definition of a variable that must not be changed. Such variables are often referred to as constants . Here’s an example:

The const keyword tells the compiler that the value of toe_count must not be changed. Any statement that attempts to modify this value will be flagged as an error during compilation; cutting off someone’s toe is a definite no-no! You can use the const keyword to fix the value of variables of any type.

Decimal Integer Literals

You can write integer literals in a very straightforward way. Here are some examples of decimal integers:

Unsigned integer literals have u or U appended. Literals of types long and type long long have L or LL appended, respectively, and if they are unsigned, they also have u or U appended. If there is no suffix, an integer constant is of type int. The U and L or LL can be in either sequence. You can use lowercase for the L and LL suffixes, but we recommend that you don’t because lowercase L is easily confused with the digit 1.

You could omit the + in the second example, as it’s implied by default, but if you think putting it in makes things clearer, that’s not a problem. The literal +123 is the same as 123 and is of type int because there is no suffix.

The fourth example, 22333, is the number that you, depending on local conventions, might write as either 22,333; 22 333; or 22.333 (though other formatting conventions exist as well). You must not use commas or spaces in a C++ integer literal, though, and adding a dot would turn it into a floating-point literal (as discussed later). Ever since C++14, however, you can use the single quote character, ', to make numeric literals more readable. Here’s an example:

Here are some statements using some of these literals:

Note that there are no restrictions on how to group the digits. Most Western conventions tend to group digits per three, but this is not universal. Natives of the subcontinent of India, for instance, would typically write the literal for 15 million as follows (using groups of two digits except for the rightmost group of three digits):

So far we have been very diligent in adding our literal suffixes—u or U for unsigned literals, L for literals of type long, and so on. In practice, however, you’ll rarely add these in variable initializers of this form. The reason is that no compiler will ever complain if you simply type this:

While all these literals are technically of type (signed) int, your compiler will happily convert them to the correct type for you. As long as the target type can represent the given values without loss of information, there’s no need to issue a warning.

An initializing value should always be within the permitted range for the type of variable, as well as from the correct type. The following two statements violate these restrictions. They require, in other words, what you know to be narrowing conversions:

As we explained earlier, depending on which compiler you use, these braced initializations will result in at least a compiler warning, if not a compilation error.

Hexadecimal Literals

A major use for hexadecimal literals is to define particular patterns of bits. Each hexadecimal digit corresponds to 4 bits, so it’s easy to express a pattern of bits as a hexadecimal literal. The red, blue, and green components (RGB values) of a pixel color, for instance, are often expressed as three bytes packed into a 32-bit word. The color white can be specified as 0xFFFFFF because the intensity of each of the three components in white have the same maximum value of 255, which is 0xFF. The color red would be 0xff0000. Here are some examples:

Octal Literals

Binary Literals

We have illustrated in the code fragments how you can write various combinations for the prefixes and suffixes such as 0x or 0X and UL, LU, or Lu, but of course it’s best to stick to a consistent way of writing integer literals.

As far as your compiler is concerned, it doesn’t matter which number base you choose when you write an integer value. Ultimately it will be stored as a binary number. The different ways for writing an integer are there just for your convenience. You choose one or other of the possible representations to suit the context.

Compound Arithmetic Expressions

If multiple operators appear in the same expression, multiplication, division, and modulus operations always execute before addition and subtraction. Here’s an example of such a case:

You can control the order in which more complicated expressions are executed using parentheses. You could write the statement that calculates a value for perimeter as follows:

The subexpression within the parentheses is evaluated first. The result then is multiplied by two, which produces the same end result as before. If you omit the parentheses here, however, the result would no longer be 18. The result, instead, would become 14:

The reason is that multiplication is always evaluated before addition. So, the previous statement is actually equivalent to the following one:

Parentheses can be nested, in which case subexpressions between parentheses are executed in sequence from the innermost pair of parentheses to the outermost. This example of an expression with nested parentheses will show how it works:

The expression 5*d is evaluated first, and c is added to the result. That result is multiplied by 4, and b is added. That result is multiplied by 3, and a is added. Finally, that result is multiplied by 2 to produce the result of the complete expression.

We will have more to say about the order in which such compound expressions are evaluated in the next chapter. The main thing to remember is that whatever the default evaluation order is, you can always override it by adding parentheses. And even if the default order happens to be what you want, it never hurts to add some extra parentheses just for the sake of clarity:

The op= Assignment Operators

In Ex2_02.cpp, there was a statement that you could write more economically:

This statement could be written using an op= assignment operator. The op = assignment operators, or also compound assignment operators , are so called because they’re composed of an operator and an assignment operator =. You could use one to write the previous statement as follows:

This is the same operation as the previous statement.

In general, an op= assignment is of the following form:

lhs represents a variable of some kind that is the destination for the result of the operator. rhs is any expression. This is equivalent to the following statement:

The parentheses are important because you can write statements such as the following:

This is equivalent to the following:

Without the implied parentheses, the value stored in x would be the result of x * y + 1, which is quite different.

Note that there can be no spaces between op and the =. If you include a space, it will be flagged as an error. You can use += when you want to increment a variable by some amount. For example, the following two statements have the same effect:

The shift operators that appear in the table, << and >>, look the same as the insertion and extraction operators that you have been using with streams. The compiler can figure out what << or >> means in a statement from the context. You'll understand how it is possible that the same operator can mean different things in different situations later in the book.

Postfix Increment and Decrement Operations

The postfix form of ++ increments the variable to which it applies after its value is used in context. For example, you can rewrite the earlier example as follows:

With an initial value of 5 for count, total is assigned the value 11. In this case, count will be incremented to 6 only after being used in the surrounding expression. The preceding statement is thus equivalent to the following two statements:

In an expression such as a++ + b, or even a+++b, it’s less than obvious what you mean, or indeed what the compiler will do. These two expressions are actually the same, but in the second case you might have meant a + ++b, which is different—it evaluates to one more than the other two expressions. It would be clearer to write the preceding statement as follows:

Alternatively, you can use parentheses:

The rules that we’ve discussed in relation to the increment operator also apply to the decrement operator. For example, suppose count has the initial value 5 and you write this statement:

This results in total having the value 10 assigned. However, consider this statement:

In this instance, total is set to 11.

You should take care applying these operators to a given variable more than once in an expression. Suppose count has the value 5 and you write this:

The result of this statement is undefined because the statement modifies the value of count more than once using increment operators. Even though this expression is undefined according to the C++ standard, this doesn’t mean that compilers won’t compile them. It just means that there is no guarantee at all of consistency in the results.

The effects of statements such as the following used to be undefined as well:

Here you’re incrementing the value of the variable that appears on the left of the assignment operator in the expression on the right, so you’re again modifying the value of k twice. Starting with C++17, however, the latter expression has become well-defined. Informally, the C++17 edition of the standard added the rule that all side effects of the right side of an assignment (and this includes compound assignments, increments, and decrements) are fully committed before evaluating the left side and the actual assignment. Nevertheless, the precise rules of when precisely an expression is defined or undefined remain subtle, even in C++17, so our advice remains unchanged:

The increment and decrement operators are usually applied to integers, particularly in the context of loops, as you’ll see in Chapter 5. You’ll see later in this chapter that you can apply them to floating-point variables too. In later chapters, you’ll explore how they can also be applied to certain other data types, in some cases with rather specialized (but very useful) effects.

Pitfalls

Invalid Floating-Point Results

So far as the C++ standard is concerned, the result of division by zero is undefined. Nevertheless, floating-point operations in most computers are implemented according to the IEEE 754 standard (also known as IEC 559). So in practice, compilers generally behave quite similarly when dividing floating-point numbers by zero. Details may differ across specific compilers, so consult your product documentation.

The IEEE floating-point standard defines special values having a binary mantissa of all zeroes and an exponent of all ones to represent +infinity or -infinity, depending on the sign. When you divide a positive nonzero value by zero, the result will be +infinity, and dividing a negative value by zero will result in -infinity.

value in the table is any nonzero value. You can discover how your compiler presents these values by plugging the following code into main():

You’ll see from the output when you run this how ±infinity and NaN look . One possible outcome is this:

Mathematical Functions

The cmath Standard Library header file defines a large selection of trigonometric and numerical functions that you can use in your programs. In this section, we’ll only discuss some of the functions that you are likely to use on a regular basis, but there are many, many more. The functions defined by cmath today truly range from the very basic to some of the most advanced mathematical functions (in the latter category, the C++17 standard, for instance, has recently added beauties such as cylindrical Neumann functions, associated Laguerre polynomials, and the Riemann zeta function). You can consult your favorite Standard Library reference for the complete list.

Besides these, the cmath header provides all basic trigonometric functions (std::cos(), sin(), and tan()), as well as their inverse functions (std::acos(), asin(), and atan()). Angles are always expressed in radians.

Let’s look at some examples of how these are used. Here’s how you can calculate the cosine of an angle in radians :

If the angle is in degrees, you can calculate the tangent by using a value for π to convert to radians:

If you know the height of a church steeple is 100 feet and you’re standing 50 feet from its base, you can calculate the angle in radians of the top of the steeple like this:

You can use this value in angle and the value of distance to calculate the distance from your toe to the top of the steeple:

Of course, fans of Pythagoras of Samos could obtain the result much more easily, like this:

Let’s try a floating-point example. Suppose that you want to construct a circular pond in which you will keep fish. Having looked into the matter, you know that you must allow 2 square feet of pond surface area for every 6 inches of fish length. You need to figure out the diameter of the pond that will keep the fish happy. Here’s how you can do it:

With input values of 20 fish with an average length of 9 inches, this example produces the following output:

You first define three const variables in main() that you’ll use in the calculation. Notice the use of a constant expression to specify the initial value for fish_factor. You can use any expression for an initial value that produces a result of the appropriate type. You specify fish_factor, inches_per_foot, and pi as const because their values are fixed and should not be altered.

Next, you define the fish_count and fish_length variables in which you’ll store the user input. Both have an initial value of zero. The input for the fish length is in inches, so you convert it to feet before you use it in the calculation for the pond. You use the /= operator to convert the original value to feet.

You define a variable for the area for the pond and initialize it with an expression that produces the required value:

The product of fish_count and fish_length gives the total length of all the fish in feet, and multiplying this by fish_factor gives the required area for the pond in square feet. Once computed and initialized, the value of pond_area will and should not be changed anymore, so you might as well declare the variable const to make that clear.

The area of a circle is given by the formula πr², where r is the radius. You can therefore calculate the radius of the circular pond by dividing the area by π and calculating the square root of the result. The diameter is twice the radius, so the whole calculation is carried out by this statement:

You obtain the square root using the sqrt() function from the cmath header.

Of course, you could calculate the pond diameter in a single statement like this:

This eliminates the need for the pond_area variable so the program will be smaller and shorter. It’s debatable whether this is better than the original, though, because it’s far less obvious what is going on.

The last statement in main() outputs the result. Unless you’re an exceptionally meticulous pond enthusiast, however, the pond diameter has more decimal places than you need. Let’s look into how you can fix that.

Old-Style Casts

Prior to the introduction of static_cast<> into C++ around 1998—so a very, very long time ago—an explicit cast of the result of an expression was written like this:

The result of expression is cast to the type between the parentheses. For example, the statement to calculate inches in the previous example could be written like this:

This type of cast is a remnant of the C language and is therefore also referred to as a C-style cast. There are several kinds of casts in C++ that are now differentiated, but the old-style casting syntax covers them all. Because of this, code using the old-style casts is more prone to errors. It isn’t always clear what you intended, and you may not get the result you expected. Therefore:

Finding Other Properties of Fundamental Types

You can retrieve many other items of information about various types. The number of binary digits, or bits, for example, is returned by this expression:

type_name is the type in which you’re interested. For floating-point types, you’ll get the number of bits in the mantissa. For signed integer types, you’ll get the number of bits in the value, that is, excluding the sign bit. You can also find out what the range of the exponent component of floating-point values is, whether a type is signed or not, and so on. You can consult a Standard Library reference for the complete list.

Before we move on, there are two more numeric_limits<> functions we still want to introduce. We promised you earlier that we would. To obtain the special floating-point values for infinity and not-a-number (NaN), you should use expressions of the following form:

None of these expressions would compile for integer types, nor would they compile in the unlikely event that the floating-point types that your compiler uses do not support these special values. Besides quiet_NaN(), there’s a function called signaling_NaN()—and not loud_NaN() or noisy_NaN(). The difference between the two is outside the scope of this brief introduction, though: if you’re interested, you can always consult your Standard Library documentation.

Working with Unicode Characters

ASCII is generally adequate for national language character sets that use Latin characters. However, if you want to work with characters for multiple languages simultaneously or if you want to handle character sets for many non-English languages, 256 character codes doesn’t go nearly far enough, and Unicode is the answer. You can refer to Chapter 1 for a brief introduction on Unicode and character encodings.

Type wchar_t is a fundamental type that can store all members of the largest extended character set that’s supported by an implementation. The type name derives from wide characters because the character is “wider” than the usual single-byte character. By contrast, type char is referred to as “narrow” because of the limited range of character codes that are available.

You define wide-character literals in a similar way to literals of type char, but you prefix them with L. Here’s an example:

This defines wch as type wchar_t and initializes it to the wide-character representation for Z.

Your keyboard may not have keys for representing other national language characters, but you can still create them using hexadecimal notation. Here’s an example:

The value between the single quotes is an escape sequence that specifies the hexadecimal representation of the character code. The backslash indicates the start of the escape sequence, and x or X after the backslash signifies that the code is hexadecimal.

Type wchar_t does not handle international character sets very well. It’s much better to use type char16_t, which stores characters encoded as UTF-16, or char32_t, which stores UTF-32 encoded characters. Here’s an example of defining a variable of type char16_t:

The lowercase u prefix to the literals indicates that they are UTF-16. You prefix UTF-32 literals with uppercase U. Here’s an example:

Of course, if your editor and compiler have the capability to accept and display the characters, you can define cyr like this:

The Standard Library provides standard input and output streams wcin and wcout for reading and writing characters of type wchar_t, but there is no provision with the library for handling char16_t and char32_t character data.