C: Массив с элементами различного размера

Question

Возможно ли иметь массив элементов (структур), где значения различаются по размеру?

Проблема, с которой я сталкиваюсь, заключается в том, что я не знаю, как получить доступ к элементу, так как он требует приведения. «Массив» просто содержит указатели на структуры. Поэтому я решил пойти с пустотой **. Поскольку не каждый из элементов имеет один и тот же тип, этот тип также должен быть сохранен в массиве, чтобы я знал, что делать, не делая грубых предположений. Однако это не очень эффективно. Нет ли более эффективного способа?

Answer 1

Если вам не нравится слепки, вы всегда можете использоваться союзы (и флаг, чтобы указать, какой тип объединение должно быть истолковано как)

#include <stdio.h> 

typedef struct { 
    int a; 
} A; 

typedef struct B { 
    double b; 
} B; 

typedef struct C { 
    char c[20]; 
} C; 

typedef enum { 
    TypeA, 
    TypeB, 
    TypeC, 
} type; 

typedef struct { 
    type type; 
    union { A*a; B*b; C*c; } p; 
} TypedPointer ; 

void foreach (TypedPointer* list, void (*fn)(TypedPointer)) 
{ 
    while (list->p.a) { 
     fn(*list); 
     ++list; 
    } 
} 

void print_member (TypedPointer ptr) 
{ 
    switch (ptr.type) { 
     case TypeA: printf("A (%d)\n", ptr.p.a->a); break; 
     case TypeB: printf("B (%f)\n", ptr.p.b->b); break; 
     case TypeC: printf("C (%s)\n", ptr.p.c->c); break; 
    } 
} 

int main() 
{ 
    A a = { .a = 42 }; 
    B b = { .b = 1.01 }; 
    C c = { .c = "Hello World!" }; 

    TypedPointer ptrs[] = { 
     { .type = TypeA, .p.a = &a }, 
     { .type = TypeB, .p.b = &b }, 
     { .type = TypeC, .p.c = &c }, 
     { .type = 0, .p.a = 0} }; 

    foreach(ptrs, print_member); 

    return 0; 
} 

Answer 2

Для этого мы используем массив указателей на фактические объекты.

Указатели имеют одинаковый размер.

Объекты, на которые они указывают, могут быть разных размеров.

«Дискриминационный союз» хорошо работает для этого.

typedef struct { ... } this_type; 
typedef struct { ... } that_type; 
typedef struct { 
    int subtype; 
    union { 
     this_type this; 
     that_type that 
    } 
} discriminated_union; 

An указатели на массив discriminated_union работает хорошо.

Answer 3

Броски не являются неэффективными, так как они просто говорят компьютеру, как интерпретировать область памяти. Когда они скомпилированы для сборки, компилятор создаст сборку, которая по мере необходимости будет интерпретировать область памяти.

Answer 4

Нет, в C каждый элемент массива должен быть одного типа (и, следовательно, такого же размера).

Возможно, вам понадобится добавить еще один слой абстракции, в этом случае вам нужно будет аннотировать элементы с типом, который он имеет, например. вы могли бы сделать массив структур, которые выглядят как:

enum ElemType { 
    TypeNull, 
    TypeFoo, 
    TypeBar 
]; 

struct Elem { 
enum ElemType type; 
void *realElem; 
}; 

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

struct Elem arr[42]; 
... 
switch(arr[k].type) { 
    case TypeFoo: 
    handleFoo(arr[k].realElem); 
    break; 
    ... 
} 

Answer 5

Нет, C массивы имеют постоянный размер, который должен быть известен в compiletime. Но вы можете обойти это, используя указатели и динамическое распределение.

Проблема здесь не эффективность настолько, насколько это безопасно. Кастинг не имеет стоимости исполнения во время выполнения, это всего лишь механизм для общения с компилятором, попросите его «доверять вам» и предположим, что за последовательностью бит есть определенный тип. Мы говорим о безопасности, потому что, если вы ошибаетесь, все может произойти во время выполнения.

В C (статическом языке) невозможно построить массив разных типов. То, что вы можете сделать, это построить массив определенной структуры, но удержать указатели на объекты с различными размерами. Например, если у struct есть указатель char*, в этом случае каждый объект содержит строку одной или другой длины и, следовательно, имеет переменный размер (в терминах общей памяти, используемой во время выполнения, а не в виде непрерывного пространства).

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