拷贝构造函数范文

第一篇：拷贝构造函数范文

不要轻视拷贝构造函数与赋值函数

由于并非所有的对象都会使用拷贝构造函数和赋值函数，程序员可能对这两个函数有些轻视。请先记住以下的警告，在阅读正文时就会多心：

 本章开头讲过，如果不主动编写拷贝构造函数和赋值函数，编译器将以“位拷贝”的方式自动生成缺省的函数。倘若类中含有指针变量，那么这两个缺省的函数就隐含了错误。以类String的两个对象a,b为例，假设a.m_data的内容为“hello”，b.m_data的内容为“world”。

现将a赋给b，缺省赋值函数的“位拷贝”意味着执行b.m_data = a.m_data。这将造成三个错误：一是b.m_data原有的内存没被释放，造成内存泄露;二是b.m_data和a.m_data指向同一块内存，a或b任何一方变动都会影响另一方;三是在对象被析构时，m_data被释放了两次。

 拷贝构造函数和赋值函数非常容易混淆，常导致错写 错用。拷贝构造函数是在对象被创建时调用的，而赋值函数只能被已经存在了的对象调用。以下程序中，第三个语句和第四个语句很相似，你分得清楚哪个调用了拷贝构造函数，哪个调用了赋值函数吗? Stringa(“hello”);

Stringb(“world”);

Stringc = a; // 调用了拷贝构造函数，最好写成 c(a);

c = b;// 调用了赋值函数

本例中第三个语句的风格较差，宜改写成String c(a) 以区别于第四个语句。

第二篇：拷贝构造函数的参数类型必须是引用

在C++中， 构造函数，拷贝构造函数，析构函数和赋值函数(赋值运算符重载)是最基本不过的需要掌握的知识。 但是如果我问你“拷贝构造函数的参数为什么必须使用引用类型?”这个问题， 你会怎么回答? 或许你会回答为了减少一次内存拷贝? 很惭愧的是，我的第一感觉也是这么回答。不过还好，我思索一下以后，发现这个答案是不对的。

原因：

如果拷贝构造函数中的参数不是一个引用，即形如CClass(const CClass c_class)，那么就相当于采用了传值的方式(pass-by-value)，而传值的方式会调用该类的拷贝构造函数，从而造成无穷递归地调用拷贝构造函数。因此拷贝构造函数的参数必须是一个引用。

需要澄清的是，传指针其实也是传值，如果上面的拷贝构造函数写成CClass(const CClass* c_class)，也是不行的。事实上，只有传引用不是传值外，其他所有的传递方式都是传值。

先从一个小例子开始：(自己测试一下自己看看这个程序的输出是什么?)

[cpp] view plain copy #include

using namespace std;

class CExample

{

private:

int m_nTest;

public:

CExample(int x) : m_nTest(x)

//带参数构造函数

{

cout << "constructor with argument"<

}

// 拷贝构造函数，参数中的const不是严格必须的，但引用符号是必须的

CExample(const CExample & ex)

//拷贝构造函数

{

m_nTest = ex.m_nTest;

cout << "copy constructor"<

}

CExample& operator = (const CExample &ex)

//赋值函数(赋值运算符重载)

{

cout << "assignment operator"<

m_nTest = ex.m_nTest;

return *this;

}

void myTestFunc(CExample ex)

{

}

};

int main(void)

{

CExample aaa(2);

CExample bbb(3);

bbb = aaa;

CExample ccc = aaa;

bbb.myTestFunc(aaa);

return 0;

}

这个例子的输出结果是： [cpp] view plain copy constructor with argument

// CExample aaa(2);

constructor with argument

// CExample bbb(3);

assignment operator

// bbb = aaa;

copy constructor

// CExample ccc = aaa;

copy constructor

// bbb.myTestFunc(aaa);

如果你能一眼看出就是这个结果的话， 恭喜你，可以站起来扭扭屁股，不用再往下看了。

如果你的结果和输出结果有误差， 那拜托你谦虚的看完。

第一个输出： constructor with argument

// CExample aaa(2);

如果你不理解的话， 找个人把你拖出去痛打一顿，然后嘴里还喊着“我是二师兄，我是二师兄.......”

第二个输出：constructor with argument

// CExample bbb(3);

分析同第一个

第三个输出： assignment operator

// bbb = aaa;

第四个输出： copy constructor

