Variables In C++ | Declare, Initialize, Rules & Types (+Examples)

Every one of us has heard of the term 'variable' and has a broad idea about what it entails. A variable represents something that can change based on external factors or conditions. But what does it mean in computer programming? If you don't know the answer, don't worry. By the end of this article, you will know all about variables, more so about variables in C++ programming.

We will discuss what are variables in C++, how to declare and initialize them, different types of variables, and more with detailed examples.

What Are Variables In C++?

In simple terms, variables in C++ programming language are named locations/ space in memory used to store values or data.

• The data stored in this memory location can be accessed using the variable's name, also known as its identifier.
• We can store various types of data in a variable, but this must be specified when declaring the variable (we will discuss this in a section below).
• Also, a variable's value can be altered while a program is running. i.e. depending on the directions and information passed.

All in all, variables in C++ programs are names given to a memory location, which we can access to perform various manipulation or operations on the data stored there. They are a fundamental unit of storage in a program.

Declaration & Definition Of Variables In C++

The purpose of variable declaration to tell the compiler that a variable exists, without assigning it a value yet. When the compiler receives these signals of the valid declaration it continues with the compilation process without needing more information.

• A variable declaration entails mentioning the data type of the variable, i.e., the type of the data we will store in that variable. This can be int for integer/ whole numbers, char for characters, etc.
• Along with the data type, we must also provide the variable name/ identifier. We will be using this name to refer to the variable across the program.

Also, it is important to adhere to a set of rules when naming them (which we will discuss in a later section). 

Syntax For Declaration Of Variables In C++

data_type variable_name;

Here,

• The data_type indicates the type of information/ values/ data we can store in the variable.
• The variable_name is the identifier or name we will use to identify the variable throughout the program.

As mentioned above, the declaration of variables in C++ programs is essential for the compilation process to continue, but what about the value? 

What Is Definition Of Variables In C++?

The definition of a variable in C++ refers to a phase where the compiler allocates memory space for the variable. In other words, variable declaration introduces the variable and its properties, while the definition is when memory is allocated for that variable.

• The signals given during declaration (data type and name) help the compiler decide how much space to allocate for the variable and then connect that space to the variable name. (This is a variable definition)
• Also, since the variable is still uninitialized, the compiler assigns a random garbage value to it.

Example Program For Declaration Of Variables In C++ Language

Below is an example C++ program where we declare a variable and then print its value without initialization.

Code Example:

#include <iostream>

using namespace std;

int main() {

int age;
double height;
string name;

// Printing the value of age variable
cout << "Age is " << age << endl;

return 0;
}

Output:

Age is 0

Explanation:

In the example C++ code, we first include the header file <iostream> for input/ output (cin/ cout) operations and use namespace std.

1. We then initiate the main() function which is the entry point for the program's execution.
2. In main(), we declare three variables of different data types as follows:
   • The first is variable age, which can store integer type values. 
   • Then, we have the variable height of type double, meaning it can hold floating-point values with double precision.
   • Lastly, we have the variable name of type string, meaning it can store a string value/ character array.
3. Next, as mentioned in the code comments, we use the cout statement to display the value of the age variable.
4. Since the variable is not yet initialized, it holds a garbage value (assigned by the compiler), which is displayed to the console. (It may vary from system to system.)
5. Finally, the main() function terminates with a return 0 statement, indicating successful execution.

Time Complexity: O(1)
Space Complexity: O(1)

Variable Initialization In C++

We have already discussed declaration and definition of variables in C++ programs and their purpose. Once a variable is declared and defined, you need to assign an initial value to it, to make use of the variable in your program. This process of assigning an initial value to variables is known as variable initialization. 

Why Initialize Variables In C++ Programs?

Consider a situation where you want to track your grades, which are stored at different memory addresses. Variables act as aliases for these addresses, making it easier to refer to the data. Initialization is the process of assigning an initial value to a variable, and it ensures that a variable has a well-defined value before it is used in computations.

