C Implimentation.c

Go to the documentation of this file.

// C Implimentation.c : This file contains the 'main' function. Program execution begins and ends there.
//
// C has no classes, so it has neither native inheritance-based polymorphism
// nor native interface-based polymorphism. Both are reproduced below the
// way C code conventionally simulates them: a struct holding a function
// pointer (or table of function pointers) that stands in for a vtable.
 
#include <stdio.h>
 
// ---------------------------------------------------------------------------
// Part 1: "Inheritance-based" polymorphism simulated with a base struct
// whose first member is a function pointer, mimicking a single-method vtable.
// ---------------------------------------------------------------------------
 
/**
 * @brief Base "class" simulated as a struct holding a speak function pointer.
 */
typedef struct Animal {
    void (*speak)(struct Animal*); /**< Function pointer standing in for a vtable slot. */
} Animal;
 
/**
 * @brief speak() implementation for Dog.
 * @param self Pointer to the Animal base within a Dog instance.
 */
void dogSpeak(Animal* self) {
    (void)self;
    printf("bark\n");
}
 
/**
 * @brief speak() implementation for Cat.
 * @param self Pointer to the Animal base within a Cat instance.
 */
void catSpeak(Animal* self) {
    (void)self;
    printf("meow\n");
}
 
/** @brief "Subclass" of Animal that barks. */
typedef struct { Animal base; } Dog;
/** @brief "Subclass" of Animal that meows. */
typedef struct { Animal base; } Cat;
 
/**
 * @brief Initializes a Dog instance, wiring its vtable pointer to dogSpeak.
 * @param d Pointer to the Dog instance to initialize.
 */
void Dog_init(Dog* d) { d->base.speak = dogSpeak; }
 
/**
 * @brief Initializes a Cat instance, wiring its vtable pointer to catSpeak.
 * @param c Pointer to the Cat instance to initialize.
 */
void Cat_init(Cat* c) { c->base.speak = catSpeak; }
 
/**
 * @brief Dynamic Dispatch via manual function-pointer vtable.
 * @param a Pointer to the Animal base whose speak function pointer is invoked.
 */
void makeSpeak(Animal* a) {
    a->speak(a);
}
 
// ---------------------------------------------------------------------------
// Part 2: "Inheritance with defaults" - a shared concrete function (sleep)
// plus a per-instance function pointer (speak) standing in for the abstract
// method that "subclasses" must fill in.
// ---------------------------------------------------------------------------
 
/**
 * @brief Abstract base "class" combining shared state and an abstract
 *        speak function pointer.
 */
typedef struct AbstractAnimal {
    int age; /**< Structural state isolated inside the struct footprint. */
    void (*speak)(struct AbstractAnimal*); /**< Function pointer for the abstract method. */
} AbstractAnimal;
 
/**
 * @brief A concrete default function shared by all "subclasses".
 * @param aa Pointer to the AbstractAnimal base.
 */
void Animal_sleep(AbstractAnimal* aa) {
    (void)aa;
    printf("Zzz\n");
}
 
/**
 * @brief speak() implementation for DogWithDefault.
 * @param self Pointer to the AbstractAnimal base within a DogWithDefault instance.
 */
void dogWithDefaultSpeak(AbstractAnimal* self) {
    (void)self;
    printf("bark\n");
}
 
/** @brief Concrete AbstractAnimal "subclass" that implements speak(). */
typedef struct { AbstractAnimal base; } DogWithDefault;
 
/**
 * @brief Initializes a DogWithDefault instance.
 * @param d Pointer to the DogWithDefault instance to initialize.
 */
void DogWithDefault_init(DogWithDefault* d) {
    d->base.age = 0;
    d->base.speak = dogWithDefaultSpeak;
}
 
/**
 * @brief Dynamic Dispatch using abstract parent pointer.
 * @param aa Pointer to the AbstractAnimal base; sleep() is a shared,
 *           non-overridden default function.
 */
void makeSleep(AbstractAnimal* aa) {
    Animal_sleep(aa);
}
 
// ---------------------------------------------------------------------------
// Part 3: "Interface-based" polymorphism simulated with a struct that holds
// only a function pointer, i.e. a contract with no shared state or code.
// ---------------------------------------------------------------------------
 
