The function main() in the example consists of the function header defining it as main() plus everything from the first opening curly brace ({) to the corresponding closing curly brace (}). The braces enclose the executable statements in the function, which are referred to collectively as the body of the function.

As you'll see, all functions consist of a header that defines (among other things) the function name, followed by the function body that consists of a number of program statements enclosed between a pair of braces. The body of a function may contain no statements at all, in which case, it doesn't do anything.

A function that doesn't do anything may seem somewhat superfluous, but when you're writing a large program, you may map out the complete program structure in functions initially, but omit the code for many of the functions, leaving them with empty or minimal bodies. Doing this means that you can compile and execute the whole program with all its functions at any time and add detailed coding for the functions incrementally.

The program statements making up the function body of main() are each terminated with a semicolon. It's the semicolon that marks the end of a statement, not the end of the line. Consequently, a statement can be spread over several lines when this makes the code easier to follow, and several statements can appear in a single line. The program statement is the basic unit in defining what a program does. This is a bit like a sentence in a paragraph of text, where each sentence stands by itself in expressing an action or an idea, but relates to and combines with the other sentences in the paragraph in expressing a more general idea. A statement is a self-contained definition of an action that the computer is to carry out, but that can be combined with other statements to define a more complex action or calculation.

The action of a function is always expressed by a number of statements, each ending with a semicolon. Take a quick look at each of the statements in the example just written, just to get a general feel for how it works. I will discuss each type of statement more fully later in this chapter.

The first statement in the body of the main() function is:

int apples, oranges;           // Declare two integer variables

This statement declares two variables, apples and oranges. A variable is just a named bit of computer memory that you can use to store data, and a statement that introduces the names of one or more variables is called a variable declaration. The keyword int in the preceding statement indicates that the variables with the names apples and oranges are to store values that are whole numbers, or integers. Whenever you introduce the name of a variable into a program, you always specify what kind of data it will store, and this is called the type of the variable.

The next statement declares another integer variable, fruit:

int fruit;                               // ...then another one

While you can declare several variables in the same statement, as you did in the preceding statement for apples and oranges, it is generally a good idea to declare each variable in a separate statement on its own line, as this enables you to comment them individually to explain how you intend to use them.

The next line in the example is:

apples = 5; oranges = 6;       // Set initial values

This line contains two statements, each terminated by a semicolon. I put this here just to demonstrate that you can put more than one statement in a line. While it isn't obligatory, it's generally good programming practice to write only one statement on a line, as it makes the code easier to understand. Good programming practice is about adopting approaches to coding that make your code easy to follow, and minimize the likelihood of errors.

The two statements in the preceding line store the values 5 and 6 in the variables apples and oranges, respectively. These statements are called assignment statements, because they assign a new value to a variable, and the = is the assignment operator.

The next statement is:

fruit = apples + oranges;      // Get the total fruit

This is also an assignment statement, but is a little different because you have an arithmetic expression to the right of the assignment operator. This statement adds together the values stored in the variables apples and oranges and stores the result in the variable fruit.

The next three statements are:

cout << endl;               // Start output on a new line
cout << "Oranges are not the only fruit ... " << endl
     << "- and we have " << fruit << " fruits in all.";
cout << endl;               // Start output on a new line

These are all output statements. The first statement is the first line here, and it sends a newline character, denoted by the word endl, to the command line on the screen. In C++, a source of input or a destination for output is referred to as a stream. The name cout specifies the "standard" output stream, and the operator << indicates that what appears to the right of the operator is to be sent to the output stream, cout. The << operator "points" in the direction that the data flows — from the variable or string that appears on the right of the operator to the output destination on the left. Thus, in the first statement, the value represented by the name endl — which represents a newline character — is sent to the stream identified by the name cout — and data transferred to cout is written to the command line.

The meaning of the name cout and the operator << are defined in the standard library header file iostream, which you added to the program code by means of the #include directive at the beginning of the program. cout is a name in the standard library and, therefore, is within the namespace std. Without the using directive, it would not be recognized unless you used its fully qualified name, which is std::cout, as I mentioned earlier. Because cout has been defined to represent the standard output stream, you shouldn't use the name cout for other purposes, so you can't use it as the name of a variable in your program, for example. Obviously, using the same name for different things is likely to cause confusion.

The second output statement of the three is spread over two lines:

cout << "Oranges are not the only fruit ... " << endl
     << "- and we have " << fruit << " fruits in all.";

As I said earlier, you can spread each statement in a program over as many lines as you wish if it helps to make the code clearer. The end of a statement is always signaled by a semicolon, not the end of a line. Successive lines are read and combined into a single statement by the compiler until it finds the semicolon that defines the end of the statement. Of course, this means that if you forget to put a semicolon at the end of a statement, the compiler will assume the next line is part of the same statement and join them together. This usually results in something the compiler cannot understand, so you'll get an error message.

The statement sends the text string "Oranges are not the only fruit..." to the command line, followed by another newline character (endl), then another text string, "- and we have ", followed by the value stored in the variable fruit, then, finally, another text string, " fruits in all.". There is no problem stringing together a sequence of things that you want to output in this way. The statement executes from left to right, with each item being sent to cout in turn. Note that each item to be sent to cout is preceded by its own << operator.

The third and last output statement just sends another newline character to the screen, and the three statements produce the output from the program that you see.

The last statement in the program is:

return 0;                      // Exit the program

This terminates execution of the main() function, which stops execution of the program. Control returns to the operating system, and the 0 is a return code that tells the operating system that the application terminated successfully after completing its task. I'll discuss all these statements in more detail later.

The statements in a program are executed in the sequence in which they are written, unless a statement specifically causes the natural sequence to be altered. In Chapter 3, you'll look at statements that alter the sequence of execution.

Whitespace is the term used in C++ to describe blanks, tabs, newline characters, form feed characters, and comments. Whitespace serves to separate one part of a statement from another and enables the compiler to identify where one element in a statement, such as int, ends and the next element begins. Otherwise, whitespace is ignored and has no effect.

For example, consider the following statement

int fruit;                     // ...then another one

There must be at least one whitespace character (usually a space) between int and fruit for the compiler to be able to distinguish them, but if you add more whitespace characters, they will be ignored. The content of the line following the semicolon is all whitespace and is therefore ignored.

On the other hand, look at this statement:

fruit = apples + oranges;      // Get the total fruit

No whitespace characters are necessary between fruit and =, or between = and apples, although you are free to include some if you wish. This is because the = is not alphabetic or numeric, so the compiler can separate it from its surroundings. Similarly, no whitespace characters are necessary on either side of the + sign, but you can include some if you want to aid the readability of your code.

As I said, apart from its use as a separator between elements in a statement that might otherwise be confused, whitespace is ignored by the compiler (except, of course, in a string of characters between quotes). Therefore, you can include as much whitespace as you like to make your program more readable, as you did when you spread an output statement in the last example over several lines. Remember that in C++, the end of a statement is wherever the semicolon occurs.

