Jak zaimplementować klasę w C?

Ja też musiałem to zrobić, żeby odrobić lekcje. Zastosowałem takie podejście:

1. Zdefiniuj swoje dane w struct.
2. Zdefiniuj swoje funkcje, które weź wskaźnik do swojej struktury jako pierwszy argument.
3. Zrób to w jednym nagłówku i jednym c. Nagłówek dla definicji struktury & deklaracje funkcji, c dla wdrożenia.

Prostym przykładem może być:

/// Queue.h
struct Queue
{
    /// members
}
typedef struct Queue Queue;

void push(Queue* q, int element);
void pop(Queue* q);
// etc.
/// 

Jeśli chcesz tylko jedną klasę, użyj tablicy struct s jako danych " obiektów "i przekaż im wskaźniki do funkcji" member". Możesz użyć typedef struct _whatever Whatever przed zadeklarowaniem struct _whatever, aby ukryć implementację przed kodem klienta. Nie ma różnicy między takim "obiektem" a obiektem standardowej biblioteki C FILE.

Jeśli chcesz mieć więcej niż jedną klasę z dziedziczeniem i funkcjami wirtualnymi, to często używa się wskaźników do funkcji jako członków struktury lub współdzielonego wskaźnika do tabeli funkcji wirtualnych. Biblioteka GObject używa zarówno tego, jak i sztuczki typedef i jest szeroko stosowana.

Istnieje również książka na temat technik do tego dostępna online- Programowanie obiektowe z ANSI C .

Możesz spojrzeć na GOBject. jest to biblioteka systemu operacyjnego, która daje szczegółowy sposób na wykonanie obiektu.

Http://library.gnome.org/devel/gobject/stable/

interfejsy i implementacje C: techniki tworzenia oprogramowania Wielokrotnego Użytku, David R. Hanson

Http://www.informit.com/store/product.aspx?isbn=0201498413

Ta książka doskonale odpowiada na twoje pytanie. Należy do serii Addison Wesley Professional Computing.

Podstawowy paradygmat jest taki:

/* for data structure foo */

FOO *myfoo;
myfoo = foo_create(...);
foo_something(myfoo, ...);
myfoo = foo_append(myfoo, ...);
foo_delete(myfoo);

Miro Samek opracował obiektowy framework C dla swojej maszyny stanowej: http://sourceforge.net/projects/qpc / . napisał też o tym książkę: http://www.state-machine.com/psicc2/.

Użyj struct do symulacji danych klasy. Pod względem zakresu metod można symulować metody prywatne, umieszczając w nich prototypy funkcji private .pliku c oraz funkcji public {[3] } wplik H.

Podam prosty przykład, jak OOP powinno się zrobić w C. zdaję sobie sprawę, że thead jest z 2009 roku, ale i tak chciałbym to dodać.

/// Object.h
typedef struct Object {
    uuid_t uuid;
} Object;

int Object_init(Object *self);
uuid_t Object_get_uuid(Object *self);
int Object_clean(Object *self);

/// Person.h
typedef struct Person {
    Object obj;
    char *name;
} Person;

int Person_init(Person *self, char *name);
int Person_greet(Person *self);
int Person_clean(Person *self);

/// Object.c
#include "object.h"

int Object_init(Object *self)
{
    self->uuid = uuid_new();

    return 0;
}
uuid_t Object_get_uuid(Object *self)
{ // Don't actually create getters in C...
    return self->uuid;
}
int Object_clean(Object *self)
{
    uuid_free(self->uuid);

    return 0;
}

/// Person.c
#include "person.h"

int Person_init(Person *self, char *name)
{
    Object_init(&self->obj); // Or just Object_init(&self);
    self->name = strdup(name);

    return 0;
}
int Person_greet(Person *self)
{
    printf("Hello, %s", self->name);

    return 0;
}
int Person_clean(Person *self)
{
    free(self->name);
    Object_clean(self);

    return 0;
}

/// main.c
int main(void)
{
    Person p;

    Person_init(&p, "John");
    Person_greet(&p);
    Object_get_uuid(&p); // Inherited function
    Person_clean(&p);

    return 0;
}

