Variables, Types and Operators

This lesson is a quick introductory tour of variables and operators within C++. It is not intended for those who are entirely new to programming. Rather, the people who may find it useful include:

• those who have completed our introductory course, but want a quick review
• those who are already familiar with programming in another language, but are new to C++
• those who have used C++ in the past, but would benefit from a refresher

It summarises several lessons from our introductory course. For more thorough explanations or additional context, consider completing Chapter 1 of the beginner course.

Previous Course

Intro to Programming with C++

Starting from the fundamentals, become a C++ software engineer, step by step.

View Course

Comments

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*/

Variables and Types

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};

Operators and Expressions

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};

White Space

C++ is generally insensitive to white space. We can space our code as preferred:

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};

Automatic Type Deduction

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.

Type Conversions

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.5 (double) converted to 2 (int)
5int MyInteger { 2.5 };
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
4// It's reasonable to use auto here, as we already
5// specify the type in the call to static cast
6auto MyInt { static_cast<int>(2.5f) };
7auto MyFloat { static_cast<float>(MyInt) };

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.

For example, it 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. Rather than rounding the value to 3, which we may not notice, the compiler instead throws an error if we use the { } syntax:

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',
2possible loss of data

Numbers

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. This can be manipulated by introducing brackets, ( and )

14 + 2 / 2;    // 5 (4 + 1)
2(4 + 2) / 2;  // 3 (6 / 2)

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

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

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
35 > 2 && 5 > 10; // false

We also have the logical or operator ||:

1true || true; // true
2true || false; // true
35 > 2 || 10 > 5; // true

Boolean Order of Operations

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

1MyBool = (true && false) || true; // false
2MyBool = true && (false || true); // true

Boolean Inversion

Boolean expressions can be inverted using the ! operator

1!true; // false
2!false; // true
3!(5 < 2); // true
4!(5 > 2 || 10 > 5); // false

Boolean Implicit Conversion

Numeric types can be implicitly cast to booleans. 0 is falsey; anything else is truthy

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

Summary

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

Next Lesson

Introduction to Functions

Learn the basics of writing and using functions in C++, including syntax, parameters, return types, and scope rules.

ContinueView Course