Pointers, Polymorphism, Memory, and Duck Typing: A Unified Perspective with Memory Models

Modern programming languages differ in syntax and abstraction, but they all rely on the same underlying principles: how data is stored in memory and how behavior is resolved at runtime. Concepts such as pointers, polymorphism, V-tables, and duck typing form a continuum from low-level system control to high-level flexibility. By examining C++, Java, and Python together, we can uncover the shared mechanisms beneath these abstractions.

1. Polymorphism and Dynamic Dispatch

Polymorphism allows a single interface to represent different underlying types, enabling dynamic behavior at runtime.

C++ Example

#include <iostream>

class Animal {
public:
    virtual void make_sound() {
        std::cout << "Generic animal sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void make_sound() override {
        std::cout << "Bark!" << std::endl;
    }
};

int main() {
    Animal* my_dog = new Dog();
    my_dog->make_sound();
    delete my_dog;
    return 0;
}

In C++, polymorphism is implemented using virtual functions. The compiler constructs a V-table, which is an array of function pointers. Each object contains a hidden pointer (vptr) that points to this table.

Java Example

class Animal {
    void makeSound() {
        System.out.println("Generic animal sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Bark!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound();
    }
}

Java uses references instead of explicit pointers. Internally, the JVM performs dynamic dispatch using method tables similar to V-tables.

Python Example

class Animal:
    def make_sound(self):
        print("Generic animal sound")

class Dog(Animal):
    def make_sound(self):
        print("Bark!")

def play_sound(animal):
    animal.make_sound()

my_dog = Dog()
play_sound(my_dog)

Python resolves method calls dynamically at runtime without requiring explicit type relationships.

2. Duck Typing: Behavior Over Type

Duck typing represents a flexible form of polymorphism: if an object behaves like a duck, it is treated as one. The function does not require inheritance—only the presence of a method.

def play_sound(animal):
    animal.make_sound()

This contrasts with type-based polymorphism in C++ and Java, where inheritance is required.

3. Understanding Pointers in C++

Pointers store memory addresses, enabling indirect access to data.

#include <iostream>

int main() {
    int x = 100;       // A box that stores the value 100
    int* p = &x;       // p stores the address of x

    std::cout << "Address stored in p: " << p << std::endl;
    std::cout << "Value via dereferencing: " << *p << std::endl;

    *p = 200;
    std::cout << "Now x becomes: " << x << std::endl;

    return 0;
}

The * operator is used both for declaring pointers and dereferencing them.

4. Memory Layout: Stack vs Heap

In C++, stack memory is automatically managed, while heap memory is dynamically allocated using new.

flowchart LR subgraph Stack A["my_dog (pointer)"] end subgraph Heap B["Dog Object"] C["vptr (inside object)"] end subgraph Static_Memory ["Static/Read-Only Memory"] E["vtable for Dog"] D["Dog::make_sound()"] end A -->|stores address| B B --- C C -->|points to| E E -->|entry points to| D

5. Inside the Object: V-Table Connection

flowchart TD A[Dog Object] A --> B[vptr] A --> C[Other data] B --> D[V-Table] D --> E["Dog::make_sound()"]

6. V-Table Structure

flowchart TD subgraph Animal_VTable A1["Animal::make_sound"] end subgraph Dog_VTable D1["Dog::make_sound"] end

7. Runtime Dispatch Process

sequenceDiagram participant Main participant Pointer as my_dog participant Object as Dog Object participant VTable as Dog V-Table Main->>Pointer: call make_sound() Pointer->>Object: follow address Object->>VTable: access vptr VTable-->>Main: Dog::make_sound()

8. Java and Python Comparison

Java

flowchart LR A[Reference] --> B[Object] B --> C[Method Table] C --> D["makeSound()"]

Python (Duck Typing)

flowchart LR A[Variable] --> B[Object] B --> C[Dynamic Lookup] C --> D[make_sound]

9. Pointer vs Ordinary Variable

flowchart LR subgraph Stack X[x = 100] P[p → address of x] end P --> X

10. Why C++ Requires delete

Animal* my_dog = new Dog();
delete my_dog;

Without delete

flowchart LR A[Pointer destroyed ❌] B[Heap memory still allocated ⚠️] A -.-> B

With delete

flowchart LR A[Pointer] B[Heap Object] A --> B A -->|delete| B B --> C[Memory freed ✅]

11. Unified Model

flowchart TD A[Pointer / Reference] B[Heap Object] C[vptr / Method Table] D[Function] A --> B B --> C C --> D

Conclusion

Across C++, Java, and Python, the same fundamental mechanism exists: a reference or pointer is used to access an object, and the correct method is resolved at runtime. The differences lie in abstraction levels.

• C++: full control over memory and pointers
• Java: structured abstraction with hidden memory management
• Python: flexible behavior through duck typing

Understanding these layers provides a complete mental model bridging low-level system design and high-level software engineering.