• +91-9142290450

  • Hajipur, Bihar, 844101

☰
❮
❯

C++ Variables

← Previous Next →

What Are Variables in C++?

In C++, a variable is a name given to a memory location that stores a value. You can think of it as a container that holds data that may change during the program’s execution. Each variable in C++ has a type, a name, and a value. The type defines what kind of data it can store — for example, an integer, a character, or a floating-point number.

Without variables, programs wouldn’t be able to store or manipulate data. They are one of the most fundamental building blocks of programming in C++.

Syntax of Variable Declaration

Before using a variable, you must declare it. The declaration tells the compiler what kind of data the variable will hold.

Syntax:

data_type variable_name = value;

  • data_type: Defines the type of data (e.g., int, float, char).

  • variable_name: The name that identifies the variable.

  • value (optional): You can assign a value when declaring the variable.

Example:

int age = 20;
float height = 5.6;
char grade = 'A';

Here, three variables are declared — one for integer, one for floating-point, and one for character data.

Declaring Variables Without Initialization

You can declare variables first and assign values later in your program.

Example:

#include <iostream>
using namespace std;

int main() {
    int marks; // variable declared
    marks = 90; // value assigned later
    cout << "Marks: " << marks;
    return 0;
}

This approach is useful when you don’t know the value of a variable at the start of the program.

Multiple Variable Declarations

You can declare multiple variables of the same type in one line to make your code cleaner.

Example:

int x = 5, y = 10, z = 15;

This line declares three integer variables x, y, and z, and assigns values to each of them.

You can also declare them without assigning initial values:

int a, b, c;

Rules for Naming Variables in C++

C++ has certain rules for naming variables. If you don’t follow them, you’ll get a compiler error.

Rules:

  1. Variable names can contain letters, digits, and underscores.

  2. They must begin with a letter or underscore (not a digit).

  3. Variable names are case-sensitive (Age and age are different).

  4. No spaces or special characters are allowed.

  5. You cannot use C++ keywords as variable names (like int, float, or while).

Examples:

int totalAmount;  // valid
float _discount;  // valid
int 2rate;        // invalid, starts with a number
char for;         // invalid, keyword used

Following a consistent naming style helps keep your code clear and professional.

Types of Variables in C++

C++ provides several types of variables based on how they are used and where they are declared. Let’s understand each one.

1. Local Variables

Local variables are declared inside a function or block and can only be used within that block.

Example:

void display() {
    int num = 10;  // local variable
    cout << num;
}

You cannot access num outside the function display().

2. Global Variables

Global variables are declared outside of all functions and can be accessed by any function in the program.

Example:

#include <iostream>
using namespace std;

int count = 5;  // global variable

int main() {
    cout << count;
    return 0;
}

Global variables are accessible throughout the program, which makes them useful but sometimes risky if not managed carefully.

3. Static Variables

Static variables retain their values between multiple function calls. They are declared using the keyword static.

Example:

#include <iostream>
using namespace std;

void showCount() {
    static int count = 0;
    count++;
    cout << count << endl;
}

int main() {
    showCount();
    showCount();
    showCount();
    return 0;
}

Output:

1
2
3

Here, the variable count remembers its value every time the function is called.

4. Constant Variables

Constants are variables whose values cannot be changed after initialization. They are declared using the keyword const.

Example:

#include <iostream>
using namespace std;

int main() {
    const float PI = 3.1416;
    cout << "Value of PI: " << PI;
    return 0;
}

If you try to modify PI, the compiler will show an error. Constants are often used for fixed values that don’t change, such as mathematical constants or configuration values.

Assigning and Reassigning Values

You can assign a value to a variable using the assignment operator =.
If the variable is not constant, you can change its value anytime.

Example:

int score = 50;
score = 75;
cout << score;  // Output: 75

The second assignment overwrites the old value.

Variable Scope and Lifetime

Each variable in C++ has:

  • Scope: Where the variable can be accessed.

  • Lifetime: How long it exists in memory.

Local variables exist only during function execution. Global variables exist as long as the program runs. Static variables exist through the entire runtime of the program but are visible only in their defined scope.

Variable Initialization

Initialization means assigning a value to a variable at the time of declaration.

C++ allows three main types of initialization:

1. Copy Initialization

int x = 10;

2. Direct Initialization

int y(20);

3. Uniform Initialization (C++11 and later)

int z{30};

Uniform initialization avoids narrowing conversions (e.g., assigning a float to an int without explicit cast).

Difference Between Variable Declaration and Definition

In C++, declaration tells the compiler that a variable exists, while definition allocates memory for it.

Example:

extern int count; // declaration
int count = 10;   // definition

The keyword extern tells the compiler that the variable will be defined elsewhere in the program or another file.

Best Practices for Variables in C++

  • Always initialize variables before using them.

  • Use meaningful names (totalMarks instead of tm).

  • Use constants for fixed values.

  • Keep variable scope as limited as possible.

  • Avoid using global variables unless necessary.

Following these practices makes your code more efficient and easier to maintain.

Summary of C++ Variables

Variables in C++ are memory locations used to store and manage data. Every variable has a type, name, and value. You can declare them locally, globally, statically, or as constants depending on your need. Variables follow naming rules and have specific lifetimes and scopes. Proper naming, initialization, and use of constants lead to clean and reliable C++ programs.

Practice Questions

  1. What is a variable in C++ and why is it important in programming?

  2. Write the correct syntax for declaring and initializing a variable in C++.

  3. What are the naming rules that must be followed while creating variables in C++?

  4. Write a C++ program that declares three variables (name, age, and marks) and displays them using cout.

  5. Differentiate between local and global variables with examples.

  6. What is a static variable? Write a short program to show how it retains its value across multiple function calls.

  7. Write a C++ program that uses a const variable to store the value of PI and calculates the area of a circle.

  8. Explain the difference between variable declaration and variable definition in C++.

  9. Demonstrate the three types of variable initialization methods in C++ with examples.

  10. Why is it considered a good practice to limit the scope of a variable in a program?

← Previous Next →

Try a Short Quiz.

coding learning websites codepractice

No quizzes available.

CPP Programming

online coding class codepractice

Introduction to C++

C++ Basics

Control Flow

Collections & Memory

Functions

Object-Oriented Programming

File Handling & Date

Error Handling & Validation

STL & Data Structures

Namespaces

codepractice logo
Login
Go Back Top