// CExample ccc = aaa;

这两个得放到一块说。 肯定会有人问为什么两个不一致。原因是， bbb对象已经实例化了，不需要构造，此时只是将aaa赋值给bbb，只会调用赋值函数，就这么简单，还不懂的话，撞墙去! 但是ccc还没有实例化，因此调用的是拷贝构造函数，构造出ccc，而不是赋值函数，还不懂的话，我撞墙去!!

第五个输出： copy constructor

// bbb.myTestFunc(aaa);

实际上是aaa作为参数传递给bbb.myTestFunc(CExample ex)， 即CExample ex = aaa;和第四个一致的， 所以还是拷贝构造函数，而不是赋值函数， 如果仍然不懂， 我的头刚才已经流血了，不要再让我撞了，你就自己使劲的再装一次吧。

通过这个例子， 我们来分析一下为什么拷贝构造函数的参数只能使用引用类型。

看第四个输出： copy constructor

// CExample ccc = aaa;

构造ccc，实质上是ccc.CExample(aaa); 我们假如拷贝构造函数参数不是引用类型的话， 那么将使得 ccc.CExample(aaa)变成aaa传值给ccc.CExample(CExample ex)，即CExample ex = aaa，因为 ex 没有被初始化， 所以 CExample ex = aaa 继续调用拷贝构造函数，接下来的是构造ex，也就是 ex.CExample(aaa)，必然又会有aaa传给CExample(CExample ex), 即 CExample ex = aaa;那么又会触发拷贝构造函数，就这下永远的递归下去。

所以绕了那么大的弯子，就是想说明拷贝构造函数的参数使用引用类型不是为了减少一次内存拷贝， 而是避免拷贝构造函数无限制的递归下去。

附带说明，在下面几种情况下会调用拷贝构造函数：

a、

显式或隐式地用同类型的一个对象来初始化另外一个对象。如上例中，用对象c初始化d; b、

作为实参(argument)传递给一个函数。如CClass(const CClass c_class)中，就会调用CClass的拷贝构造函数;

c、

在函数体内返回一个对象时，也会调用返回值类型的拷贝构造函数;

d、

初始化序列容器中的元素时。比如 vector svec(5)，string的缺省构造函数和拷贝构造函数都会被调用;

e、

用列表的方式初始化数组元素时。string a[] = {string(“hello”), string(“world”)}; 会调用string的拷贝构造函数。

如果在没有显式声明构造函数的情况下，编译器都会为一个类合成一个缺省的构造函数。如果在一个类中声明了一个构造函数，那么就会阻止编译器为该类合成缺省的构造函数。和构造函数不同的是，即便定义了其他构造函数(但没有定义拷贝构造函数)，编译器总是会为我们合成一个拷贝构造函数。

另外函数的返回值是不是引用也有很大的区别，返回的不是引用的时候，只是一个简单的对象，此时需要调用拷贝构造函数，否则，如果是引用的话就不需要调用拷贝构造函数。 [cpp] view plain copy #include

using namespace std;

class A

{

private:

int m_nTest;

public:

A()

{

}

A(const A& other)

//构造函数重载

{

m_nTest = other.m_nTest;

cout << "copy constructor"<

}

A & operator =(const A& other)

{

if(this != &other)

{

m_nTest = other.m_nTest;

cout<<"Copy Assign"<

}

return *this;

}

};

A fun(A &x)

{

return x;

//返回的不是引用的时候，需要调用拷贝构造函数

}

int main(void)

{

A test;

fun(test);

system("pause");

return 0;

}

分享一道笔试题目，编译运行下图中的C++代码，结果是什么?(A)编译错误;(B)编译成功，运行时程序崩溃;(C)编译运行正常，输出10。请选择正确答案并分析原因。

[cpp] view plain copy class A

{

private:

int value;

public:

A(int n)

{

value = n;

}

A(A other)

{

value = other.value;

}

void Print()

{

cout<

}

};

int main(void)

{

A a = 10;

A b = a;

b.Print();

return 0;

}

答案：编译错误。在复制构造函数中传入的参数是A的一个实例。由于是传值，把形参拷贝到实参会调用复制构造函数。因此如果允许复制构造函数传值，那么会形成永无休止的递归并造成栈溢出。因此C++的标准不允许复制构造函数传值参数，而必须是传引用或者常量引用。在Visual Studio和GCC中，都将编译出错。

