Вектор на си

typedef struct {
    void* pData;
    int elemSz;
    int size;
 
    int realMemSize; //real size of the allocated memory
}vector;

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
 
//----------------------------------------------------------------------
 
#define ERR_OK      0
#define ERR_MEMORY -1
 
#define TYPE_ID_INT      0
#define TYPE_ID_CHAR_STR 1
 
//----------------------------------------------------------------------
 
typedef int (*size_f)(int type_id, const void* data);
typedef void (*copy_f)(int type_id, void* dst, const void* src);
typedef void (*show_f)(int type_id, const void* data);
 
typedef struct {
    size_f size;
    copy_f copy;
    show_f show;
} handler_t;
 
typedef struct {
    void* data;
    int type_id;
} element_t;
 
typedef struct {
    element_t* data;
    int size_current;
    int size_max;
    handler_t handler;
} vector_t;
 
//----------------------------------------------------------------------
 
void
init_vector(vector_t* vector, const handler_t* handler) {
    vector->data = 0;
    vector->size_current = 0;
    vector->size_max = 0;
    vector->handler = *handler;
}
 
int
add_element(vector_t* vector, const void* data, int type_id) {
    if (vector->size_current >= vector->size_max) {
        int new_size_max = vector->size_max * 2 + 1;    
        void* new_memory = realloc(vector->data, new_size_max * sizeof(element_t));
        if (!new_memory) {
            return ERR_MEMORY;
        }
        vector->data = new_memory;
        vector->size_max = new_size_max;    
    }
    
    element_t new_element;
    new_element.data = malloc(vector->handler.size(type_id, data));
    if (!new_element.data) {
        return ERR_MEMORY;
    }
    vector->handler.copy(type_id, new_element.data, data);
    new_element.type_id = type_id;
    
    vector->data[vector->size_current] = new_element;
    vector->size_current++; 
 
    return ERR_OK;
}
 
void
show_vector(const vector_t *vector) {
    for (int i = 0; i < vector->size_current; i++) {
        vector->handler.show(vector->data[i].type_id, vector->data[i].data);
    }
}
 
//----------------------------------------------------------------------
 
int
size(int type_id, const void* data) {
    switch (type_id) {
    case TYPE_ID_INT:
        return sizeof(int);
    case TYPE_ID_CHAR_STR:
        return strlen(data) + 1; 
    }
}
 
void
copy(int type_id, void* dst, const void* src) {
    switch (type_id) {
    case TYPE_ID_INT:
        memcpy(dst, src, sizeof(int));
        break;
    case TYPE_ID_CHAR_STR:
        strcpy(dst, src);
        break; 
    }
}
 
void
show(int type_id, const void* data) {
    switch (type_id) {
    case TYPE_ID_INT:
        printf("%d", *((int*)data));
        break;
    case TYPE_ID_CHAR_STR:
        printf("%s", (char*)data);
        break; 
    }
    printf("\n");
}
 
//----------------------------------------------------------------------
 
int
main() {
    vector_t vector;
    handler_t handler = {size, copy, show};
 
    init_vector(&vector, &handler);
    
    for (int i = 0; i < 5; i++) {
        add_element(&vector, &i, TYPE_ID_INT);
    }
    add_element(&vector, "last_element", TYPE_ID_CHAR_STR);
    
    show_vector(&vector);   
    
    return 0;
}

      // * Макросы *
#define NEWXTD(x,T) (T *)newxtd(x,sizeof(T));
#define GETXTD(x,j,T) (T *)(x->ss[j]);

T *tt, somett;
XTD *x = genxtd();  // Создание и заполнение
for(i=0; i<N; i++) {
  // заполнили структуру somett
  tt = NEWXTD(x, T);
  *tt = somett;
}
   // Перебор и выемка
for(i=0; i<x->ns; i++) {
  tt = GETXTD(x, i, T);
   // ... tt  указывает на очередной элемент вектора
}

i=0

tt = GETXTD(x, i, T);

XTD *x = genxtd();
//И потом туда помещаете
T *t = NEWXTD(x, T);

COMPLEX *c = NEWXTD(x, COMPLEX);  // Тут только выделяется память
c->Re = 5;
c->Im = -2;
  // Или если есть уже заполненная структура 
COMPLEX a.
a.Re = 5;
a.Im=-2;
*c = a;

typedef struct {
    char *tt;    // * Массив элементов
    unsigned ms; // * Выделено памяти на элементов tt
    unsigned ns; // * Заполнено
    int st;      // * Шаг приращения памяти для tt
    int sz;      // * Величина элемента
               }  TD;
 
#define NEWTD(x,T) (T *)newtd(x);
#define GETTD(x,j,T) (T *)((x->tt)+(j)*(x->sz));
 
void gent(TD *x, short sz)
{
    x->tt = NULL;
    x->ms = x->ns = 0;
    x->st = 10;
    x->sz = sz;
}
// ------------------
TD *gentd(short sz)     // * Генерация  *
{ TD *x;
    x = malloc(sizeof(TD));
    gent(x, sz);
    return x;
}
// ********
deltd(TD *x)          // * Разрушение
{  if (x==NULL) return;
   if (x->tt!=NULL) free((x->tt));
   free(x);
}
/*********/
void *newtd (TD *x)      // * Новый элемент
{ void *p; int sz;
   sz = x->sz;
   if (x->tt==NULL) {
       x->ms = x->st;
       x->tt = malloc(x->ms * sz);
   }
   if (x->ns>=x->ms) {
     x->ms += x->st;
     x->tt = realloc(x->tt, x->ms*sz);
   }
   p = x->tt + sz*(x->ns++);
   return(p);
}