欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

构造函数(三) 拷贝构造函数

程序员文章站 2022-04-08 19:10:20
什么是拷贝构造函数 ~~拷贝听起来真高级~~ 拷贝构造函数形如 拷贝构造函数是一种特殊的构造函数,只有一个参数,这个参数是 本类 中的一个对象,以 引用 的形式传参,一般用const修饰,使参数值不变。 如果没有定义拷贝构造函数,编译器会自动隐式生成一个拷贝构造函数,用来简单的复制类中每个成员变量。 ......

什么是拷贝构造函数

拷贝听起来真高级
拷贝构造函数形如

class_name(const class_name &object_name)

拷贝构造函数是一种特殊的构造函数,只有一个参数,这个参数是本类中的一个对象,以引用的形式传参,一般用const修饰,使参数值不变。

如果没有定义拷贝构造函数,编译器会自动隐式生成一个拷贝构造函数,用来简单的复制类中每个成员变量。

一个简单的类对象拷贝

#include <bits/stdc++.h>
using namespace std;
class a {
    private :
        int a, b;
    public :
        a(int x, int y) : a(x), b(y) {}
        void print() {
            printf("%d %d\n", a, b);
        }
};

int main() {
    a a(10, 20);
    a b = a;
    b.print();
    return 0;
}

输出

10 20

具体看一下拷贝构造函数怎么用。

#include <bits/stdc++.h>
using namespace std;
class a {
    private :
        int a, b;
    public :
        a(int x, int y) : a(x), b(y) {}
        a(const a &c) {
            a = c.a;
            b = c.b;
        }
        void print() {
            printf("%d %d\n", a, b);
        }
};

int main() {
    a a(10, 20);
    a b = a;
    b.print();
    return 0;
}

这样手动的写如何复制

为什么要引用

为什么用引用的方式传参呢。
举个反例

#include <bits/stdc++.h>
using namespace std;
class a {
    private :
        int a;
    public :
        a(int x) : a(x) {}
        a(const a c) {
            a = c.a;
        }
        void print() {
            printf("%d\n", a);
        }
};

int main() {
    a a(10);
    a b = a;
    b.print();
    return 0;
}

a b = a时,调用了传值型的拷贝构造函数,
相当于b.a(a)
因为是传的值,所以要用a的值创建一个副本对象c,让c的值为a,则又需要调用构造函数c.a(a),这样会无限创造副本对象c,无限调用c.a(a);
所以
引用是为了防止无限递归。
其实没有加引用的话编译器也是不过编译的。

拷贝构造函数的调用时机

1. 对象需要通过另一个对象对其进行赋值

a a(10, 20);
a b = a;

2. 当函数的参数是类的对象

#include <bits/stdc++.h>
using namespace std;
class a {
    private :
        int a, b;
    public :
        a(int x, int y) : a(x), b(y) {}
        a(const a &c) {a = c.a, b = c.b;}
        void print() {printf("%d\n", a * b);}
};

void fun(a c) {     //函数的形参是类的对象 
    c.print();
}

int main() {
    a a(10, 20);
    fun(a);         //实参是类的对象,调用函数时将复制一个新对象c
    return 0;
}

3. 当函数的返回值是类的对象

#include <bits/stdc++.h>
using namespace std;
class a {
    private :
        int a, b;
    public :
        a(int x, int y) : a(x), b(y) {}
        a(const a &c) {a = c.a, b = c.b;}
        void print() {printf("%d\n", a * b);}
};

a fun() {   
    a b(20, 10);
    return b;       //函数的返回值是类的对象 
}

int main() {
    a a = fun();    //fun()返回 a 类的临时对象,并赋值给a 
    a.print();
    return 0;
}

深拷贝和浅拷贝

默认拷贝构造函数可以完成对象的数据值得简单复制,这就是浅拷贝。

对象的成员是指向堆时,浅拷贝只是将指针简单复制一遍,指向了原有的内存,而深拷贝是将新建的指针指向了一块新的内存。

浅拷贝

浅拷贝就是将数据简单复制一下,就像上面讲的。

看这段代码

#include <bits/stdc++.h>
using namespace std;
class a {
    private :
        int *p;
    public :
        a(int x) {
            p = new int(x);
            printf("constructor\n");
        }
        a(const a &oth) {
            this->p = new int(*oth.p);
            printf("constructor\n");
        }
        ~a() {
            if (p != null) delete p;
            printf("destructor\n"); 
        }
        void print() { printf("%d\n", *p); }
        
};
int main() {
    a a(10);
    a b = a;
    return 0;
}

这是段代码出错了,为什么?

如图所示,
构造函数(三) 拷贝构造函数

b把a的指针简单复制了一遍,两者都指向了同一块内存,释放内存的时候被释放了两次,导致出错。

深拷贝

对于上面的代码,我们手写一个拷贝构造函数,像这样

#include <bits/stdc++.h>
using namespace std;
class a {
    private :
        int *p;
    public :
        a(int x) {
            p = new int(x);
            printf("constructor\n");
        }
        a(const a &oth) {
            this->p = new int(*oth.p);
            printf("constructor\n");
        }
        ~a() {
            if (p != null) delete p;
            printf("destructor\n"); 
        }
        void print() { printf("%d\n", *p); }
        
};
int main() {
    a a(10);
    a b = a;
    return 0;
}

我们给b初始化时,给它新开辟了一段内存空间
构造函数(三) 拷贝构造函数
这样,深拷贝就没有上述浅拷贝时内存释放两次的情况了。