注册 登录  
 加关注
查看详情
   显示下一条  |  关闭
温馨提示!由于新浪微博认证机制调整,您的新浪微博帐号绑定已过期,请重新绑定!立即重新绑定新浪微博》  |  关闭

天马行空

宠辱不惊,闲看庭前花开花落;去留无意,漫观天外云展云舒……

 
 
 

日志

 
 
 
 

拷贝构造函数(复制构造函数)和赋值操作符摘要  

2010-09-12 21:43:28|  分类: 程序设计 |  标签: |举报 |字号 订阅

  下载LOFTER 我的照片书  |

拷贝构造函数的参数类型必须是引用,而且通常情况下还是const的,但是const并不是严格必须的。

#include <iostream>

#include <string>

using namespace std;

class CClass

{

public:

         CClass() : a(1), b("Hello, world.")

         {

         }

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

         CClass(const CClass& c_class)

         {

                   a = c_class.a;

                   b = c_class.b;

         }

         void setValues(int a, string b)

         {

                   this->a = a;

                   this->b = b;

         }

         void printValues()

         {

                   cout << "a = " << a << endl;

                   cout << "b = " << b << endl;

         }

private:

         int a;

         string b;

};

int main(void)

{

         CClass c;

         c.setValues(100, "Hello, boys!");

         CClass d(c);              // 此处调用拷贝构造函数

         d.printValues();

         return 0;

}

如果将拷贝构造函数中的引用符号去掉&,编译将无法通过,出错的信息如下:

非法的复制构造函数第一个参数不应是“CClass

没有可用的复制构造函数或复制构造函数声明为“explicit

原因:

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

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

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

a.       显式或隐式地用同类型的一个对象来初始化另外一个对象。如上例中,用对象c初始化d

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

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

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

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

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

如果想阻止拷贝构造函数发生作用,那么一个类,必须显式声明其拷贝构造函数,并且将其设为private 并且其实现体是空的。因为仅仅是private的话,友元函数或者友元类还是有机会调用到这个拷贝构造函数。

通常情况下,如果一个类实现了拷贝构造函数,那么这个类也需要实现缺省构造函数。

重点:包含动态分配成员的类 应提供拷贝构造函数,并重载"="赋值操作符。

以下讨论中将用到的例子:

class CExample
{
public:
	CExample(){pBuffer=NULL; nSize=0;}
	~CExample(){delete pBuffer;}
	void Init(int n){ pBuffer=new char[n]; nSize=n;}
private:
	char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
	int nSize;
};

这个类的主要特点是包含指向其他资源的指针。

pBuffer指向堆中分配的一段内存空间。

一、拷贝构造函数

int main(int argc, char* argv[])
{
	CExample theObjone;
	theObjone.Init40);
	
	//现在需要另一个对象,需要将他初始化称对象一的状态
	CExample theObjtwo=theObjone;
	...
}

语句"CExample theObjtwo=theObjone;"用theObjone初始化theObjtwo。

其完成方式是内存拷贝,复制所有成员的值。

完成后,theObjtwo.pBuffer==theObjone.pBuffer。

即它们将指向同样的地方,指针虽然复制了,但所指向的空间并没有复制,而是由两个对象共用了。这样不符合要求,对象之间不独立了,并为空间的删除带来隐患。

所以需要采用必要的手段来避免此类情况。

回顾以下此语句的具体过程:首先建立对象theObjtwo,并调用其构造函数,然后成员被拷贝。

可以在构造函数中添加操作来解决指针成员的问题。

所以C++语法中除了提供缺省形式的构造函数外,还规范了另一种特殊的构造函数:拷贝构造函数,上面的语句中,如果类中定义了拷贝构造函数,这对象建立时,调用的将是拷贝构造函数,在拷贝构造函数中,可以根据传入的变量,复制指针所指向的资源。

拷贝构造函数的格式为:构造函数名(对象的引用)

提供了拷贝构造函数后的CExample类定义为:

class CExample
{
public:
	CExample(){pBuffer=NULL; nSize=0;}
	~CExample(){delete pBuffer;}
	CExample(const CExample&); //拷贝构造函数
	void Init(int n){ pBuffer=new char[n]; nSize=n;}
private:
	char *pBuffer; //类的对象中包含指针,指向动态分配的内存资源
	int nSize;
};

CExample::CExample(const CExample& RightSides) //拷贝构造函数的定义
{
	nSize=RightSides.nSize; //复制常规成员
	pBuffer=new char[nSize]; //复制指针指向的内容
	memcpy(pBuffer,RightSides.pBuffer,nSize*sizeof(char));
}

