Variables, expressions, and operators

Variables in C++ are used for storing values which are usually input, manipulated, and output. Variables must be explicitly declared as a specific data type (e.g. basic data types) before usage.

Identifiers

As in regular mathematics, variables have a name that we call an identifier in C++. Identifiers have various rules and conventions.

Identifier rules

Identifiers must adhere to the following rules:

• May only contain alphabetic characters, digits, and underscores
• May not contain any special characters or spaces
• May not start with a digit
• May not be a reserved word
• May not be identical to other identifiers in the same scope

Identifier conventions

Although the following are all legal, identifiers should typically:

• Not start with an underscore (these are frequently used for header files)
• Not be all capital letters, unless used as a constant
• Be descriptive about what is to be stored in them to help with code readability

Identifiers may, additionally, adhere to one of many established naming conventions.

Declaration

A variable can be declared as datatype identifier;

Multiple variables can be declared in one line, for example int x, y, z;

Assignment

Variables can be assigned values as such: x = expression;

int x = 5, y;

y = x * 2;

x = y;

x = 50;

x = 50 + (y + x) * 2;

Note that assignment is associative, so a = b = 5; will first assign the value of 5 to both variables. Also note that assignment is an expression and evaluates to the variable itself, but it must be placed in parentheses. For example cout << (x = 5 + 6); will both output 11 and assign it to the variable x.

Initialization

Variables can be initialized upon declaration or their values can be set later (directly or via input). Variables should always have some value placed in them before they are used in any calculations or output, otherwise erroneous results may occur.

int age = 30; // Initialization upon declaration

double rate;
rate = 0.05; // Not initialization, but a valid method for placing a value in the variable before it is used in a calculation

double fee;
cin >> fee; // Not initialization, but a valid method for placing a value in the variable before it is used in a calculation

Mathematical operations

Standard mathematical operations for integral and floating-point values are + - * / %.

The modulo operator, %, is the remainder when an integral value is divided by another, for example 10 mod 3 = 1, 100 mod 8 = 4, and 20 mod 5 = 0.

The order of operations is similar to regular mathematics, where multiplication and division are evaluated before addition and subtraction. The modulo operator is at the same precedence level as multiplication and division.

To enforce an alternate order of operations, parentheses can be used as in regular mathematics, for example 2 + 3 * 5 = 17 but (2 + 3) * 5 = 25.