深浅拷贝

浅拷贝

浅拷贝是指当对象被复制时，并没有给新对象分配空间，只是增加了一个指针指向已存在的内存。
实现：

#include <iostream>
using namespace std;
// string浅拷贝
class String
{
public:
    String()
    {
        cout << "String()" << endl;
    }
    String(const char *str)    //初始化列表  
        :_str(new char[strlen(str)+1])    //开辟一块字符数字的空间  +1多给一个 '/0' 的位置
    {
        cout << "初始化列表" << endl;
        strcpy(_str, str);   //将目标空间拷贝给新创建的对象_str
    }
    String(const String &str)   //拷贝构造函数
        :_str(str._str)
    {
        cout << "String(const String &str)" << endl;
    }
    String&operator=(const String &str)     //赋值运算符重载
    {
        cout << "String &operator=" << endl;
        if (this != &str)
        {
            _str = str._str;  
        }
        return *this;
    }
    ~String()    //析构函数
    {
        if (_str)
        {
            cout << "~String" << endl;
            delete[]_str;    //字符数组空间
        }
    }
private:
    char * _str;
};
void test()
{
    String s1("heloow");
    String s2 = s1;
}
int main()    //程序会崩溃 因为释放同一空间
{
    test();
    system("pause");
    return 0;
}

在多个对象指向同一个空间，在调用析构函数的时候，会将一块空间多次释放，程序会崩溃。

深拷贝

深拷贝是每增加一个指针时，便申请一个新的内存，使这个增加的指针指向这个新的内存。
深拷贝情况下，释放内存不会存在重复释放同一内存的错误。

class String
{
public:

    String(const char *str="")    //初始化列表  
        :_str(new char[strlen(str) + 1])    //开辟一块字符数字的空间  +1多给一个 '/0' 的位置
    {
        cout << "初始化列表" << endl;
        strcpy(_str, str);   //将目标空间拷贝给新创建的对象_str
    }
    //String(const String &str)   //拷贝构造函数
    //  :_str(str._str)
    //{
    //  cout << "拷贝构造" << endl;
    //}
    String(const String &str)
    {
        String temp(str._str);
        swap(_str, temp._str);
    }
    String&operator=(const String &s)     //赋值运算符重载
    {
        cout << "赋值运算重载" << endl;
        if (strlen(this->_str) != strlen(s._str))
        {
            this->_str = new char[strlen(s._str) + 1];
        }
        if (this != &s)
        {
            strcpy(this->_str,s._str);
        }
        return *this;
    }

    ~String()    //析构函数
    {
        if (_str)
        {
            cout << "~String" << endl;
            delete[]_str;    //字符数组空间
        }
    }
public:
    size_t Size()const;
    size_t Lengh()const;
    char& operator[](size_t index);
    //const char &operator[](size_t index)const;
    bool operator>(const String &s);
    bool operator<(const String &s);
    bool operator==(const String &s);
    bool operator!=(const String &s);
    String &operator+=(const String &s);
private:
    char * _str;
};
size_t String::Size()const {
    return strlen(this->_str) + 1;
}
size_t String::Lengh()const {
    return strlen(this->_str);
}
char& String::operator[](size_t index) {
    _str = new char[index];
    int i = 0;
    for (i = 0; i < index; i++) {
        _str[i] = 0;
    }
    return _str[i];
}
bool String::operator>(const String &s) {
    if (strcmp(_str, s._str) > 0) return true;
    return false;
}
bool String::operator<(const String &s) {
    if (strcmp(_str, s._str) < 0) return true;
    return false;
}
bool String::operator==(const String &s) {
    if (strcmp(_str, s._str) == 0) return true;
    return false;
}
bool String::operator!=(const String &s) {
    if (strcmp(_str, s._str) == 0) return false;
    return true;
}
String& String::operator+=(const String &s) {
    char *temp = _str;
    _str = new char[strlen(s._str) + 1 + strlen(_str)];
    strcpy(_str, temp);
    strcat(_str, s._str);
    delete[]temp;
    return *this;
}

void test()
{
    String s1("hellow");
    String s2("www");
    s1 = s2;
}
int main()    
{
    test();
    system("pause");
    return 0;
}