Come si implementa una classe in C? [chiuso]

Supponendo che devo usare C (no C ++ o compilatori orientati agli oggetti) e non ho allocazione dinamica della memoria, quali sono alcune tecniche che posso usare per implementare una classe o una buona approssimazione di una classe? È sempre una buona idea isolare la "classe" in un file separato? Supponiamo che possiamo preallocare la memoria assumendo un numero fisso di istanze o persino definendo il riferimento a ciascun oggetto come costante prima del tempo di compilazione. Sentiti libero di fare ipotesi su quale concetto di OOP dovrò implementare (varierà) e suggerisci il metodo migliore per ciascuno.

restrizioni:

• Devo usare C e non un OOP perché sto scrivendo il codice per un sistema incorporato e il compilatore e la base di codici preesistenti sono in C.
• Non esiste allocazione dinamica della memoria perché non abbiamo memoria sufficiente per presumere ragionevolmente che non finiremo se iniziamo ad allocarla dinamicamente.
• I compilatori con cui lavoriamo non hanno problemi con i puntatori a funzione

Dipende dall'esatto set di funzionalità "orientato agli oggetti" che si desidera avere. Se hai bisogno di cose come il sovraccarico e / o metodi virtuali, probabilmente devi includere i puntatori di funzione nelle strutture:

typedef struct {
  float (*computeArea)(const ShapeClass *shape);
} ShapeClass;

float shape_computeArea(const ShapeClass *shape)
{
  return shape->computeArea(shape);
}

Ciò ti consentirebbe di implementare una classe "ereditando" la classe base e implementando una funzione adatta:

typedef struct {
  ShapeClass shape;
  float width, height;
} RectangleClass;

static float rectangle_computeArea(const ShapeClass *shape)
{
  const RectangleClass *rect = (const RectangleClass *) shape;
  return rect->width * rect->height;
}

Questo ovviamente richiede anche l'implementazione di un costruttore, che assicuri che il puntatore a funzione sia impostato correttamente. Normalmente alloceresti dinamicamente la memoria per l'istanza, ma puoi anche lasciare che sia il chiamante a farlo:

void rectangle_new(RectangleClass *rect)
{
  rect->width = rect->height = 0.f;
  rect->shape.computeArea = rectangle_computeArea;
}

Se vuoi diversi costruttori diversi, dovrai "decorare" i nomi delle funzioni, non puoi avere più di una rectangle_new()funzione:

void rectangle_new_with_lengths(RectangleClass *rect, float width, float height)
{
  rectangle_new(rect);
  rect->width = width;
  rect->height = height;
}

Ecco un esempio di base che mostra l'utilizzo:

int main(void)
{
  RectangleClass r1;

  rectangle_new_with_lengths(&r1, 4.f, 5.f);
  printf("rectangle r1's area is %f units square\n", shape_computeArea(&r1));
  return 0;
}

Spero che questo ti dia qualche idea, almeno. Per un framework orientato agli oggetti ricco e di successo in C, guarda nella libreria GObject di glib .

Si noti inoltre che non esiste una "classe" esplicita modellata sopra, ogni oggetto ha i propri puntatori di metodo che sono un po 'più flessibili di quanto si possa trovare in C ++. Inoltre, costa memoria. Puoi evitarlo inserendo i puntatori del metodo in una classstruttura e inventando un modo per ogni istanza di oggetto di fare riferimento a una classe.

Ho dovuto farlo anche una volta per i compiti. Ho seguito questo approccio:

1. Definire i membri dei dati in una struttura.
2. Definisci i membri della tua funzione che prendono un puntatore alla tua struttura come primo argomento.
3. Fai questi in un colpo di testa e uno c. Intestazione per la definizione della struttura e le dichiarazioni di funzione, c per le implementazioni.

Un semplice esempio sarebbe questo:

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

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