You can enclose several statements between a pair of braces, in which case, they become a block, or a compound statement. The body of a function is an example of a block. Such a compound statement can be thought of as a single statement (as you'll see when you look at the decision-making possibilities in C++ in Chapter 3). In fact, wherever you can put a single statement in C++, you could equally well put a block of statements between braces. As a consequence, blocks can be placed inside other blocks. In fact, blocks can be nested, one within another, to any depth.

In the last example, you opted to produce the project as an empty project with no source files, and then you added the source file subsequently. If you just allow the Application Wizard to generate the project, as you did in Chapter 1, the project will contain several files, and you should explore their contents in a little more depth. Create a new Win32 console project with the name Ex2_01A, and this time, just allow the Application Wizard to finish without choosing to set any of the options in the Application Settings dialog. The project will have four files containing code: the Ex2_01A.cpp and stdafx.cpp source files, the stdafx.h header file, and the targetver.h file that specifies the earliest version of Windows that is capable of running your application. This is to provide for basic capability that you might need in a console program, and represents a working program as it stands, which does nothing. If you have a project open, you can close it by selecting the File

First of all, the contents of Ex2_01A.cpp will be:

// Ex2_01A.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

int _tmain(int argc, _TCHAR* argv[])
{
  return 0;
}
                                                                 

This is decidedly different from the previous example. There is a #include directive for the stdafx.h header file that was not in the previous version, and the function where execution starts is called _tmain(), not main().

The Application Wizard has generated the stdafx.h header file as part of the project, and if you take a look at the code in there, you'll see there are three further #include directives for the targetver.h header that I mentioned earlier, plus the standard library header files stdio.h and tchar.h The old-style header stdio.h is for standard I/O and was used before the current ISO/IEC standard for C++; this covers the same functionality as the iostream header. tchar.h is a Microsoft-specific header file defining text functions. The idea is that stdafx.h should define a set of standard system include files for your project — you would add #include directives for any other system headers that you need in this file. While you are learning ISO/IEC C++, you won't be using either of the headers that appear in stdafx.h, which is one reason for not using the default file generation capability provided by the Application Wizard.

As I already explained, Visual C++ 2010 supports wmain() as an alternative to main() when you are writing a program that's using Unicode characters — wmain() being a Microsoft-specific command that is not part of ISO/IEC standard C++. In support of that, the tchar.h header defines the name _tmain so that it will normally be replaced by main, but will be replaced by wmain if the symbol _UNICODE is defined. Thus, to identify a program as using Unicode, you would add the following statement to the beginning of the stdafx.h header file:

#define _UNICODE

Actually, you don't need to do this with the Ex2_01A project you have just created, because the Character Set project property will have been set to use the Unicode character set by default.

Now that I've explained all that, I'll stick to plain old main() for our ISO/IEC C++ examples that are console applications, because this option is standard C++ and, therefore, the most portable coding approach.

The name you give to a variable is called an identifier or, more conveniently, a variable name. Variable names can include the letters A–z (upper- or lowercase), the digits 0–9, and the underscore character. No other characters are allowed, and if you happen to use some other character, you will typically get an error message when you try to compile the program. Variable names must also begin with either a letter or an underscore. Names are usually chosen to indicate the kind of information to be stored.

Because variable names in Visual C++ 2010 can be up to 2048 characters long, you have a reasonable amount of flexibility in what you call your variables. In fact, as well as variables, there are quite a few other things that have names in C++, and they, too, can have names of up to 2048 characters, with the same definition rules as a variable name. Using names of the maximum length allowed can make your programs a little difficult to read, and unless you have amazing keyboard skills, they are the very devil to type in. A more serious consideration is that not all compilers support such long names. If you anticipate compiling your code in other environments, it's a good idea to limit names to a maximum of 31 characters; this will usually be adequate for devising meaningful names and will avoid problems of compiler name length constraints in most instances.

Although you can use variable names that begin with an underscore (for example, _this and _that), this is best avoided because of potential clashes with standard system variables that have the same form. You should also avoid using names starting with a double underscore for the same reason.

Examples of good variable names include the following:

8_Ball, 7Up, and 6_pack are not legal. Neither is Hash! nor Mary-Ann. This last example is a common mistake, although Mary_Ann with an underscore in place of the hyphen would be quite acceptable. Of course, Mary Ann would not be, because blanks are not allowed in variable names. Note that the variable names republican and Republican are quite different, as names are case-sensitive, so upper- and lowercase letters are differentiated. Of course, whitespace characters in general cannot appear within a name, and if you inadvertently include whitespace characters, you will have two or more names instead of one, which will usually cause the compiler to complain.

A convention that is often adopted in C++ is to reserve names beginning with a capital letter for naming classes and use names beginning with a lowercase letter for variables. I'll discuss classes in Chapter 8.

As you saw earlier, a variable declaration is a program statement that specifies the name of a variable of a given type. For example:

int value;

This declares a variable with the name value that can store integers. The type of data that can be stored in the variable value is specified by the keyword int, so you can only use value to store data of type int. Because int is a keyword, you can't use int as a name for one of your variables.

A single declaration can specify the names of several variables, but as I have said, it is generally better to declare variables in individual statements, one per line. I'll deviate from this from time to time in this book, but only in the interests of not spreading code over too many pages.

In order to store data (for example, the value of an integer), you not only need to have defined the name of the variable, you also need to have associated a piece of the computer's memory with the variable name. This process is called variable definition. In C++, a variable declaration is also a definition (except in a few special cases, which we shall come across during the book). In the course of a single statement, we introduce the variable name, and also tie it to an appropriately sized piece of memory.

So, the statement

int value;

is both a declaration and a definition. You use the variable name value that you have declared to access the piece of the computer's memory that you have defined, and that can store a single value of type int.

You must declare a variable at some point between the beginning of your program and when the variable is used for the first time. In C++, it is good practice to declare variables close to their first point of use.

When you declare a variable, you can also assign an initial value to it. A variable declaration that assigns an initial value to a variable is called an initialization. To initialize a variable when you declare it, you just need to write an equals sign followed by the initializing value after the variable name. You can write the following statements to give each of the variables an initial value:

int value = 0;
int count = 10;
int number = 5;

In this case, value will have the value 0, count will have the value 10, and number will have the value 5.

There is another way of writing the initial value for a variable in C++ called functional notation. Instead of an equals sign and the value, you can simply write the value in parentheses following the variable name. So, you could rewrite the previous declarations as:

int value(0);
int count(10);
int number(5);

Generally, it's a good idea to use either one notation or the other consistently when you are initializing variables. However, I'll use one notation in some examples and the other notation in others, so you get used to seeing both of them in working code.

If you don't supply an initial value for a variable, then it will usually contain whatever garbage was left in the memory location it occupies by the previous program you ran (there is an exception to this that you will meet later in this chapter). Wherever possible, you should initialize your variables when you declare them. If your variables start out with known values, it makes it easier to work out what is happening when things go wrong. And one thing you can be sure of — things will go wrong.

Integer variables are variables that can have only values that are whole numbers. The number of players in a football team is an integer, at least at the beginning of the game. You already know that you can declare integer variables using the keyword int. Variables of type int occupy 4 bytes in memory and can store both positive and negative integer values. The upper and lower limits for the values of a variable of type int correspond to the maximum and minimum signed binary numbers, which can be represented by 32 bits. The upper limit for a variable of type int is 2³¹−1, which is 2,147,483,647, and the lower limit is −(2³¹), which is −2,147,483,648. Here's an example of defining a variable of type int:

int toeCount = 10;

In Visual C++ 2010, the keyword short also defines an integer variable, this time occupying 2 bytes. The keyword short is equivalent to short int, and you could define two variables of type short with the following statements:

short feetPerPerson = 2;
short int feetPerYard = 3;

Both variables are of the same type here because short means exactly the same as short int. I used both forms of the type name to show them in use, but it would be best to stick to one representation of the type in your programs, and of the two, short is used most often.

C++ also provides the integer type, long, which can also be written as long int. Here's how you declare variables of type long:

long bigNumber = 1000000L;
long largeValue = 0L;

Of course, you could also use functional notation when specifying the initial values:

long bigNumber(1000000L);
long largeValue(0L);

These statements declare the variables bigNumber and largeValue with initial values 1000000 and 0, respectively. The letter L appended to the end of the literals specifies that they are integers of type long. You can also use the small letter l for the same purpose, but it has the disadvantage that it is easily confused with the digit 1. Integer literals without an L appended are of type int.

Integer variables declared as long in Visual C++ 2010 occupy 4 bytes and can have values from −2,147,483,648 to 2,147,483,647. This is the same range as for variables declared as type int.

If you need to store integers of an even greater magnitude, you can use variables of type long long:

long long huge = 100000000LL;

Variables of type long long occupy 8 bytes and can store values from −9223372036854775808 to 9223372036854775807. The suffix to identify an integer constant as type long long is LL or ll, but the latter is best avoided.

The char data type serves a dual purpose. It specifies a one-byte variable that you can use either to store integers within a given range, or to store the code for a single ASCII character, which is the American Standard Code for Information Interchange. You can declare a char variable with this statement:

char letter = 'A';

Or you could write this as:

char letter('A'),

This declares the variable with the name letter and initializes it with the constant 'A'. Note that you specify a value that is a single character between single quotes, rather than the double quotes used previously for defining a string of characters to be displayed. A string of characters is a series of values of type char that are grouped together into a single entity called an array. I'll discuss arrays and how strings are handled in C++ in Chapter 4.

Because the character 'A' is represented in ASCII by the decimal value 65, you could have written the statement as:

char letter = 65;            // Equivalent to A

This produces the same result as the previous statement. The range of integers that can be stored in a variable of type char with Visual C++ is from −128 to 127.

The type wchar_t is so called because it is a wide character type, and variables of this type store 2-byte character codes with values in the range from 0 to 65,535. Here's an example of defining a variable of type wchar_t:

wchar_t letter = L'Z';       // A variable storing a 16-bit character code

This defines a variable, letter, that is initialized with the 16-bit code for the letter Z. The L preceding the character constant, 'Z', tells the compiler that this is a 16-bit character code value. A wchar_t variable stores Unicode code values.

You could have used functional notation here, too:

wchar_t letter(L'Z'),        // A variable storing a 16-bit character code

You can also use hexadecimal constants to initialize integer variables, including those of type char, and it is obviously going to be easier to use this notation when character codes are available as hexadecimal values. A hexadecimal number is written using the standard representation for hexadecimal digits: 0 to 9, and A to F (or a to f) for digits with values from 10 to 15. It's also prefixed by 0x (or 0X) to distinguish it from a decimal value. Thus, to get exactly the same result again, you could rewrite the last statement as follows:

wchar_t letter(0x5A);        // A variable storing a 16-bit character code

Notice that Windows XP, Vista, and Windows 7 provide a Character Map utility that enables you to locate characters from any of the fonts available to Windows. It will show the character code in hexadecimal and tell you the keystroke to use for entering the character. You'll find the Character Map utility if you click on the Start button and look in the System Tools folder that is within the Accessories folder.

Variables of the integral types char, int, short, or long store signed integer values by default, so you can use these types to store either positive or negative values. This is because these types are assumed to have the default type modifier signed. So, wherever you wrote int or long, you could have written signed int or signed long, respectively.

You can also use the signed keyword by itself to specify the type of a variable, in which case, it means signed int. For example:

signed value = −5;           // Equivalent to signed int

This usage is not particularly common, and I prefer to use int, which makes it more obvious what is meant.

The range of values that can be stored in a variable of type char is from −128 to 127, which is the same as the range of values you can store in a variable of type signed char. In spite of this, type char and type signed char are different types, so you should not make the mistake of assuming they are the same.

If you are sure that you don't need to store negative values in a variable (for example, if you were recording the number of miles you drive in a week), then you can specify a variable as unsigned:

unsigned long mileage = 0UL;

Here, the minimum value that can be stored in the variable mileage is zero, and the maximum value is 4,294,967,295 (that's 2³²−1). Compare this to the range of −2,147,483,648 to 2,147,483,647 for a signed long. The bit that is used in a signed variable to determine the sign of the value is used in an unsigned variable as part of the numeric value instead. Consequently, an unsigned variable has a larger range of positive values, but it can't represent a negative value. Note how a U (or u) is appended to unsigned constants. In the preceding example, I also have L appended to indicate that the constant is long. You can use either upper- or lowercase for U and L, and the sequence is unimportant. However, it's a good idea to adopt a consistent way of specifying such values.

You can also use unsigned by itself as the type specification for a variable, in which case, you are specifying the variable to be of type unsigned int.

Boolean variables are variables that can have only two values: a value called true and a value called false. The type for a logical variable is bool, named after George Boole, who developed Boolean algebra, and type bool is regarded as an integer type. Boolean variables are also referred to as logical variables. Variables of type bool are used to store the results of tests that can be either true or false, such as whether one value is equal to another.

You could declare the name of a variable of type bool with the statement:

bool testResult;

Of course, you can also initialize variables of type bool when you declare them:

bool colorIsRed = true;

Or like this:

bool colorIsRed(true);

Values that aren't integral are stored as floating-point numbers. A floating-point number can be expressed as a decimal value such as 112.5, or with an exponent such as 1.125E2 where the decimal part is multiplied by the power of 10 specified after the E (for Exponent). Our example is, therefore, 1.125 × 10², which is 112.5.

You can specify a floating-point variable using the keyword double, as in this statement:

double in_to_mm = 25.4;

A variable of type double occupies 8 bytes of memory and stores values accurate to approximately 15 decimal digits. The range of values stored is much wider than that indicated by the 15 digits accuracy, being from 1.7 × 10⁻³⁰⁸ to 1.7 × 10³⁰⁸, positive and negative.

If you don't need 15 digits' precision, and you don't need the massive range of values provided by double variables, you can opt to use the keyword float to declare floating-point variables occupying 4 bytes. For example:

float pi = 3.14159f;

This statement defines a variable pi with the initial value 3.14159. The f at the end of the constant specifies that it is of type float. Without the f, the constant would have been of type double. Variables that you declare as float have approximately 7 decimal digits of precision and can have values from 3.4 × 10⁻³⁸ to 3.4 × 10³⁸, positive and negative.

The ISO/IEC standard for C++ also defines the long double floating-point type, which in Visual C++ 2010, is implemented with the same range and precision as type double. With some compilers, long double corresponds to a 16-byte floating-point value with a much greater range and precision than type double.

I have already used a lot of explicit constants to initialize variables, and in C++, constant values of any kind are referred to as literals. A literal is a value of a specific type, so values such as 23, 3.14159, 9.5f, and true are examples of literals of type int, type double, type float, and type bool, respectively. The literal "Samuel Beckett" is an example of a literal that is a string, but I'll defer discussion of exactly what type this is until Chapter 4. Here's a summary of how you write literals of various types.

You can't specify a literal to be of type short or unsigned short, but the compiler will accept initial values that are literals of type int for variables of these types, provided the value of the literal is within the range of the variable type.

You will often need to use literals in calculations within a program, for example, conversion values such as 12 for feet into inches or 25.4 for inches to millimeters, or a string to specify an error message. However, you should avoid using numeric literals within programs explicitly where their significance is not obvious. It is not necessarily apparent to everyone that when you use the value 2.54, it is the number of centimeters in an inch. It is better to declare a variable with a fixed value corresponding to your literal instead — you might name the variable inchesToCentimeters, for example. Then, wherever you use inchesToCentimeters in your code, it will be quite obvious what it is. You will see how to fix the value of a variable a little later on in this chapter.

The typedef keyword enables you to define your own type name for an existing type. Using typedef, you could define the type name BigOnes as equivalent to the standard long int type with the declaration:

typedef long int BigOnes;       // Defining BigOnes as a type name

This defines BigOnes as an alternative type specifier for long int, so you could declare a variable mynum as long int with the declaration:

BigOnes mynum = 0L;             // Define a long int variable

There's no difference between this declaration and the one using the built-in type name. You could equally well use

long int mynum = 0L;            // Define a long int variable

for exactly the same result. In fact, if you define your own type name such as BigOnes, you can use both type specifiers within the same program for declaring different variables that will end up as having the same type.

Because typedef only defines a synonym for an existing type, it may appear to be a bit superficial, but it is not at all. You'll see later that it fulfills a very useful role in enabling you to simplify more complex declarations by defining a single name that represents a somewhat convoluted type specification. This can make your code much more readable.

You will sometimes be faced with the need for variables that have a limited set of possible values that can be usefully referred to by labels — the days of the week, for example, or months of the year. There is a specific facility in C++ to handle this situation, called an enumeration. Take one of the examples I have just mentioned — a variable that can assume values corresponding to days of the week. You can define this as follows:

enum Week{Mon, Tues, Wed, Thurs, Fri, Sat, Sun} thisWeek;

This declares an enumeration type with the name Week and the variable thisWeek, which is an instance of the enumeration type Week that can assume only the constant values specified between the braces. If you try to assign to thisWeek anything other than one of the set of values specified, it will cause an error. The symbolic names listed between the braces are known as enumerators. In fact, each of the names of the days will be automatically defined as representing a fixed integer value. The first name in the list, Mon, will have the value 0, Tues will be 1, and so on.

You could assign one of the enumeration constants as the value of the variable thisWeek like this:

thisWeek = Thurs;

Note that you do not need to qualify the enumeration constant with the name of the enumeration. The value of thisWeek will be 3 because the symbolic constants that an enumeration defines are assigned values of type int by default in sequence, starting with 0.

By default, each successive enumerator is one larger than the value of the previous one, but if you would prefer the implicit numbering to start at a different value, you can just write:

enum Week {Mon = 1, Tues, Wed, Thurs, Fri, Sat, Sun} thisWeek;

Now, the enumeration constants will be equivalent to 1 through 7. The enumerators don't even need to have unique values. You could define Mon and Tues as both having the value 1, for example, with the statement:

enum Week {Mon = 1, Tues = 1, Wed, Thurs, Fri, Sat, Sun} thisWeek;

As the type of the variable thisWeek is type int, it will occupy 4 bytes, as will all variables that are of an enumeration type.

Note that you are not allowed to use functional notation for initializing enumerators. You must use the assignment operator as in the examples you have seen.

Having defined the form of an enumeration, you can define another variable as follows:

enum Week nextWeek;

This defines a variable nextWeek as an enumeration that can assume the values previously specified. You can also omit the enum keyword in declaring a variable, so, instead of the previous statement, you could write:

Week next_week;

If you wish, you can assign specific values to all the enumerators. For example, you could define this enumeration:

enum Punctuation {Comma = ',', Exclamation = '!', Question = '?'} things;

Here, you have defined the possible values for the variable things as the numerical equivalents of the appropriate symbols. The symbols are 44, 33, and 63, respectively, in decimal. As you can see, the values assigned don't have to be in ascending order. If you don't specify all the values explicitly, each enumerator will be assigned a value incrementing by 1 from the last specified value, as in our second Week example.

You can omit the enumeration type if you don't need to define other variables of this type later. For example:

enum {Mon, Tues, Wed, Thurs, Fri, Sat, Sun} thisWeek, nextWeek, lastWeek;

Here, you have three variables declared that can assume values from Mon to Sun. Because the enumeration type is not specified, you cannot refer to it. Note that you cannot define other variables for this enumeration at all, because you would not be permitted to repeat the definition. Doing so would imply that you were redefining values for Mon to Sun, and this isn't allowed.

You obtain input from the keyboard through the standard input stream, cin, using the extraction operator for a stream, >>. To read two integer values from the keyboard into integer variables num1 and num2, you can write this statement:

std::cin >> num1 >> num2;

The extraction operator, >>, "points" in the direction that data flows — in this case, from cin to each of the two variables in turn. Any leading whitespace is skipped, and the first integer value you key in is read into num1. This is because the input statement executes from left to right. Any whitespace following num1 is ignored, and the second integer value that you enter is read into num2. There has to be some whitespace between successive values, though, so that they can be differentiated. The stream input operation ends when you press the Enter key, and execution then continues with the next statement. Of course, errors can arise if you key in the wrong data, but I will assume that you always get it right!

Floating-point values are read from the keyboard in exactly the same way as integers, and of course, you can mix the two. The stream input and operations automatically deal with variables and data of any of the fundamental types. For example, in the statements,

int num1 = 0, num2 = 0;
double factor = 0.0;
std::cin >> num1 >> factor >> num2;

the last line will read an integer into num1, then a floating-point value into factor, and finally, an integer into num2.

You have already seen output to the command line, but I want to revisit it anyway. Writing information to the display operates in a complementary fashion to input. As you have seen, the standard output stream is called cout, and you use the insertion operator, <<, to transfer data to the output stream. This operator also "points" in the direction of data movement. You have already used this operator to output a text string between quotes. I can demonstrate the process of outputting the value of a variable with a simple program.

// Ex2_02.cpp
// Exercising output
#include <iostream>

using std::cout;
using std::endl;

int main()
{
   int num1 = 1234, num2 = 5678;
   cout << endl;                                // Start on a new line
   cout << num1 << num2;                        // Output two values
   cout << endl;                                // End on a new line
   return 0;                                    // Exit program
}
                                                                 

12345678

You can fix the problem of there being no spaces between items of data quite easily, though, just by outputting a space between the two values. You can do this by replacing the following line in your original program:

cout << num1 << num2;                        // Output two values

Just substitute the statement:

cout << num1 << ' ' << num2;                 // Output two values

Of course, if you had several rows of output that you wanted to align in columns, you would need some extra capability because you do not know how many digits there will be in each value. You can take care of this situation by using what is called a manipulator. A manipulator modifies the way in which data output to (or input from) a stream is handled.

Manipulators are defined in the standard library header file iomanip, so you need to add a #include directive for it. The manipulator that you'll use is setw(n), which will output the value that follows right-justified in a field n spaces wide, so setw(6) causes the next output value to be presented in a field with a width of six spaces. Let's see it working.

// Ex2_03.cpp
// Exercising output
#include <iostream>
#include <iomanip>

using std::cout;
using std::endl;
using std::setw;

int main()
{
   int num1 = 1234, num2 = 5678;
   cout << endl;                                // Start on a new line
   cout << setw(6) << num1 << setw(6) << num2;  // Output two values
   cout << endl;                                // Start on a new line
   return 0;                                    // Exit program
}
                                                                  

1234 5678

cout << std::setiosflags(std::ios::left);

When you write a character string between double quotes, you can include special character sequences called escape sequences in the string. They are called escape sequences because they allow characters to be included in a string that otherwise could not be represented in the string, and they do this by escaping from the default interpretation of the characters. An escape sequence starts with a backslash character, , and the backslash character cues the compiler to interpret the character that follows in a special way. For example, a tab character is written as , so the t is understood by the compiler to represent a tab in the string, and not the letter t. Look at these two output statements:

cout << endl << "This is output.";
cout << endl << "	This is output after a tab.";

They will produce these lines:

This is output.
     This is output after a tab.

The in the second output statement causes the output text to be indented to the first tab position.

In fact, instead of using endl, you could use the escape sequence for the newline character, , in each string, so you could rewrite the preceding statements as follows:

cout << "
This is output.";
cout << "
	This is output after a tab.";

Here are some escape sequences that may be particularly useful:

Obviously, if you want to be able to include a backslash or a double quote as a character to appear in a string, you must use the appropriate escape sequences to represent them. Otherwise, the backslash would be interpreted as the start of another escape sequence, and the double quote would indicate the end of the character string.

You can also use characters specified by escape sequences in the initialization of variables of type char. For example:

char Tab = '	';               // Initialize with tab character

Because a character literal is delimited by single quote characters, you must use an escape sequence to specify a character literal that is a single quote, thus '''.

// Ex2_04.cpp
// Using escape sequences
#include <iostream>
#include <iomanip>

using std::cout;

int main()
{
   char newline = '
';                         // Newline escape sequence
   cout << newline;                             // Start on a new line
   cout << ""We'll make our escapes in sequence", he said.";
   cout << "
	The program's over, it's time to make a beep beep.aa";
   cout << newline;                             // Start on a new line
   return 0;                                    // Exit program
}
                                                                  

"We'll make our escapes in sequence", he said.
        The program's over, it's time to make a beep beep.

You have already seen examples of the assignment statement. A typical assignment statement looks like this:

whole = part1 + part2 + part3;

The assignment statement enables you to calculate the value of an expression that appears on the right-hand side of the equals sign, in this case, the sum of part1, part2, and part3, and store the result in the variable specified on the left-hand side, in this case, the variable with the name whole. In this statement, the whole is exactly the sum of its parts, and no more.

You can also write repeated assignments, such as:

a = b = 2;

This is equivalent to assigning the value 2 to b and then assigning the value of b to a, so both variables will end up storing the value 2.

The basic arithmetic operators you have at your disposal are addition, subtraction, multiplication, and division, represented by the symbols +, -, *, and /, respectively. Generally, these operate as you would expect, with the exception of division, which has a slight aberration when working with integer variables or constants, as you'll see. You can write statements such as the following:

netPay = hours * rate - deductions;

Here, the product of hours and rate will be calculated and then deductions subtracted from the value produced. The multiply and divide operators are executed before addition and subtraction, as you would expect. I will discuss the order of execution of the various operators in expressions more fully later in this chapter. The overall result of evaluating the expression hours*rate-deductions will be stored in the variable netPay.

The minus sign used in the last statement has two operands — it subtracts the value of its right operand from the value of its left operand. This is called a binary operation because two values are involved. The minus sign can also be used with one operand to change the sign of the value to which it is applied, in which case it is called a unary minus. You could write this:

int a = 0;
int b = −5;
a = -b;                        // Changes the sign of the operand

Here, a will be assigned the value +5 because the unary minus changes the sign of the value of the operand b.

Note that an assignment is not the equivalent of the equations you saw in high-school algebra. It specifies an action to be carried out rather than a statement of fact. The expression to the right of the assignment operator is evaluated and the result is stored in the location specified on the left.

Look at this statement:

number = number + 1;

This means "add 1 to the current value stored in number and then store the result back in number." As a normal algebraic statement, it wouldn't make sense, but as a programming action, it obviously does.

// Ex2_05.cpp
// Calculating how many rolls of wallpaper are required for a room
#include <iostream>

using std::cout;
using std::cin;
using std::endl;

int main()
{
   double height = 0.0, width = 0.0, length = 0.0; // Room dimensions
   double perimeter = 0.0;                         // Room perimeter

   const double rollWidth = 21.0;                  // Standard roll width
   const double rollLength = 12.0*33.0;            // Standard roll length(33ft.)

   int strips_per_roll = 0;                        // Number of strips in a roll
   int strips_reqd = 0;                            // Number of strips needed
   int nrolls = 0;                                 // Total number of rolls

   cout << endl                                    // Start a new line
        << "Enter the height of the room in inches: ";
   cin >> height;

   cout  << endl                                   // Start a new line
         << "Now enter the length and width in inches: ";
   cin >> length >> width;

   strips_per_roll = rollLength / height;          // Get number of strips per roll
   perimeter = 2.0*(length + width);               // Calculate room perimeter
   strips_reqd = perimeter / rollWidth;            // Get total strips required
   nrolls = strips_reqd / strips_per_roll;         // Calculate number of rolls

cout << endl
        << "For your room you need " << nrolls << " rolls of wallpaper."
        << endl;

   return 0;
}
                                                                 

const double rollWidth = 21.0;                   // Standard roll width
const double rollLength = 12.0*33.0;             // Standard roll length(33ft.)

rollWidth = 0;

const double rollArea = rollWidth*rollLength;

cout << endl                                     // Start a new line
     << "Enter the height of the room in inches: ";
cin >> height;

cout << endl                                      // Start a new line
     << "Now enter the length and width in inches: ";
cin >> length >> width;

strips_per_roll = rollLength / height;    // Get number of strips in a roll
perimeter = 2.0*(length + width);         // Calculate room perimeter
strips_reqd = perimeter / rollWidth;      // Get total strips required
nrolls = strips_reqd / strips_per_roll;   // Calculate number of rolls

strips_per_roll = static_cast<int>(rollLength / height);   // Get number
                                                           // of strips in
                                                           // a roll

cout << endl
     << "For your room you need " << nrolls << " rolls of wallpaper."
     << endl;

return 0;

You saw in the last example that dividing one integer value by another produces an integer result that ignores any remainder, so that 11 divided by 4 gives the result 2. Because the remainder after division can be of great interest, particularly when you are dividing cookies amongst children, for example, C++ provides a special operator, %, for this. So you can write the following statements to handle the cookie-sharing problem:

int residue = 0, cookies = 19, children = 5;
residue = cookies % children;

The variable residue will end up with the value 4, the number left after dividing 19 by 5. To calculate how many cookies each child receives, you just need to use division, as in the statement:

each = cookies / children;

It's often necessary to modify the existing value of a variable, such as by incrementing it or doubling it. You could increment a variable called count using the statement:

count = count + 5;

This simply adds 5 to the current value stored in count and stores the result back in count, so if count started out as 10, it would end up as 15.

You also have an alternative, shorthand way of writing the same thing in C++:

count += 5;

This says, "Take the value in count, add 5 to it, and store the result back in count." We can also use other operators with this notation. For example,

count *= 5;

has the effect of multiplying the current value of count by 5 and storing the result back in count. In general, you can write statements of the form,

lhs op= rhs;

lhs stands for any legal expression for the left-hand side of the statement and is usually (but not necessarily) a variable name. rhs stands for any legal expression on the right-hand side of the statement. op is any of the following operators:

You have already met the first five of these operators, and you'll see the others, which are the shift and logical operators, later in this chapter.

The general form of the statement is equivalent to this:

lhs = lhs op (rhs);

The parentheses around rhs imply that this expression is evaluated first, and the result becomes the right operand for op.

This means that you can write statements such as:

a /= b + c;

This will be identical in effect to this statement:

a = a/(b + c);

Thus, the value of a will be divided by the sum of b and c, and the result will be stored back in a.

This section introduces some unusual arithmetic operators called the increment and decrement operators. You will find them to be quite an asset once you get further into applying C++ in earnest. These are unary operators that you use to increment or decrement the value stored in a variable that holds an integral value. For example, assuming the variable count is of type int, the following three statements all have exactly the same effect:

count = count + 1;      count += 1;      ++count;

They each increment the variable count by 1. The last form, using the increment operator, is clearly the most concise.

The increment operator not only changes the value of the variable to which you apply it, but also results in a value. Thus, using the increment operator to increase the value of a variable by 1 can also appear as part of a more complex expression. If incrementing a variable using the ++ operator, as in ++count, is contained within another expression, then the action of the operator is to first increment the value of the variable and then use the incremented value in the expression. For example, suppose count has the value 5, and you have defined a variable total of type int. Suppose you write the following statement:

total = ++count + 6;

This results in count being incremented to 6, and this result is added to 6, so total is assigned the value 12.

So far, you have written the increment operator, ++, in front of the variable to which it applies. This is called the prefix form of the increment operator. The increment operator also has a postfix form, where the operator is written after the variable to which it applies; the effect of this is slightly different. The variable to which the operator applies is incremented only after its value has been used in context. For example, reset count to the value 5 and rewrite the previous statement as:

total = count++ + 6;

Then total is assigned the value 11, because the initial value of count is used to evaluate the expression before the increment by 1 is applied. The preceding statement is equivalent to the two statements:

total = count + 6;
++count;

The clustering of "+" signs in the preceding example of the postfix form is likely to lead to confusion. Generally, it isn't a good idea to write the increment operator in the way that I have written it here. It would be clearer to write:

total = 6 + count++;

Where you have an expression such as a++ + b, or even a+++b, it becomes less obvious what is meant or what the compiler will do. They are actually the same, but in the second case, you might really have meant a + ++b, which is different. It evaluates to one more than the other two expressions.

Exactly the same rules that I have discussed in relation to the increment operator apply to the decrement operator, --. For example, if count has the initial value 5, then the statement

total = --count + 6;

results in total having the value 10 assigned, whereas,

total = 6 + count--;

sets the value of total to 11. Both operators are usually applied to integers, particularly in the context of loops, as you will see in Chapter 3. You will see in later chapters that they can also be applied to other data types in C++, notably variables that store addresses.

// Ex2_06.cpp
// Exercising the comma operator
#include <iostream>

using std::cout;
using std::endl;

int main()
{
   long num1(0L), num2(0L), num3(0L), num4(0L);

   num4 = (num1 = 10L, num2 = 20L, num3 = 30L);
   cout << endl
        << "The value of a series of expressions "

<< "is the value of the rightmost: "
        << num4;
   cout << endl;

   return 0;
}
                                                                 

The value of a series of expressions is the value of the rightmost: 30

num4 = num1 = 10L

long num1(1L), num2(10L), num3(100L), num4(0L);
num4 = (++num1, ++num2, ++num3);

So far, I haven't talked about how you arrive at the sequence of calculations involved in evaluating an expression. It generally corresponds to what you will have learned at school when dealing with basic arithmetic operators, but there are many other operators in C++. To understand what happens with these, you need to look at the mechanism used in C++ to determine this sequence. It's referred to as operator precedence.

As you saw in example Ex2_05.cpp earlier in this chapter, you can cause an implicit type conversion by writing an expression on the right-hand side of an assignment that is of a different type from the variable on the left-hand side. This can cause values to be changed and information to be lost. For instance, if you assign an expression that results in a float or double value to a variable of type int or a long, the fractional part of the float or double result will be lost, and just the integer part will be stored. (You may lose even more information if the value of your floating-point result exceeds the range of values available for the integer type concerned.)

For example, after executing the following code fragment,

int number = 0;
float decimal = 2.5f;
number = decimal;

the value of number will be 2. Note the f at the end of the constant 2.5f. This indicates to the compiler that this constant is single-precision floating-point. Without the f, the default would have been type double. Any constant containing a decimal point is floating-point. If you don't want it to be double-precision, you need to append the f. A capital letter F would do the job just as well.

With mixed expressions involving the basic types, your compiler automatically arranges casting where necessary, but you can also force a conversion from one type to another by using an explicit type conversion, which is also referred to as a cast. To cast the value of an expression to a given type, you write the cast in the form:

static_cast<the_type_to_convert_to>(expression)

The keyword static_cast reflects the fact that the cast is checked statically — that is, when your program is compiled. No further checks are made when you execute the program to see if this cast is safe to apply. Later, when you get to deal with classes, you will meet dynamic_cast, where the conversion is checked dynamically — that is, when the program is executing. There are also two other kinds of cast — const_cast for removing the const-ness of an expression, and reinterpret_cast, which is an unconditional cast — but I'll say no more about these here.

The effect of the static_cast operation is to convert the value that results from evaluating expression to the type that you specify between the angled brackets. The expression can be anything from a single variable to a complex expression involving lots of nested parentheses.

Here's a specific example of the use of static_cast<>():

double value1 = 10.5;
double value2 = 15.5;
int whole_number = static_cast<int>(value1) + static_cast<int>(value2);

The initializing value for the variable whole_number is the sum of the integral parts of value1 and value2, so they are each explicitly cast to type int. The variable whole_number will therefore have the initial value 25. The casts do not affect the values stored in value1 and value2, which will remain as 10.5 and 15.5, respectively. The values 10 and 15 produced by the casts are just stored temporarily for use in the calculation and then discarded. Although both casts cause a loss of information in the calculation, the compiler will always assume that you know what you are doing when you specify a cast explicitly.

Also, as I described in Ex2_05.cpp relating to assignments involving different types, you can always make it clear that you know the cast is necessary by making it explicit:

strips_per_roll = static_cast<int>(rollLength / height);     //Get number of strips
                                                             // in a roll

You can write an explicit cast for a numerical value to any numeric type, but you should be conscious of the possibility of losing information. If you cast a value of type float or double to type long, for example, you will lose the fractional part of the value when it is converted, so if the value started out as less than 1.0, the result will be 0. If you cast a value of type double to type float, you will lose accuracy because a float variable has only 7 digits precision, whereas double variables maintain 15. Even casting between integer types provides the potential for losing data, depending on the values involved. For example, the value of an integer of type long long can exceed the maximum that you can store in a variable of type int, so casting from a long long value to an int may lose information.

In general, you should avoid casting as far as possible. If you find that you need a lot of casts in your program, the overall design of your program may well be at fault. You need to look at the structure of the program and the ways in which you have chosen data types to see whether you can eliminate, or at least reduce, the number of casts in your program.

Prior to the introduction of static_cast<>() (and the other casts: const_cast<>(), dynamic_cast<>(), and reinterpret_cast<>(), which I'll discuss later in the book) into C++, an explicit cast of the result of an expression to another type was written as:

(the_type_to_convert_to)expression

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

strips_per_roll = (int)(rollLength / height);      //Get number of strips in a roll

Essentially, there are four different kinds of casts, and the old-style casting syntax covers them all. Because of this, code using the old-style casts is more error-prone — it is not always clear what you intended, and you may not get the result you expected. Although you will still see the old style of casting used extensively (it's still part of the language and you will see it in MFC code for historical reasons), I strongly recommend that you stick to using only the new casts in your code.

The bitwise AND, &, is a binary operator that combines corresponding bits in its operands in a particular way. If both corresponding bits are 1, the result is a 1 bit, and if either or both bits are 0, the result is a 0 bit.

The effect of a particular binary operator is often shown using what is called a truth table. This shows, for various possible combinations of operands, what the result is. The truth table for & is as follows:

For each row and column combination, the result of & combining the two is the entry at the intersection of the row and column. You can see how this works in an example:

char letter1 = 'A', letter2 = 'Z', result = 0;
result = letter1 & letter2;

You need to look at the bit patterns to see what happens. The letters 'A' and 'Z' correspond to hexadecimal values 0x41 and 0x5A, respectively. The way in which the bitwise AND operates on these two values is shown in Figure 2-9.

Figure 2.9. FIGURE 2-9

You can confirm this by looking at how corresponding bits combine with & in the truth table. After the assignment, result will have the value 0x40, which corresponds to the character "@".

Because the & produces zero if either bit is zero, you can use this operator to make sure that unwanted bits are set to 0 in a variable. You achieve this by creating what is called a "mask" and combining with the original variable using &. You create the mask by specifying a value that has 1 where you want to keep a bit, and 0 where you want to set a bit to zero. The result of AND-ing the mask with another integer will be 0 bits where the mask bit is 0, and the same value as the original bit in the variable where the mask bit is 1. Suppose you have a variable letter of type char where, for the purposes of illustration, you want to eliminate the high-order 4 bits, but keep the low-order 4 bits. This is easily done by setting up a mask as 0x0F and combining it with the value of letter using & like this:

letter = letter & 0x0F;

or, more concisely:

letter &= 0x0F;

If letter started out as 0x41, it would end up as 0x01 as a result of either of these statements. This operation is shown in Figure 2-10.

Figure 2.10. FIGURE 2-10

The 0 bits in the mask cause corresponding bits in letter to be set to 0, and the 1 bits in the mask cause corresponding bits in letter to be kept as they are.

Similarly, you can use a mask of 0xF0 to keep the 4 high-order bits, and zero the 4 low-order bits. Therefore, this statement,

letter &= 0xF0;

will result in the value of letter being changed from 0x41 to 0x40.

The bitwise OR, |, sometimes called the inclusive OR, combines corresponding bits such that the result is a 1 if either operand bit is a 1, and 0 if both operand bits are 0. The truth table for the bitwise OR is:

You can exercise this with an example of how you could set individual flags packed into a variable of type int. Suppose that you have a variable called style of type short that contains 16 individual 1-bit flags. Suppose further that you are interested in setting individual flags in the variable style. One way of doing this is by defining values that you can combine with the OR operator to set particular bits on. To use in setting the rightmost bit, you can define:

short vredraw = 0x01;

For use in setting the second-to-rightmost bit, you could define the variable hredraw as:

short hredraw = 0x02;

So, you could set the rightmost two bits in the variable style to 1 with the statement:

style = hredraw | vredraw;

The effect of this statement is illustrated in Figure 2-11. Of course, to set the third bit of style to 1, you would use the constant 0x04.

Because the OR operation results in 1 if either of two bits is a 1, OR-ing the two variables together produces a result with both bits set on.

Figure 2.11. FIGURE 2-11

A common requirement is to be able to set flags in a variable without altering any of the others that may have been set elsewhere. You can do this quite easily with a statement such as:

style |= hredraw | vredraw;

This statement will set the two rightmost bits of the variable style to 1, leaving the others at whatever they were before the execution of this statement.

The exclusive OR, ^, is so called because it operates similarly to the inclusive OR but produces 0 when both operand bits are 1. Therefore, its truth table is as follows:

Using the same variable values that we used with the AND, you can look at the result of the following statement:

result = letter1 ^ letter2;

This operation can be represented as:

letter1 0100 0001
letter2 0101 1010

EOR-ed together produce:

result 0001 1011

The variable result is set to 0x1B, or 27 in decimal notation.

The ^ operator has a rather surprising property. Suppose that you have two char variables, first with the value 'A', and last with the value 'Z', corresponding to binary values 0100 0001 and 0101 1010. If you write the statements,

first ^= last;             // Result first is 0001 1011
last ^= first;             // Result last is 0100 0001
first ^= last;             // Result first is 0101 1010

the result of these is that first and last have exchanged values without using any intermediate memory location. This works with any integer values.

The bitwise NOT, ∼, takes a single operand, for which it inverts the bits: 1 becomes 0, and 0 becomes 1. Thus, if you execute the statement,

result = ~letter1;

if letter1 is 0100 0001, the variable result will have the value 1011 1110, which is 0xBE, or 190 as a decimal value.

These operators shift the value of an integer variable a specified number of bits to the left or right. The operator >> is for shifts to the right, while << is the operator for shifts to the left. Bits that "fall off" either end of the variable are lost. Figure 2-12 shows the effect of shifting the 2-byte variable left and right, with the initial value shown.

Figure 2.12. FIGURE 2-12

You declare and initialize a variable called number with the statement:

unsigned short number = 16387U;

As you saw earlier in this chapter, you write unsigned integer literals with a letter U or u appended to the number. You can shift the contents of this variable to the left with the statement:

number <<= 2;              // Shift left two bit positions

The left operand of the shift operator is the value to be shifted, and the number of bit positions that the value is to be shifted is specified by the right operand. The illustration shows the effect of the operation. As you can see, shifting the value 16,387 two positions to the left produces the value 12. The rather drastic change in the value is the result of losing the high-order bit when it is shifted out.

You can also shift the value to the right. Let's reset the value of number to its initial value of 16,387. Then you can write:

number >>= 2;              // Shift right two bit positions

This shifts the value 16,387 two positions to the right, storing the value 4,096. Shifting right 2 bits is effectively dividing the value by 4 (without remainder). This is also shown in the illustration.

As long as bits are not lost, shifting n bits to the left is equivalent to multiplying the value by 2, n times. In other words, it is equivalent to multiplying by 2ⁿ. Similarly, shifting right n bits is equivalent to dividing by 2ⁿ. But beware: as you saw with the left shift of the variable number, if significant bits are lost, the result is nothing like what you would expect. However, this is no different from the multiply operation. If you multiplied the 2-byte number by 4, you would get the same result, so shifting left and multiply are still equivalent. The problem of accuracy arises because the value of the result of the multiplication is outside the range of a 2-byte integer.

You might imagine that confusion could arise between the operators that you have been using for input and output and the shift operators. As far as the compiler is concerned, the meaning will always be clear from the context. If it isn't, the compiler will generate a message, but you need to be careful. For example, if you want to output the result of shifting a variable number left by 2 bits, you could write the following statement:

cout << (number << 2);

Here, the parentheses are essential. Without them, the shift operator will be interpreted by the compiler as a stream operator, so you won't get the result that you intended; the output will be the value of number followed by the value 2.

The right-shift operation is similar to the left-shift. For example, suppose the variable number has the value 24, and you execute the following statement:

number >>= 2;

This will result in number having the value 6, effectively dividing the original value by 4. However, the right shift operates in a special way with signed integer types that are negative (that is, the sign bit, which is the leftmost bit, is 1). In this case, the sign bit is propagated to the right. For example, declare and initialize a variable number of type char with the value −104 in decimal:

char number = −104;        // Binary representation is 1001 1000

Now you can shift it right 2 bits with the operation:

number >>= 2;              // Result 1110 0110

The decimal value of the result is −26, as the sign bit is repeated. With operations on unsigned integer types, of course, the sign bit is not repeated and zeros appear.

The variables that you have declared so far have been declared within a block — that is, within the extent of a pair of braces. These are called automatic variables and are said to have local scope or block scope. An automatic variable is "in scope" from the point at which it is declared until the end of the block containing its declaration. The space that an automatic variable occupies is allocated automatically in a memory area called the stack that is set aside specifically for this purpose. The default size for the stack is 1MB, which is adequate for most purposes, but if it should turn out to be insufficient, you can increase the size of the stack by setting the /STACK option for the project to a value of your choosing.

An automatic variable is "born" when it is defined and space for it is allocated on the stack, and it automatically ceases to exist at the end of the block containing the definition of the variable. This will be at the closing brace matching the first opening brace that precedes the declaration of the variable. Every time the block of statements containing a declaration for an automatic variable is executed, the variable is created anew, and if you specified an initial value for the automatic variable, it will be reinitialized each time it is created. When an automatic variable dies, its memory on the stack will be freed for use by other automatic variables. Let's look at an example demonstrating some of what I've discussed so far about scope.

// Ex2_07.cpp
// Demonstrating variable scope
#include <iostream>

using std::cout;
using std::endl;

int main()
{                                    // Function scope starts here
   int count1 = 10;
   int count3 = 50;
   cout << endl
        << "Value of outer count1 = " << count1
        << endl;

   {                                // New scope starts here...
      int count1 = 20;              // This hides the outer count1
      int count2 = 30;
      cout << "Value of inner count1 = " << count1
           << endl;
      count1 += 3;                  // This affects the inner count1
      count3 += count2;
   }                                // ...and ends here

   cout << "Value of outer count1 = " << count1
        << endl
        << "Value of outer count3 = " << count3
        << endl;

   // cout << count2 << endl;       // uncomment to get an error

   return 0;
}                                   // Function scope ends here
                                                                 

Value of outer count1 = 10
Value of inner count1 = 20

Value of outer count1 = 10
Value of outer count3 = 80

cout << "Value of inner count1 = " << count1
     << endl;

count1 += 3;               // This affects the inner count1

count3 += count2;

// cout << count2 << endl;          // uncomment to get an error

c:microsoft visual studiomyprojectsEx2_07Ex2_07.cpp(29) : error
     C2065: 'count2' : undeclared identifier

You have great flexibility as to where you can place the declarations for your variables. The most important aspect to consider is what scope the variables need to have. Beyond that, you should generally place a declaration close to where the variable is to be first used in a program. You should write your programs with a view to making them as easy as possible for another programmer to understand, and declaring a variable at its first point of use can be helpful in achieving that.

It is possible to place declarations for variables outside of all of the functions that make up a program. The next section looks what effect that has on the variables concerned.

Variables that are declared outside of all blocks and classes (I will discuss classes later in the book) are called globals and have global scope (which is also called global namespace scope or file scope). This means that they are accessible throughout all the functions in the file, following the point at which they are declared. If you declare them at the very top of your program, they will be accessible from anywhere in the file.

Globals also have static storage duration by default. Global variables with static storage duration will exist from the start of execution of the program until execution of the program ends. If you do not specify an initial value for a global variable, it will be initialized with 0 by default. Initialization of global variables takes place before the execution of main() begins, so they are always ready to be used within any code that is within the variable's scope.

Figure 2-13 shows the contents of a source file, Example.cpp, and the arrows indicate the scope of each of the variables.

Figure 2.13. FIGURE 2-13

The variable value1, which appears at the beginning of the file, is declared at global scope, as is value4, which appears after the function main(). The scope of each global variable extends from the point at which it is defined to the end of the file. Even though value4 exists when execution starts, it cannot be referred to in main() because main() is not within the variable's scope. For main() to use value4, you would need to move its declaration to the beginning of the file. Both value1 and value4 will be initialized with 0 by default, which is not the case for the automatic variables. Note that the local variable called value1 in function() hides the global variable of the same name.

Since global variables continue to exist for as long as the program is running, this might raise the question in your mind, "Why not make all variables global and avoid this messing about with local variables that disappear?" This sounds very attractive at first, but as with the Sirens of mythology, there are serious side effects that completely outweigh any advantages you may gain.

Real programs are generally composed of a large number of statements, a significant number of functions, and a great many variables. Declaring all variables at the global scope greatly magnifies the possibility of accidental erroneous modification of a variable, as well as making the job of naming them sensibly quite intractable. They will also occupy memory for the duration of program execution. By keeping variables local to a function or a block, you can be sure they have almost complete protection from external effects, they will only exist and occupy memory from the point at which they are defined to the end of the enclosing block, and the whole development process becomes much easier to manage. That's not to say you should never define variables at global scope. Sometimes, it can be very convenient to define constants that are used throughout the program code at global scope.

If you take a look at the Class View pane for any of the examples that you have created so far and extend the class tree for the project by clicking on the [unfilled] symbol, you will see an entry called Global Functions and Variables. If you click on this, you will see a list of everything in your program that has global scope. This will include all the global functions, as well as any global variables that you have declared.

// Ex2_08.cpp
// Demonstrating variable scope
#include <iostream>

using std::cout;
using std::endl;

int count1 = 100;                         // Global version of count1

int main()
{                                         // Function scope starts here
   int count1 = 10;
   int count3 = 50;
   cout << endl
        << "Value of outer count1 = " << count1
        << endl;
   cout << "Value of global count1 = " << ::count1            // From outer block
        << endl;

 {                                // New scope starts here...
      int count1 = 20;            // This hides the outer count1
      int count2 = 30;
      cout << "Value of inner count1 = " << count1
           << endl;
      cout << "Value of global count1 = " << ::count1         // From inner block
           << endl;

    count1 += 3;                  // This affects the inner count1
      count3 += count2;

}                              // ...and ends here.

   cout << "Value of outer count1 = " << count1
        << endl
        << "Value of outer count3 = " << count3
        << endl;

   //cout << count2 << endl;        // uncomment to get an error
   return 0;
}                                   // Function scope ends here
                                                                 

Value of outer count1 = 10
Value of global count1 = 100
Value of inner count1 = 20
Value of global count1 = 100
Value of outer count1 = 10
Value of outer count3 = 80

int count1 = 100;                         // Global version of count1

cout << "Value of global count1 = " << ::count1               // From outer block
     << endl;

cout << "Value of global count1 = " << ::count1               // From inner block
     << endl;

It's conceivable that you might want to have a variable that's defined and accessible locally, but which also continues to exist after exiting the block in which it is declared. In other words, you need to declare a variable within a block scope, but to give it static storage duration. The static specifier provides you with the means of doing this, and the need for this will become more apparent when we come to deal with functions in Chapter 5.

In fact, a static variable will continue to exist for the life of a program even though it is declared within a block and available only from within that block (or its sub-blocks). It still has block scope, but it has static storage duration. To declare a static integer variable called count, you would write:

static int count;

If you don't provide an initial value for a static variable when you declare it, then it will be initialized for you. The variable count declared here will be initialized with 0. The default initial value for a static variable is always 0, converted to the type applicable to the variable. Remember that this is not the case with automatic variables.

You use the keyword namespace to declare a namespace — like this:

namespace myStuff
{
  // Code that I want to have in the namespace myStuff...
}

This defines a namespace with the name myStuff. All name declarations in the code between the braces will be defined within the myStuff namespace, so to access any such name from a point outside this namespace, the name must be qualified by the namespace name, myStuff, or have a using declaration that identifies that the name is from the myStuff namespace.

You can't declare a namespace inside a function. It's intended to be used the other way around; you use a namespace to contain functions, global variables, and other named entities such as classes in your program. You must not put the definition of main() in a namespace, though. The function main() is where execution starts, and it must always be at global namespace scope; otherwise, the compiler won't recognize it.

You could put the variable value in the previous example in a namespace:

// Ex2_09.cpp
// Declaring a namespace
#include <iostream>

namespace myStuff
{
  int value = 0;
}

int main()
{
  std::cout << "enter an integer: ";
  std::cin  >> myStuff::value;
  std::cout << "
You entered " << myStuff::value
          << std::endl;
  return 0;
}
                                                                 

The myStuff namespace defines a scope, and everything within the namespace scope is qualified with the namespace name. To refer to a name declared within a namespace from outside, you must qualify it with the namespace name. Inside the namespace scope, any of the names declared within it can be referred to without qualification — they are all part of the same family. Now, you must qualify the name value with myStuff, the name of our namespace. If not, the program will not compile. The function main() now refers to names in two different namespaces, and in general, you can have as many namespaces in your program as you need. You could remove the need to qualify value by adding a using directive:

// Ex2_10.cpp
// Using a using directive
#include <iostream>

namespace myStuff
{
  int value = 0;
}

using namespace myStuff;            // Make all the names in myStuff available

int main()
{

std::cout << "enter an integer: ";
  std::cin  >> value;
  std::cout << "
You entered" << value
          << std::endl;
  return 0;
}
                                                                 

You could also have a using directive for std as well, so you wouldn't need to qualify standard library names either, but as I said, this defeats the whole purpose of namespaces. Generally, if you use namespaces in your program, you should not add using directives all over your program; otherwise, you might as well not bother with namespaces in the first place. Having said that, I will add a using directive for std in some of our examples to keep the code less cluttered and easier for you to read. When you are starting out with a new programming language, you can do without clutter, no matter how useful it is in practice.

A real-world program is likely to involve multiple namespaces. You can have multiple declarations of a namespace with a given name, and the contents of all namespace blocks with a given name are within the same namespace. For example, you might have a program file with two namespaces:

namespace sortStuff
{
   // Everything in here is within sortStuff namespace
}

namespace calculateStuff
{
  // Everything in here is within calculateStuff namespace
  // To refer to names from sortStuff they must be qualified
}

namespace sortStuff
{
  // This is a continuation of the namespace sortStuff
  // so from here you can refer to names in the first sortStuff namespace
  // without qualifying the names
}

A second declaration of a namespace with a given name is just a continuation of the first, so you can reference names in the first namespace block from the second without having to qualify them. They are all in the same namespace. Of course, you would not usually organize a source file in this way deliberately, but it can arise quite naturally with header files that you include into a program. For example, you might have something like this:

#include <iostream>       // Contents are in namespace std
#include "myheader.h"     // Contents are in namespace myStuff

#include <string>         // Contents are in namespace std

// and so on...

Here, iostream and string are ISO/IEC C++ standard library headers, and myheader.h represents a header file that contains our program code. You have a situation with the namespaces that is an exact parallel of the previous illustration.

This has given you a basic idea of how namespaces work. There is a lot more to namespaces than I have discussed here, but if you grasp this bit, you should be able to find out more about it without difficulty, if the need arises.

You can and should use the ISO/IEC C++ fundamental data type names in your C++/CLI programs, and with arithmetic operations, they work exactly as you have seen in native C++. Although all the operations with fundamental types you have seen work in the same way in C++/CLI, the fundamental type names in a C++/CLI program have a different meaning and introduce additional capabilities in certain situations. A fundamental type in a C++/CLI program is a value class type and can behave either as an ordinary value or as an object if the circumstances require it.

Within the C++/CLI language, each ISO/IEC fundamental type name maps to a value class type that is defined in the System namespace. Thus, in a C++/CLI program, the ISO/IEC fundamental type names are shorthand for the associated value class type. This enables the value of a fundamental type to be treated simply as a value or be automatically converted to an object of its associated value class type when necessary. The fundamental types, the memory they occupy, and the corresponding value class types are shown in the following table:

By default, type char is equivalent to signed char, so the associated value class type is System::SByte. Note that you can change the default for char to unsigned char by setting the compiler option /J, in which case, the associated value class type will be System::Byte. System is the root namespace name in which the C++/CLI value class types are defined. There are many other types defined within the System namespace, such as the type String for representing strings that you'll meet in Chapter 4. C++/CLI also defines the System::Decimal value class type within the System namespace, and variables of type Decimal store exact decimal values with 28 decimal digits precision.

As I said, the value class type associated with each fundamental type name adds important additional capabilities for such variables in C++/CLI. When necessary, the compiler will arrange for automatic conversions from the original value to an object of a value class type, and vice versa; these processes are referred to as boxing and unboxing, respectively. This allows a variable of any of these types to behave as a simple value or as an object, depending on the circumstances. You'll learn more about how and when this happens in Chapter 9.

Because the ISO/IEC C++ fundamental type names are aliases for the value class type names in a C++/CLI program, in principle, you can use either in your C++/CLI code. For example, you already know you can write statements creating integer and floating-point variables like this:

int count = 10;
double value = 2.5;

You could use the value class names that correspond with the fundamental type names and have the program compile without any problem, like this:

System::Int32 count = 10;
System::Double value = 2.5;

Note that this is not exactly the same as using the fundamental type names such as int and double in your code, rather than the value class names System::Int32 and System::Double. The reason is that the mapping between fundamental type names and value class types I have described applies to the Visual C++ 2010 compiler; other compilers are not obliged to implement the same mapping. Type long in Visual C++ 2010 maps to type Int32, but it is quite possible that it could map to type Int64 on some other implementation. On the other hand, the representations of the value class type that are equivalents to the fundamental native C++ types are fixed; for example, type System::Int32 will always be a 32-bit signed integer on any C++/CLI implementation.

Having data of the fundamental types being represented by objects of a value class type is an important feature of C++/CLI. In ISO/IEC C++, fundamental types and class types are quite different, whereas in C++/CLI, all data is stored as objects of a class type, either as a value class type or as a reference class type. You'll learn how you define reference class types in Chapter 7.

Next, you'll try a CLR console program.

TRY IT OUT: A Fruity CLR Console Program

Create a new project and select the project type as CLR and the template as CLR Console Application. You can then enter the project name as Ex2_11, as shown in Figure 2-14.

Figure 2.14. FIGURE 2-14

When you click on the OK button, the Application Wizard will generate the project containing the following code:

// Ex2_11.cpp : main project file.

#include "stdafx.h"

using namespace System;

int main(array<System::String ^> rgs)
{
    Console::WriteLine(L"Hello World");
    return 0;
}

I'm sure you noticed the extra stuffbetween the parentheses following main. This is concerned with passing values to the function main() when you initiate execution of the program from the command line, and you'll learn more about this when you explore functions in detail. If you compile and execute the default project, it will write "Hello World" to the command line. Now, you'll convert this program to a CLR version of Ex2_02 so you can see how similar it is. To do this, you can modify the code in Ex2_11.cpp as follows:

// Ex2_11.cpp : main project file.
#include "stdafx.h"

using namespace System;

int main(array<System::String ^> rgs)
{
   int apples, oranges;                   // Declare two integer variables
   int fruit;                             // ...then another one

   apples = 5; oranges = 6;                 // Set initial values
   fruit = apples + oranges;                // Get the total fruit

   Console::WriteLine(L"
Oranges are not the only fruit...");
   Console::Write(L"- and we have ");
   Console::Write(fruit);
   Console::Write(L" fruits in all.
");
   return 0;
}
                                                                 

The new lines are shown shaded and those in the lower block replace the two lines in the automatically generated version of main(). You can now compile and execute the project. The program should produce the following output:

Oranges are not the only fruit...
- and we have 11 fruits in all.

Remember, if the command window showing the output disappears before you can see it, you can add the following statement immediately before the return statement in the preceding code:

Console::ReadLine();

The program will pause when this statement is reached, waiting for you to press the Enter key.

How It Works

The only significant difference is in how the output is produced. The definitions for the variables and the computation are the same. Although you are using the same type names as in the ISO/IEC C++ version of the example, the effect is not the same. The variables apples, oranges, and fruit will be of the C++/CLI type, System::Int32, that is specified by type int, and they have some additional capabilities compared with the ISO/IEC type. The variables here can act as objects in some circumstances or as simple values as they do here. If you want to confirm that Int32 is the same as int in this case, you could replace the int type name with Int32 and recompile the example. It should work in exactly the same way.

Evidently, the following line of code produces the first line of output:

Console::WriteLine(L"
Oranges are not the only fruit...");

The WriteLine() function is a C++/CLI function that is defined in the Console class in the System namespace. You'll learn about classes in detail in Chapter 7, but for now, the Console class represents the standard input and output streams that correspond to the keyboard and the command line in a command- line window. Thus, the WriteLine() function writes whatever is between the parentheses following the function name to the command line and then writes a newline character to move the cursor to the next line ready for the next output operation. Thus, the preceding statement writes the text " Oranges are not the only fruit..." between the double quotes to the command line. The L that precedes the string indicates that it is a wide-character string where each character occupies two bytes.

The Write() function in the Console class is essentially the same as the WriteLine() function, the only difference being that it does not automatically write a newline character following the output that you specify. You can therefore use the Write() function when you want to write two or more items of data to the same line in individual output statements.

Values that you place between the parentheses that follow the name of a function are called arguments. Depending on how a function was written, it will accept zero, one, or more arguments when it is called. When you need to supply more than one argument, they must be separated by commas. There's more to the output functions in the Console class, so I want to explore Write() and WriteLine() in a little more depth.

You saw in the previous example how you can use the Console::Write() and Console::WriteLine() methods to write a string or other items of data to the command line. You can put a variable of any of the types you have seen between the parentheses following the function name, and the value will be written to the command line. For example, you could write the following statements to output information about a number of packages:

int packageCount = 25;                 // Number of packages
Console::Write(L"There are ");         // Write string - no newline
Console::Write(packageCount);          // Write value - no newline
Console::WriteLine(L" packages.");     // Write string followed by newline

Executing these statements will produce the output:

There are 25 packages.

The output is all on the same line because the first two output statements use the Write() function, which does not output a newline character after writing the data. The last statement uses the WriteLine() function, which does write a newline after the output, so any subsequent output will be on the next line.

It looks a bit of a laborious process having to use three statements to write one line of output, and it will be no surprise to you that there is a better way. That capability is bound up with formatting the output to the command line in a.NET Framework program, so you'll explore that a little next.

Both the Console::Write() and Console::WriteLine() functions have a facility for you to control the format of the output, and the mechanism works in exactly the same way with both. The easiest way to understand it is through some examples. First, look at how you can get the output that was produced by the three output statements in the previous section with a single statement:

int packageCount = 25;
Console::WriteLine(L"There are {0} packages.", packageCount);

The second statement here will output the same output as you saw in the previous section. The first argument to the Console::WriteLine() function here is the string L"There are {0} packages.", and the bit that determines that the value of the second argument should be placed in the string is "{0}." The braces enclose a format string that applies to the second argument to the function, although in this instance, the format string is about as simple as it could get, being just a zero. The arguments that follow the first argument to the Console::WriteLine() function are numbered in sequence starting with zero, like this:

referenced by:                       0     1     2   etc.
Console::WriteLine("Format string", arg2, arg3, arg4, ... );

Thus, the zero between the braces in the previous code fragment indicates that the value of the packageCount argument should replace the {0} in the string that is to be written to the command line.

If you want to output the weight as well as the number of packages, you could write this:

int packageCount = 25;
double packageWeight = 7.5;
Console::WriteLine(L"There are {0} packages weighing {1} pounds.",
                                                      packageCount, packageWeight);

The output statement now has three arguments, and the second and third arguments are referenced by 0 and 1, respectively, between the braces. So, this will produce the output:

There are 25 packages weighing 7.5 pounds.

You could also write the statement with the last two arguments in reverse sequence, like this:

Console::WriteLine(L"There are {1} packages weighing {0} pounds.",
                                                      packageWeight, packageCount);

The packageWeight variable is now referenced by 0 and packageCount by 1 in the format string, and the output will be the same as previously.

You also have the possibility to specify how the data is to be presented on the command line. Suppose that you wanted the floating-point value packageWeight to be output with two places of decimals. You could do that with the following statement:

Console::WriteLine(L"There are {0} packages weighing {1:F2} pounds.",
                                                      packageCount, packageWeight);

In the substring {1:F2}, the colon separates the index value, 1, that identifies the argument to be selected from the format specification that follows, F2. The F in the format specification indicates that the output should be in the form "±ddd.dd..." (where d represents a digit) and the 2 indicates that you want to have two decimal places after the point. The output produced by the statement will be:

There are 25 packages weighing 7.50 pounds.

In general, you can write the format specification in the form {n,w : Axx} where the n is an index value selecting the argument following the format string, w is an optional field width specification, the A is a single letter specifying how the value should be formatted, and the xx is an optional one or two digits specifying the precision for the value. The field-width specification is a signed integer. The value will be right-justified in the field if w is positive and left-justified when it is negative. If the value occupies less than the number of positions specified by w, the output is padded with spaces; if the value requires more positions than that specified by w, the width specification is ignored. Here's another example:

Console::WriteLine(L"Packages:{0,3} Weight: {1,5:F2} pounds.",
                                                      packageCount, packageWeight);

The package count is output with a field width of 3 and the weight with a field width of 5, so the output will be:

Packages: 25 Weight:  7.50 pounds.

There are other format specifiers that enable you to present various types of data in different ways. Here are some of the most useful format specifications:

That gives you enough of a toehold in output to continue with more C++/CLI examples. Now, you'll take a quick look at some of this in action.

// Ex2_12.cpp : main project file.
// Calculating the price of a carpet
#include "stdafx.h"

using namespace System;

int main(array<System::String ^> rgs)
{
  double carpetPriceSqYd = 27.95;
  double roomWidth = 13.5;             // In feet
  double roomLength = 24.75;           // In feet
  const int feetPerYard = 3;
  double roomWidthYds = roomWidth/feetPerYard;
  double roomLengthYds = roomLength/feetPerYard;
  double carpetPrice = roomWidthYds*roomLengthYds*carpetPriceSqYd;

  Console::WriteLine(L"Room size is {0:F2} yards by {1:F2} yards",
                                roomLengthYds, roomWidthYds);
  Console::WriteLine(L"Room area is {0:F2} square yards",
                                roomLengthYds*roomWidthYds);
  Console::WriteLine(L"Carpet price is ${0:F2}", carpetPrice);
  return 0;
}
                                                                 

Room size is 8.25 yards by 4.50 yards
Room area is 37.13 square yards
Carpet price is $1037.64

The keyboard input capabilities that you have with a.NET Framework console program are somewhat limited. You can read a complete line of input as a string using the Console::ReadLine() function, or you can read a single character using the Console::Read() function. You can also read which key was pressed using the Console::ReadKey() function.

You would use the Console::ReadLine() function like this:

String^ line = Console::ReadLine();

This reads a complete line of input text that is terminated when you press the Enter key. The variable line is of type String^ and stores a reference to the string that results from executing the Console::ReadLine() function; the little hat character, ^, following the type name, String, indicates that this is a handle that references an object of type String. You'll learn more about type String and handles for String objects in Chapter 4.

A statement that reads a single character from the keyboard looks like this:

char ch = Console::Read();

With the Read() function, you could read input data character by character, and then, analyze the characters read and convert the input to a corresponding numeric value.

The Console::ReadKey() function returns the key that was pressed as an object of type ConsoleKeyInfo, which is a value class type defined in the System namespace. Here's a statement to read a key press:

ConsoleKeyInfo keyPress = Console::ReadKey(true);

The argument true to the ReadKey() function results in the key press not being displayed on the command line. An argument value of false (or omitting the argument) will cause the character corresponding to the key pressed being displayed. The result of executing the function will be stored in keyPress. To identify the character corresponding to the key (or keys) pressed, you use the expression keyPress.KeyChar. Thus, you could output a message relating to a key press with the following statement:

Console::WriteLine(L"The key press corresponds to the character: {0}",
                                                            keyPress.KeyChar);

The key that was pressed is identified by the expression keyPress.Key. This expression refers to a value of a C++/CLI enumeration (which you'll learn about very soon) that identifies the key that was pressed. There's more to the ConsoleKeyInfo objects than I have described. You'll meet them again later in the book.

While not having formatted input in a C++/CLI console program is a slight inconvenience while you are learning, in practice, this is a minor limitation. Virtually all the real-world programs you are likely to write will receive input through components of a window, so you won't typically have the need to read data from the command line. However, if you do, the value classes that are the equivalents of the fundamental types can help.

Reading numerical values from the command line will involve using some facilities that I have not yet discussed. You'll learn about these later in the book, so I'll gloss over some of the details at this point.

If you read a string containing an integer value using the Console::ReadLine() function, the Parse() function in the Int32 class will convert it to a 32-bit integer for you. Here's how you might read an integer using that:

Console::Write(L"Enter an integer: ");
int value = Int32::Parse(Console::ReadLine());
Console::WriteLine(L"You entered {0}", value);

The first statement just prompts for the input that is required, and the second statement reads the input. The string that the Console::ReadLine() function returns is passed as the argument to the Parse() function that belongs to the Int32 class. This will convert the string to a 32-bit integer and store it in value. The last statement outputs the value to show that all is well. Of course, if you enter something that is not an integer, disaster will surely follow.

The other value classes that correspond to native C++ fundamental types also define a Parse() function, so, for example, when you want to read a floating-point value from the keyboard, you can pass the string that Console::ReadLine() returns to the Double::Parse() function. The result will be a value of type double.

The safe_cast operation is for explicit casts in the CLR environment. In most instances, you can use static_cast to cast from one type to another in a C++/CLI program without problems, but because there are exceptions that will result in an error message, it is better to use safe_cast. You use safe_cast in exactly the same way as static_cast. For example:

double value1 = 10.5;
double value2 = 15.5;
int whole_number = safe_cast<int>(value1) + safe_cast<int>(value2);

The last statement casts each of the values of type double to type int before adding them together and storing the result in whole_number.

Enumerations in a C++/CLI program are significantly different from those in an ISO/IEC C++ program. For a start, you define an enumeration in C++/CLI like this:

enum class Suit{Clubs, Diamonds, Hearts, Spades};

This defines an enumeration type, Suit, and variables of type Suit can be assigned only one of the values defined by the enumeration — Hearts, Clubs, Diamonds, or Spades. When you refer to the constants in a C++/CLI enumeration, you must always qualify the constant you are using with the enumeration type name. For example:

Suit suit = Suit::Clubs;

This statement assigns the value Clubs from the Suit enumeration to the variable with the name suit. The :: operator that separates the type name, Suit, from the name of the enumeration constant, Clubs, is the scope resolution operator that you have seen before, and it indicates that Clubs exists within the scope of the Suit enumeration.

Note the use of the word class in the definition of the enumeration, following the enum keyword. This does not appear in the definition of an ISO/IEC C++ enumeration as you saw earlier, and it identifies the enumeration as C++/CLI. In fact, the two words combined, enum class, are a keyword in C++/CLI that is different from the two keywords, enum and class. The use of the enum class keyword gives a clue to another difference from an ISO/IEC C++ enumeration; the constants here that are defined within the enumeration — Hearts, Clubs, and so on — are objects, not simply values of a fundamental type as in the ISO/IEC C++ version. In fact, by default, they are objects of type Int32, so they each encapsulate a 32-bit integer value; however, you must cast a constant to the fundamental type int before attempting to use it as such.

Because a C++/CLI enumeration is a class type, you cannot define it locally, within a function, for example, so if you want to define such an enumeration for use in main(), for example, you would define it at global scope.

This is easy to see with an example.

// Ex2_13.cpp : main project file.
// Defining and using a C++/CLI enumeration.
#include "stdafx.h"

using namespace System;

// Define the enumeration at global scope
enum class Suit{Clubs, Diamonds, Hearts, Spades};

int main(array<System::String ^> rgs)
{
    Suit suit = Suit::Clubs;
    int value = safe_cast<int>(suit);
    Console::WriteLine(L"Suit is {0} and the value is {1} ", suit, value);
    suit = Suit::Diamonds;
    value = safe_cast<int>(suit);
    Console::WriteLine(L"Suit is {0} and the value is {1} ", suit, value);
    suit = Suit::Hearts;
    value = safe_cast<int>(suit);
    Console::WriteLine(L"Suit is {0} and the value is {1} ", suit, value);
    suit = Suit::Spades;
    value = safe_cast<int>(suit);
    Console::WriteLine(L"Suit is {0} and the value is {1} ", suit, value);
    return 0;
}
                                                                 

Suit is Clubs and the value is 0
Suit is Diamonds and the value is 1
Suit is Hearts and the value is 2
Suit is Spades and the value is 3

Suit suit = Suit::Clubs;

value = safe_cast<int>(suit);

short       int         long         long long     signed char    char
unsigned    unsigned    unsigned     unsigned      unsigned       bool
short       int         long         long long     char

enum class Face : char {Ace, Two, Three, Four, Five, Six, Seven,
                        Eight, Nine, Ten, Jack, Queen, King};

enum class Face : char {Ace = 1, Two, Three, Four, Five, Six, Seven,
                        Eight, Nine, Ten, Jack, Queen, King};

enum class Face : char {Ace = 14, Two = 2, Three, Four, Five, Six, Seven,
                        Eight, Nine, Ten, Jack, Queen, King};

enum class WeekDays : bool { Mon = true, Tues = true, Wed = true,
                            Thurs = true, Fri = true, Sat = false, Sun = false };

Face card = Face::Ten;
++card;
Console::WriteLine(L"Card is {0}", card);

Card is Jack

card = card – Face::Two;

card = card – 2;                       // Wrong! Will not compile.

card = card - safe_cast<Face>(2);      //OK!

[Flags] enum class FlagBits{ Ready = 1, ReadMode = 2, WriteMode = 4,
                                                        EOF = 8, Disabled = 16};

FlagBits status = FlagBits::Ready | FlagBits::ReadMode | FlagBits::EOF;

0000 0000 0000 0000 0000 0000 0000 1011

Console::WriteLine(L"Current status: {0}", status);

Current status: Ready, ReadMode, EOF

status = status & ~FlagBits::Ready;

status &= ~FlagBits::Ready;           // Wrong! Will not compile.