Есть ли способ указать размер массива в базовом классе в унаследованном классе?

Если массив непосредственно встроен в базовый класс, как в вашем примере, тогда невозможно указать размер этого массива. Точнее, изменение размера этого массива потребует создания совершенно другой версии этого базового класса для каждого конкретного размера массива. Это победит цель, так как ваше намерение, по-видимому, состоит в том, чтобы иметь единый общий базовый класс в иерархии. Это?

Это именно та проблема, с которой вы столкнулись с вашим шаблоном "решение". У вашей программы больше нет общего Baseclass. Вместо этого у вас есть Baseclass<5>, Baseclass<10> и т.д. - все совершенно разные независимые базовые классы. По-видимому, это не то, что вам нужно.

Единственный способ получить общий базовый класс с массивом размера времени выполнения в нем - это сохранить массив в базовом классе косвенно. Т.е. объявлять указатель uint16_t * в базовом классе и выделять необходимый объем памяти во время выполнения. Или вы можете просто использовать std::vector<uint16_t> вместо необработанного массива.

Обратите внимание: если вы решите пойти по указателю, не обязательно выделять память массива динамически. Вы можете просто сделать фактическую "память массива" членом производного класса, который уже "знает" конкретный размер

class Baseclass {
public:
  uint16_t *arr;
  size_t arraySize;

  Baseclass(uint16_t *arr, size_t arraySize) : arr(arr), arraySize(arraySize)
    {}
};

class InheritedClass : public Baseclass
{
  InheritedClass() : Baseclass(arr_memory, 5)
    {}
private:
  uint16_t arr_memory[5];
};

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

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

#include <iostream>
// instantiation specifies size explicitly, default calculation ignored
// after instantiation names in default calculation are bound correctly

template<class d,int size=sizeof d::m2/sizeof *d::m2>
struct b {
        int m[size];
};

struct d: b<d,20> {
        double m2[20];
};

int main() {
        std::cout<<sizeof b<d>::m/sizeof *b<d>::m<<'\n';
}

В качестве взлома, который, вероятно, будет работать, baseclass метод в baseclass который reinterpret_cast this в baseclass<1>.

Это зависит от того, как ty0es компилируется в относительно разумные макеты: чтобы это произошло, убедитесь, что baseclass - это модуль или стандартная компоновка.

Хотя результатом является неопределенное поведение, в каждом компиляторе, который я использовал, он будет работать.

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

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

class Baseclass {
public:
    uint16_t *arr;
    Baseclass(int arrlen) {
        arr = new int[arrlen];
    }

    ~Baseclass() {
        delete arr;
    }

};

class InheritedClass :
    public Baseclass {
public:
    Inherited() : Baseclass(5){
    }
};

Если можно, вы можете просто использовать динамическое распределение.