String類模擬實現：

#include <iostream>
#include <assert.h>
#include <string.h>
using namespace std;


class String
{
public:
    String(char* str = "")
    {
        _size = strlen(str);
        _str = new char[_size+1];
        strcpy(_str,str);
    }
    String(const String& str)
    {
        _
 
size = strlen(str._str);
        _str = new char[_size+1];
        strcpy(_str,str._str);
    }

    String& operator=(const String& str)
    {
        String tmp(str._str);
        char* p = tmp._str;
        tmp._str = _str;
        _str = p;
        _size = tmp._size;
        return *this;

    }
    ~String()
    {
        if
 
 (_str)
        {
            delete[] _str;
            _size = 0;
        }
    }
    void DisPlay()
    {
        cout<<_str<<"->"<<_size<<endl;
    }

    size_t Size()const//返回物件
    {
        return _size;
    }
    char& operator[](size_t index)
    {

        assert
 
(index<_size);
        return _str[index-1];
    }
    String operator+(const String& s)
    {
        char* p = new char[strlen(_str)+strlen(s._str)+1];
        strcpy(p,_str);
        strcat(p,s._str);
        String tmp(p);
        delete p;
        return tmp;
    }

    bool operator>(const String& s)
    {
        char* p1 = _str;
        char* p2 = s._str;
        while ((*p1 == *p2)&&(*p1 != '\0')&&(*p2 != '\0'))
        {
            *p1++;
            *p2++;
        }
        if ((*p1 - *p2)>0)
        {
            return 1;
        }
        return 0;
    }

    bool operator<(const String& s)
    {
        char* p2 = _str;
        char* p1 = s._str;
        while ((*p1 == *p2)&&(*p1 != '\0')&&(*p2 != '\0'))
        {
            *p1++;
            *p2++;
        }
        if ((*p1 - *p2)>0)
        {
            return 1;
        }
        return 0;
    }

    bool operator==(const String& s)
    {
        char* p2 = _str;
        char* p1 = s._str;
        while ((*p1 == *p2)&&(*p1 != '\0')&&(*p2 != '\0'))
        {
            *p1++;
            *p2++;
        }
        if ((*p1 == '\0')&&(*p2 == '\0'))
        {
            return 1;
        }
        return 0;
    }

    bool operator!=(const String& s)
    {
        char* p2 = _str;
        char* p1 = s._str;
        while ((*p1 == *p2)&&(*p1 != '\0')&&(*p2 != '\0'))
        {
            *p1++;
            *p2++;
        }
        if ((*p1 == '\0')&&(*p2 == '\0'))
        {
            return 0;
        }
        return 1;
    }

    const char* C_Str()const//返回類中的字串
    {
        return _str;
    }

    String SubStr(size_t pos, size_t n)//返回一個物件的子串物件
    {
        char* p = new char[n+1];
        strncpy(p,_str+pos-1,n);
        p[n]='\0';
        String tmp(p);
        delete p;
        return tmp;
    }

protected:
private:
    char* _str;
    size_t _size;
};

測試程式碼：

void Test1()//測試構造，拷貝構造，複製過載
{
    String str("hello ");
    str.DisPlay();
    String str1(str);
    str1.DisPlay();
    String str2 = str1;
    str2.DisPlay();
}
void Test2()//測試下標運算子[]，和加法運算子+的過載
{
    String str("hello ");
    String str1("world ");
    String str2("private");
    str2 = str + str1;
    str2.DisPlay();

    cout<<str[2]<<endl;
}
void Test3()//測試關係運算符 >, <, ==, !=, 的過載
{
    String str("hello ");
    String str1("world ");
    String str2("hello ");
    if (str > str1)
    {
        cout<<"str 大於 str1"<<endl;
    }
    else
    {
        cout<<"str 不大於 str1"<<endl;
    }

    if (str < str1)
    {
        cout<<"str 小於 str1"<<endl;
    }
    else
    {
        cout<<"str 不小於 str1"<<endl;
    }

    if (str == str2)
    {
        cout<<"str 等於 str2"<<endl;
    }
    else
    {
        cout<<"str 不等於 str2"<<endl;
    }   

    if (str1 != str2)
    {
        cout<<"str 不等於 str2"<<endl;
    }
    else
    {
        cout<<"str 等於 str2"<<endl;
    }
}
void Test4()
{
    String str("hello ");
    String str1("world ");
    const char * pstr = str1.C_Str();
    cout<<pstr<<endl;
    str1 = str.SubStr(2,4);
    str1.DisPlay();
}


int main()
{

    Test1();
    Test2();
    Test3();
    Test4();
    return 0;
}

淺拷貝和深拷貝

　　在某些狀況下，類內成員變數需要動態開闢堆記憶體，如果實行位拷貝，也就是把物件裡的值完全複製給另一個物件，如A=B。這時，如果B中有一個成員變數指標已經申請了記憶體，那A中的那個成員變數也指向同一塊記憶體。這就出現了問題：當B把記憶體釋放了（如：析構），這時A內的指標就是野指標了，出現執行錯誤。

深拷貝：
在進行拷貝的過程中，新開闢一塊空間，然後將要拷貝的內容放到新開闢的空間裡，

對另一個物件進行賦值時，要根據賦值物件，對被賦值物件的空間進行調整，這時候就要用到深拷貝。