Массив переменной длины, инициализирующийся при компиляции

    class NewClass
    {
        byte array[100];
    };
 
    NewClass a;
    NewClass b;

    NewClass a(10);
    NewClass b(10000);

template <int size>
class Buff
{
    uint8_t rawData[size];
    
    // тут много всяких функций по работе с этим rawData.
};

Buff<100> buff1;
Buff<1000> buff2;

void Func1(Buff* buff);
 
void main(void)
{
    Func1(&buff1);       // не компилируется
}

class Buff
{
    uint8_t rawData[1];
 
    // тут много всяких функций по работе с этим rawData.
};
 
 
 
template <int size>
class BuffT : public Buff
{
    uint8_t rawData[size];
};

BuffT<100> buff1;
BuffT<1000> buff2;
 
void Func1(Buff* buff)
{
 
}
 
void main(void)
{
    Func1(&buff1);
}

template <int size>
class Buff
{
public:
    uint8_t m_rawData[size];
    static constexpr int m_size{size};
    
    // тут много всяких функций по работе с этим rawData.
};
 
void Func1(uint8_t rawData[], int size)
{
    for(int i = 0; i < size; ++i)
        rawData[i] = 8;
}
 
int main()
{
    Buff<100> bb;
    Func1(bb.m_rawData, bb.m_size);
    Buff<500> cc;
    Func1(cc.m_rawData, cc.m_size);

template <int size>
class Buff
{
public:
    uint8_t m_rawData[size];
    static constexpr int m_size{size};
    
    // тут много всяких функций по работе с этим rawData.
};
 
template <int size>
void Func1(Buff<size> &buff)
{
    for(int i = 0; i < buff.m_size; ++i)
        buff.m_rawData[i] = 59;
}
 
int main()
{
    Buff<100> bb;
    Func1(bb);
 
    Buff<500> cc;
    Func1(cc);

class Buff
{
public:
    virtual uint8_t * rawData() = 0;
 
    // ....
};
 
template <int size>
class BuffT : public Buff
{
    uint8_t m_rawData[size];
public:
    override uint8_t * rawData() { return m_rawData; }
};

class Buff
{
    uint8_t *m_dataPtr{};
public:
    uint8_t * rawData() { return m_dataPtr; }
 
protected:
    void initPtr(uint8_t *p) { m_dataPtr = p; }
 
    // ....
};
 
template <int size>
class BuffT : public Buff
{
    uint8_t m_rawData[size];
public:
    BuffT() { Buff::initPtr(m_rawData); }
};

// Интерфейс.
class IBuff
{
public:
    virtual int GetRawDataSize(void)
    {
        return 1;
    }
};
 
 
 
// Базовый класс.
template <int size>
class Buff : public IBuff
{
    uint8_t rawData[size];
    
public:
    int GetRawDataSize(void)
    {
        return sizeof(rawData);
    }
 
};
 
 
 
 
 
 
// Функция-клиент.
void Func(IBuff* buff)
{
    printf("Func\r\n");
    printf("size = %d\r\n", buff->GetRawDataSize());
}
 
 
 
 
 
 
// Переменные
Buff<100> buff1;
Buff<1000> buff2;
 
 
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    Func(&buff1);       // напечатает 100
    Func(&buff2);       // напечатает 1000
 
}

// Наследник с удвоенным буфером
template <int size>
class DoubleBuff : public Buff<size>
{
    uint8_t rawData[size * 2];
 
public:
    int GetRawDataSize(void)
    {
        return sizeof(rawData);
    }
 
};
 
 
 
DoubleBuff<250> doubleBuff1;
 
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    Func(&doubleBuff1); // напечатает 500.