Variables, Constants & Additional Topics

Each bit can carry 2 values (0 or 1), so a type with n bits holds 2ⁿ values.

• char = 8 bits = 2⁸ = 256 values (0–255)

Signed variables use the Most Significant Bit (MSB) to denote sign. If the MSB is 1, the value is negative — leaving 2⁷ positive values.

• Storing a number too large for its variable type causes it to overflow back to 0
• Overflow behavior for signed variables is compiler-dependent (undefined behavior)

Smaller types like char and short are automatically promoted to int when used in expressions. This happens silently and is worth being aware of — especially given the narrowing and overflow rules above.

char a = 10;
char b = 20;
auto result = a + b; // result is int, not char — promotion happened

typedef lets you substitute a type name with something more convenient.

typedef unsigned int POSITIVE_NUM;
// Now you can use POSITIVE_NUM instead of "unsigned int"

typedef double Perimeter; // another example

Literals

• Raw values: 1, "Hello", 0b00 (binary prefix 0b)

Declared Constants

const double pi = 3.14;

Expression Constants (constexpr)

• Function-like declaration of constants
• As long as the compiler can evaluate it at compile-time, it can be used anywhere a const is expected
• Can trigger compile-time optimization — replacing the expression with its evaluated value in the binary
• Must be simple (generally). C++14 allows decision-making and loops inside constexpr

Enums allow you to define a named set of integer constants. The compiler converts them to integers automatically.

// Definition
enum Dir {
    North,
    South,
    East,
    West
};

// Declaring a variable
Dir direction = North;

You can add single-quotes as digit separators in number literals for readability:

int moneyInBank = 7'000'000;

Lets you specify the exact bit-width of an integer — useful for portability:

Assigning a value too large for its type may silently convert (or fail) depending on the compiler:

short smallNum = 5000000; // ⚠ Too large for short — some compilers allow it

Use list initialization { } to prevent narrowing — it will refuse to compile:

short smallNum { 5000000 }; // ✗ Will not compile — safer!

auto instructs the compiler to detect the variable type from its initialization. The variable must be initialized to use it. Convenient and can prevent narrowing errors:

auto x = 42;      // deduced as int
auto y = 3.14;    // deduced as double

decltype(expression) returns the type that results from evaluating the expression — without actually evaluating it:

int x = 5;
decltype(x) y = 7; // compiler deduces y should be "int"

The stack grows downward in memory and the heap grows upward — they expand toward each other. If they ever collide, you get a stack overflow or out-of-memory crash.

Example: class Shape Memory Placement

class Shape {
    float area;
    float perimeter;
    static double PI;
public:
    Shape();
    virtual float GetArea();
    static double GetPI();
};