For much of this year, I've been discussing polymorphic types and virtual functions. Last month, I explained the memory layout of polymorphic objects. I also previously shown how to emulate a polymorphic C++ class (a class with at least one virtual function) as a C structure that has an additional member commonly called a vptr (VEE-pointer). The vptr points to a table of function pointers called a vtbl (VEE-table). This month, I'll look at initializing derived class objects.

As in my prior articles, my sample classes represent an assortment of two-dimensional geometric shapes such as circle, rectangle, and triangle, all derived from a common base class called shape. The C++ definition for the shape base class looks in part like:

class shape {
public:
    shape(color o, color f);        // constructor
    virtual double area() const;
    virtual double perimeter() const;
private:
    color outline, fill;
};

In C, the comparable declarations look like:

// shape.h - a C base class for shapes
#ifndef SHAPE_H_INCLUDED
#define SHAPE_H_INCLUDED

typedef struct shape shape;

typedef struct shape_vtbl shape_vtbl;
struct shape_vtbl {
    double (*area)(shape const *s);
    double (*perimeter)(shape const *s);
};

struct shape {
    shape_vtbl *vptr;
    color outline, fill;
};

void shape_construct(shape *s, color o, color f);
double shape_area(shape const *s);
double shape_perimeter(shape const *s);

#endif

As I showed last month, you can define the shape vtbl object in a source file that also defines the member functions of the shape "class":

// shape.c - a C base class for shapes

#include "shape.h"

~~~

static shape_vtbl the_shape_vtbl = {
    shape_area,
    shape_perimeter
};

void shape_construct(shape *s, color o, color f) {
    s->vptr = &the_shape_vtbl;
    s->outline = o;
    s->fill = f;
}

In C++, the definition for a circle class derived from shape looks like:

class circle: public shape {
public:
    circle(double r, color o, color f); // constructor
    virtual double area() const;
    virtual double perimeter() const;
    ~~~
private:
    double radius;
};

Derivation defines an "is a" or "is a kind of" relationship between the derived and base class. That is, it lets you substitute a derived class object, such as a circle or rectangle, for a base class shape object. For example, given a C++ function such as:

void f(shape *p) {
   ~~~
   p->perimeter(); // virtual call to shape's perimeter
   ~~~
}

you can pass it a derived class object, as in:

circle c;
  ~~~
  f(&c); // pass a circle as a shape

and it computes the circle's perimeter correctly. With a little more effort, you can emulate this behavior in C. In C, you have to explicitly mention the vptr in virtual function calls, as in:

void f(shape *p) {
   ~~~
   p->vptr->perimeter(p); // virtual call to shape's perimeter
   ~~~
}