Podstawowa koncepcja zakłada umieszczenie 'dziedziczonej klasy' na szczycie struktury. W ten sposób, dostęp do pierwszych 4 bajtów w strukturze uzyskuje również dostęp do pierwszych 4 bajtów w 'dziedziczonej klasie' (jako Nie-szalone optymalizacje). Teraz, gdy wskaźnik struktury jest przypisany do 'dziedziczonej klasy', 'dziedziczona klasa' może uzyskać dostęp do 'dziedziczone wartości' w taki sam sposób, w jaki normalnie uzyskałby dostęp do swoich członków.

To i niektóre konwencje nazewnicze dla konstruktorów, destruktorów, alokacji i funkcji deallocarion (polecam init, clean, new, free) zapewnią ci długą drogę.

Jeśli chodzi o funkcje wirtualne, użyj wskaźników funkcji w strukturze, ewentualnie z Class_func(...); wrapper też. Jeśli chodzi o (proste) szablony, Dodaj parametr size_t, aby określić rozmiar, wymagaj wskaźnika void* lub wymagaj typu "class" z tylko funkcjonalność, na której ci zależy. (np. int GetUUID( Object * self); GetUUID (&p);)

W Twoim przypadku dobrym przybliżeniem klasy może być an ADT . Ale to nie będzie to samo.

Moja strategia to:

