c++拷贝函数

2019.6.14 c++拷贝构造函数详解

一、什么是拷贝构造函数

首先对于普通类型的对象来说,他们之间的复制是很简单的,例如:

int a = 100;
int b = a;

而类对象与普通对象不同,类对象内部结构一般较为复杂,存在各种成员变量。

下面看一个类对象拷贝的简单例子。

#include<iostream>
using namespace std;
class CExample
{
private:
    int a;
public:
    //构造函数
    CExample(int b)
    {
        a = b;
        printf("constructor is called\n");
    }
    //拷贝构造函数
    CExample(const CExample & c)
    {
        a = c.a;
        printf("copy constructor is called\n");
    }
    //析构函数
    ~CExample()
    {
        cout<<"destructor is called\n";
    }
    void Show()
    {
        cout<<a<<endl;
    }
};
int main()
{
    CExample A(100);
    CExample B = A;
    B.show();
    return 0;
}

运行程序,屏幕输出100。从以上代码的运行结果可以看出,系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言,相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。

CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见,拷贝构造函数是一种特殊的构造函数。函数的名称必须和类名称一致,它必须的一个参数是本类型的一个引用变量。

二、拷贝构造函数的调用时机

1.当函数的参数为类的对象时

#include<iostream>
using namespace std;
class CExample
{
private:
    int a;
public:
    CExample(int b)
    {
        a=b;
        printf("constructor is called\n");
    }
    CExample(const CExample & c)
    {
        a=c.a;
        printf("copy constructor is called\n");
    }
    ~CExample()
    {
     cout<<"destructor is called\n";
    }
    void Show()
    {
     cout<<a<<endl;
    }
};
void g_fun(CExample c)
{
    cout<<"g_func"<<endl;
}
int main()
{
    CExample A(100);
    CExample B=A;
    B.Show(); 
    g_fun(A);
    return 0;
}

调用g_fun()时,会产生以下几个重要步骤:

(1) A对象传入形参时,会先产生一个临时变量,就叫C吧。

(2) 然后调用拷贝构造函数把A的值给C。整个这两个步骤有点像:CExample C(A);

(3) 等g_fun()执行完后,析构掉C对象

2.函数的返回值是类的对象

#include<iostream>
using namespace std;
class CExample
{
private:
    int a;
public:
    //构造函数
    CExample(int b)
    {
        a=b;
        printf("constructor is called\n");
    }
    //拷贝构造函数
    CExample(const CExample & c)
    {
        a=c.a;
        printf("copy constructor is called\n");
    }
    //析构函数
    ~CExample()
    {
     cout<<"destructor is called\n";
    }
    void Show()
    {
     cout<<a<<endl;
    }
};
CExample g_fun()
{
    CExample temp(0);
    return temp;
}
int main()
{
    
    g_fun();
    return 0;
}

   当g_Fun()函数执行到return时,会产生以下几个重要步骤:
(1). 先会产生一个临时变量,就叫XXXX吧。
(2). 然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像:CExample XXXX(temp);
(3). 在函数执行到最后先析构temp局部变量。
(4). 等g_fun()执行完后再析构掉XXXX对象。 

3.对象需要通过另外一个对象继续初始化

CExample A(100);
CExample B(A);

三、浅拷贝与深拷贝

1.默认拷贝构造函数

很多时候在我们都不知道拷贝构造函数的情况下,传递对象给函数参数或者函数返回对象都能很好的进行,这是因为编译器会给我们自动产生一个拷贝构造函数,这就是“默认拷贝构造函数”,这个构造函数很简单,仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值,它一般具有以下形式:

Rect::Rect(const Rect& r)
{
    width = r.width;
    height = r.height;
}

当然,以上代码不用我们编写,编译器会为我们自动生成。但如果认为这样就可以解决对象的复制问题,那就错了,让我们来考虑以下一段代码:

#include<iostream>
using namespace std;
class Rect
{
public:
    Rect()
    {
     count++;
    }
    ~Rect()
    {
     count--;
    }
    static int getCount()
    {
     return count;
    }
private:
    int width;
    int height;
    static int count;
};
int Rect::count=0;
int main()
{
    Rect rect1;
    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
    Rect rect2(rect1);
    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
    return 0;
}

这段代码对前面的类,加入了一个静态成员,目的是进行计数。在主函数,首先创建对象rect1,输出此时的对象个数,然后使用rect1复制出对象rect2,再输出此时的对象个数。按照理解,此时应该有两个对象存在,但实际程序运行时,输出的都是1,反映出只有1个对象。此外,在销毁对象时,由于会调用销毁两个对象,类的析构函数会调用两次,此时的计数器将变为负数。

说白了,就是拷贝构造函数没有处理静态数据成员。

出现这些问题最根本就在于复制对象时,计数器没有递增,我们重新编写拷贝构造函数,如下:

#include<iostream>
using namespace std;
class Rect
{
public:
    Rect()
    {
        count++;
    }
    Rect(const Rect& r)
    {
        width=r.width;
        height=r.height;
        count++;
    }
    ~Rect()
    {
        count--;
    }
    static int getCount()
    {
        return count;
    }
private:
    int width;
    int height;
    static int count;
};
int Rect::count=0;
int main()
{
    Rect rect1;
    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
    Rect rect2(rect1);
    cout<<"The count of Rect:"<<Rect::getCount()<<endl;
    return 0;
}