Se si desidera solo una classe, utilizzare una matrice di structs come dati "oggetti" e passare loro i puntatori alle funzioni "membro". È possibile utilizzare typedef struct _whatever Whateverprima di dichiarare struct _whateverdi nascondere l'implementazione dal codice client. Non c'è differenza tra un tale "oggetto" e l' FILEoggetto libreria standard C.

Se si desidera più di una classe con ereditarietà e funzioni virtuali, è comune disporre di puntatori alle funzioni come membri della struttura o di un puntatore condiviso a una tabella di funzioni virtuali. La libreria GObject utilizza sia questo che il trucco typedef ed è ampiamente utilizzata.

C'è anche un libro sulle tecniche per questo disponibili on-line - Object Oriented Programming con ANSI C .

puoi dare un'occhiata a GOBject. è una libreria del sistema operativo che ti dà un modo dettagliato per fare un oggetto.

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

Interfacce e implementazioni C: tecniche per la creazione di software riutilizzabile , David R. Hanson

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

Questo libro fa un ottimo lavoro nel rispondere alla tua domanda. È nella serie di calcolo professionale Addison Wesley.

Il paradigma di base è qualcosa del genere:

/* for data structure foo */

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

Darò un semplice esempio di come OOP dovrebbe essere fatto in C. Mi rendo conto che questa testata è del 2009, ma vorrei aggiungerla comunque.

/// 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;
}

Il concetto di base prevede che la "classe ereditaria" sia posta in cima alla struttura. In questo modo, l'accesso ai primi 4 byte nella struttura accede anche ai primi 4 byte nella "classe ereditata" (Assumendo ottimizzazioni non pazze). Ora, quando il puntatore della struttura viene lanciato sulla "classe ereditata", la "classe ereditata" può accedere ai "valori ereditati" nello stesso modo in cui accederà ai suoi membri normalmente.

Questa e alcune convenzioni di denominazione per i costruttori, i distruttori, le funzioni di allocazione e deallocarion (raccomando init, clean, new, free) ti aiuteranno molto.

Per quanto riguarda le funzioni virtuali, utilizzare i puntatori a funzione nella struttura, possibilmente con Class_func (...); anche involucro. Per quanto riguarda i modelli (semplici), aggiungi un parametro size_t per determinare la dimensione, richiedere un puntatore void * o richiedere un tipo 'class' con solo la funzionalità che ti interessa. (es. int GetUUID (Object * self); GetUUID (& p);)

Utilizzare a structper simulare i membri di dati di una classe. In termini di ambito del metodo è possibile simulare metodi privati ​​inserendo i prototipi di funzioni private nel file .c e le funzioni pubbliche nel file .h.

#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;
};

Nel tuo caso la buona approssimazione della classe potrebbe essere un ADT . Ma non sarà più lo stesso.

La mia strategia è:

