Variables, Types and Operators

In C++, single line comments start with // and comment blocks extend from /* to */

1// This is a single-line comment
2
3/*
4This is a multiline
5comment
6*/

C++ is a strongly typed language, so we always declare the types of our variables. Statements end with a semicolon.

1// A boolean - a true or false value
2bool MyBoolean;
3
4// An integer such as 42
5int MyInteger;
6
7// A floating point number such as 3.14
8float MyFloat;
9
10// "Double Precision" floating point numbers
11// use extra memory to improve accuracy
12double MyDouble;

Variables can be initialized at the same time they are declared. There are several ways of doing this, but we typically use braces { and }:

1int MyInteger{42};
2
3// Float literals have an f suffix
4float MyFloat{5.2f};
5
6double MyDouble{5.2};
7
8bool MyBool{true};

Once they've been created, variables are updated using the assignment operator =:

1int MyInteger{42};
2MyInteger = 10;

Literals, variables, and the result of expressions can be used interchangeably:

1int MyInteger{2};
2int AnotherInt{2 + 2};
3int IntegerFromVariable{MyInteger};
4int IntegerFromExpression{MyInteger + 1};

C++ is mostly insensitive to spaces, tabs and line breaks. These are collectively known as white space. We can generally add or remove white space from our code to lay it out in any way we prefer:

1int SomeInt{5};
2int AnotherInt { 5 };
3
4bool SomeBool {
5  false
6};
7
8bool AnotherBool
9  { false };
10
11int A{5}; int B{10}; int C{15};

When providing an initial value, we can ask the compiler to infer the type using the auto keyword.

Note that auto is not dynamic typing. The type will be fixed once the variable is created:

1// Creates a variable of type int
2auto MyVariable { 10 };

This should be used sparingly, as visually concealing the types from our code can make it harder to understand and debug.

C++ performs implicit type conversion at compile time where possible:

1// 2.5 (double) converted to 2.5f (float)
2float MyFloat { 2.5 };
3
4// 2.0 (double) converted to 2 (int)
5int MyInteger { 2.0 };
6
7// 2 (int) converted to 2.0 (double)
8double MyDouble = MyInteger;
9
10// 3 (int) converted to 3.0f (float)
11float MyFloat = 1 + 2;

We can explicitly ask the compiler to do conversions using static_cast. The syntax looks like this:

1static_cast<type_to_cast_to>(value_to_cast)

For example:

1static_cast<int>(2.5); // Returns 2
2static_cast<float>(2); // Returns 2.0f
3
4int MyInt { static_cast<int>(2.5f) };
5float MyFloat { static_cast<float>(MyInt) };

Narrowing Conversions

There are other ways to initialize variables, including the = operator, but uniform initialization using { and } is recommended. It includes some safeguards against potential human error.

Most notably, uniform initialization will throw a compiler error if we attempt an implicit narrowing conversion which would cause data loss.

For example, if we try to store the floating point value 3.14 in an integer, that may be a mistake on our part. Narrowing 3.14 to an integer means we'll be using the value 3. This will mean future calculations are less accurate, and we may not even notice.

The compiler allows narrowing casts at initialization if we use =, but not if we use { and }:

1// Implicit narrowing conversion allowed
2int MyNumber1 = 3.14;
3
4// Implicit narrowing conversion disallowed
5int MyNumber2{3.14}; 
6
7// We make it explicit if this was intended
8int MyNumber3{static_cast<int>(3.14)};

1conversion from 'double' to 'int', possible loss of data

Numbers support all the typical mathematical operators we're familiar with from other programming languages. Below, we demonstrate this with integers, but the techniques work with any numeric type.

1int x { 4 };
2
3// Addition
4x = x + 2; // x is now 6
5
6// Subtraction
7x = x - 2; // x is now 4
8
9// Multiplication
10x = x * 2; // x is now 8
11
12// Division
13x = x / 2; // x is now 4

Integer Division (Quotient and Modulus)

When dividing integers, the result of 5 divided by 2 is considered to be 2, with 1 remaining.

The / operator returns the quotient (2, in this example) whilst % returns the modulus (1, in this example)

1// Integer division returns the quotient
25 / 2; // 2
3
4// Modulus is available using % operator
55 % 2; // 1

Order of Operations

C++ operators are subject to an order of operations. When these are mathematical operations, the order is equivalent to what we expect from math. For example, multiplication happens before addition:

14 + 2 * 2; // = 4 + 4 = 8

Order of operations can be manipulated by introducing brackets:

1(4 + 2) * 2;  // = 6 * 2 = 12

Integer and Floating Point Interaction

Different numeric types generally interact in predictable ways. When either operand of division is a floating point number, the result will also be a floating point number

15 / 2.0; // 2.5
25.0 / 2; // 2.5

When a floating point number is directly converted to an integer, the floating point component is discarded