这样,定义新对象,并用已有对象初始化新对象时,CExample(const CExample& RightSides)将被调用,而已有对象用别名RightSides传给构造函数,以用来作复制。

原则上,应该为所有包含动态分配成员的类都提供拷贝构造函数。

拷贝构造函数的另一种调用。

当对象直接作为参数传给函数时,函数将建立对象的临时拷贝,这个拷贝过程也将调同拷贝构造函数。

例如

BOOL testfunc(CExample obj);

testfunc(theObjone); //对象直接作为参数。

BOOL testfunc(CExample obj)
{
	//针对obj的操作实际上是针对复制后的临时拷贝进行的
}

还有一种情况,也是与临时对象有关的

当函数中的局部对象被被返回给函数调者时,也将建立此局部对象的一个临时拷贝,拷贝构造函数也将被调用

CTest func()
{
	CTest theTest;
	return theTest
}

二、赋值符的重载

下面的代码与上例相似

int main(int argc, char* argv[])
{
	CExample theObjone;
	theObjone.Init(40);
	
	CExample theObjthree;
	theObjthree.Init(60);

	//现在需要一个对象赋值操作,被赋值对象的原内容被清除,并用右边对象的内容填充。
	theObjthree=theObjone;
	return 0;
}

也用到了"="号,但与"一、"中的例子并不同,"一、"的例子中,"="在对象声明语句中,表示初始化。更多时候,这种初始化也可用括号表示。

例如 CExample theObjone(theObjtwo);

而本例子中,"="表示赋值操作。将对象theObjone的内容复制到对象theObjthree;,这其中涉及到对象theObjthree原有内容的丢弃,新内容的复制。

但"="的缺省操作只是将成员变量的值相应复制。旧的值被自然丢弃。

由于对象内包含指针,将造成不良后果:指针的值被丢弃了,但指针指向的内容并未释放。指针的值被复制了,但指针所指内容并未复制。

因此,包含动态分配成员的类除提供拷贝构造函数外,还应该考虑重载"="赋值操作符号。

类定义变为:

class CExample
{
	...
	CExample(const CExample&); //拷贝构造函数
	CExample& operator = (const CExample&); //赋值符重载
	...
};

//赋值操作符重载
CExample & CExample::operator = (const CExample& RightSides)
{
	nSize=RightSides.nSize; //复制常规成员
	char *temp=new char[nSize]; //复制指针指向的内容 
	memcpy(temp,RightSides.pBuffer,nSize*sizeof(char));

	delete []pBuffer; //删除原指针指向内容  (将删除操作放在后面,避免X=X特殊情况下,内容的丢失)
	pBuffer=temp;   //建立新指向
	return *this
}

三、拷贝构造函数使用赋值运算符重载的代码。

CExample::CExample(const CExample& RightSides)
{
	pBuffer=NULL;
	*this=RightSides	 //调用重载后的"="
}

一 拷贝构造函数是C++最基础的概念之一,大家自认为对拷贝构造函数了解么?请大家先回答一下三个问题:

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

  1. X::X(const X&);   
  2. X::X(X);   
  3. X::X(X&, int a=1);   
  4. X::X(X&, int a=1, b=2);  

 2. 一个类中可以存在多于一个的拷贝构造函数吗?

3. 写出以下程序段的输出结果, 并说明为什么? 如果你都能回答无误的话,那么你已经对拷贝构造函数有了相当的了解。

  1. #include    
  2. #include    
  3.   
  4. struct X {   
  5.   template<typename T>   
  6.   X( T& ) { std::cout << "This is ctor." << std::endl; }   
  7.   
  8.   template<typename T>   
  9.     X& operator=( T& ) { std::cout << "This is ctor." << std::endl; }   
  10. };   
  11.   
  12. void main() {   
  13.   X a(5);   
  14.   X b(10.5);   
  15.   X c = a;   
  16.   c = b;   
  17. }  

 

解答如下:

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

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

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

  1. class X {      
  2. public:      
  3.   X(const X&);      
  4.   X(X&);            // OK   
  5. };  

注意,如果一个类中只存在一个参数为X&的拷贝构造函数,那么就不能使用const X或volatile X的对象实行拷贝初始化.

  1. class X {   
  2. public:   
  3.   X();   
  4.   X(X&);   
  5. };   
  6.     
  7. const X cx;   
  8. X x = cx;    // error   

