Static vs. Dynamic in C++: Key Features

Posted on Mar 10, 2025 in Computers

Static and Dynamic in C++

Static

The term “static” in C++ refers to features that involve compile-time behavior, fixed memory allocation, or a class/function being bound to a particular point in time. Static behavior is established at compile-time, meaning decisions about allocation and binding are made before the program runs.

1. Static Variables

Definition:

A static variable retains its value between function calls and is initialized only once. Its lifetime is the entire runtime of the program, but its scope is limited to the function or class where it is declared.

Characteristics:

  • Lifetime: The variable exists for the lifetime of the program.
  • Scope: Limited to the block (function or class) where it is declared.
  • Initialization: A static variable is initialized only once, and its value persists across function calls.

Syntax:

static type variableName;

2. Static Member Variables

Definition:

A static member variable is shared by all objects of the class. Unlike regular member variables, static members are not tied to any specific instance of the class. They are shared across all instances.

Characteristics:

  • Shared: Static members are shared among all objects of the class.
  • Access: Can be accessed using the class name (without creating an object).

Syntax:

class ClassName {
    static type variableName;
};

3. Static Functions

Definition:

A static function is associated with the class itself, rather than any particular object. It can only access static data members, not non-static members.

Syntax:

class ClassName {
public:
    static ReturnType functionName(Arguments);
};

Dynamic

The term “dynamic” in C++ refers to behaviors involving memory allocation or binding decisions made at runtime. Dynamic operations occur while the program is running, such as memory allocation on the heap or function binding during execution.

1. Dynamic Memory Allocation

Definition:

Dynamic memory allocation is allocating memory during program execution. This is done using the new operator for variables or arrays, and delete to free that memory.

Characteristics:

  • Allocated at runtime.
  • Heap-based memory.
  • Manual Management: The programmer must deallocate memory using delete to avoid leaks.

Syntax:

pointer = new type;          // For single variable allocation
pointer = new type[size];      // For array allocation
delete pointer;                // For single variable deallocation
delete[] pointer;              // For array deallocation

2. Dynamic Polymorphism (Virtual Functions)

Definition:

Dynamic polymorphism occurs when a function call is resolved at runtime. It uses virtual functions and function overriding. The base class function is declared as virtual, allowing the derived class to override it. The invoked function is determined at runtime based on the object type.

Characteristics:

  • Resolved at runtime.
  • Allows base class pointers/references to invoke derived class methods.
  • Uses the virtual keyword to enable dynamic dispatch.

Syntax:

class Base {
public:
    virtual void functionName() {
        // Base class method
    }
};

class Derived : public Base {
public:
    void functionName() override {
        // Derived class method
    }
};

3. Dynamic Binding vs. Static Binding

Static Binding (Early Binding):

  • Happens at compile-time.
  • Method/function calls are linked to definitions before the program runs.
  • Default behavior when no virtual keyword is used.

Dynamic Binding (Late Binding):

  • Happens at runtime.
  • Function calls are determined dynamically based on the object type (not the pointer type) during execution.
  • Achieved using the virtual keyword.

4. Inheritance

Definition:

Inheritance is when one class (child/derived) inherits properties and behaviors (data and methods) from another class (parent/base). It allows code reusability and supports hierarchical classification.

Key Features:

  • Base Class: The class being inherited from.
  • Derived Class: The class that inherits.
  • Types of Inheritance:
    1. Single: One derived class inherits from one base class.
    2. Multiple: One derived class inherits from multiple base classes.
    3. Multilevel: A class is derived from another derived class.
    4. Hierarchical: Multiple classes inherit from a single base class.
    5. Hybrid: A combination of the above.

Advantages:

  1. Promotes code reusability.
  2. Allows for logical grouping of related classes.
  3. Enables method overriding for polymorphism.
#include <iostream>
using namespace std;

class Animal {
public:
    void eat() {
        cout << "This animal eats food." << endl;
    }
};

class Dog : public Animal { // Derived class
public:
    void bark() {
        cout << "The dog barks." << endl;
    }
};

int main() {
    Dog myDog;

    myDog.eat(); // Inherited from Animal
    myDog.bark(); // Defined in Dog

    return 0;
}

5. Polymorphism

Definition:

Polymorphism means “many forms.” It allows methods/operators to behave differently based on context. Achieved through function overloading, operator overloading, and method overriding.

Types of Polymorphism:

  1. Compile-Time Polymorphism (Static Binding):

    • Achieved using function and operator overloading.
    • Resolved during compile time.

  2. Run-Time Polymorphism (Dynamic Binding):

    • Achieved using virtual functions and method overriding.
    • Resolved during runtime using function pointers or v-tables.