四、拷贝构造函数的几个细节

1.为什么拷贝构造函数必须是引用传递,不能是值传递?
     简单的回答是为了防止递归引用。
          具体一些可以这么讲:
              当 一个对象需要以值方式传递时,编译器会生成代码调用它的拷贝构造函数以生成一个复本。如果类A的拷贝构造函数是以值方式传递一个类A对象作为参数的话,当 需要调用类A的拷贝构造函数时,需要以值方式传进一个A的对象作为实参; 而以值方式传递需要调用类A的拷贝构造函数;结果就是调用类A的拷贝构造函数导 致又一次调用类A的拷贝构造函数,这就是一个无限递归。

 2. 拷贝构造函数的作用。     
           作用就是用来复制对象的,在使用这个对象的实例来初始化这个对象的一个新的实例。

3.参数传递过程到底发生了什么?
      将地址传递和值传递统一起来,归根结底还是传递的是"值"(地址也是值,只不过通过它可以找到另一个值)!
      i)值传递:
         对于内置数据类型的传递时,直接赋值拷贝给形参(注意形参是函数内局部变量);
         对于类类型的传递时,需要首先调用该类的拷贝构造函数来初始化形参(局部对象);如void foo(class_type obj_local){}, 如果调用foo(obj);  首先class_type obj_local(obj) ,这样就定义了局部变量obj_local供函数内部使用
     ii)引用传递:
        无论对内置类型还是类类型,传递引用或指针最终都是传递的地址值!而地址总是指针类型(属于简单类型), 显然参数传递时,按简单类型的赋值拷贝,而不会有拷贝构造函数的调用(对于类类型).
4. 在类中有指针数据成员时,拷贝构造函数的使用?
        如果不显式声明拷贝构造函数的时候,编译器也会生成一个默认的拷贝构造函数,而且在一般的情况下运行的也很好。但是在遇到类有指针数据成员时就出现问题 了:因为默认的拷贝构造函数是按成员拷贝构造,这导致了两个不同的指针(如ptr1=ptr2)指向了相同的内存。当一个实例销毁时,调用析构函数 free(ptr1)释放了这段内存,那么剩下的一个实例的指针ptr2就无效了,在被销毁的时候free(ptr2)就会出现错误了, 这相当于重复释放一块内存两次。这种情况必须显式声明并实现自己的拷贝构造函数,来为新的实例的指针分配新的内存。

问题1和2回答了为什么拷贝构造函数使用值传递会产生无限递归调用的问题;
问题3回答了回答了在类中有指针数据成员时,拷贝构造函数使用值传递等于白显式定义了拷贝构造函数,因为默认的拷贝构造函数就是这么干的。

5. 拷贝构造函数里能调用private成员变量吗?
解答:
这个问题是在网上见的,当时一下子有点晕。其时从名子我们就知道拷贝构造函数其时就是一个特殊的构造函数,操作的还是自己类的成员变量,所以不受private的限制。

 6. 以下函数哪个是拷贝构造函数,为什么?

X::X(const X&);  //拷贝构造函数
X::X(X);
X::X(X&, int a = 1);  //拷贝构造函数
X::X(X&, int a = 1, int b = 2);  //拷贝构造函数

   解答:对于一个类X, 如果一个构造函数的第一个参数是下列之一:
   a) X&
   b) const X&
   c) volatile X&
   d) const volatile X&
   且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.

7. 一个类中可以存在多于一个的拷贝构造函数吗?
   解答:
类中可以存在超过一个拷贝构造函数。

class X{
public:
    X(const X&);  //const的拷贝构造
    X(X&)  //非const的拷贝构造
}

注意,如果一个类中只存在一个参数为 X& 的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.
  如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数。
  这个默认的参数可能为 X::X(const X&)或 X::X(X&),由编译器根据上下文决定选择哪一个。

五、C++构造函数以及析构函数的若干面试问题
 
 Q1:构造函数能否重载,析构函数能否重载,为什么?
 A1:构造函数可以,析构函数不可以。

 

  Q2:析构函数为什么一般情况下要声明为虚函数?

  A2:虚函数是实现多态的基础,当我们通过基类的指针是析构子类对象时候,如果不定义成虚函数,那只调用基类的析构函数,子类的析构函数将不会被调用。如       果定义为虚函数,则子类父类的析构函数都会被调用。

  Q3:什么情况下必须定义拷贝构造函数?

  A3:当类的对象用于函数值传递时(值参数,返回类对象),拷贝构造函数会被调用。如果对象复制并非简单的值拷贝,那就必须定义拷贝构造函数。例如大的堆       栈数据拷贝。如果定义了拷贝构造函数,那也必须重载赋值操作符。

参考博客:
 http://blog.csdn.net/lwbeyond/article/details/6202256
http://jaden.blog.51cto.com/1549175/324480
http://blog.chinaunix.net/uid-28662931-id-3496322.html

发布了7 篇原创文章 · 获赞 4 · 访问量 5905
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览