Syntax For Initialization Of Variables In C++

data_type variable_name = initial_value;

Here, the first part of the syntax is the same as the declaration. In the second half, the equals (=) sign refers to the assignment operator and the initial_value refers to the value you want to assign to the variable.

In the syntax above, we have assigned the value to the variable at the time of declaration. Alternatively, we can initialize variables in C++ programs separately from the declaration. In this case, the syntax will be as follows:

data_type variable_name; //Declaration without initialization
variable_name = initial_value; // Initialization

The primary difference in this syntax and the one before is that, we have assigned the initial value to the variable in a line separate from where we declared it. Look at the C++ program example below, which illustrates both methods of initialization. 

Code Example:

#include <iostream>
using namespace std;

int main() {

int age;
age = 23;

double height = 1.74;
string name = "Anant";

cout << "My name is " << name << ", and I am " << age << " years old." << endl;
cout << "I am " << height << " meters tall." << endl;

return 0;
}

Output:

My name is Anant, and I am 23 years old.
I am 1.74 meters tall.

Explanation:

In the C++ code example, 

1. We declare an integer variable age inside the main() function without initialization.
2. In the next line, we initialize age with the value 23. (This is initialization after the declaration in a separate line)
3. Next, we declare and initialize two variables: height of type double with value 1.74, and name of type string with value "Anant". (This is initialization with declaration).
4. After that, we use the cout command to print the values of the variables with descriptive string messages.

This example demonstrates that both methods of initializing variables in C++ program structure work fine.

Rules & Regulations For Naming Variables In C++ Language

In this section, we will look at the various rules that one must comply with when defining variables in C++. They are as follows: 

1. Letters, Numbers, and Underscores: Variable names can only contain letters (both uppercase and lowercase), numbers, and underscores (_). It cannot contain other special characters.
2. Start With a Letter or Underscore: Variable names must begin with a letter or an underscore. They cannot start with a number.
3. No Reserved Keywords: You cannot use C++ reserved keywords (e.g., int, float, double, return, etc.) as variable names.
4. Case Sensitivity: C++ is case-sensitive, which means Marks and marks are treated as two different variables.
5. Must Declare Before Use: Variables must be declared before they are used in the code. If not declared, the compiler will throw an error.
6. Assignment Operator (=): You can use the assignment operator (=) to assign an initial value to a variable as well as to update the value during the course of execution.
7. Unique Variable Names: Each variable in a program must have a unique name within the same scope. You cannot define two variables with the same name in the same block of code.

Check out this amazing course to become the best version of the C++ programmer you can be.

Different Types Of Variables In C++

In C++, there are six widely accepted types of variables that are crucial for understanding how data is managed. Let’s explore each type with examples.

Local Variables In C++

Variables that are defined inside a block of code (like a function or method) are called local variables. The access to these variables is restricted to only the block in which they were declared. In other words, we can access these variables only within that specified block.

Code Example:

#include <iostream>
using namespace std;

int main() {

int x = 5; // local variable
cout << "The value of x is: " << x << endl;

return 0;
}

/* void addition() {
int result = x + 5;
cout << "The result of addition operation is " << result << endl;
}*/

Output:

The value of x is: 5

Explanation:

In the C++ program sample, we include the essential header files and namespace.

1. In the main() function, we initialize an integer variable x with the value 5.
2. Then, we use the cout statement to print its value to the console.
3. The main() function closes with a return 0, indicating successful execution.
4. After that, we have defined a function addition() in the multi-line comment. In this function, we try to access the variable x, which is local to the main() function only. 
5. If this line were uncommented, it would throw an error, indicating that the variable x is accessible only inside the scope of the function where it is defined, i.e., main().

Global Variables In C++

A variable that is declared outside of any block of code, or function or class is called global variable. It is accessible to across all block of code within the same program/ file. In other words, they have a global scope.

Code Example:

#include <iostream>

int globalVar = 10; // global variable

void foo() {
std::cout << "The value of globalVar inside foo() is: " << globalVar << std::endl;
}

int main() {

std::cout << "The value of globalVar inside main() is: " << globalVar << std::endl;
foo();

return 0;
}

Output:

The value of globalVar inside main() is: 10
The value of globalVar inside foo() is: 10

Explanation:

In this example,

1. We declare an integer variable globlVar at the beginning of the program (outside any block) and initialize it with the value 10. This is the global variable.
2. Then, we define a function foo() which uses std::cout statement to access and print the value of the this variable.
3. Inside the main() function, we use another std::cout statement to access and print the value of the variable with a descriptive message.
4. After that, we call the foo() function before the main() function terminates with a return 0 statement.

As shown in the output, we were able to access the global variable from any block throughout the program. Just like we could access it both through the main() function and in the function foo().

Static Variables In C++

These are variables that are declared using the static keyword and they persist their value across multiple function calls. This means, when a static variable is declared within a function, it is initialized only once and retains its value between different function executions.

• Lifetime: A static variable persists for the duration of the program rather than being destroyed and recreated when a function is called.
• Initialization: If a static variable is not explicitly initialized, it is automatically initialized to 0.
• Value retention: The value of a static variable is retained between function calls, meaning they retain the updated value from the previous function call to the next, rather than getting destroyed after the function is done performing.

Code Example:

#include <iostream>

void incrementAndPrint(){
static int count = 0; // declaring static variable
count++;
std::cout << "Count: " << count << std::endl;
}

int main(){

incrementAndPrint();
incrementAndPrint();
incrementAndPrint();

return 0;
}

Output:

Count: 1
Count: 2
Count: 3

Explanation:

In the C++ example, 

1. We define a function incrementAndPrint(), which has a void return type, meaning it does not return a value. Inside:
   • We declare a static integer variable count and initialize it with the value 0.
   • Next, we use the post-increment operator (++) to increase the value of count by 1 and then print its value using the std::cout statement.
2. In the main() function, we call the incrementAndPrint() function three times.
3. As seen in the output, the initial value of count in first function call is 0, in the second call is 1 (which was the value from the previous operation) and in the third call it is 2. 
4. This shows that static variables persist with their values between function calls.

Instance Variables In C++

Non-static variables that belong to a specific instance (or object) of a class are called instance variables in C++. These variables are defined within a class but outside of any methods, functions, or blocks. They are created when an object of the class is instantiated and destroyed when the object is destroyed.

Each object of a class gets its own copy of the instance variables, meaning that changes made to the instance variable of one object do not affect the instance variables of other objects. They are integral part of the object-oriented programming concepts in C++.

• Belong to an instance of a class (each object has its own copy).
• Declared inside a class but outside any function or method.
• Accessible via objects of the class.
• Lifecycle tied to the object, i.e., are created when an object is created and destroyed when the object is destroyed.

Code Example:

#include <iostream>
using namespace std;

class Person {
public:
string name;
int age;
};

int main() {

Person person1;
person1.name = "Rose";
person1.age = 26;

cout << "Name: " << person1.name << endl;
cout << "Age: " << person1.age << endl;

return 0;
}

Output:

Name: Rose
Age: 26

Explanation:

In the C++ code example,

1. We define a class Person containing two public instance variables, name (of type string) and age (of type int), to hold a person's name and age, respectively. 
2. Here, the public access specifier indicates that they can be accessed from all parts of the program.
3. In the main() function, we create an instance/ object person1 of the Person class.
4. Note that each individual object gets its own copy of instance variables, which are also known as data members of the class, class attributes, or class variables.
5. Then, we use the dot operator to assign the values to both instance variables for the person1 class object. Here, we assign string value "Rose" to name and 26 to age instance variables.
6. Next, we use cout statements to print the values of the instance variables to the console.

