Pure ANSI-C: crea array generico

Question

È possibile replicare un array generico in puro ANSI-C?

Ho questa struttura che contiene un array (per i float al momento) e alcune variabili come dimensione e capacità per la mutazione nell'array.

typedef struct _CustomArray 
{ 
    float* array; //the array in which the objects will be stored 
    int size; //the current size of the array 
    int capacity; //the max capacity of the array 
} CustomArray; 

Io uso questa struct in modo da poter fare una matrice in puro C dove posso aggiungere/rimuovere elementi, espandere dinamicamente la dimensione della matrice, se necessario, ecc tutte le cose che un allineamento "standard" fa, tranne che è fatto solo in C. E ora voglio fare in modo che quando inizializzi questa struct puoi impostare il tipo di dati degli elementi che dovrebbe contenere, in questo momento è solo in grado di memorizzare i tipi di dati float, ma voglio farlo in modo che possa memorizzare qualsiasi tipo di dati/altre strutture. Ma non so se questo è possibile.

In questo momento la possibilità di eseguire questa matrice è:

CustomArray* CustomArray_Create(int initCapacity, /*type elementType*/) 
{ 
    CustomArray* customArray_ptr; //create pointer to point at the structure 
    float* internalArray = (float*)malloc(sizeof(float) * initCapacity); //create the internal array that holds the items 
    if(internalArray != NULL) 
    { 
     CustomArray customArray = { internalArray, 0, initCapacity }; //make the struct with the data 
     customArray_ptr = &customArray; //get the adress of the structure and assign it to the pointer 
     return customArray_ptr; //return the pointer 
    } 
    return NULL; 
} 

E 'possibile che invia un tipo di dati come parametro così posso malloc memoria per tale tipo di dati e espressi come quella proposta tipo di dati in un array dinamico ?

Grazie in anticipo,

Marnix van Rijswijk

Answer 1

Il codice ha un problema serio ... stai tornando l'indirizzo di una variabile locale (CustomArray), e quando la funzione restituisce tale variabile è distrutta così non si può continua a usarlo con il puntatore. Devi malloc anche quella struttura in modo che la memoria sia ancora disponibile una volta che la funzione ritorna.

di fare il tipo di un parametro è possibile ottenere un po 'vicino con le macro ... per esempio con qualcosa di simile:

#include <stdlib.h> 
#define DefArray(type) \ 
typedef struct T_##type##Array {\ 
    type *array; \ 
    int size, capacity; \ 
} type##Array; \ 
static type##Array *type##ArrayCreate(int capacity)\ 
{\ 
    type##Array *s = malloc(sizeof(type##Array));\ 
    if (!s) return NULL;\ 
    s->array = malloc(sizeof(type) * capacity);\ 
    if (!s->array) { free(s); return NULL; }\ 
    s->size=0; s->capacity = capacity;\ 
    return s;\ 
} 

Quindi è possibile utilizzare in questo modo

#include "customarray.h" 
DefArray(float); 
DefArray(double); 

void foo() 
{ 
    floatArray *fa = floatArrayCreate(100); 
    ... 
} 

Si noti che è 'usare le macro per definire tutte le tue funzioni personalizzate. Nota anche che questo approccio duplicherà il codice in ogni modulo (direi non un grosso problema, ma se non puoi usare C++ probabilmente la tua piattaforma di destinazione è piuttosto piccola). Con un approccio leggermente più complesso è possibile generare file .h e .c file separati per l'implementazione.

Answer 2

Boy, questo suona davvero come un lavoro per C++.

Penso che il più vicino possibile a questo in C è quello di non passare il tipo, ma piuttosto la dimensione (sizeof (tipo)).

È possibile rendere la propria funzione più generica in modo che possa fare ciò che deve fare se tutto ciò che conosce è la dimensione di ciascun elemento nell'array. Questo è il modo in cui funzionano funzioni come bsearch().

Answer 3

Un modo per ottenere ciò è utilizzare il cosiddetto X-macros.

Here è un'implementazione vettoriale generica (probabilmente con errori) che utilizza questa tecnica.

Viene poi utilizzato come

// defining generic parameters 
#define PREFIX tv 
#define ITEM token 
#define NAME token_vector 
#include "vector.h" 

... 
token_vector tv = tv_new(100); 
*(tv.front) = some_token; 
tv_push_back(&tv, other_token); 

Answer 4

Ho lavorato con la programmazione generica in C qualche anno fa, solo per il gusto di farlo.

Fondamentalmente, ho finito per sfruttare il preprocessore. Credo di aver avuto un lieve successo: ho realizzato alcune notazioni macro per molte delle più importanti strutture di dati generici.

Quello che sicuramente non ha compire (in qualsiasi modo automatico almeno) è stato in modo ricorsivo l'esecuzione delle macro - vale a dire, la creazione di una matrice-di-array o array di hash-ecc Questo è dovuto al interessante tosse pazzo tosse semantica di macro preprocessore C.

Se siete interessati, ecco il codice: https://github.com/christianfriedl/CGenerics/blob/master/src/cgArray.h