1int a = 2.1; // 2
2int b = 2.5; // 2
3int c = 2.9; // 2

When initializing a variable, the expression is evaluated before considering what type our variable should eventually have:

1float a{5 / 2}; // 2.0

Assignment using = is an operator too, and it is ordered after most other operators:

1float a;
2a = {5 / 2}; // 2.0

Increment and Decrement Operators

The increment and decrement operators (++ and --) are available. They can come before the operand (as a prefix operator) or after the operand (as a postfix operator)

The prefix and postfix operators modify their operands in the same way. However, the prefix operators return the new value of the operand, whilst the postfix operator returns the previous value.

1int x { 1 };
2int y;
3
4y = ++x; // both x and y are now 2
5y = x++; // x is now 3, but y is still 2

1int x { 1 };
2int y;
3
4y = --x; // both x and y are now 0
5y = x--; // x is now -1, but y is still 0

Compound Assignment

A variable can be modified in place using the compound assignment operators, +=, -=. *= and /=.

These are shorthand ways of writing longer expressions. For example, x += 2 is equivalent to x = x + 2. More examples are below:

1int x { 4 };
2x += 5; // x is now 9
3x -= 5; // x is now 4
4x *= 2; // x is now 8
5x /= 2; // x is now 4

Floating Point Shorthand

When the decimal component of a floating point number is 0, it can be omitted

1float MyFloat { 2.f }; // 2.0f
2double MyDouble { 2. }; // 2.0

Thousands Separator

The ' character can be added to numbers for readability. Typically, this is used as a thousands separator for large numbers:

1int ABigInteger { 1'000'000'000 };
2float ABigFloat { 2'000'000'000.f };

Booleans in C++ have the bool type, and their literal values are either true or false

1bool Bool1 { true };
2bool Bool2 { false };

A boolean value in C++ can be generated in the same way as almost every other modern programming language. We have the 6 usual comparison operators:

• == returns true if the two operands are equal
• != returns true if the two operands are not equal
• > returns true if the left operand is larger than the right operand
• >= returns true if the left operand is larger than or equal to the right operand
• < returns true if the left operand is smaller than the right operand
• <= returns true if the left operand is smaller than or equal to the right operand

1bool MyBool { false };
2
3// The equality operator: ==
4MyBool = 5 == 5; // true
5
6// The inequality operator: !=
7MyBool = 5 != 5; // false
8
9// The greater than operator: >
10MyBool = 5 > 2; // true
11MyBool = 5 > 5; // false
12
13// The greater than or equal to operator: >=
14MyBool = 5 >= 5; // true
15
16// The less than operator: <
17MyBool = 5 < 2; // false
18MyBool = 5 < 5; // false
19
20// The less than or equal to operator: <=
21MyBool = 5 <= 5; // true;

Combining Booleans

Booleans can be combined using the logical and operator, &&:

1true && true; // true
2true && false; // false
3
4// Simplifies to false && true
52 > 5 && 5 > 2; // false

We also have the logical or operator ||:

1true || true; // true
2true || false; // true
3
4// Simplifies to false || true
52 > 5 || 5 > 2; // true

Boolean Order of Operations

Similar to other operators, && and || are subject to an order of operations. We can introduce brackets to control this:

1// Simplifies to true && false
2MyBool = (true || false) && false; // false
3
4// Simplifies to true || false
5MyBool = true || (false && false); // true

Boolean Inversion

Boolean expressions can be inverted using the ! operator

1!true; // false
2!false; // true
3
4// Simplifies to !(false)
5!(5 < 2); // true
6
7// Simplifies to !(false || true), which is !(true)
8!(5 < 2 || 10 > 5); // false

Boolean Implicit Conversion

Many types, including numeric types like int and float can be implicitly cast to booleans. Numeric values that are equal to 0 are considered false, whilst any non-zero number is considered true. For example:

1bool MyBool { 0 }; // false
2bool MyBool { 1 }; // true

Similarly, the opposite is true, although less useful. Boolean true is implicitly cast to numeric 1, whilst false is cast to 0

1int MyInt { true }; // 1
2float MyFloat { false }; // 0.f

In this lesson, we took a tour of the fundamental building blocks of C++: variables, primitive data types, and operators. We learned how to declare and initialize variables, work with the built-in types, and perform operations on them. Key takeaways:

• C++ is a statically-typed language, meaning we must declare the type of a variable when we create it
• The basic built-in types are bool, int, float, and double
• We can initialize variables using braced initialization with the { and } syntax
• The auto keyword can be used for type deduction, but should be used sparingly for clarity
• C++ provides arithmetic, comparison, and logical operators that work as expected from other languages
• Integer and floating-point division work differently - integer division returns the quotient, while floating-point division returns a precise result
• We can use explicit casts like static_cast when we need to convert between types