C++拷贝构造函数

  1. 如果程序员没有提供拷贝构造函数,则编译器自动提供一个:

include "stdafx.h"

#include

using namespace std;

class CExample {

private:

int a;

public:

// 构造函数

CExample(int b)

{ a = b;}



// 一般函数

void Show ()

{

cout<<a<<endl;

}

};

int main()

{

CExample A(100);

CExample B = A; //注意这里的对象初始化要调用拷贝构造函数,而非赋值

A.Show();

B.Show();

return 0;

}

  1. 如果程序员提供了一个拷贝构造函数,那么编译器不再提供。

特别注意,如果程序提供的拷贝构造函数功能不完整,那么新的实例将得不到正确的初始化!(因为编译器不再自动提供相应的拷贝构造函数)

include

using namespace std;

class CExample {

private:

int a;

public:

//构造函数

CExample(int b)

{ a = b;}



//拷贝构造函数

CExample(const CExample& C)

{

a = C.a;

}

//一般函数

void Show ()

{

cout<<a<<endl;

}

};

int main()

{

CExample A(100);

CExample B = A; // CExample B(A); 也是一样的

B.Show ();

return 0;

}

拷贝构造函数的调用时机

*1. 对象以值传递的方式传入函数参数*

class CExample

{

private:

int a;

public:

//构造函数

CExample(int b)

{

a = b;

cout<<"creat: "<<a<<endl;

}

//拷贝构造

CExample(const CExample& C)

{

a = C.a;

cout<<"copy"<<endl;

}



//析构函数

~CExample()

{

cout<< "delete: "<<a<<endl;

}

void Show ()

{

cout<<a<<endl;

}

};

//全局函数,传入的是对象

void g_Fun(CExample C)

{

cout<<"test"<<endl;

}

int main()

{

CExample test(1);

//传入对象

g_Fun(test);

return 0;

}

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

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

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

(3).等g_Fun()执行完后, 析构掉 C 对象。

2. 对象以值传递的方式从函数返回

include

using namespace std;

class CExample

{

private:

int a;

public:

CExample(int b)

{

a = b;

}

CExample(const CExample& C)

{

a = C.a;

cout<<"copy"<<endl;

}

~CExample()

{

cout<<"delete"<<endl;

}

void Show ()

{

cout<<a<<endl;

}

};

CExample g_Fun()

{

CExample temp(100);

return temp;

}

int main()

{

CExample c = g_Fun();

c.Show();

return 0;

}

这里虽然temp很快被析构掉了,但是它的值被拷贝到了c里。有点不懂,return temp;的时候,到底temp还存在吗?

3. 对象需要通过另外一个对象进行初始化;

CExample A(100);

CExample B = A;

// CExample B(A);

三. 浅拷贝和深拷贝

1. 默认拷贝构造函数

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

Rect::Rect(const Rect& r)

{

width = r.width;

height = r.height;

}

新问题:

class Rect

{

public:

Rect() // 构造函数,计数器加1

{

count++;

}

~Rect() // 析构函数,计数器减1

{

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); // 使用rect1复制rect2,此时应该有两个对象

cout<<"The count of Rect: "<<Rect::getCount()<<endl;

return 0;

}

结论:拷贝构造函数没有处理静态数据成员。特别注意 rect2(rect1)这句语句,使得 Rect()构造函数反而不会执行了,自动提供的拷贝构造函数也不会去处理静态成员。

2. 浅拷贝

所谓浅拷贝,指的是在对象复制时,只对对象中的数据成员进行简单的赋值,默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了,但是一旦对象存在了动态成员,那么浅拷贝就会出问题了,让我们考虑如下一段代码:

class Rect

{

public:

Rect() // 构造函数,p指向堆中分配的一空间

{

p = new int(100);

}

~Rect() // 析构函数,释放动态分配的空间

{

if(p != NULL)

{

delete p;

}

}

private:

int width;

int height;

int *p; // 一指针成员

};

int main()

{

Rect rect1;

Rect rect2(rect1); // 复制对象

return 0;

}

最后运行会出错。因为rect2的p拷贝得到了值,但却指向rect1的p的同一个对象100,然而却要强行删除p所代表的对象(其实不存在),所以会出错。解决方法就是深拷贝。

在“深拷贝”的情况下,对于对象中动态成员,就不能仅仅简单地赋值了,而应该重新动态分配空间。(这时候大概必须手动写拷贝构造函数)

class Rect

