class string
{
private:
    char * m_Buffer = nullptr;
    int m_offset = sizeof(int);
public:
    ~string()
    {
        delete[] m_Buffer;
    }
    bool Copy(const void * aBuffer, int aLength)
    {
        m_Buffer = new char[aLength + m_offset];
        return memcpy(m_Buffer, &aLength, m_offset)
            && memcpy(m_Buffer + m_offset, aBuffer, aLength);
    }
    char * String()
    {
        return m_Buffer + m_offset;
    }
    int Length()
    {
        return *m_Buffer;
    }
};

class string
{
private:
    const string * m_Copy = nullptr;
    const int m_Offset = sizeof(int);
    char * m_Buffer = nullptr;
private: 
    void Assign(string * aString)
    {
        if (m_Copy)
            delete(m_Copy);
        m_Copy = aString;
    }
public:
    string()
    {

    }
    string(string * aString) noexcept
    {
        Assign(aString);
    }
    string(const void * aBuffer, int aLength)
    {
        m_Buffer = new char[aLength + m_Offset];
        if ((!memcpy(m_Buffer, &aLength, m_Offset))
            || (!memcpy(m_Buffer + m_Offset, aBuffer, aLength)))
            printf("Can't allocate string");
    }
    ~string()
    {
        if (m_Buffer)
            delete[] m_Buffer;
        if (m_Copy)
            delete(m_Copy);
    }
    char * String()
    {
        if (m_Copy)
            return m_Copy->m_Buffer + m_Copy->m_Offset;
        if (m_Buffer)
            return m_Buffer + m_Offset;
        printf("Not allocated string value");
        return nullptr;
    }
    int Length()
    {
        if (m_Copy)
            return *m_Copy->m_Buffer;
        if (m_Buffer)
            return *m_Buffer;
        printf("Not allocated string length");
        return 0;
    }
    string * operator = (string * aString)
    {
        Assign(aString);
        return this;
    }
};