Как сделать наследование на языке, отличном от объектно-ориентированного?

В любом случае в C вы делаете это так, как это делал cfront в первые дни C ++, когда код C ++ был переведен на C. Но вам нужно быть достаточно дисциплинированным и выполнять всю работу вручную.

Ваши «классы» должны быть инициализированы с помощью функции, выполняющей работу конструктора. это будет включать инициализацию указателя на таблицу указателей полиморфных функций для виртуальных функций. Вызов виртуальных функций должен выполняться через указатель функции vtbl (который будет указывать на структуру указателей функций - по одному для каждой виртуальной функции).

Структура виртуальной функции для каждого производного класса calss должна быть надмножеством структуры базового класса.

Некоторые механизмы этого можно скрыть / помочь с помощью макросов.

Первое издание "Практические диаграммы состояний на C / C ++" Миро Самека содержит приложение A - «C + - объектно-ориентированное программирование на C», в котором есть такие макросы. Похоже, это было исключено из второго издания. Наверное, потому, что это больше хлопот, чем того стоит. Просто используйте C ++, если хотите ...

Вам также следует прочитать Липпмана "Внутри объекта C ++ Модель ", в которой подробно рассказывается о том, как C ++ работает" за кулисами ", часто с фрагментами того, как что-то может работать в C.

Думаю, я понимаю, что тебе нужно. Может быть.

Как может что-то вроде этого работать:

typedef 
struct foo {
    int a;
} foo;

void doSomething( foo f);   // note: f is passed by value

typedef
struct bar {
    foo base;
    int b;
} bar;


int main() {
    bar b = { { 1 }, 2};

    doSomething( b);    // how can the compiler know to 'slice' b
                        //  down to a foo?

    return 0;
}

Что ж, вы не можете сделать это так просто без языковой поддержки - вам нужно будет сделать некоторые вещи вручную (вот что означает отсутствие языковой поддержки):

    doSomething( b.base);       // this works

По сути, структуры внутри структур.

struct Base {
    int blah;
};

struct Derived {
    struct Base __base;
    int foo;
};

Когда вы хотите, скажем, преобразовать Derived * в Base *, вы фактически вернете указатель на элемент __base производной структуры, которая в этом случае является первой вещью в структуре, поэтому указатели должны быть одинаковыми (не было бы ' Однако это относится к классам с множественным наследованием).

Если вы хотите получить доступ к blah в этом случае, вы должны сделать что-то вроде derived.__base.blah.

Виртуальные функции обычно выполняются с помощью специальной таблицы указателей функций, которая является частью каждого объекта, элементарной записи типа «какой у меня тип».

Вот как это делает COM для языка C. Я немного подзабыл, но суть такова. Каждая переменная-член «класса» - это просто структура.

struct Shape
{
  int value;
};

struct Square
{
  struct Shape shape; // make sure this is on top, if not KABOOM
  int someothervalue;
};

все методы на самом деле являются обычными функциями. нравится

void Draw(Shape * shape,int x,int y)
{
  shape->value=10; // this should work even if you put in a square. i think...
}

затем они используют препроцессор, чтобы «обмануть» код C, чтобы он отобразил что-то вроде этого.

Square * square;
square->Draw(0,0); // this doesnt make sense, the preprocessor changes it to Draw(square,0,0);

Увы, я не знаю, какие уловки препроцессора используются, чтобы преобразовать вызов функции, похожий на C ++, в вызов Plan vanilla C.

Таким образом объявляются COM-объекты DirectX.

У доктора Добба была умеренно подробная статья на эту тему: Классы одиночного наследования в C.

Структуры внутри структур - это обычное дело, но это затрудняет доступ к унаследованным полям. Вам нужно либо использовать косвенное обращение (например, child->parent.field), либо преобразование (((PARENT *) child)->field).

Альтернатива, которую я видел, больше похожа на это:

#define COUNTRY_FIELDS \
    char *name; \
    int population;

typedef struct COUNTRY
{
    COUNTRY_FIELDS
} COUNTRY;

#define PRINCIPALITY_FIELDS \
    COUNTRY_FIELDS \
    char *prince;

typedef struct PRINCIPALITY
{
    PRINCIPALITY_FIELDS
} PRINCIPALITY;

Это дает типам прямой доступ к унаследованным полям. Полученные объекты по-прежнему можно безопасно привести к родительскому типу, потому что поля родительского и унаследованные поля начинаются в одном месте.

Синтаксис можно немного улучшить с помощью макросов. Я видел это в более старом исходном коде POV-Ray (но я думаю, что с тех пор они преобразованы в C ++).

Если вам нужна хорошая справка о том, как это работает, взгляните на библиотеки с открытым исходным кодом glib / gdk / gtk. У них довольно хорошая документация, и весь фреймворк основан на C OO.

Вы можете имитировать объект, написав конструкторы, сеттеры, геттеры и деструкторы со скрытым указателем this, вызываемым явно.

Наследование осуществляется путем включения в производный объект указателя на базовый объект в структуре производного объекта.