C++ - Variables

Variables in C++ 

In C++, a variable is a name given to a memory location that stores data. Variables allow you to store and manipulate data within a program. Each variable has a specific data type, which determines the size and type of data it can hold.

1. Declaring Variables

In C++, variables must be declared before they are used. When declaring a variable, you specify its data type and its name.

Syntax

data_type variable_name ;

For example:

    int x;  // Declares an integer variable named 'x'
    double y;  // Declares a double variable named 'y'

Example

#include 

int main() {
    int a;  // Declare an integer variable
    double b;  // Declare a double variable

    a = 5;  // Assign value to 'a'
    b = 3.14;  // Assign value to 'b'

    std::cout << "a: " << a << std::endl;
    std::cout << "b: " << b << std::endl;

    return 0;
}

2. Data Types in C++

C++ supports several data types that define the kind of data a variable can store. Some of the commonly used data types are:

• int: Used to store integer values (whole numbers).
• float: Used to store single-precision floating point numbers (decimal values).
• double: Used to store double-precision floating point numbers.
• char: Used to store a single character.
• bool: Used to store boolean values (true or false).
• std::string: Used to store a sequence of characters (strings).

Example of Variable Declaration with Different Data Types

#include 

int main() {
    int age = 25;  // Integer variable
    float height = 5.9f;  // Float variable
    double pi = 3.14159;  // Double variable
    char grade = 'A';  // Character variable
    bool isStudent = true;  // Boolean variable
    std::string name = "Alice";  // String variable

    std::cout << "Age: " << age << std::endl;
    std::cout << "Height: " << height << std::endl;
    std::cout << "Pi: " << pi << std::endl;
    std::cout << "Grade: " << grade << std::endl;
    std::cout << "Is Student: " << isStudent << std::endl;
    std::cout << "Name: " << name << std::endl;

    return 0;
}

3. Initializing Variables

When declaring a variable, you can also initialize it by assigning a value at the time of declaration. This is called variable initialization.

Syntax

data_type variable_name = value;

Example

int a = 10;  // Declare and initialize an integer variable 'a'
double b = 3.14;  // Declare and initialize a double variable 'b'

You can also initialize a variable without assigning a value at the time of declaration, and then assign the value later:

    int x;  // Declare variable 'x' without initializing
    x = 5;  // Assign value to 'x'

4. Constants and Constant Variables

If you want to create a variable whose value cannot be changed after it is initialized, you can declare it as a constant using the const keyword.

Syntax

const data_type variable_name = value ;

Example

#include 

int main() {
    const int MAX_SIZE = 100;  // Declare a constant integer variable
    std::cout << "Max size is: " << MAX_SIZE << std::endl;

    // MAX_SIZE = 200;  // Uncommenting this line will result in an error

    return 0;
}

5. Scope of Variables

The scope of a variable determines where in the program the variable can be accessed. There are two main types of scopes:

• Local Scope: A variable declared inside a function or block is called a local variable, and it is accessible only within that function or block.
• Global Scope: A variable declared outside of all functions is called a global variable, and it can be accessed by any function in the program.

Example

#include 

int globalVar = 100;  // Global variable

void display() {
    int localVar = 50;  // Local variable
    std::cout << "Local Variable: " << localVar << std::endl;
    std::cout << "Global Variable: " << globalVar << std::endl;
}

int main() {
    display();
    // std::cout << "Local Variable: " << localVar << std::endl;  // This would cause an error
    return 0;
}

6. Typecasting in C++

Typecasting is the process of converting one data type into another. C++ supports both implicit and explicit typecasting:

• Implicit Typecasting: The compiler automatically converts one data type to another. For example, when an integer is assigned to a double variable.
• Explicit Typecasting: You manually convert a data type using a cast operator (static_cast<> or C-style cast).

Example

#include 

int main() {
    int a = 5;
    double b = a;  // Implicit typecasting (int to double)

    std::cout << "Value of b: " << b << std::endl;

    // Explicit typecasting
    double c = 3.14;
    int d = static_cast(c);  // Explicit typecasting (double to int)

    std::cout << "Value of d: " << d << std::endl;

    return 0;
}