类的四个默认函数以及string 的自己实现

首先类的默认函数

A(void); // 缺省的无参数构造函数

A(const A &a); // 缺省的拷贝构造函数

~A(void); // 缺省的析构函数

A & operate =(const A &a); // 缺省的赋值函数

在实现的字符串中我们发现
1.一般的构造函数

String::String(const char* str)//通用构造
{
    if (!str)
    {//为空。String a()
        length = 0;
        data = new char[1];
        *data = '\0';
    }
    else
    {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);//会拷贝源的结束符
    }
}

2.拷贝构造函数（由于原指针是空，因此只涉及到赋值，没有释放问题）
使用形式是String str1=String (“zjs”); String str2=str1;

String::String(const String &str)//拷贝构造，深拷贝
{
    length = str.size();
    data = new char[length + 1];
    strcpy(data, str.c_str());
}

3.析构函数

String::~String()
{
    delete[] data;
    length = 0;
}

4.重载运算符“=”函数(里面涉及到将原指针释放重新赋值问题)
string str1=“meimei”;
string str2=“zjs”;
str2=str1;

String& String::operator=(const String &str)//赋值操作符4步
{
    if (this == &str) return *this;//1 自我赋值，返回自身引用

    delete[] data;//2 删除原有数据
    
    length = str.size();//3 深拷贝
    data = new char[length + 1];
    strcpy(data, str.c_str());

    return *this;//4 返回自身引用
}

我们可以发现其实string类有一个char * p指针，和一个记录长度的数字

#include <iostream>

using namespace std;

class String
{
public:
    String(const char* str = NULL);//通用构造函数,String("abc")
    String(const String &str);//拷贝构造
    ~String();
    String& operator=(const String &str);//赋值运算符。返回引用

    String operator+(const String &str) const;
    String& operator+=(const String &str);//+=操作符。返回引用
    char& operator[](int n) const;//下标操作符。返回引用
    bool operator==(const String &str) const;

    int size() const;//字符串实际大小，不包括结束符
    const char *c_str() const;//将string转为char *

private:
    char *data;
    int length;
};

String::String(const char* str)//通用构造
{
    if (!str)
    {//为空。String a()
        length = 0;
        data = new char[1];
        *data = '\0';
    }
    else
    {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);//会拷贝源的结束符
    }
}


String::String(const String &str)//拷贝构造，深拷贝
{
    length = str.size();
    data = new char[length + 1];
    strcpy(data, str.c_str());
}

String::~String()
{
    delete[] data;
    length = 0;
}

String& String::operator=(const String &str)//赋值操作符4步
{
    if (this == &str) return *this;//1 自我赋值，返回自身引用

    delete[] data;//2 删除原有数据
    
    length = str.size();//3 深拷贝
    data = new char[length + 1];
    strcpy(data, str.c_str());

    return *this;//4 返回自身引用
}
String String::operator+(const String &str) const//+操作符3步
{//新建对象包括新空间，拷贝两个数据，返回新空间
    String newString;
    newString.length = length + str.size();
    newString.data = new char[newString.length + 1];
    strcpy(newString.data, data);
    strcat(newString.data, str.data);
    return newString;
}

String& String::operator+=(const String &str)//+=操作符5步
{//重分配新空间，拷贝两个数据，删除自己原空间，赋值为新空间，返回引用
    length += str.size();//成员length是实际长度
    char *newdata = new char[length + 1];
    strcpy(newdata, data);
    strcat(newdata, str.c_str());
    delete[] data;
    data = newdata;
    return *this;
}

char& String::operator[](int n) const
{//下标操作符，返回引用
    if (n >= length) return data[length - 1];//如果越界，返回最后一个字符
    else return data[n];
}

bool String::operator==(const String &str) const
{
    if (length != str.size()) return false;
    return strcmp(data, str.c_str()) ? false : true;
}

int String::size() const
{
    return length;
}

const char *String::c_str() const
{
    return data;
}

int main()
{
    char a[] = "Hello", b[] = "World!";
    String s1(a), s2(b);
    cout << s1.c_str() << endl;
    cout << s2.c_str() << endl;
    s1 += s2;
    cout << s1.c_str() << endl;
    s1 = s2;
    cout << s1.c_str() << endl;
    cout << (s1 + s2).c_str() << endl;
    cout << s1.size() << endl;
    cout << s1[1] << endl;

    if (s1 == s2)
        cout << "相等" << endl;
}

疑问：
当我们重载运算符+号是，如果拷贝构造函数参数列表中不加入const

String::String(String &str)//拷贝构造，深拷贝
{
    length = str.size();
    data = new char[length + 1];
    strcpy(data, str.c_str());
}

我们的重载"+"运算符还是

String String::operator+(const  String &str) const//+操作符3步
{//新建对象包括新空间，拷贝两个数据，返回新空间
	String newString;
	newString.length = length + str.size();
	newString.data = new char[newString.length + 1];
	strcpy(newString.data, data);
	strcat(newString.data, str.data);
	return newString;
}

此时在编译器中将会报错
我没想通，也就是+运算符返回值是默认的const类型？因此找不到构造函数？(const在参数列表中是可以实现函数重载的)

特别感谢”仔仔“的帮助，虽然没有找到合理解释的原因，但是找到了问题所在，当然欢迎各位大佬指出问题所在以及解释！！！