Advantages:

  1. Promotes flexibility and extensibility of code.
  2. Enables dynamic behavior of objects.
  3. Reduces code duplication.

Examples:

  1. Compile-Time Polymorphism (Function Overloading)

    #include <iostream>
using namespace std;

class Calculator {
public:
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
};

int main() {
    Calculator calc;

    cout << "Int Addition: " << calc.add(2, 3) << endl;
    cout << "Double Addition: " << calc.add(2.5, 3.7) << endl;

    return 0;
}

  2. Run-Time Polymorphism (Virtual Functions)

    #include <iostream>
using namespace std;

class Animal {
public:
    virtual void makeSound() { // Virtual function
        cout << "Animal makes a sound." << endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() override {
        cout << "Dog barks." << endl;
    }
};

int main() {
    Animal* animal = new Dog();
    animal->makeSound(); // Calls Dog's makeSound()

    delete animal;
    return 0;
}

Difference Between OOP and Structured Programming

1. Approach and Focus

Object-Oriented Programming (OOP):

  1. Approach: OOP centers around objects and classes, organizing code around data and operations on that data.
  2. Focus: Emphasizes data abstraction, encapsulation, inheritance, and polymorphism. Models real-world entities as objects with attributes (data) and behaviors (methods).
  3. Encourages modularity and reusability by breaking problems into smaller, self-contained objects.

Structured Programming:

  1. Approach: Breaks down problems into smaller sub-problems/functions using a top-down approach. Organizes code into sequences, selections, and iterations.
  2. Focus: Improves clarity and maintainability using logical structures like loops, conditionals, and functions.
  3. Avoids global variables and emphasizes functional decomposition, dividing problems into smaller, manageable functions.

2. Code Organization

OOP:

  1. Classes and Objects: Organizes code into classes defining object properties and behaviors. Classes act as blueprints.
  2. Encapsulation: Data and methods are encapsulated into a single unit (class), protecting data from outside access (using access specifiers like private, public, etc.).
  3. Modularity: Promotes a modular structure where objects interact.

Structured Programming:

  1. Functions and Procedures: Code is organized into functions or procedures for specific tasks.
  2. Global Data: Data may be shared across functions, but there’s no strong data protection or encapsulation.

3. Reusability and Extensibility

OOP:

  1. Inheritance: Allows new classes to inherit properties/methods from existing classes, promoting code reuse.
  2. Polymorphism: A single function/method can act on different types, allowing for flexible and reusable code.
  3. Extensibility: Systems can be easily extended without changing existing code. New features can be added by creating/modifying classes.

Structured Programming:

  1. Limited Reusability: Focuses on function reuse but lacks mechanisms for inheritance or polymorphism.
  2. Modularity: Achieved by dividing programs into functions, but lacks the extensibility and reusability of OOP.

4. Data Handling

OOP:

  1. Encapsulation of Data: Data is encapsulated within objects, accessed/modified through defined methods, ensuring data integrity and security.
  2. Data and Behavior Together: Data and functions are grouped together, making code more organized and closer to real-world scenarios.

Structured Programming:

  1. Global Variables: Data is often in global variables, accessible by any function, leading to potential data integrity issues.
  2. Separation of Data and Functions: Functions (procedures) and data are often separated, with data manipulated by passing it to functions.

5. Modularity and Maintainability

OOP:

  1. High Modularity: Encourages high modularity by encapsulating data and behavior into discrete objects. Objects can be modified independently, making code easier to maintain.
  2. Easier Maintenance: Due to encapsulation and inheritance, modifications in one part typically don’t affect others, making the system easier to maintain.

Structured Programming:

  1. Low Modularity: Code tends to be more linear and less modular. Large functions/code blocks can make it harder to isolate bugs or maintain code.
  2. Harder to Maintain: As the program grows, it can become difficult to maintain because changes in one function may affect many other parts.

6. Real-World Modeling

OOP:

  1. Real-World Modeling: Models real-world entities as objects with attributes and behaviors, making it suitable for complex applications like GUIs, simulations, and games.
  2. Abstraction: Models real-world concepts at a higher level of abstraction, simplifying complex problems.

Structured Programming:

  1. Limited Real-World Modeling: Focuses on solving problems through logical steps and functions rather than modeling real-world entities. More suitable for linear tasks and smaller programs.

7. Code Readability and Scalability

OOP:

  1. Better Scalability: Modular nature and use of inheritance and polymorphism make it easier to scale large applications.
  2. Enhanced Readability: Organizing code into classes and objects improves readability, making it easier to understand the structure and behavior of the system.

Structured Programming:

  1. Limited Scalability: As the program grows, it can become harder to scale due to reliance on function calls and global variables.
  2. Less Readable: Large procedural programs can become difficult to read and maintain due to their linear flow and lack of encapsulation.