A C++ variable name can be any combination of letters, numbers, and underscores, as long as the first character of the variable name is a letter or an underscore. Although C++ does not place any restrictions on your choice of variable names, they should be meaningful, and you should be consistent in your naming conventions to increase the readability of your code. C++ is case-sensitive. This means that myvariable and myVariable are two separate variables. However, it’s not a good idea to differentiate variables solely on the basis of case; doing so could lead to confusion. It would be easy to type a letter in the wrong case and end up using a completely wrong variable!

You use an assignment expression to assign a value to a variable. All expressions return a value when evaluated, and the value of the assignment expression becomes the new value of the object on the left side. This functionality makes it possible to assign the same value to a group of variables.

noOfMammals = noOfDogs = noOfCats = 0;

In this example, all three variables—noOfMammals, noOfDogs, and noOfCats—are set to 0.

C++ has 12 arithmetic operators, 5 of which operate like the standard mathematical operators: the addition operator + (the plus sign), the subtraction operator – (the minus sign), the multiplication operator * (the asterisk), the division operator / (the slash), and the modulus operator % (the percent sign), which returns the remainder after division.

result = 4 + 2 - 3;  // result = 3
result = 4 * 5;      // result = 20
remainder = 7 % 3;   // remainder = 1

In addition, there are a number of arithmetic assignment operators, each of which consists of the operator and the = (equal sign): so the addition assignment operator += is a plus sign with an equal sign, and we also have –=, *=, /=, %=. These operators are shorthand forms that combine the corresponding mathematical operation with the assignment operation. So, the following two statements are identical:

a = a + 5;
a += 5;

The addition assignment operator is a shortcut operators; thus, there is no difference between the two statements. In both statements, an addition is performed, followed by an assignment. The second form is just a shorter way of expressing a frequently used operation.

The increment and decrement operators are similar shorthand operators, but these operators only add or subtract 1 from the value of the variable.

a++; // Adds 1 to the value of the variable a
a--; // Subtracts 1 from the value of the variable a

There are two forms of the increment and decrement operators: the prefix form ++a or – –a, and the postfix forms a++ or a– –. Although both forms add or subtract 1, in the prefix form, the mathematical operation is performed before the variable is used in the expression; in the postfix form, the variable is incremented or decremented after the variable has been used in the expression.

int a, b, c;
a = b = c = 0;
b = ++a;  // a = 1, b = 1
c = a++;  // c = 1, a = 2

In this code fragment, the final values of the variables are a = 2, b = 1, and c = 1. The prefix increment operator expression added 1 to the value of a before assigning the value of the variable a to the variable b. The postfix increment operator expression assigned the value of the variable a to the variable c and then incremented the value of the variable a by 1.

Relational operators are used to compare two values or expressions, returning a value of true or false. C++ has six relational operators, as shown in the following code:

a > b    // returns true if a is greater than b.
a >= b   // returns true if a is greater than or equal to b.
a < b    // returns true if a is less than b.
a <= b   // returns true if a is less than or equal to b.
a == b   // returns true if a is equal to b.
a != b   // returns true if a is not equal to b.

A logical operator is used to relate two relational expressions. C++ has three logical operators: the AND operator && (two ampersands), the OR operator || (two pipes), and the NOT operator ! (an exclamation point). The AND operator relates two expressions, both of which must be true for the operator to return a true value. The OR operator returns true if either of the two expressions evaluates to true.

a && b               // returns true if both a and b are true
(a > b) && (a < c)   // returns true if a is greater than b and a
                     // is less than c
a || b               // returns true if either a or b are true
(a > b) || (a < c)   // returns true if either a is greater than b
                     // or a is less than c

The evaluation of a relational expression stops as soon as the logical value of the whole expression is determined, a feature known as short-circuit evaluation. For example, the expression expr1 && expr2 is true only if both expr1 and expr2 are true. If expr1 is false, the final value of the expression must be false, and therefore, expr2 is not evaluated.

The NOT operator returns the negation of the Boolean value of its operand:

!a    // returns false if a is true
      // returns true if a is false

These operators are most often used in decision or loop structures, which are discussed in Chapter 5.

