Реализация гибких элементов массива с шаблонами и базовым классом

Небольшое приведение типов также позволяет использовать шаблон C в C ++.

Просто сделайте массив начального размера один, и выделите указатель на структуру, используя new char[...]:

struct Foo {
int var1;
int var2[1];
};

Foo* foo_ptr = reinterpret_cast<Foo*>(new char[sizeof(Foo) + sizeof(int) * (n - 1)]);

Тогда вы, конечно, должны использовать его при освобождении структуры:

delete[] reinterpret_cast<char*>(foo_ptr);

Я не очень рекомендую это для общего использования. Единственное приемлемое (для меня) место, где можно использовать такую ​​схему, — это когда-либо передается структура (сеть или файлы). И затем я рекомендую сделать маршалинг в / из «правильного» объекта C ++ с std::vector для данных переменной длины.

То, что вы хотите сделать, вообще невозможно в C ++. Причина в том, что sizeof (T) является константой во время компиляции, поэтому размещение массива внутри типа дает ему размер во время компиляции. Так что правильный способ сделать это на языке c ++ не позволяет использовать массив вне типов. Обратите внимание, что размещение массива в стек возможно только в том случае, если он внутри какого-либо типа. Таким образом, все на основе стека ограничено размером массива во время компиляции. (alloca может исправить это). В вашей исходной версии C также была похожая проблема: типы не могут работать с массивами размера во время выполнения.

Это также касается массивов переменной длины в C ++. Не поддерживается, так как это нарушает sizeof, а классы c ++ полагаются на sizeof для доступа к элементам данных. Любое решение, которое нельзя использовать вместе с классами c ++, бесполезно. У std :: vector таких проблем нет.

Обратите внимание, что constexpr в c ++ 11 значительно упрощает вычисление смещения в ваших пользовательских типах данных — ограничение времени компиляции все еще существует.

Я знаю, что я немного опаздываю, но мое предложение будет таким:

template<size_t N>
struct Foo {
int var1;
std::array<int,N> var2;
};

std::array хранит данные как int v[N]; (не в куче), поэтому не было бы проблем с преобразованием его в потоки байтов

Я тоже немного опоздал, но это решение совместимо с гибкими массивами Си (если вы, конечно, играете с препроцессором):

#include <cstdlib>
#include <iostream>

using namespace std;

template <typename T>
class Flexible
{
public:
Flexible(){}
~Flexible(){}
inline T & operator[](size_t ind){
return reinterpret_cast<T*>(this)[ind];
}
inline Flexible<T> * getThis() { return this; }
inline operator T * () { return reinterpret_cast<T*>(this); }
};

struct test{
int a;
Flexible<char> b;
};

int main(int argc, char * argv[]){
cout << sizeof(test) << endl;
test t;
cout << &t << endl;
cout << &t.a << endl;
cout << &t.b << endl;
cout << t.b.getThis() << endl;
cout << (void*)t.b << endl;
test * t2 = static_cast<test*>(malloc(sizeof(test) + 5));
t2->b[0] = 'a';
t2->b[1] = 'b';
t2->b[2] = 0;
cout << t2->b << endl;
return 0;
}

(проверено на GCC, и лязг с clang++ -fsanitize=undefinedЯ не вижу причин, по которым это не будет стандартом, кроме reinterpret_cast часть…)

ПРИМЕЧАНИЕ: вы не получите ошибку, если это не последнее поле структуры. Будьте особенно осторожны при использовании этого в объектах, содержащих эту структуру как sub-sub -…- sub-member, потому что вы можете непреднамеренно добавить другое поле после и получить некоторые странные ошибки. Например, я бы не советовал определять структуру / класс с членом, который сам содержит Flexible, такой как этот:

class A{
Flexible<char> a;
};

class B{
A a;
};

Потому что легко сделать эту ошибку после:

class B{
A a;
int i;
};