/**
 * @brief Interface contract simulated as a struct holding only a function pointer.
 */
typedef struct ISpeaker {
    void (*speak)(struct ISpeaker*); /**< Function pointer representing the contract. */
} ISpeaker;
 
/**
 * @brief speak() implementation for InterfaceDog.
 * @param self Pointer to the ISpeaker base within an InterfaceDog instance.
 */
void interfaceDogSpeak(ISpeaker* self) {
    (void)self;
    printf("bark\n");
}
 
/**
 * @brief speak() implementation for InterfaceCat.
 * @param self Pointer to the ISpeaker base within an InterfaceCat instance.
 */
void interfaceCatSpeak(ISpeaker* self) {
    (void)self;
    printf("meow\n");
}
 
/** @brief ISpeaker implementation that barks. */
typedef struct { ISpeaker base; } InterfaceDog;
/** @brief ISpeaker implementation that meows. */
typedef struct { ISpeaker base; } InterfaceCat;
 
/**
 * @brief Initializes an InterfaceDog instance.
 * @param d Pointer to the InterfaceDog instance to initialize.
 */
void InterfaceDog_init(InterfaceDog* d) { d->base.speak = interfaceDogSpeak; }
 
/**
 * @brief Initializes an InterfaceCat instance.
 * @param c Pointer to the InterfaceCat instance to initialize.
 */
void InterfaceCat_init(InterfaceCat* c) { c->base.speak = interfaceCatSpeak; }
 
/**
 * @brief Contractual Dispatch via manual function-pointer lookup.
 * @param s Pointer to the ISpeaker contract whose speak function pointer is invoked.
 */
void makeSpeakInterface(ISpeaker* s) {
    s->speak(s);
}
 
// ---------------------------------------------------------------------------
// Part 4: Monomorphism - a single concrete struct with a directly-named
// function, called without going through any function pointer at all.
// There is only one implementation, so there is nothing to sever/redirect.
// ---------------------------------------------------------------------------
 
/** @brief The sole concrete "speaker" type; no vtable is needed. */
typedef struct { int dummy; } PureBreedDog;
 
/**
 * @brief Direct, non-polymorphic speak implementation for PureBreedDog.
 * @param self Pointer to the PureBreedDog instance.
 */
void PureBreedDog_speak(PureBreedDog* self) {
    (void)self;
    printf("Woof\n");
}
 
/**
 * @brief Scenario A: Monomorphic target - direct call, no vtable indirection.
 * @param explicitDog Pointer to the concrete PureBreedDog instance.
 */
void directSpeak(PureBreedDog* explicitDog) {
    PureBreedDog_speak(explicitDog);
}
 
/**
 * @brief Entry point exercising all four polymorphism scenarios.
 * @return 0 on successful completion.
 */
int main()
{
    // Part 1
    Dog myDog; Dog_init(&myDog);
    Cat myCat; Cat_init(&myCat);
    makeSpeak(&myDog.base);
    makeSpeak(&myCat.base);
 
    // Part 2
    DogWithDefault dog; DogWithDefault_init(&dog);
    makeSleep(&dog.base);
 
    // Part 3
    InterfaceDog iDog; InterfaceDog_init(&iDog);
    InterfaceCat iCat; InterfaceCat_init(&iCat);
    makeSpeakInterface(&iDog.base);
    makeSpeakInterface(&iCat.base);
 
    // Part 4
    PureBreedDog pureDog;
    directSpeak(&pureDog);
 
    return 0;
}
 
// Run program: Ctrl + F5 or Debug > Start Without Debugging menu
// Debug program: F5 or Debug > Start Debugging menu
 
// Tips for Getting Started:
//   1. Use the Solution Explorer window to add/manage files
//   2. Use the Team Explorer window to connect to source control
//   3. Use the Output window to see build output and other messages
//   4. Use the Error List window to view errors
//   5. Go to Project > Add New Item to create new code files, or Project > Add Existing Item to add existing code files to the project
//   6. In the future, to open this project again, go to File > Open > Project and select the .sln file