• Definire tutto il codice per la classe in un file separato
• Definire tutte le interfacce per la classe in un file di intestazione separato
• Tutte le funzioni membro prendono un "ClassHandle" che sta per il nome dell'istanza (invece di o.foo (), call foo (oHandle)
• Il costruttore viene sostituito con una funzione void ClassInit (ClassHandle h, int x, int y, ...) OR ClassHandle ClassInit (int x, int y, ...) a seconda della strategia di allocazione della memoria
• Tutte le variabili membro vengono archiviate come membro di una struttura statica nel file di classe, incapsulandolo nel file, impedendo ai file esterni di accedervi
• Gli oggetti sono memorizzati in una matrice della struttura statica sopra, con handle predefiniti (visibili nell'interfaccia) o un limite fisso di oggetti che possono essere istanziati
• Se utile, la classe può contenere funzioni pubbliche che attraverseranno l'array e chiameranno le funzioni di tutti gli oggetti istanziati (RunAll () chiama ogni Run (oHandle)
• Una funzione Deinit (ClassHandle h) libera la memoria allocata (indice di array) nella strategia di allocazione dinamica

Qualcuno vede problemi, buchi, potenziali insidie ​​o vantaggi / svantaggi nascosti a entrambe le varianti di questo approccio? Se sto reinventando un metodo di progettazione (e presumo che debba essere), puoi indicarmi il nome?

Vedi anche questa risposta e questa

È possibile. Sembra sempre una buona idea al momento, ma in seguito diventa un incubo per la manutenzione. Il tuo codice si riempie di pezzi di codice che legano tutto insieme. Un nuovo programmatore avrà molti problemi a leggere e comprendere il codice se si utilizzano i puntatori a funzione poiché non sarà ovvio quali funzioni vengano chiamate.

Nascondere i dati con le funzioni get / set è facile da implementare in C ma fermarsi qui. Ho visto più tentativi in ​​questo ambito nell'ambiente incorporato e alla fine è sempre un problema di manutenzione.

Dal momento che tutti voi avete problemi di manutenzione, vorrei evitare.

Il mio approccio sarebbe quello di spostare le structe tutte le funzioni associate principalmente in un file di origine separato in modo che possa essere usato "portabilmente".

A seconda del tuo compilatore, potresti essere in grado di includere funzioni in struct, ma questa è un'estensione molto specifica per il compilatore e non ha nulla a che fare con l'ultima versione dello standard che ho usato abitualmente :)

Il primo compilatore c ++ era in realtà un preprocessore che traduceva il codice C ++ in C.

Quindi è molto possibile avere classi in C. Potresti provare a scavare un vecchio preprocessore C ++ e vedere che tipo di soluzioni crea.

GTK è interamente costruito su C e utilizza molti concetti OOP. Ho letto il codice sorgente di GTK ed è piuttosto impressionante e sicuramente più facile da leggere. Il concetto di base è che ogni "classe" è semplicemente una struttura e funzioni statiche associate. Tutte le funzioni statiche accettano la struttura "istanza" come parametro, fanno tutto ciò che serve e restituiscono i risultati se necessario. Ad esempio, potresti avere una funzione "GetPosition (CircleStruct obj)". La funzione scava semplicemente attraverso la struttura, estrae i numeri di posizione, probabilmente costruisce un nuovo oggetto PositionStruct, inserisce la xey nel nuovo PositionStruct e lo restituisce. GTK implementa anche l'ereditarietà in questo modo incorporando le strutture all'interno delle strutture. abbastanza intelligente.

Vuoi metodi virtuali?

In caso contrario, è sufficiente definire un set di puntatori a funzione nella struttura stessa. Se assegni tutti i puntatori a funzioni C standard, sarai in grado di chiamare funzioni da C in sintassi molto simili a come faresti in C ++.

Se vuoi avere metodi virtuali, diventa più complicato. Fondamentalmente sarà necessario implementare il proprio VTable per ogni struttura e assegnare i puntatori di funzione al VTable a seconda della funzione chiamata. Avresti quindi bisogno di un set di puntatori a funzione nella struttura stessa che a sua volta chiamano il puntatore a funzione nel VTable. Questo è essenzialmente ciò che fa C ++.

TBH però ... se vuoi quest'ultimo, probabilmente stai meglio trovando un compilatore C ++ che puoi usare e ricompilare il progetto. Non ho mai capito l'ossessione per il C ++ di non essere utilizzabile in embedded. L'ho usato molte volte e funziona velocemente e non ha problemi di memoria. Sicuramente devi stare un po 'più attento a quello che fai ma non è poi così complicato.

C non è un linguaggio OOP, come giustamente fai notare, quindi non esiste un modo integrato per scrivere una vera classe. La cosa migliore da fare è guardare le strutture e i puntatori di funzioni , che ti permetteranno di costruire un'approssimazione di una classe. Tuttavia, poiché C è procedurale, potresti prendere in considerazione la possibilità di scrivere più codice simile a C (ovvero senza provare a utilizzare le classi).

Inoltre, se puoi usare C, puoi probabilmente usare C ++ e ottenere classi.