Creating Variables

In the previous lesson, we constructed a list like this, to show some of the data we would need to describe one of our monsters:

In this lesson, we will see how we can create the variables to store this data.

Let's start with the bool that represents whether or not the monster is currently alive:

1bool isAlive;

This line is an instruction that we want to create a variable of type bool, and we will be using the name isAlive to identify it. Remember, and instruction like this is called a statement and, in C++, we end each statement with a semicolon ;

This statement will cause our program to make a request to the operating system, asking that we be allocated some space in memory. Specifically, it is requesting enough memory to store a boolean value.

From then on, we can use the isAlive identifier any time we want to access the data stored in that memory location.

Code Comments

By using // in our code, we can add a comment.

1// Is the monster currently alive?
2bool isAlive;

Comments are mainly to help developers describe in plain language what their code is doing, and why. They are ignored by the processes that convert our code into an executable.

Anything after the // on a line of code is treated as a comment. In the above example, the entire line is a comment. But comments can also be on the same line as functional code:

1bool isAlive; // This is a comment

As an alternative to a line comment using //, we can also place comments between /* and */ tokens:

1bool isAlive; /* This is a comment */

This style of comment can span multiple lines:

1/*
2This is a comment
3on multiple lines
4*/
5bool isAlive;

It can even go in the middle of a line of functional code, although this is not commonly used:

1bool /* This is a comment */ isAlive;

We'll use comments quite a lot in the code samples of this lesson to explain what is happening.

It is often worth adding comments to your code too, especially as a beginner. They can help you get back up to speed if you come back to your code later, and need a reminder of what certain lines are doing.

Variable Values

Once we have created a variable, we can store a value in it like this:

1// Is the monster currently alive?
2bool isAlive;
3isAlive = false;

The isAlive = false; statement visits the memory location created for the isAlive variable. It then updates that location to represent the boolean value false.

We can provide an initial value for a variable at the same time we first declare it. This is called initializing the variable. This code will request some space to store a boolean, and initialize that boolean to contain the value of false:

1// Is the monster currently alive?
2bool isAlive { false };

The { and } characters are commonly called braces and are used a lot in programming. On US/UK keyboard layouts, they are typically to the right of the P key.

When initializing a variable with a value, we can also do it with the = symbol

1// Is the monster currently alive?
2bool isAlive = false;

1bool isAlive = false;

1bool isAlive { false };

Let's also create an int and a string variable:

1int Level { 5 };
2
3// Remember, strings need wrapped in double quotes
4string Name { "Goblin Warrior" };

Outputting Variables

In the first lesson, we were working with this basic code structure to stream information to the console.

1#include <iostream>
2using namespace std;
3
4int main() {
5  cout << "Hello World!";
6}

1Hello World!

Let's see how our variables integrate with this. Until we learn more, I'd suggest creating all our variables after the using namespace std; line, and doing all cout statements between the { and the } of the main code block.

1int LookAtMe { 5 };

1int ThisWontWork { "Hello World!" };

1int DontDoThis { true };

The following is an example of a program using our new knowledge of variables:

1#include <iostream>
2using namespace std;
3
4string Name { "Goblin Warrior" };
5int Level { 10 };
6
7int main() {
8  cout << "The monster's name is "<< Name;
9  cout << "\nand its level is " << Level;
10}

When we compile and run this, we should see a message like this logged out to the terminal:

1The monster's name is Goblin Warrior
2and its level is 10

Note, if we try to cout boolean values, you might not get what you expect. true will log out as 1 and false will log out as 0. That's not very useful right now, but we will explore booleans in more detail soon.

1bool isAlive;
2
3// Error!  We already have a variable called "isAlive"
4bool isAlive = false;

1bool isAlive;
2
3isAlive = false;

1bool isAlive { false };
2
3// Error! This brace syntax is only for initialization
4isAlive { true };

1bool isAlive { false };
2
3isAlive = true;

Copying Variables

We can initialize a variable using the value of another variable.

In the below code, we are copying the value of the MaxHealth variable into a new variable called CurrentHealth.

1int MaxHealth { 150 };
2int CurrentHealth { MaxHealth };

After this code runs, we will have two variables that initially have the same value, but can then be updated individually.

More Examples

The code sample below shows more examples of how we can create and work with variables.

1// Initialise a new integer variable
2int Health { 150 };
3
4// We can also initialize a variable using =
5int ExperienceLevel = 1;
6
7/*
8We can update the value of an existing
9variable later in our code using the = sign
10*/
11Health = 200;
12
13// We can copy booleans too
14bool isAlive { false };
15bool canAttack { isAlive };
16
17/*
18Remember, we don't redeclare the variable's
19type when we update its value.  We only
20declare its type when we first create it.
21Line 24 is an error because Health
22was already initialized
23*/
24int Health = 250; // error!
25
26/*
27However, when updating a variable, we cannot
28use the { braces } syntax.  Braces are only
29used for initialization.  Therefore,
30line 32 will cause an error
31*/
32ExperienceLevel { 3 }; // error!

Summary

In this lesson, we've covered several key aspects of creating and updating variables in C++. Here's a quick recap:

• Variable Creation: We learned how to declare variables in C++ using various data types like bool, int, float, and string.
• Understanding Statements: We explored the concept of a statement in C++, focusing on its structure and the necessity of ending each statement with a semicolon.
• Memory Allocation: Discussed how declaring a variable requests memory space and how the variable name/identifier allows us to re-access this memory later.
• Using Comments: We introduced how to use comments (// and /* ... */) to make code more readable and understandable.
• Initializing Variables: The lesson covered initializing variables with values using = and braces {}.
• Error Handling: We delved into common errors such as 'Use of undeclared identifier' and 'Redefinition of variable', and how to avoid them.
• Outputting Variables: Demonstrated how to output variable values to the console using cout.
• Copying Variables: Explored initializing variables using the value of other variables, and how they can be updated individually.

Preview of Next Lesson

In our next lesson, we will shift our focus to Using Numeric Variables in C++. This upcoming lesson will delve into:

• Different Numeric Types: Understanding the variety of numeric data types in C++, like int, float, double, and their usage.
• Arithmetic Operations: We will learn how to perform basic arithmetic operations with numeric variables.
• Numeric Precision and Limits: Exploring the concepts of precision in floating-point numbers and the limits of different numeric types.

Let's continue our initial exploration of variables by looking at numbers in more depth!

Next Lesson

Numbers

An introduction to the different types of numbers in C++, and how we can do basic math operations on them.

ContinueView Course