含有指针变量的类需要重写拷贝构造函数，拷贝赋值函数，析构函数

编译器自带拷贝构造（ctor）和拷贝赋值函数（operator =）， 但是对于成员变量含有指针的类，其不能使用默认的拷贝赋值函数。因为使用默认的，会直接将指针指向的地址进行赋值 (浅拷贝，共享内存，共指一个对象），而不是分配一块内存，具有相同的数值 (深拷贝,独立，两个对象)。

 

浅拷贝容易造成dangling pointer。

 

用一个例子来展示：

#ifndef __MYSTRING__
#define __MYSTRING__

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;
        }
    private:
        char* m_data;  // 带指针成员的类:一定要注意拷贝赋值，拷贝构造，析构
        // String的底部通过char实现，在外部表现为string
};

inline String::String ( const char* cstr=0 ){
    if(cstr){  
        m_data=new char[strlen(cstr)+1];
        strcpy(m_data,cstr);  //  char * strcpy ( char * destination, const char * source );  
    }
    else{ // 考虑cstr=0;
        m_data=new char[1];
        m_data[0]='\0';
    }
}

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

inline String::~String(){
    delete[] m_data;
}

inline String& String::operator=(const String& str){
    if(this==&str){ // self assignment ：自我检验  （如果没有进行这样的处理，在自我赋值会产生严重的错误） 
        return *this;
    }
    // 构造函数是第一次，因此不需要删除，但是赋值需要先进行delete
    delete[] m_data;  // 先删除，重新分配一样大小！
    m_data=new char[strlen(str.get_c_str())+1];
    strcpy(m_data,str.m_data);
    return *this;   // 其实不用返回*this也可以，因为已经实现了修改，但是这样有一个好处  可以实现 a=b=c；  （因为返回的类型继续支持=）
}

// 调用形式： cout <<  String() ;   第一个参数为 << 左边 ，第二个参数为 << 右侧；返回ostream 可以实现 cout <<  a << b ;
ostream& operator<<(ostream& os,const String& str){
    os<<str.get_c_str();
    return os;
}

#endif