如果一个类中没有定义拷贝构造函数,那么编译器会自动产生一个默认的拷贝构造函数.
这个默认的参数可能为X::X(const X&)或X::X(X&),由编译器根据上下文决定选择哪一个.

默认拷贝构造函数的行为如下:
 默认的拷贝构造函数执行的顺序与其他用户定义的构造函数相同,执行先父类后子类的构造.
 拷贝构造函数对类中每一个数据成员执行成员拷贝(memberwise Copy)的动作.
 a)如果数据成员为某一个类的实例,那么调用此类的拷贝构造函数.
 b)如果数据成员是一个数组,对数组的每一个执行按位拷贝.
 c)如果数据成员是一个数量,如int,double,那么调用系统内建的赋值运算符对其进行赋值.

 

3.  拷贝构造函数不能由成员函数模版生成. 

  1. struct X {   
  2.     template<typename T>   
  3.     X( const T& );    // NOT copy ctor, T can't be X   
  4.   
  5.     template<typename T>   
  6.     operator=( const T& );  // NOT copy ass't, T can't be X   
  7. };   
  8.   

原因很简单, 成员函数模版并不改变语言的规则,而语言的规则说,如果程序需要一个拷贝构造函数而你没有声明它,那么编译器会为你自动生成一个. 所以成员函数模版并不会阻止编译器生成拷贝构造函数, 赋值运算符重载也遵循同样的规则.(参见Effective C++ 3edition, Item45)


二 针对上面作者的讨论,理解更深了,但是下面我还是会给出一个一般的标准的实现和注意事项:
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空#include "stdafx.h"
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空#include 
"stdio.h"
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空#include 
<iostream>
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空#include 
<string>
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
struct Test1 
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
{
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test1() 
{ }
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test1(
int i) { id = i; }
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test1(
const Test1& test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
{
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        id 
= test.id;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    }

拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test1
& operator = (const Test1& test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
{
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
if(this == &test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空            
return *this;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        id 
= test.id;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
return *this;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    }

拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
int id;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空}
;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
class Test2
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
{
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
public:
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2()
{ m_pChar = NULL;}
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2(
char *pChar) { m_pChar = pChar;}
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2(
int num) 
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    

拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        m_pChar 
= new char[num];
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
for(int i = 0; i< num; ++i)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空            m_pChar[i] 
= 'a';
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        m_pChar[num
-1= '\0';
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    }

拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2(
const Test2& test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
{
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
char *pCharT = m_pChar;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        m_pChar 
= new char[strlen(test.m_pChar)];
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        strcpy(m_pChar, test.m_pChar);
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
if(!pCharT)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空            delete []pCharT;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    }

拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2
& operator = (const Test2& test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
{
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
if(this == &test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空            
return *this;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
char *pCharT = m_pChar;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        m_pChar 
= new char[strlen(test.m_pChar)];
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        strcpy(m_pChar, test.m_pChar);
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
if(!pCharT)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空            delete []pCharT;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空        
return *this;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    }

拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
private:
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
char *m_pChar;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空}
;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
int main(int argc, char* argv[])
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
{
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
const Test1 ts(1); // Test1()
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
    const Test1* p_ts = &ts;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
const Test1 ts2(ts); //Test(const Test1& test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
    const Test1 ts3 = ts; //Test(const Test1& test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空
    Test1 ts4; ts4 = ts;  //Test1& operator = (const Test1& test)
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空

拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2 t(
5);
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2 t2(t);
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2 t3 
= t2;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    Test2 t4; t4 
= t;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空    
return 0;
拷贝构造函数(复制构造函数)和赋值操作符摘要 - 547502462 - 天马行空}
以上内容均为摘录,并做笔记用,如有版权问题,请通知,谢谢!

  评论这张
 
阅读(604)| 评论(0)
推荐 转载

历史上的今天

在LOFTER的更多文章

评论

<#--最新日志,群博日志--> <#--推荐日志--> <#--引用记录--> <#--博主推荐--> <#--随机阅读--> <#--首页推荐--> <#--历史上的今天--> <#--被推荐日志--> <#--上一篇,下一篇--> <#-- 热度 --> <#-- 网易新闻广告 --> <#--右边模块结构--> <#--评论模块结构--> <#--引用模块结构--> <#--博主发起的投票-->
 
 
 
 
 
 
 
 
 
 
 
 
 
 

页脚

网易公司版权所有 ©1997-2018