Собственный класс String

#pragma once
#include <iostream>
 
class String
{
public:
    String();
    String(const char& ch);
    String(const String& strOther);
    ~String();
 
    String& operator= (const String& str);
    String operator+ (const String& str) const;
    String operator+ (const char* ch) const;
    size_t GetSize();
    char& operator[] (size_t i);
 
    std::ostream& operator<< (std::ostream& os, const String& str);
 
private:
    size_t mLength;
    char* mChar;
};

#include "String.h"
 
String::String()
    : mLength(0)
    , mChar(nullptr)
{
}
 
String::String(const char& ch)
    : mLength(length(ch)) // тут кричит
    , mChar(new char[mLength + 1])
{
    for (int i = 0; i < mLength; ++i)
        mChar[i] = ch[i];   // тут кричит
}
 
String::String(const String& srtOther)
    : mLength(srtOther.mLength)
    , mChar(new char[mLength + 1])
{
    for (int i = 0; i < mLength; ++i)
        mChar[i] = srtOther.mLength[i];  // тут кричит
}
 
String::~String()
{
    delete[] mChar;
}
 
String& String::operator=(const String& str)
{
    if (this != &str)
    {
        mLength = str.mLength;
        delete[] mChar;
        mChar = new char[mLength];
        for (unsigned index = 0; index < mLength; ++index)
            mChar[index] = str.mChar[index];
    }
    return *this;
 
}
 
String String::operator+(const String& str) const  // не уверена в  правельно ли сделала  функцию
{
    char* temp = new char[mLength + str.mLength + 1];
    strcpy(temp, this->mChar);
    for (unsigned index = 0; index < mLength; ++index)
        temp[index] = mChar[index];
    for (unsigned index = 0; index < mLength; ++index)
        temp[index] = mChar[index] + str.mChar[index];
    String result(temp);
    delete[] temp;
    return result;
}
 
String String::operator+(const char* ch) const // не уверена в  правельно ли сделала  функцию
{
    size_t length = 0;
    if (mLength != 0)
        length = this->mLength + 2;
    else
        length = 2;
    char* temp = new char[length];
    if (mChar)
    {
        for (unsigned index = 0; index < mLength; ++index)
            temp[index] = mChar[index];
    }
    temp[length - 2] = ch;
    temp[length - 1] = '\0';
    String result(temp);
    delete[]temp;
    return result;
}
 
size_t String::GetSize()
{
    return mLength;
}
 
char& String::operator[](size_t i)
{
     return mChar[i];
}
 
std::ostream& String::operator<<(std::ostream& os, const String& str) // тут кричит
{
    for (int i = 0; i < str.size(); i++)
        os << str.mChar[i]; // тут кричит
    return os;
}

String::String(const char& ch)
    : mLength(length(ch)) // тут кричит
    , mChar(new char[mLength + 1])
{
    for (int i = 0; i < mLength; ++i)
        mChar[i] = ch[i];   // тут кричит
}

String String::operator+(const String& str) const
{
    char* temp = new char[mLength + str.mLength + 1];
    for (unsigned index = 0; index < mLength; ++index)
        temp[index] = mChar[index];
    for (unsigned index = 0; index < mLength; ++index)
        temp[index] = mChar[index] + str.mChar[index];
    String result(temp); // тут кричит
    delete[] temp;
    return result;
}

String::String(const String& srtOther)
    : mLength(srtOther.mLength)
    , mChar(new char[mLength + 1])
{
    for (int i = 0; i < mLength; ++i)
        mChar[i] = srtOther.mLength[i];// ????
}

String String::operator+(const char* ch) const
{
    size_t length = 0;
    if (mLength != 0)
        length = this->mLength + 2;
    else
        length = 2;
    char* temp = new char[length];
    if (mChar)
    {
        for (unsigned index = 0; index < mLength; ++index)
            temp[index] = mChar[index];
    }
    temp[length - 2] = ch; // ???
    temp[length - 1] = '\0';
    String result(temp);
    delete[]temp;
    return result;
}

std::ostream& String::operator<<(std::ostream& os, const String& str) // оно кричит на operator
{
    for (int i = 0; i < str.size(); i++) // тут на сайз
        os << str.mChar[i]; //  тут  на str.mChar[i]
    return os;
}

mChar[i] = srtOther[i];

// .h
class String
{
    friend std::ostream operator<<(std::ostream &, const String&);
/*
    Всё то же самое, но убрать operator<<
    но добавить:
*/
    char operator[] const (size_t i);
};
 
//.cpp
char String::operator[] const (size_t i)
{
    return const_cast<String*>(this)->operator[](i);
}
 
std::ostream& operator<<(std::ostream& os, const String& str) // оно кричит на operator
{
    for (int i = 0; i < str.GetSize(); i++) // тут на сайз, потому что у вас нет size а есть GetSize
        os << str.mChar[i]; //  тут  на str.mChar[i] потому что нет константной версии operator[]
    return os;
}

char operator[] (size_t i) const;
 
char String::operator[](size_t i) const
{
    return const_cast<String*>(this)->operator[](i);
}

const char & String::operator[](size_t i) const
{
    return mChar[i];
}

String& String::operator=(const char& other)
{
    //? ? ? ? ?
}

String& operator= (const char& other);
    String& operator= (const char other);

const char* String::GetBuffer() const
{
    return mString;
}
 
char* String::GetBuffer()
{
    return mString;
}

String& operator= (const char& other);
    String& operator= (const char other);

String& operator= (const String& other);

String & String::operator=(const char* other)
{
    delete[] mString;
    mSize = other.GetSize();
    mString = new char[mSize + 1];
    for (decltype(mSize) i = 0; i < mSize; ++i)
        mString[i] = other.GetBuffer;
    mString[mSize] = '\0';
    return *this;
}

String & String::operator=(const char* other)
{
    delete[] mString;
    mSize = strlen(other);
    mString = new char[mSize + 1];
    for (decltype(mSize) i = 0; i < mSize; ++i)
        mString[i] = other[i];
    mString[mSize] = '\0';
    return *this;
}

String & String::operator=(const char other)
{
    delete[] mString;
    mSize = other.GetSize();
    mString = new char[mSize + 1];
    for (decltype(mSize) i = 0; i < mSize; ++i)
        mString[i] = other.GetBuffer();
    mString[mSize] = '\0';
    return *this;
}

String & String::operator=(const char other)
{
    delete[] mString;
    mSize = std::strlen(&other);
    mString = new char[mSize + 1];
    for (decltype(mSize) i = 0; i < mSize; ++i)
        mString[i] = other[&i];
    mString[mSize] = '\0';
    return *this;
}

String & String::operator=(const char other)
{
    char str[]={other,0};
    return *this=str;
}