массивы — Структурный эквивалент взлома в переполнении стека

Это C ++, поэтому шаблоны доступны:

template <int N>
struct hack {
int filler;
int thing [N];
};

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

Первое, что приходит на ум, это не надо, не пишите C на C ++. В 99,99% случаев это hack не требуется, не принесет заметного улучшения производительности по сравнению с std::vector и усложнит вашу жизнь и жизнь других сопровождающих проекта, в котором вы это внедрили.

Если вы хотите использовать стандартный совместимый подход, предоставьте тип оболочки, который динамически выделяет кусок памяти, достаточно большой, чтобы содержать hack (минус массив) плюс N*sizeof(int) для эквивалента массива (не забудьте обеспечить правильное выравнивание). Класс будет иметь средства доступа, которые отображают члены и элементы массива в правильное расположение в памяти.

Игнорирование выравнивания и кода котельной пластины, чтобы сделать интерфейс красивым и безопасным для реализации:

template <typename T>
class DataWithDynamicArray {
void *ptr;
int* array() {
return static_cast<int*>(static_cast<char*>(ptr)+sizeof(T)); // align!
}
public:
DataWithDynamicArray(int size) : ptr() {
ptr = malloc(sizeof(T) + sizeof(int)*size); // force correct alignment
new (ptr) T();
}
~DataWithDynamicArray() {
static_cast<T*>(ptr)->~T();
free(ptr);
}
// copy, assignment...
int& operator[](int pos) {
return array()[pos];
}
T& data() {
return *static_cast<T*>(ptr);
}
};

struct JustSize { int size; };
DataWithDynamicArray<JustSize> x(10);
x.data().size = 10
for (int i = 0; i < 10; ++i) {
x[i] = i;
}

Теперь я бы на самом деле не реализовал это таким образом (я бы вообще этого не делал !!), так как, например, размер должен быть частью состояния DataWithDynamicArray…

Этот ответ предоставляется только в качестве упражнения, чтобы объяснить, что то же самое можно сделать без расширений, но будьте осторожны, это всего лишь игрушечный пример, который имеет много проблемы, включая, но не ограничиваясь, исключение безопасности или выравнивания (и все же лучше, чем принуждение пользователя сделать malloc с правильным размером). Тот факт, что вы Можно не значит что ты должен, и реальный вопрос в том, необходимость эта функция и то, что вы пытаетесь сделать, это хороший дизайн или нет.

Если вы действительно чувствуете необходимость использовать взлом, почему бы просто не использовать

struct hack {
char filler;
int things[1];
};

с последующим

hack_p = malloc(sizeof(struct hack)+(N-1)*sizeof int));

Или даже не беспокойтесь о -1 и живите с небольшим дополнительным пространством.

В C ++ нет понятия «гибкие массивы». Единственный способ иметь гибкий массив в C ++ — это использовать динамический массив — что заставляет вас использовать int* things, Вам понадобится параметр размера, если вы пытаетесь прочитать эти данные из файла, чтобы вы могли создать массив соответствующего размера (или использовать std::vector и просто продолжайте читать, пока не дойдете до конца потока).

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

Кроме того, прежде чем люди начнут предлагать хранить int * отдельно
выделенная часть памяти в структуре, это не
удовлетворительный ответ. Я хочу выделить один кусок памяти для
держать и мою структуру и элементы массива. Использование std :: vector также
попадает в ту же категорию.

Тот является так, как вы бы сделали это в C ++. Вы можете отклонить все, что хотите, но факт остается фактом: нестандартное расширение не сработает, когда вы перейдете к компилятору, который его не поддерживает. Если вы придерживаетесь стандарта (например, избегаете использования хаков, специфичных для компилятора), вы с меньшей вероятностью столкнетесь с этими типами проблем.

Существует по крайней мере одно преимущество для гибких элементов массива по сравнению с массивами нулевой длины, когда компилятор является Clang.

struct Strukt1 {
int fam[];
int size;
};

struct Strukt2 {
int fam[0];
int size;
};

Здесь лязг будет ошибка, если он видит Strukt1 но не ошибется, если увидит Strukt2, gcc и icc принимают либо без ошибок, либо с ошибками msvc в любом случае. gcc выдает ошибку, если код скомпилирован как C.

То же самое относится и к этому похожему, но менее очевидному примеру:

struct Strukt3 {
int size;
int fam[];
};

strukt Strukt4 {
Strukt3 s3;
int i;
};