• Zdefiniuj cały kod dla klasy w oddzielnym pliku
• Zdefiniuj wszystkie interfejsy dla klasy w oddzielnym pliku nagłówkowym
• wszystkie funkcje Członkowskie przyjmują "ClassHandle", które oznacza nazwę instancji (zamiast o. foo(), wywołaj foo (oHandle)
• konstruktor jest zastąpiony funkcją Void ClassInit (ClassHandle h, int x, int y,...) Lub ClassHandle ClassInit (int x, int y,...) w zależności od strategii alokacji pamięci
• Wszystkie zmienne członkowskie są przechowywane jako element statycznej struktury w pliku klasy, zamykając ją w pliku, uniemożliwiając zewnętrznym plikom dostęp do niej
• obiekty są przechowywane w tablicy statycznej struktury powyżej, z predefiniowanymi uchwytami (widocznymi w interfejsie) lub ustalonym limitem obiektów, które można utworzyć instancję
• jeśli jest to użyteczne, klasa może zawierać publiczne funkcje, które będą pętlować przez tablicę i wywoływać funkcje wszystkich instancji obiektów (RunAll() wywołuje każdy z nich Run (oHandle)
• funkcja Deinit(ClassHandle h) zwalnia przydzieloną pamięć (indeks tablicy) w strategii dynamicznej alokacji

Czy ktoś widzi jakieś problemy, dziury, potencjalne pułapki lub ukryte korzyści / wady obu wariacji tego podejścia? Jeśli wymyślam na nowo metodę projektowania (i zakładam, że muszę nią być), czy możesz wskazać mi jej nazwę?

Jest bardzo obszerna książka na ten temat, która może być warta sprawdzenia:

Programowanie obiektowe w ANSI-C

Zobacz też Ta odpowiedź i Ta

To możliwe. To zawsze wydaje się dobrym pomysłem w tym czasie, ale potem staje się koszmarem konserwacji. Twój kod staje się zaśmiecony kawałkami kodu wiążącymi wszystko razem. Nowy programista będzie miał wiele problemów z czytaniem i zrozumieniem kodu, jeśli użyjesz wskaźników funkcji, ponieważ nie będzie oczywiste, jakie funkcje są nazywane.

Ukrywanie danych za pomocą funkcji get/set jest łatwe do zaimplementowania w C, ale zatrzymaj się. Widziałem wiele prób tego w środowisku wbudowanym i w końcu zawsze jest to problem konserwacyjny.

Ponieważ wszyscy gotowi mają problemy z konserwacją, będę omijać.

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <uchar.h>

/**
 * Define Shape class
 */
typedef struct Shape Shape;
struct Shape {
    /**
     * Variables header...
     */
    double width, height;

    /**
     * Functions header...
     */
    double (*area)(Shape *shape);
};

/**
 * Functions
 */
double calc(Shape *shape) {
        return shape->width * shape->height;
}

/**
 * Constructor
 */
Shape _Shape() {
    Shape s;

    s.width = 1;
    s.height = 1;

    s.area = calc;

    return s;
}

/********************************************/

int main() {
    Shape s1 = _Shape();
    s1.width = 5.35;
    s1.height = 12.5462;

    printf("Hello World\n\n");

    printf("User.width = %f\n", s1.width);
    printf("User.height = %f\n", s1.height);
    printf("User.area = %f\n\n", s1.area(&s1));

    printf("Made with \xe2\x99\xa5 \n");

    return 0;
};

Może być Ta książka Online może pomóc ci rozwiązać twój problem.

Moim podejściem byłoby przeniesienie structi wszystkich przede wszystkim związanych z funkcji do osobnego pliku(ów) źródłowego (ów) tak, że może być używany "przenośnie".

W zależności od kompilatora, Może BYĆ w stanie włączyć funkcje do struct, ale jest to bardzo specyficzne dla kompilatora rozszerzenie i nie ma nic wspólnego z ostatnią wersją standardu, którego rutynowo używałem:)

Pierwszy kompilator c++ był w rzeczywistości preprocesorem, który przetłumaczył kod C++ na C.

Więc bardzo możliwe są zajęcia w C. Możesz spróbować wykopać Stary preprocesor C++ i zobaczyć, jakie rozwiązania tworzy.

GTK jest zbudowany w całości na C i wykorzystuje wiele koncepcji OOP. Przeczytałem kod źródłowy GTK i jest dość imponujący i zdecydowanie łatwiejszy do odczytania. Podstawową koncepcją jest to, że każda "klasa" jest po prostu strukturą i powiązanymi funkcjami statycznymi. Wszystkie funkcje statyczne akceptują strukturę" instance " jako parametr, wykonują wszystko, co jest potrzebne i zwracają wyniki, jeśli jest to konieczne. Na przykład możesz mieć funkcję " GetPosition (CircleStruct obj)". Funkcja wystarczy przekopać struktura, wyodrębnij numery pozycji, prawdopodobnie zbuduj nowy obiekt PositionStruct, przyklej X i y do nowej struktury pozycyjnej i zwróć ją. GTK implementuje nawet dziedziczenie w ten sposób, osadzając struktury wewnątrz struktur. całkiem sprytne.

Chcesz wirtualnych metod?

Jeśli nie, to po prostu definiujesz zbiór wskaźników funkcji w samej strukturze. Jeśli przypisasz wszystkie wskaźniki funkcji do standardowych funkcji C, będziesz mógł wywoływać funkcje z języka C w bardzo podobnej składni jak w C++.

Jeśli chcesz mieć metody wirtualne, staje się to bardziej skomplikowane. Zasadniczo będziesz musiał zaimplementować własną Vtable do każdej struktury i przypisać Wskaźniki funkcji do VTable w zależności od tego, który funkcja jest wywoływana. Następnie będziesz potrzebował zestawu wskaźników funkcji w samej strukturze, które z kolei wywołują wskaźnik funkcji w tabeli VTable. To jest zasadniczo to, co robi C++.

TBH.. jeśli chcesz tego ostatniego, to prawdopodobnie lepiej jest po prostu znaleźć kompilator C++, którego możesz użyć i ponownie skompilować projekt. Nigdy nie rozumiałem obsesji na punkcie tego, że C++ nie jest użyteczny w embedded. Używałem go wiele razy i działa szybko i nie ma problemów z pamięcią. Jasne. musisz być trochę bardziej ostrożny o tym, co robisz, ale to naprawdę nie jest skomplikowane.

C nie jest językiem OOP, jak słusznie zauważyłeś, więc nie ma wbudowanego sposobu na napisanie prawdziwej klasy. Najlepiej jest spojrzeć na struktury i Wskaźniki funkcji , które pozwolą Ci zbudować przybliżenie klasy. Jednakże, ponieważ C jest proceduralne, możesz rozważyć napisanie kodu bardziej przypominającego C (tj. bez używania klas).

Ponadto, jeśli możesz używać C, możesz używać C++ i pobierać klasy.