第三篇：构造法之构造函数

：题设条件多元-构造一次函数

B：题设有相似结构-构造同结构函数主要介绍

C：题设条件满足三角特性-构造三角函数 D：其它方面——参考构造函数解不等式

A、题设条件多元时，选择构造一次函数

例

1、 已知x.y.z(0,1).求证：x(1y)y(1z)z(1x)1(第15届俄罗斯数学竞赛

题)

分析 此题条件、结论均具有一定的对称性，然而难以直接证明，不妨用构造法一试。可构造一次函数试解本题.证法一 函数图像性质法、构造函数f(x)(yz1)x(yzyz1) 因为y,z(0,1)，所以

f(0)yzyz1(y1)(z1)0

f(1)yz1(yzyz1)yz0

而f(x)是一次函数，其图象是直线，

所以由x0,1恒有f(x)0，即(yz1)x(yzyz1)0，整理可得x(1y)y(1z)z(1x)

1证法二函数单调性法、 构造一次函数f(x)x(1y)y(1z)z(1x)整理，得：

f(x)(1yz)x(yzyz).(0x1)

因为0x1，0y1,0z1 所以11yz

1(1)当01yz1时,f(x)在0,1上是增函数，于是f(x)(2)当

11yz0

f(x)1yz1;

时,

f(x)

在1,0上是减函数，于是

f(x)f(x)=yzyz=1(1y)(1z)1;

(3)当1yz0时，即yz1时，f(x)

成立。

yzyz1yz1。综上所知，所证不等式

小结 (1)为了利用所构造的一次函数的单调性，将11yz1分成

“01yz1,11yz0,1yz0”三种情况讨论，使问题得以解决。

(2)解决本题有两个核心的地方，一是将证式构造成一次函数，二是对一次项系数进行逻辑划分。

(3)本题也可以构造关于y或z的一次函数，这就需要真正理解函数的实质概念。

例

2、 已知1a,b,c1：，求证:abcabc

2证明 构造一次函数y(bc1)x2bc，易知bc10，在1又x

则由一次函数的性质不难得知当1

x1时，y0;又1a1所以xa

1时,y(bc1)12bc

x1时，y

为减函数;

=bc1bc(1b)(1c)0

时，y0，

即(bc1)a2bc0 命题得证

B、题设条件有相似结构时-构造同样结构的函数

例

1、a、b、c, R，求证

abc1abc



a1a



b1b



c1c

.证明：构作函数f(x)当任意x1，x2满足0

f(x2)f(x1)

x21x

2x1x

x1x

，x[0,)，则研究这个函数性质如下：

时，

0

x1x2



x11x

1

x2x1

(1x1)(1x2)

，

所以函数f(x)在[0,)是递增函数.

f(|a||b||c|).

因为|abc||a||b||c|，所以f(|abc|)即

|abc|1|abc|



|a||b||c|1(|a||b||c|)

|a|1|a|

|b|1|b|



|a|

1|a||b||c|



|b|

1|a||b||c|



|c|

1|a||b||c|



|c|1|c|

.不等式得证.

例

2、解方程(6x+5)(1+

(6x5)4)x(1

x4)0.

为f(6x+5)=-f(x).只要证明f(x)是奇函数且是单调函数，就能简单的解出此题.

解：构造函数

f(x)=x(1+

原方程化为

f(6x+5)+f(x)=0.

显然f(-x)=-f(x)，f(x)是奇函数.再证f(x)具有单调性.x4)

)，

f(x)在(-∞,+∞)上是增函数.所以f(6x+5)=f(-x)x=-

7

5C、题设条件满足三角函数的特性时-构造三角函数

例

1、已知a.b.x.yR.且a2b

21，xy1.求证：1axby

1证明 已知x

y

由a2b21，xy1，可设

bsin,acos.xcos,ysinaxbycoscossinsincos()1所

以1axby1

例

2、

分析 由根号里面的代数式可以看出有这样的关系：x1x1且0故想到三角函数关系式并构造xsin2

所以ysinxcosx

D、其它-参考构造函数解不等式

在解决不等式的证明题时常常通过构造辅助函数，把原来问题转化为研究辅助函数的性质，并利用函数的单调性、有界性、奇偶性等性质来解决。

例

1、求证不等式：

证明：构造函数：f(x)

x1