{

public:

Rect() // 构造函数,p指向堆中分配的一空间

{

p = new int(100);

}

Rect(const Rect& r)

{

width = r.width;

height = r.height;

p = new int; // 为新对象重新动态分配空间

p = (r.p);

}

~Rect() // 析构函数,释放动态分配的空间

{

if(p != NULL)

{

delete p;

}

}

private:

int width;

int height;

int *p; // 一指针成员

};

3. 防止默认拷贝发生

通过对对象复制的分析,我们发现对象的复制大多在进行“值传递”时发生,这里有一个小技巧可以止按值传递——声明一个私有拷贝构造函数。甚至不必去定义这个拷贝构造函数,这样因为拷贝构造函数是私有的,如果用户试图按值传递或函数返回该类对象,将得到一个编译错误,从而可以避免按值传递或返回对象。

// 防止按值传递

class CExample

{

private:

int a;

public:

//构造函数

CExample(int b)

{

a = b;

cout<<"creat: "<<a<<endl;

}

private:

//拷贝构造,只是声明

CExample(const CExample& C);

public:

~CExample()

{

cout<< "delete: "<<a<<endl;

}

void Show ()

{

cout<<a<<endl;

}

};

//全局函数

void g_Fun(CExample C)

{

cout<<"test"<<endl;

}

int main()

{

CExample test(1);

//g_Fun(test); 按值传递将出错



return 0;

}

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

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&

且没有其他参数或其他参数都有默认值,那么这个函数是拷贝构造函数.

所以第二个不是。

3. 类中可以存在超过一个拷贝构造函数。

class X {

public:

X(const X&); // const 的拷贝构造

X(X&); // 非const的拷贝构造

};

4. 如果一个类有两个拷贝构造函数,即

class X {

public:

X(const X&); // const 的拷贝构造

X(X&); // 非const的拷贝构造

};

X a;

X b(a);//这时调用哪个拷贝构造函数?答:调用X(X&)

X u=a;//这时调用哪个拷贝构造函数?答:还是调用X(X&)

const X a_1;

X b_1(a_1);//这时调用哪个拷贝构造函数?答:调用X(const X&)

X u_1 = a_1//同上

u_1 = a_1//此时呢?答;此时是对象赋值,不调用构造函数,而是调用的被重载过的=运算符

举例说明:

#include <iostream>
using namespace std;

class myclass
{
    public:
    myclass()
    {
        cout << "构造函数" << endl;
    }
    ~myclass()
    {
        cout << "析构函数" << endl;
    }
};

void function(myclass mc)
{
}

int main()
{
    myclass mc;
    function(mc);
    return 0;
}

运行结果:

构造函数

析构函数

析构函数

在这里,程序员没有提供拷贝构造函数,因此编译器会自动提供一个。在function(myclass mc)时候,会产生一个对象的复制(浅复制)然而这个复制会调用这个拷贝构造函数,而没有运行程序员提供的构造函数(不是拷贝构造函数),所以构造函数总共执行一次(另一次是拷贝构造函数),但析构函数会执行两遍。

使用拷贝构造函数的技巧,使得静态函数在栈上创建对象(它的类构造函数是私有的),注意观察一共调用了三次:

#include "stdafx.h"

class A 
{
private: 
    A() { printf("private constructor of A !\n"); n1=100; }
public:
    int n1;
    static A InstA() { A a1 =A(); return a1; }
};

int main(int argc, char* argv[])
{
    A a2 = A::InstA();
    int n2 = a2.n1;
    printf("n2=%d\n", n2);

    return 0;
}

class A 
{
private: 
    A() { printf("private constructor of A !\n"); n1=100; }
public:
    int n1;
    A(const A& C) { printf("copy constructor of A !\n"); n1=C.n1; }
    static A InstA() { A a1 =A(); return a1; }
};

int main(int argc, char* argv[])
{
    A a2 = A::InstA();
    int n2 = a2.n1;
    printf("n2=%d\n", n2);

    return 0;
}

原文链接: https://www.cnblogs.com/findumars/archive/2013/05/06/3063901.html

欢迎关注

微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍

原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/87296

非原创文章文中已经注明原地址,如有侵权,联系删除

关注公众号【高性能架构探索】,第一时间获取最新文章

转载文章受原作者版权保护。转载请注明原作者出处!

(0)
上一篇 2023年2月9日 下午11:02
下一篇 2023年2月9日 下午11:02

相关推荐