我无法捕捉触发重载赋值运算符的时刻，以及可以优化的内容

好吧，我会做这样的事情......

#include <cstring>
#include <iostream>

class String
{
private:
    size_t length;
    char* cstring;
  
    void swap(String& s)
    {
        std::swap(cstring,s.cstring);
        std::swap(length,s.length);
    }
public:    
    String(const char* str = "")
        : length(str ? strlen(str) : 0)
        , cstring(new char[length + 1])
    {
        strcpy(cstring, str ? str : "");
    }

    String(size_t size, char symbol)
        : length(size)
        , cstring(new char[size + 1])
    {
        memset(cstring, symbol, size);
        cstring[size] = '\0';
    }

    String(const String& other):String(other.cstring) {}

    String& operator=(const String& other)
    {
        if (this != &other)
        {
            String tmp(other);
            swap(tmp);
        }
        return *this;
    }

    String(String&& other) noexcept
        : length(other.length)
        , cstring(other.cstring)
    {
        other.length  = 0;
        // Вообще-то после move должно оставаться
        // СОГЛАСОВАННОЕ состояние, но у вас
        // нулевая длина означает пустую строку.
        // Возможно, стоит переписать эту строку
        // соответствующим образом:
        other.cstring = nullptr;
    }

    String& operator = (String&& other) noexcept
    {
        if (this != &other) swap(other);
        return *this;
    }

    String& operator +=(String const& other)
    {
        if (other.length) {
            size_t size = length + other.length;
            char* buff = new char[size + 1];
            strcpy(buff, cstring);
            strcat(buff, other.cstring);
            delete[] cstring;
            cstring = buff;
            length  = size;
        }
        return *this;
    }

    ~String()
    {
        delete[] cstring;
    }

    bool        isEmpty()   const { return length == 0; }
    size_t      getLength() const { return length; }
    const char* c_str()     const { return cstring; }

    bool operator==(const String& t) const noexcept
    {
        return length == t.length && strcmp(cstring, t.cstring) == 0;
    }
    bool operator !=(const String& t) const noexcept
    {
        return !(*this == t);
    }

    char& operator[](size_t i)  // Без проверок?
    {
        return cstring[i];
    }

    String& Lo() {
        for (int j = 0; j < length; ++j)
            cstring[j] = (char)(tolower(cstring[j]));
        return *this;
    }

    String& Up() {
        for (int j = 0; j < length; ++j)
            cstring[j] = (char)(toupper(cstring[j]));
        return *this;
    }

    String& reverse() {
        for (size_t i = 0, j = length-1; i < j; ++i, --j) {
            std::swap(cstring[i], cstring[j]);
        }
    }

    friend String operator+(const String& l, const String& r)
    {
        String t(l);
        return t += r;
    }

    friend std::istream& operator >>(std::istream& is, String& obj)
    {
        // Оставляю на вашей совести невозможность чтения длинных слов
        char* buff = new char[99];
        memset(&buff[0], 0, sizeof(buff));
        // Это в современном С++ не компилируемо:
        is >> buff;
        obj = String(buff);
        delete[] buff;
        return is;
    }

    friend std::ostream& operator <<(std::ostream& os, const String& obj) {
        os << obj.cstring;
        return os;
    }
};

using namespace std;

int main() {
    //SetConsoleCP(1251);
    //SetConsoleOutputCP(1251);
    String var("Люблю ");
    String var2("много пива");
    String var3;
    var3 = var + var2;   // Теперь тут есть присваивание
    cout << var << endl;
    cout << var2 << endl;
    cout << var3 << endl;
}

主要是明确定义类不变量。然后零长度可以对应空字符串和nullptr. 长度本身仅对足够大的字符串长度有意义，否则它不会进行太多优化。

不需要相同的clean()，因为在类中不需要将长度归零的情况下调用它。是的，它delete可以与 一起使用nullptr，不需要检查。

一般来说，如果不清楚为什么我做错了什么，看看是什么以及如何做 - 问。

是的，以防万一：不要意外更改数据成员的声明顺序，您的构造函数依赖它。还有一件事——在声明一个类时，你不应该使用using namespace，把它留给用户。在一个类中，最好使用完全限定名。