2x

x1.(0



)





)，当



即x时

,ymax



x12

x



x2

(x0)



x2

(x0)

x2x2

x

x

f(x)

x12

x

2

1

x2

所以

f(x)的图像关于y



xx

1(12)x212x12

x

x

x

x2

f(x).

轴对称。当x0时，12x

0

，故f(x)0;当x0时，依图象的

对称性知f(x)0.故当x0时，恒有f(x)0.即

x12

x



x2

(x0).

例

2、已知x0，求证：x

1x



1x

1x



52证明：构造函数f(x)

x

1x

(x0)，则x

1x

2，设2,由

f()f()

1

(

11()(1)

)()



1显然：因为2



，所以-<0，>1，所以f()

f()0

，

所以f(x)在2,上是单调递增的，所以

x

1x

1x

1x

f(2)

52

以上两题的实质上是用的函数的单调性、奇偶性来证明的，其中如何来构造恰当的函数是进一步证明的关键。

第四篇：构造函数法

函数与方程数学思想方法是新课标要求的一种重要的数学思想方法，构造函数法便是其中的一种。

高等数学中两个重要极限

1.limsinx1 x0x

11x2.lim(1)e(变形lim(1x)xe) x0xx

由以上两个极限不难得出，当x0时

1.sinxx，

2.ln(1x)x(当nN时，(1)ne(1)n1).

下面用构造函数法给出两个结论的证明.

(1)构造函数f(x)xsinx，则f(x)1cosx0，

所以函数f(x)在(0,)上单调递增，f(x)f(0)0.所以xsinx0，即sinxx.

(2)构造函数f(x)xln(1x)，则f(x)11n1n1x0.所以函数f(x)在1x1x

(0,)上单调递增，f(x)f(0)0，所以xln(1x)，即ln(1x)x. 1要证1n事实上：设1n111e,两边取对数，即证ln1, nn111t,则n(t1), nt1

1因此得不等式lnt1(t1) t

1构造函数g(t)lnt1(t1),下面证明g(t)在(1,)上恒大于0. t

11g(t)20, tt

∴g(t)在(1,)上单调递增，g(t)g(1)0, 即lnt1, 1

t

111∴ ln1,∴1nnn1n1e,

以上两个重要结论在高考中解答与导数有关的命题有着广泛的应用.

第五篇：构造函数-析构函数的调用顺序

C++继承中构造函数、析构函数调用顺序及虚函数的动态绑定

昨天面试被问到这些，惭愧的很，居然搞混了，悔恨了一把。决定要彻底搞清楚。也算是有所收获。

首先说说构造函数，大家都知道构造函数里就可以调用成员变量，而继承中子类是把基类的成员变成自己的成员，那么也就是说子类在构造函数里就可以调用基类的成员了，这就说明创建子类的时候必须先调用基类的构造函数，只有这样子类才能在构造函数里使用基类的成员，所以是创建子类时先调用基类的构造函数然后再调用自己的构造函数。通俗点说，你要用某些物品，但这些物品你没办法自己生产，自然就要等别人生产出来，你才能拿来用。

接着就是析构函数了，上面说到子类是将基类的成员变成自己的成员，那么基类就会只存在子类中直到子类调用析构函数后。做个假设：假如在基类的析构函数调用比子类的先，这样会发生什么事呢?类成员终止了，而类本身却还在，但是在类存在的情况下，类成员就应该还存在的，这不就产生矛盾了吗?所以子类是调用自身的析构函数再调用基类的析构函数。

现在到了虚函数了，virtual主要作用是在多态方面，而C++的多态最主要的是类的动态绑定，动态绑定则是指将子类的指针或引用转换成基类对象，基类对象就可以动态判断调用哪个子类成员函数。这就说明在没有子类指针或引用转换为基类对象的话，virtual没有存在意义(纯虚函数除外)，也就是有没有virtual都是调用其自身的成员函数。通过这些分析，对于virtual就有了眉目了。当子类指针或引用转换为基类时，若基类中有用virtual定义的函数，被子类重写后，此基类对象就会根据子类调用子类中的重写后的函数，而不是基类中的函数;反之，若是基类中没有用virtual定义，则不管基类被赋值的是哪个子类的值，调用的都是基类的成员函数(当然指的是子类重载的基类函数，不然就算要调用子类特有的成员函数也会编译不过)。