Note: Just like variables inside a class are called member variables/ data members, functions defined inside a class are known as member functions.

Automatic Variables In C++

In modern C++ (starting from C++11), the auto keyword allows the compiler to automatically deduce the data type of a variable based on the initial value provided. So, automatic variables in C++ programs are those that are declared using the auto keyword.

• The use of auto, simplifies code by letting the compiler determine the most appropriate data type, especially in complex expressions or when working with iterators and templates.
• In other words, the memory of automatic variables is automatically managed by the system.
• By default, all local variables are automatic variables, but they can also be explicitly defined using the auto keyword in modern C++ (especially C++11 and later).

Code Example:

#include <iostream>

int main() {
auto x = 10; // x is automatically deduced as an integer
auto y = 3.14; // y is automatically deduced as a double
auto z = "Hello, World!"; // z is automatically deduced as a string/ character array

std::cout << "x = " << x << std::endl;
std::cout << "y = " << y << std::endl;
std::cout << "z = " << z << std::endl;

return 0;
}

Output:

x = 10
y = 3.14
z = Hello, World!

Explanation:

In this example,

1.  We declare and initialize three variables (of different data types) using the auto keyword:
   • The variable x is assigned the value 10, which is deduced to be of integer type because of the auto keyword.
   • Similarly, variables y and z are assigned values 3.14 and "Hello, World!", which are automatically deduced to be of double and string type, respectively. 
2. Next, we use a set of std::cout statements to print these values to the console.
3. As seen in the output, the correct values are printed indicating that we can define variables without specifying the data type, if we use auto keyword. 

This feature makes the code more readable, especially when working with complex types, but it is important to assign a value at the time of declaration, as auto requires an initializer to deduce the type.

External Variables In C++

External variables (also known as global variables with external linkage) are declared using the extern keyword and can be shared across different files in a C++ program. External variables are often used in large programs where multiple source files need to share data.

• Scope: These variables are declared in one file but can be accessed and modified from other files.
• Linkage: External variables are declared with the extern keyword to let the compiler know that the variable exists in another file.
• Initialization: They need to be defined (initialized) in one file but can be declared as extern in other files to refer to the same variable.

Code Example: Let's look at an example where we define and initialize a variable in a separate file and then employ it in another program using the extern keyword.

file1.cpp: Declaring and initializing a variable

// file2.cpp
int globalVar = 42; // Definition and initialization of external variable

file1.cpp: Using the global external variable in code.

// file1.cpp
#include <iostream>

extern int globalVar; // Declaration of external variable

int main() {
std::cout << "The value of globalVar is: " << globalVar << std::endl;
return 0;
}

Both these files must be compiled together as follows:

g++ file1.cpp file2.cpp -o program

Output:

The value of myVariable is: 42

Explanation:

In the example,

1. We first define and initialize the external global variable globalVar in file2.cpp, with the value 42.
2. This variable is accessible from file1.cpp using the extern keyword. The extern keyword tells the compiler that the variable globalVar is defined somewhere else (in this case, in another file), and it should link to that definition during the linking stage.
3. In the file1.cpp, we declare the globalVar variable using the extern keyword. 
4. Then, in the main() function, we use an std::cout statement to print the value of the variable.

Level up your coding skills with the 100-Day Coding Sprint at Unstop and get the bragging rights now!

Different Types of Variable Initialization In C++

The methods and syntax of variable initialization in the section above, are the common ways used in application. But, we can classify the process of variable initialization in two more categpries/ types: static and dynamic.

Static Initialization Of Variables In C++ (Summarized)

Static initialization happens when a variable is assigned a value at compile time, typically when the variable is declared.

• If a statically initialized variable is not explicitly assigned a value, it defaults to zero.
• Global and static variables are zero-initialized if not explicitly initialized.
• This occurs before the program starts executing.

Dynamic Initialization Of Variables In C++ (Summarized)

Dynamic initialization refers to assigning values to variables at runtime.