C++/CLI has six bitwise operators: the AND operator & (an ampersand), the OR operator | (a vertical bar), the exclusive OR operator ^ (a caret), the complement operator ~ (a tilde), the right-shift operator >> (two right angle brackets), and the left-shift operator << (two left angle brackets). These operators work on the individual bits of the byte and can only be applied to integral operands—the types char, short, int, and long. The bitwise AND operator compares the bits of two operands; if the bit in the same position for each operand is 1, the resulting bit is 1; if, however, either bit is 0 the resulting bit is set to 0. This operator is often used to mask off bits.

The bitwise OR operator compares the bits of two operands. If either bit is 1, the corresponding bit of the result is 1, and if both bits are 0, the corresponding bit of the result is set to 0. The bitwise OR operator is often used to turn on bits, flags, or options.

The exclusive OR operator sets the result bit to 1 only if one of the operands has the corresponding bit set to 1. If the corresponding bit of both operands is 1 or 0, the bit is set to 0.

The complement operator reverses the bit setting of the operand. If the bit is 1, it is set to 0; if the bit is 0, it is set to 1.

The left-shift operator moves the bit pattern of its left operand to the left by the number of bits specified by its right operand. The bits vacated by the left shift are filled with zeros. The right-shift operator moves the bit pattern of its right operand to the right by the number of bits specified by its right operand. If the variable is an unsigned data type, the vacated bits will be filled with zeros; if the variable is signed, the vacated bits will be filled with the sign bit.

int a;
a = 5;
a = a << 2;   // The bits of a will be shifted two bits to the left
              // and the value of 20 assigned to a.
a = 5;
a = a >> 2;   // The bits of a will be shifted two bits to the
              // right and the value of 1 assigned to a.

The ternary operator ?: (a question mark and a colon) acts like an inline if statement. (See Chapter 5 for more information on if statements.) The expression to the left of the question mark is evaluated; if it is true, the value or expression between the question mark and the colon will be returned. If it is false, the value or expression after the colon will be returned.

int a;
bool b;
b = true;
a = b ? 1 : 2;   // b is true, so a is assigned 1.
b = false;
a = b ? 1 : 2;   // b is false, so a is assigned 2.

C++/CLI supports the C-style cast operator, whereby the type to which you want to convert the expression is placed in parentheses in front of the expression; for example, (float) 7. It also supports five C++ cast operators:

The static_cast<> operator changes the data type of the variable, with the type to which you want to cast being placed in the angle brackets. For example, if an expression needs to convert an int to a double, the number should be cast by using the static_cast<double> operator. Here’s an example:

int a = 10;

double b;

b = (int) a;                 // old C-style cast

b = static_cast<double>(a);  // C++ static cast

You use the dynamic_cast<> operator to cast objects down or across the inheritance hierarchy. The const_cast<> operator works with pointers, and references can be used to add or remove the const qualification of the variable. The safe_cast<> operator is an extension added to C++/CLI; it performs the same function as dynamic_cast<> but throws an exception if the cast fails. Using the reinterpret_cast<> operator, you can convert any pointer to a pointer of another type. This particular operator is not used that often in application code.

There are two ways by which the expression 2 + 3 * 4 could be evaluated: It could be evaluated as (2 + 3) * 4, yielding a value of 20, or it could be evaluated as 2 + (3 * 4), yielding a value of 14.

The rules of operator precedence specify an unambiguous evaluation of expressions. Operators higher in the hierarchy are given precedence over operators lower in the hierarchy. Because the * operator is higher than the + operator, the second interpretation of the above expression, 2 + (3 * 4), would be evaluated. For situations in which two operators are at the same level in the hierarchy, the order of evaluation proceeds from left to right. Hence, 2 * 3 / 2 * 3 would be evaluated as ((2 * 3) / 2) * 3, giving a value of 9. Parentheses can be used to group operators and override the precedence hierarchy. For example, (2 * 3) / (2 * 3) results in a value of 1. Many people use parentheses even when they are not strictly required, simply to clarify their intentions. The following table shows the hierarchy of precedence from highest to lowest. Operators in the same row of the table share the same level of precedence.