• Choose a category
• All
• Classic-Fiction

bool true or false (same as non-0 or 0) bool b = true;

auto The compiler will decide the type automatically auto i = 7; // i will be an int

decltype(expr) The type will be the type of the expression expr int i = 7;

decltype(i) j = 8; // j will also be an int

C++ does not provide a basic string type. However, a standard implementation of a string is provided as part of the standard library as described later in this chapter and in Chapter 14.

Variables can be converted to other types by casting them. For example, an int can be cast to a bool. C++ provides three ways of explicitly changing the type of a variable. The first method is a holdover from C, but is still the most commonly used. The second method seems more natural at first but is rarely seen. The third method is the most verbose, but often considered the cleanest.

bool someBool = (bool)someInt; // method 1

bool someBool = bool(someInt); // method 2

bool someBool = static_cast(someInt); // method 3

The result will be false if the integer was 0 and true otherwise. Chapter 9 describes the different casting methods in more detail. In some contexts, variables can be automatically cast, or coerced. For example, a short can be automatically converted into a long because a long represents the same type of data with additional precision.

long someLong = someShort; // no explicit cast needed

When automatically casting variables, you need to be aware of the potential loss of data. For example, casting a float to an int throws away information (the fractional part of the number). Many compilers will issue a warning if you assign a float to an int without an explicit cast. If you are certain that the left-hand side type is fully compatible with the right-hand side type, it’s okay to cast implicitly.

Operators

What good is a variable if you don’t have a way to change it? The following table shows the most common operators used in C++ and sample code that makes use of them. Note that operators in C++ can be binary (operate on two variables), unary (operate on a single variable), or even ternary (operate on three variables). There is only one ternary operator in C++ and it is covered in the section “Conditionals.”

OPERATOR DESCRIPTION USAGE

= Binary operator to assign the value on the right to the variable on the left. int i;

i = 3;

int j;

j = i;

! Unary operator to complement the true/false (non-0/0) status of a variable. bool b = !true;

bool b2 = !b;

+ Binary operator for addition. int i = 3 + 2;

int j = i + 5;

int k = i + j;

-

*

/ Binary operators for subtraction, multiplication, and division. int i = 5-1;

int j = 5*2;

int k = j / i;

% Binary operator for remainder of a division operation.

Also referred to as the mod operator. int remainder = 5 % 2;

++ Unary operator to increment a variable by 1. If the operator occurs after the variable or post-increment, the result of the expression is the unincremented value. If the operator occurs before the variable or pre-increment, the result of the expression is the new value. i++;

++i;

-- Unary operator to decrement a variable by 1. i--;

--i;

+= Shorthand syntax for i = i + j i += j;

-=

*=

/=

%= Shorthand syntax for

i = i - j;

i = i * j;

i = i / j;

i = i % j; i -= j;

i *= j;

i /= j;

i %= j;

&

&= Takes the raw bits of one variable and performs

a bitwise “AND” with the other variable. i = j & k;

j &= k;

|

|= Takes the raw bits of one variable and performs a bitwise “OR” with the other variable. i = j | k;

j |= k;

<<

>>

<<=

>>= Takes the raw bits of a variable and “shifts” each

bit left (<<) or right (>>) the specified number

of places. i = i << 1;

i = i >> 4;

i <<= 1;

i >>= 4;

^

^= Performs a bitwise “exclusive or” operation on

the two arguments. i = i ^ j;

i ^= j;

The following program shows the most common variable types and operators in action. If you’re unsure about how variables and operators work, try to figure out what the output of this program will be, and then run it to confirm your answer.

#include

using namespace std;

int