ООП на Си

[intmain]

ООП на обычном си без классов возможно ли (наследование, полиморфизм и другое )? И если да, то - как? Можно короткие примеры или ссылки на статьи?

[Abstraction]

Возможно. Первые компиляторы C++ состояли из препроцессора, переводившего код в C-код и компилятора C. Полагаю, нет вопроса, возможен ли ООП на C++.
Наследование:

typedef struct {
  int value;
} Parent;

typedef struct {
  Parent p;
} Child;

//...
Child c;
c.p.value = 0;

[_Bers]

Сообщение от Abstraction

Возможно. Первые компиляторы C++ состояли из препроцессора, переводившего код в C-код и компилятора C. Полагаю, нет вопроса, возможен ли ООП на C++.
Наследование:

typedef struct {
  int value;
} Parent;

typedef struct {
  Parent p;
} Child;

//...
Child c;
c.p.value = 0;

В приведенном куске кода нет наследования. Есть агрегирование.


По сабжу: на языке си можно воссоздать все ООП механизмы. Правда делать это придется ручками, без поддержки компилятора с его технологиями.

Если я не ошибаюсь, то Кармак в своей кваке именно так и поступил: реализовал технологию полиморфизма.

Сам я правда приплюснутый, и сишечкой особо не заморачивался. Но заметил, что в различных холиварах пример с Кармаком часто используют защитники ООП, заявляя, что в крупной системе без ООП никуда. И если он там не поддерживается, значит велосипедируется в ручную.

[Perchik71]

Квака 3... великолепный сорс....
но дум ещё круче.

Ваще да это не наследование....
наследование, это

class A
{
.....
}

class B: public A// разрешено идти даже в протект, но не приват
{
.....
}

class C: protected A/// запрещён протект с приватом
{
.....
}

class D: private A/// всё запрещено.
{
.....
}

[Пепел Феникса]

это синтаксис наследования в С++.
а не обьяснение что такое наследование.

[Perchik71]

Наследование — один из четырёх важнейших механизмов объектно-ориентированного программирования (наряду с инкапсуляцией, полиморфизмом и абстракцией), позволяющий описать новый класс на основе уже существующего (родительского), при этом свойства и функциональность родительского класса заимствуются новым классом.

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

Класс, от которого произошло наследование, называется базовым или родительским (англ. base class). Классы, которые произошли от базового, называются потомками, наследниками или производными классами (англ. derived class).

В некоторых языках используются абстрактные классы. Абстрактный класс — это класс, содержащий хотя бы один абстрактный метод, он описан в программе, имеет поля, методы и не может использоваться для непосредственного создания объекта. То есть от абстрактного класса можно только наследовать. Объекты создаются только на основе производных классов, наследованных от абстрактного.

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

При множественном наследовании у класса может быть более одного предка. В этом случае класс наследует методы всех предков. Достоинства такого подхода в большей гибкости. Множественное наследование реализовано в C++. Из других языков, предоставляющих эту возможность, можно отметить Python и Эйфель. Множественное наследование поддерживается в языке UML.

