String類裡面主要包含構造，拷貝構造，析構，賦值，比較，字串相加，獲取長度及子串等方法。

#include <iostream>
#include <cstring>
using namespace std;

class String{
public:
    // 預設建構函式
    String(char *str = NULL);
    // 複製建構函式
    String(String &str);
    // 解構函式
    ~String();
    // 字串連線
    String operator+(const String & str);
    // 字串賦值
 

    String& operator=(const String &str);
    // 判斷是否字串相等
    bool operator==(const String &str);
    // 獲取字串長度
    int length();
    // 求子字串[start,start+n-1]
    String substr(int start, int n);
    // 過載輸出
    friend ostream & operator<<(ostream &o,const String &str);
private
 
:
    char* m_data;
    int m_size;
};

// 建構函式
String::String(char *str = NULL){
//空構造也會建立一個長度為1的字串陣列
    if(str == NULL){
        m_data = new char[1];
        m_data[0] = '\0';
        m_size = 0;
    }
    else{
        m_size = strlen(str);
        m_data = new char[m_size + 1];
        strcpy(m_data,str);
    }
}

//拷貝建構函式
 

String::String(const String &str){
    m_size = str.m_size;
    m_data = new char[m_size + 1];
    strcpy(m_data, str.m_data);
}

//解構函式
String::~String(){
    delete[] m_data;
}

// 字串連線
//這裡返回的不是引用，而是值
String String::operator+(const String &str){
    String newStr;
    //釋放原有空間
    delete[] newStr.m_data;
    //建立長度為兩個字串長度和的空間大小
    newStr.m_size = m_size + str.m_size;
    newStr.m_data = new char[newStr.m_size + 1];
    strcpy(newStr.m_data, m_data);
    strcpy(newStr.m_data + m_size, str.m_data);
    return newStr;
}

//賦值函式
/*
這裡為什麼返回物件的引用呢?原因有兩個：①允許進行連續賦值 ②防止返回物件(返回物件也可以進行連續賦值)的時候呼叫拷貝建構函式和解構函式導致不必要的開銷，降低賦值運算子等的效率。
對於第二點原因：如果用“值傳遞”的方式，雖然功能仍然正確，但由於return語句要把 *this拷貝到儲存返回值的外部儲存單元之中，增加了不必要的開銷，會降低賦值函式的效率。
因此，如果賦值運算子返回的是物件引用，那麼其不會呼叫類的拷貝建構函式，這是問題的關鍵所在！！
*/

String& String::operation=(const char * str){
    if (m_data == str){
    return *this;
    }
    delete[] m_data;
    m_size = strlen(str);
    m_data = new char[m_size + 1];
    strcpy(m_data, str);
    return *this;
}

//判斷是否相等
bool String::operation==(const char *str){
    return strcmp(m_data, str.m_data) == 0;
}

//獲取長度
int String::length(){
    return m_size;
}

//求子字串[start,start+n-1]
String String::substr(int start, int n){
    String newStr;
    //釋放原有記憶體
    delete[] newStr.m_data;
    //重新申請記憶體
    newStr.m_data = new char[n + 1];
    for (int i = 0; i < n; i++){
        newStr.m_data[i] = m_data[start + i];   
    }
    newStr.m_data[n] = '\0';
    newStr.m_size = n;
    return newStr;
}

// 過載輸出
ostream & operator<<(ostream &o, const String &str){
    o<<str.data;
    return o;
}