c++ 拷贝构造函数、拷贝运算符、析构函数

拷贝构造函数、拷贝运算符、析构函数

拷贝构造函数、拷贝运算符、析构函数

定义行为像值的类

class HasPtr{
    public:
        HasPtr(const string &s = string()):ps(new string(s)), i(0) {
            cout<<"HasPtr(const string &s = string())"<<endl;
        }
        HasPtr(const HasPtr &hp) :ps(new string(*hp.ps)), i(hp.i) {
            cout<<"HasPtr(const HasPtr &hp)"<<endl;
        }
        HasPtr &operator=(const HasPtr &hp) {
            auto tmp = new string(*hp.ps); // 右侧对象拷贝到临时变量，考虑自己拷贝自己的情况。
　　　　　　　delete ps;                     // 析构左侧对象
　　　　　　  ps = tmp;
            i = hp.i;
            cout<<"HasPtr &operator="<<endl;
            return *this;
        }
        
        HasPtr testCopy(HasPtr hp) {
            return hp;
        }
        
        HasPtr &testCopy1(HasPtr &hp) {
            return hp;
        }
        
        ~HasPtr() {
            cout<<"~HasPtr()"<<endl;
        }
        
        void print() {
            cout<<*ps<<endl;
        }
        
        void setPs(const string &str) {
            *ps = str;
        }
        
    private:
        string *ps;
        int i;
};

测试代码

HasPtr hp("hello");                // 调用构造函数，输出HasPtr(const string &s = string())
HasPtr hp1 = hp;                   // 调用拷贝构造函数，输出HasPtr(const HasPtr &hp)
HasPtr hp2;                        // 调用构造函数，输出HasPtr(const string &s = string())
hp2 = hp;                          // 调用拷贝运算符函数，输出HasPtr &operator=
hp1.setPs("word");                 // 构造函数、拷贝构造函数、拷贝赋值运算符函数都为ps分配了新空间
hp.print();                        // 所以hp、hp1、hp2的ps指针指向的空间不一样，修改一个的值其他的不变。
hp1.print();                       // 输出word,由setPs函数修改
hp2.print();                       // 输出hello，值从hp拷贝过来，空间是新分配的。
// 实参初始化形参要调用一次拷贝构造函数，形参初始化返回的临时变量也要调用一次拷贝构造函数，
hp.testCopy(hp1);                  // 形参和临时变量在函数结束时时要销毁，调用两次析构函数。
hp.testCopy1(hp1);                 // 都是引用初始化，不需要调用拷贝构造函数。
HasPtr *hp_ptr = new HasPtr;       // 调用构造函数
vector<HasPtr> vec;                // 调用vector的默认构造函数。
vec.push_back(hp);                 // 调用拷贝构造函数

// 接下来要销毁hp,hp1,hp2和vector中的HasPtr的元素，要调用4次析构函数，但是hp_ptr指向的空间不会被销毁。

定义行为像指针的类

class HasPtr{
    public:
        // 构造函数，为指针指向分配空间（整个类也只在这个地方分配空间），use初始化为1
        HasPtr(const string &s = string()):ps(new string(s)), i(0) ,use(new size_t(1)){ 
            cout<<"HasPtr(const string &s = string())-->use"<<*use<<endl;
        }
        
        // 拷贝构造函数，只拷贝指针，use值递增
        HasPtr(const HasPtr &hp) :ps(new string(*hp.ps)), i(hp.i) ,use(hp.use){         
            ++*use;
            cout<<"HasPtr(const HasPtr &hp)-->use"<<*use<<endl;
        }
        
        // 拷贝赋值运算符，左侧use递减，当use为0，释放左侧指针指向空间，拷贝右侧数据和指针到左侧对象，use递增。
        HasPtr &operator=(const HasPtr &hp) {
            if(--*use == 0) {
                delete ps;
                delete use;
            }
            ++*hp.use;
            ps = hp.ps;
            use = hp.use;
            i = hp.i;
            cout<<"HasPtr &operator=-->use"<<*use<<endl;
            return *this;
        }
        
        HasPtr testCopy(HasPtr hp) {
            return hp;
        }
        
        HasPtr &testCopy1(HasPtr &hp) {
            return hp;
        }
        
        // 析构函数，递减use，当use为0，释放指针指向空间。
        ~HasPtr() {
            if(--*use == 0){
                delete ps;
                delete use;
            }
            cout<<"~HasPtr()-->use"<<*use<<endl;
        }
        
        void print() {
            cout<<*ps<<endl;
        }
        
        void setPs(const string &str) {
            *ps = str;
        }
        
    private:
        string *ps;    // 共享，只有构造函数分配，最后一次析构函数销毁
        int i;         // 每个对象独享，每次构造函数、拷贝构造函数、拷贝运算符都分配，每次析构都销毁
        size_t *use;   // 共享，只有构造函数分配，最后一次析构函数销毁
};

测试程序

HasPtr hp("hello");                // 调用构造函数，输出HasPtr(const string &s = string())
HasPtr hp1 = hp;                   // 调用拷贝构造函数，输出HasPtr(const HasPtr &hp)
HasPtr hp2;                        // 调用构造函数，输出HasPtr(const string &s = string())
hp2 = hp;                          // 调用拷贝运算符函数，输出HasPtr &operator=
hp1.setPs("word");                 // 拷贝构造函数、拷贝赋值运算符不为指针ps和use分配新空间
hp.print();                        // 所以hp、hp1、hp2的ps指针指向相同的空间，修改一个的值其他的也变。
hp1.print();                       // 输出word,由setPs函数修改
hp2.print();                       // 输出word,由setPs函数修改
// 实参初始化形参要调用一次拷贝构造函数，形参初始化返回的临时变量也要调用一次拷贝构造函数，
hp.testCopy(hp1);                  // 形参和临时变量在函数结束时时要销毁，调用两次析构函数。
hp.testCopy1(hp1);                 // 都是引用初始化，不需要调用拷贝构造函数。
HasPtr *hp_ptr = new HasPtr;       // 调用构造函数
vector<HasPtr> vec;                // 调用vector的默认构造函数。
vec.push_back(hp);                 // 调用拷贝构造函数

// 接下来要销毁hp,hp1,hp2和vector中的HasPtr的元素，要调用4次析构函数，只有最后一次调用析构函数才会释放ps和use指向的空间。
// 但是hp_ptr指向的空间不会被销毁。