技術標籤：c++

首先類的預設函式

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在引數列表中是可以實現函式過載的)

特別感謝”仔仔“的幫助，雖然沒有找到合理解釋的原因，但是找到了問題所在，當然歡迎各位大佬指出問題所在以及解釋！！！