侯捷C++-＞三大函数：拷贝构造、拷贝赋值、析构

1、拷贝：如果类里带指针不能使用编译器给的那套赋值，仅仅是多了一个指针指向相同的内存（浅拷贝）。（指针指向的内容不属于对象本身）

如果类带有指针，big three一定要写

2、拷贝构造：构造函数（函数名称和类名相同），参数是自己。需要分配内存，将被拷贝的类的内存拷贝到分配的内存里

拷贝赋值：赋值，参数是自己。先自我赋值校验，通过后释放原来指向的内存，最后分配内存，将被拷贝的类的内存拷贝到分配的内存里

析构函数：释放指针指向的内存区域

3、

class String
{
    public:
        String(const char* cstr = 0);//构造函数
        String(const String& str);//拷贝构造函数  这里无返回值
        String& operator = (const String& str);//拷贝赋值函数  
        ~String();//析构函数
        char* get_c_str() const {return m_data};//直接在classbody里定义的函数是inline,函数不改变数据内容，加const.      
    private:
        char* m_data;
} 
inline String::~String()
{
    //delete[] String.m_data;
    delete[] m_data;//在对象内部调用该函数，直接使用private变量
}
//构造函数
inline String::String(const char* cstr = 0)
{
     if (cstr)
        {
            m_data = new char[strlen(cstr)+1];//对象内部调用该构造函数，可以直接使用私有变量m_data
            strcpy(m_data, cstr);
            
        }
    else
        {
            m_data = new char[1];
            *m_data = '\0';//指针内容为'\0'
        }
}
//拷贝构造函数(深拷贝)
iniline String::String(const String& str)
{
    if (str)
        {
            m_data = new char[strlen(str.m_data) + 1];//直接取另一个object的private,同一个类的不同对象互为friend
            strcpy(m_data, str.m_data);            
        }
    else//侯捷老师的教案没有else,可能是String类默认m_data!=NULL
        {
            m_data = new char[1];
            *m_data = '\0';
        }   
}
//拷贝赋值函数
//错误示范1
String& String:: operator = (const String& str)
{
    if (str.m_data)
        {
            this.m_data = new char[strlen(str.m_data) + 1];//错误1：对象内部可以直接使用private变量，不需要写this 错误2：直接给m_data赋值，m_data原来指向的内存泄露
            strcpy(this.m_data, str.m_data);            
        }
    else
        {
            this.m_data = new char[1];
            this.m_data = "/0";
        }
    return *this;
}
//错误示范2
String& String:: operator = (const String& str)
{
    //给已有的指针赋值时，先释放掉原来指向的内存
    delete[] m_data;//错误：如果str.m_data和this.m_data指向同一块内存，则释放后str.m_data变成野指针
    if (str.m_data)
        {
            m_data = new char[strlen(str.m_data) + 1];
            strcpy(m_data, str.m_data);            
        }
    else
        {
            m_data = new char[1];
            m_data = "/0";
        }
    return *this;
}
//拷贝赋值函数正确写法
String& String:: operator = (const String& str)
{
    //自我赋值校验
    //本人写法if (m_data == str.m_data)
    //侯捷老师写法
    if (this == &str)
        return *this;//直接return 就不需要加else   
    //给已有的指针赋值时，先释放掉原来指向的内存
    delete[] m_data;
    /*if (str.m_data)
        {
            m_data = new char[strlen(str.m_data) + 1];
            strcpy(m_data, str.m_data);            
        }
    else
        {
            m_data = new char[1];
            m_data = "/0";
        }*/
    //侯捷老师没有空指针校验
    m_data = new char[strlen(str.m_data) + 1];
    strcpy(m_data, str.m_data);
    return *this;
}

{//此作用域调用三次构造函数，离开的时候调用三次析构函数，并释放掉p
    String s1();
    String s2("hello");
    String* p = new String("hello");//动态创建对象的方式
    delete p;
}

{
    String s1("hello");//调用构造函数
    String s3(s1);//调用拷贝构造函数
    String s3 = s1; //上面两语句一样的意思，构造且赋值
}

3、释放内存时一定要检测指向该内存的指针是否只有一个

给指针赋值时一定要检测指针原来指向的内存是否释放掉