Data Types and Variables in C++

In C++, data types specify the type and size of data that a variable can store. Because C++ is a strongly-typed and statically-typed language, every variable must have a declared data type before it can be used, and this type cannot change during runtime.

Understanding how data types map to memory allocation is foundational to writing optimized, high-performance C++ applications.

Video Explanation​

Watch

1. Declaring and Initializing Variables​

A variable is a named storage location in memory. To use a variable, you must first declare it. You can also optionally initialize it (assign an initial value) at the same time.

Declaration​

Specifies the type and the identifier (name) of the variable. This tells the compiler how much memory to reserve.

int age;          // Reserves memory for an integer
double salary;     // Reserves memory for a double-precision float
char grade;        // Reserves memory for a single character

Initialization​

Assigns a literal value to the allocated memory location.

int age = 25;
double salary = 45000.50;
char grade = 'A';

2. Primitive Data Types Summary​

The table below summarizes the core primitive data types in C++ (assuming a standard 64-bit architecture):

3. Deep Dive: Primitive & Standard Types​

A. Integer Types (int)​

Used for storing whole numbers without decimals.

int executionCount = 150;
int temperature = -12;

B. Floating-Point Types (float, double)​

Used for representing fractional numbers or decimals. Use the f suffix for float literals to prevent automatic promotion to double.

float pi = 3.14159f;       // Single precision
double precisionG = 9.80665; // Double precision (preferred for accuracy)

C. Character Type (char)​

Stores a single character enclosed in single quotes. Under the hood, C++ stores characters as their integer ASCII values.

char networkStatus = 'G'; // 'G' for Good

D. Boolean Type (bool)​

Represents conditional states. Explicitly holds either true or false.

bool isEngineRunning = true;
bool hasPermission = false;

E. String Type (std::string)​

Unlike primitive types, strings are compound objects provided by the Standard Library (<string>). They represent sequences of characters enclosed in double quotes.

#include <string>

std::string username = "JohnDoe_99";

4. Constant Variables (const)​

If a variable's value should remain unchanged throughout the program's lifecycle, prepend the declaration with the const qualifier. Any attempt to modify a const variable will trigger a compilation error.

const double COULOMBS_CONSTANT = 8.987551e9;
// COULOMBS_CONSTANT = 9.1; // Error: assignment of read-only variable

5. Variable Scope​

Scope dictates the visibility and lifetime of a variable within your program.

Local Variables​

Declared inside a function or a specific code block ({}). They are created when the block is entered and destroyed when the block is exited.

void calculateMetrics() {
    int localResult = 42; // Only accessible within calculateMetrics()
}
// localResult is inaccessible here

Global Variables​

Declared outside of all functions. They are accessible from any point in the file after their declaration and persist for the entire duration of the application.

int globalSystemState = 1; // Global scope

void updateState() {
    globalSystemState = 2; // Modifying global variable
}

6. Type Conversion (Casting)​

Type conversion happens when a value of one data type is transferred to another.

Implicit Conversion (Coercion)​

Handled automatically by the compiler when converting a smaller data type to a larger data type without risk of data loss.

int basicValue = 100;
double promotedValue = basicValue; // Implicitly converted to 100.0

Explicit Conversion (Casting)​

Required when data loss might occur (e.g., converting a floating-point number to an integer, which truncates the decimal). Modern C++ favors static_cast over C-style casting for safety and clarity.

double exactMeasurement = 45.97;

// C-Style Casting (Discouraged in modern C++)
int truncatedValue = (int)exactMeasurement; // Evaluates to 45

// Modern C++ Casting (Recommended)
int refinedValue = static_cast<int>(exactMeasurement); // Evaluates to 45

7. Dynamic Variables & Memory Allocation​

While standard variables are managed on the Stack, dynamic variables are allocated at runtime on the Heap using raw pointers. You must explicitly manage this memory to prevent memory leaks.

// 1. Allocate memory on the Heap for an integer
int* dynamicPointer = new int;  

// 2. Assign a value to the allocated memory (dereferencing)
*dynamicPointer = 500;          

// 3. Deallocate memory to prevent memory leaks
delete dynamicPointer;          

// 4. Clear pointer to prevent dangling pointer errors
dynamicPointer = nullptr;