Обработка строк или как сделать свой велосипед

struct Data {
  char field[10];
};
 
Data data;
MyStr<sizeof(Data.field)> myStr(data.field);
myStr += "add";

struct Data {
  char field[10];
} data;
 
struct Data2 {
  MyStr<10> field;
} data2;
 
sizeof(data) == sizeof(data2) /* Должно быть истиной */

class MyStr
{
public:
    template <size_t Size>
    MyStr(char (&str)[Size])
    : m_str(str)
    , m_cap(Size)
    {
        m_ln = .......................;
    }
}
protected:
    char *m_str = nullptr;
    size_t m_ln = 0;
    size_t m_cap = 0;
};

class Data 
{
public:
    MyStringView GetField() 
    {
        return MyStringView(field);
    }
private:
    char field[10];
};

template<class T>
class IDb2StringBase
{
  public:
  size_t Size() { return static_cast<T*>(this)->GetSize(); }  
  
  private:
  char*  Ptr()  { return static_cast<T*>(this)->GetPtr(); }         
};
 
 
class IDb2StrRef : public IDb2StringBase<IDb2StrRef>
{
  friend IDb2StringBase<IDb2StrRef>;
  
  public:
  template <size_t N>
  IDb2StrRef(char (&data)[N]) : m_data(data), m_size(N) {}
  
  private:
  char*  GetPtr()        { return m_data; }
  size_t GetSize() const { return m_size; }  
  char*  const m_data;
  size_t const m_size;
}; 
 
 
template<size_t N>
class IDb2String : public IDb2StringBase< IDb2String<N>>
{
  static_assert(N > 0, "The size of the array cannot be 0.");
  friend IDb2StringBase<IDb2String<N>>;
  
  private:
  char*  GetPtr()        { return m_data; }
  size_t GetSize() const { return sizeof(m_data); }  
  char   m_data[N];
};

int main(int argc, char** argv)
{
  char data[5];
  IDb2StrRef db2ref(data);
  printf("sizeof(db2ref) = %d\n", sizeof(db2ref));
  printf("db2ref.Size()  = %d\n", db2ref.Size());  
  
  IDb2String<4> db2str;
  printf("sizeof(db2str) = %d\n", sizeof(db2str));
  printf("db2str.Size()  = %d\n", db2str.Size());
}

template<size_t N>
class IDb2String
{
    static_assert(N > 0, "The size of the array cannot be 0.");
 
    IDb2String()
    {
        std::fill(std::begin(m_data), std::end(m_data), ' ');
    }
 
    char*  GetPtr()        { return m_data; }
    size_t GetSize() const { return std::size(m_data); }  
 
    IDb2StrRef ref() const
    {
        return IDb2StrRef(m_data);
    }
 
    operator IDb2StrRef() const
    {
        return ref;
    }
 
 
private:
      char m_data[N];
};

template<class T>
class IDb2StringBase
{
  public:
  size_t Size() { return static_cast<T*>(this)->GetSize(); }  
    
  void clear()
  {
      memset(Ptr(), ' ', Size());
  }
  
  private:
  char*  Ptr()  { return static_cast<T*>(this)->GetPtr(); }         
};