Множественное наследование — потенциальный источник ошибок, которые могут возникнуть из-за наличия одинаковых имен методов в предках. В языках, которые позиционируются как наследники C++ (Java, C# и др.), от множественного наследования было решено отказаться в пользу интерфейсов. Практически всегда можно обойтись без использования данного механизма. Однако, если такая необходимость все-таки возникла, то, для разрешения конфликтов использования наследованных методов с одинаковыми именами, возможно, например, применить операцию расширения видимости — «::» — для вызова конкретного метода конкретного родителя.

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

Большинство современных объектно-ориентированных языков программирования (C#, C++, Java, Delphi и др.) поддерживает возможность одновременно наследоваться от класса-предка и реализовать методы нескольких интерфейсов одним и тем же классом. Этот механизм позволяет во многом заменить множественное наследование — методы интерфейсов необходимо переопределять явно, что исключает ошибки при наследовании функциональности одинаковых методов различных классов-предков.

В C++ существует три типа наследования: public, protected, private. Спецификаторы доступа членов базового класса меняются в потомках следующим образом:

при public-наследовании все спецификаторы остаются без изменения.
при protected-наследовании все спецификаторы остаются без изменения, кроме спецификатора public, который меняется на спецификатор protected (то есть public-члены базового класса в потомках становятся protected).
при private-наследовании все спецификаторы меняются на private.

Одним из основных преимуществ public-наследования является то, что указатель на классы—наследники может быть неявно преобразован в указатель на базовый класс, то есть для примера выше можно написать:
A* a = new B;

Эта интересная особенность открывает возможность динамической идентификации типа (RTTI).

//----------

Надеюсь вопросов нет.
да и пример выше...

[_Bers]

Сообщение от Perchik71

В C++ существует три типа наследования: public, protected, private. Спецификаторы доступа членов базового класса меняются в потомках следующим образом:

А теперь правильный ответ:

В языке с++ существует 4ре вида наследования. О трех уже было сказано выше. 4й призван решить все возможные проблемы с неоднозначностями вызовов методов. Хотя он и не является самостоятельным видом наследования, но он является одним из вариантов наследования и дополняет вышеуказанные три.

Чаще всего, его приводят в качестве примера решения проблем ромбовидных иерархий: виртуальное наследование.

http://ru.wikipedia.org/wiki/%C2%E8%...E2%E0%ED%E8%E5

[Perchik71]

Чувак, люди опухают и с этими 3...
но спасибо я запамятовал.. надо в книгу злесть...

[intmain]

Я извиняюсь, но речь я вел исключительно о СИ без классов. Спасибо всем кто прокомментировал.
Я тут кое чего написал, но не пойму почему у меня нули везде когда должны быть цифры 10 20 и 30 ? И кстати вопрос, это как-то походит на наследование в пределах обычного СИ? И еще вопрос, насколько я правильно освобождаю память?

#include <stdio.h>
#include <stdlib.h>
#include <Windows.h>

#define SHAPEME(T) ((struct shape*)(T))

#define SHAPE_SHAPE   0
#define SHAPE_BOX       1
#define SHAPE_CIRCLE   2


typedef struct shape 
{
    int x;
    int y;
    int type;
   void (*shapeDraw) (struct shape* s);
} shape;


typedef struct box 
{
    struct shape baseShape;
    int someBoxProp;
} box;

typedef struct circle 
{
    struct shape baseShape;
    int someCircleProp;
} circle;

void drawShape( struct shape *s ) 
{
    printf("draw shape at position %f %f\n", s->x, s->y);
};

void drawBox( struct shape* s ) 
{
    printf("draw box at position %f %f\n", s->x, s->y);
}

void drawCircle( struct shape *s) 
{
    printf("draw circle at position %f %f\n", s->x, s->y);  
}


struct shape* shapeFactory(int type, int xpos, int ypos) 
{
    struct shape* ptr = 0;

    switch (type)
    {
        case 0: 
            ptr = (struct shape*) malloc(sizeof(shape));
            ptr->shapeDraw = &drawShape;
            break;
        case 1:
            ptr = (struct shape*) malloc(sizeof(box));
            ptr->shapeDraw = &drawBox;
            break;
        case 2:
            ptr = (struct shape*) malloc(sizeof(circle));
            ptr->shapeDraw = &drawCircle;
            break;
    };

    ptr->type = type;
    ptr->x =xpos;
    ptr->y = ypos;
    return ptr;
}


void shapeFree(struct shape* s) 
{
    switch (s->type)
    {
    case 0:
        free((struct shape*)(s));
        break;
    case 1:
        free((struct box*)(s));
        break;
    case 2:
        free((struct circle*)(s));
        break;
    };    
}

void draw(struct shape* s) 
{
    s->shapeDraw(s);
};

int main() 
{
    shape* s = 0;
    box* b = 0;
    circle* c = 0;

    s = shapeFactory(SHAPE_SHAPE, 10, 10);
    b = (struct box*) shapeFactory(SHAPE_BOX, 20,20);
    c = (struct circle*) shapeFactory(SHAPE_CIRCLE, 30, 30);
  
    draw((SHAPEME(s)));
    draw((SHAPEME(b)));
    draw((SHAPEME(c)));

    shapeFree((SHAPEME(s)));
    shapeFree((SHAPEME(b)));
    shapeFree((SHAPEME(c)));


    system("pause");
    return 0;
}

[Abstraction]

Я тут кое чего написал, но не пойму почему у меня нули везде когда должны быть цифры 10 20 и 30 ?

Потому что тип int, а выводите Вы их почему-то со спецификатором %f (float). Поправьте.

И еще вопрос, насколько я правильно освобождаю память?

free принимает произвольный указатель. Так что в данном примере можете просто вызывать free(s), а в принципе достаточно добавить указатель на метод deconstruct в структуру, который будет освобождать ресурсы объекта и вызывать для него free - опять же, без приведения типов.