• This is useful when the initial value depends on a calculation or external input that isn't known at compile time.
• It occurs during program execution.
• It is useful when variables depend on conditions or inputs determined at runtime.

Ways To Initialize Variables In C++ Programs

C++ provides multiple ways to initialize variables. While it's good to be aware of newer syntax introduced in C++11 and beyond, traditional initialization methods are still the most commonly used.

Classic Initialization:

int x = 5;

The equals sign is a familiar way to initialize variables, and it's straightforward for most use cases.

Braced List Initialization (C++11 and beyond):

int y{10};

Braced initialization offers type safety and is part of modern C++ standards, although not widely used in basic programs.

Parentheses Initialization:

int z(15);

Less common but still valid, this approach is more specific to certain situations where narrowing conversions need to be avoided.

Looking for guidance? Find the perfect mentor from select experienced coding & software experts here.

Conclusion

In this article, we explored the essential concept of variables in C++—the building blocks for storing and manipulating data in your programs.

• The declaration and definition of variables entails letting the compiler know of the existence of a variable and then allocate the memory depending on the data type.
• Initialization refers to the process of assigning the initial value.
• We also discussed the rules that must be adhered to when naming variables in C++, such as the importance of meaningful names, avoiding keywords, and adhering to proper syntax for readability and maintainability. 
• It is important to note that there are six primary types of variables in C++ programs: local, global, static, instance, auto, and external. The lifetime and scope of variables differ depending upon these types.

By understanding these types, you now have a solid foundation in working with variables in C++. Whether you're writing simple functions or complex object-oriented programs, knowing how to properly declare, initialize, and manage variables in C++ language is crucial to writing efficient and error-free code.

Also read- 51 C++ Interview Questions For Freshers & Experienced (With Answers)

Frequently Asked Questions

Q. What is a variable in C++?

A variable in C++ is a named memory region that is used to store data. It serves as a basic unit of storage whose value can be changed while the program is running. Variables must be declared before they can be used in C++.

Q. What is the difference between a local variable and a global variable?

Q. What is variable initialization in C++?

The initialization of variables in C++ is the process of assigning an initial value to a variable after it has been declared. There are two main ways to initialize a variable: static initialization (at compile time) and dynamic initialization (at runtime).

Q. What is a constant variable in C++?

A constant variable in C++ is one whose value cannot be changed after it has been initialized. To declare a constant variable, use the keyword const before the data type. For example:

const int maxScore = 100;.

Q. What is the scope of a variable in C++?

The scope of a variable refers to the region of the code where the variable is accessible. In C++, variable scope is typically divided into two parts:

• Local Scope: Variables declared within a function or block are only accessible within that context.
• Global Scope: Variables declared outside any function are accessible throughout the program.

Q. What is a static variable in C++? Is it the same as global variable? 

A static variable in C++ is declared using the static keyword. It retains its value across function calls and is initialized only once, at program startup.

• Unlike global variables, static variables are not accessible outside the block in which they are declared, even though they maintain their value across multiple calls.
• Therefore, while both types of variables maintain state, they are used in different contexts.

9. What is the lifetime of a variable in C++?

The lifetime of variables in C++ programs refers to the duration for which the variable exists in memory and holds a value. For example:

• Local variables exist during the execution of the block they are declared in.
• Static variables exist for the duration of the entire program.
• Global variables in C++ exist throughout the program’s execution as well.

Test Your Skills: Quiz Time

Here are a few more topics you must explore:

1. For Loop In C++ | Syntax, Working, Types & More (+Code Examples)
2. Bitwise Operators In C++ Explained In Detail With Examples
3. Pointers in C++ | A Roadmap To All Pointer Types (With Examples)
4. C++ Type Conversion & Type Casting | Simplified With Code Examples
5. Typedef In C++ | Syntax, Application & How To Use (+Code Examples)
6. Switch Case In C++ (Statement), Uses, Break & More With Examples