Вариативный размер массива в разных экземплярах класса

class uart
{
 static const BUF_SIZE = 128;     
 uint8_t buf[BUF_SIZE];    
}

#include <cstddef>
#include <cstdint>
 
template<size_t BUF_SIZE>
class uart
{
    uint8_t buf[BUF_SIZE];    
};
 
int main()
{
    uart<128> u1;
    uart<256> u2;
}

class uart
{
  static const unsigned BUF_SIZE = 128;     
  uint8_t buf[BUF_SIZE];    
};

#include <iostream>
//#include <cstddef>
#include <cstdint>
 
#define MIN2(a, b) (((a) < (b)) ? (a) : (b))
 
template<size_t BUF_SIZE>
class uart
{
  private:
    uint8_t buf[BUF_SIZE];    
  public:
    void fill_ordered(void)
    {
      for (auto idx = 0; idx != BUF_SIZE; idx++) 
        buf[idx] = idx & 0xFF;
    }
    
    void fill_rand(uint8_t max = 255)
    {
      for (auto &x : buf) 
        x = rand() % max;
    }
    
    void print(size_t from_idx = 0, size_t count = 0)
    {
      auto lim = count ? MIN2(from_idx + count, BUF_SIZE) : BUF_SIZE - from_idx;
      for (auto idx = from_idx; idx < lim; idx++)
        printf("%u ", buf[idx]);
      printf("\n");  
    }
};
 
int main()
{
  uart<64> u1;
  uart<128> u2;
  
  u1.fill_rand();
  u1.print();
  
  u2.fill_ordered();
  u2.print();
    
  return 0;  
}

template <const uint16_t BUF_SIZE>
class usart
{                                                         
   uint8_t buf[BUF_SIZE];
 public:
   void init();
  
};
 
void usart::init()
{
 uint16_t a = buf[0]; 
}
 
int main() {
    // your code goes here
 usart<10> u;
 u.init();
}

#include <cstddef>
#include <cstdint>
 
template <uint16_t BUF_SIZE>
class usart
{                                                         
    uint8_t buf[BUF_SIZE];
public:
    void init();
};
 
template <uint16_t BUF_SIZE>
void usart<BUF_SIZE>::init()
{
    uint16_t a = buf[0]; 
}
 
int main()
{
    usart<10> u;
    u.init();
}

#include <iostream>
#include <cstdint>
 
#define TEMPLATE_USART template <const uint16_t BUF_SIZE>
 
TEMPLATE_USART class usart
{                                                         
   uint8_t buf[BUF_SIZE];
 public:
   void init();
};
 
TEMPLATE_USART void usart<BUF_SIZE>::init()
{
 uint16_t a = buf[0]; 
}
 
int main() 
{
    // your code goes here
 usart<10> u;
 u.init();
}

#include <iostream>
class Allocator{
   static inline constexpr unsigned SIZE = 65536;
   char buf[SIZE];
   unsigned pos = 0;
public:
   char* get(unsigned size){
      if (size && size <= (SIZE - pos))
         return &buf[(pos+=size)-size];
      throw std::runtime_error("Allocate automatic buffer error");
   }
};
 
struct Class{
   Class(char* buf, unsigned size)
      : buf{buf}, size{size}{
      
   }
   char* buf;
   unsigned size;
};
 
int main(){
   Allocator a;
   Class c1(a.get(128), 128);
   Class c2(a.get(256), 256);
}

usart(uint16_t size) : BUF_SIZE(size) {}