神马文学网拷贝构造函数
来源：百度文库 编辑：神马文学网 时间：2024/04/29 20:27:45
在C++中，下面三种对象需要拷贝的情况。因此，拷贝构造函数将会被调用。
1)． 一个对象以值传递的方式传入函数体
2)． 一个对象以值传递的方式从函数返回
3)．一个对象需要通过另外一个对象进行初始化
以上的情况需要拷贝构造函数的调用。如果在前两种情况不使用拷贝构造函数的时候，就会导致一个指针指向已经被删除的内存空间。对于第三种情况来说，初始化和赋值的不同含义是构造函数调用的原因。事实上，拷贝构造函数是由普通构造函数和赋值操作赋共同实现的。描述拷贝构造函数和赋值运算符的异同的参考资料有很多。
拷贝构造函数不可以改变它所引用的对象，其原因如下：当一个对象以传递值的方式传一个函数的时候，拷贝构造函数自动的被调用来生成函数中的对象。如果一个对象是被传入自己的拷贝构造函数，它的拷贝构造函数将会被调用来拷贝这个对象这样复制才可以传入它自己的拷贝构造函数，这会导致无限循环。
除了当对象传入函数的时候被隐式调用以外，拷贝构造函数在对象被函数返回的时候也同样的被调用。换句话说，你从函数返回得到的只是对象的一份拷贝。但是同样的，拷贝构造函数被正确的调用了，你不必担心。
如果在类中没有显式的声明一个拷贝构造函数，那么，编译器会私下里为你制定一个函数来进行对象之间的位拷贝（bitwise copy）。这个隐含的拷贝构造函数简单的关联了所有的类成员。许多作者都会提及这个默认的拷贝构造函数。注意到这个隐式的拷贝构造函数和显式声明的拷贝构造函数的不同在于对于成员的关联方式。显式声明的拷贝构造函数关联的只是被实例化的类成员的缺省构造函数除非另外一个构造函数在类初始化或者在构造列表的时候被调用。
拷贝构造函数是程序更加有效率，因为它不用再构造一个对象的时候改变构造函数的参数列表。设计拷贝构造函数是一个良好的风格，即使是编译系统提供的帮助你申请内存默认拷贝构造函数。事实上，默认拷贝构造函数可以应付许多情况。
以下讨论中将用到的例子:
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; //删除原指针指向内容
pBuffer=NULL;
pBuffer=temp;
return *this
}
三、拷贝构造函数使用赋值运算符重载的代码。
CExample::CExample(const CExample& RightSides)
{
*this=RightSides
}
1－什么时候会用到拷贝构造函数？
当任何你想复印东西的时候，而不管东西被复印成什么样子。即任何你想利用一个已有的类实例给另一个类实例赋值时，这种赋值可能是显式的，也可能是隐式的
显式：classa_1=class_2;
隐式：函数的形参有用到类对象却没有用引用或传址技术时
函数的返回值是一个对象也没有应用传址技术时
2－什么时候有必要用拷贝构造函数？
上述3种情况，如果没有涉及到深拷贝问题，就没有必要自己来编写拷贝构造函数，编译器有默认的可以很完美的完成任务
还一种情况就是变态的拷贝：在拷内过程中进行缩放，放大等处理，不过没什么用
//关于深拷贝以下是引用：traceback:http://www.netology.cn/blog/user1/bachelor/archives/2006/375.html
关于深拷贝
如果一个类中含有指针成员变量，则在利用一个已存在对象构造新的对象时，就会面临两种选择：深拷贝和浅拷贝。
浅拷贝只是将对象间对应的指针成员变量进行简单的拷贝，即拷贝结束后新旧对象的指针指向相同的资源（指针的值是相同的）；这种拷贝会导致对象的成员不可用，如下例：
class Person
{
public :
//....
char * home;//the person's home
void SetHome(char * str)
{home = str;}
~Person()
{
//...
delete [] home;
}
}
//....
char * place = new char [20];
strcpy(place,"China");
Person *A = new Person();
A->SetHome(place);
Person * B= Person(A);
delete A;
//....
此时对象A 和对象B的成员home值相同,如果A对象 destroy，则对象B的成员home指向的地址变为不可用（对象A撤销时将home指向的资源释放了）。
深拷贝是相对于浅拷贝而言的，为了避免上述情况的发生，将上例中的代码改造：对象拷贝时将指针指向的内容拷贝，代码如下：
class Person
{
public :
//....
char * home;//the person's home
void SetHome(char * str)
{home = str;}
Person & Person(const Person & per)
{
//...
if(* this == per)//copy itself
return *this;
home = new char[strlen(per.home) +1];//alloc new memory
strcpy(home,per.home);
return * this;
}
~Person()
{
//...
delete [] home;
}
}
深拷贝之后，新旧对象的home成员指向的内容的值相同，而其自身的值不同。这样就可避免出现其中之一
destroy 之后，另一对象的home成员不可用。
但是，此种开辟新的内存区域然后赋值拷贝的方法在面临指针成员指向的数据量很大时出现效率低下的问题，因此又有下面的处理方法：为指针保留引用计数（reference counting）。
当类每次拷贝这个指针时，就增加它的计数；对象destroy时检察指针的引用计数，如果为0就删除其指向的资源，否则计数减小。如果指针所指数据相对恒定是，指针引用计数尤为有效。而且在数据量庞大的时候，可以有较高的执行效率。
类示例代码如下：
//一个引用计数器很容易作为一个类来完成
//用于带一个引用计数值得void指针的类
class VoidRefPtr
{
public:
//constructor allocates memory for data
VoidRefPtr(void * pData,int nSize)
{
ptr = malloc(nSize);
memcpy(ptr,pData,nSize);
nCount = 1;
}
//increment the reference count
VoidRefPtr * Ref()
{
nCount ++;
return this;
}
//decrement the count and delete if zero
void Derf()
{
if(!--nCount)
delete this;
}
~VoidRefPtr()
{
delete ptr
}
void * ptr()
{
return ptr
}
private:
void * ptr;//the data
unsigned int nCount;//the reference count
};
//这个类包含了一个实际的指针和用于对引用计数器自加自减的成员函数
//当引用计数器减到零时，对象撤销自身。
class RefcountCharPtr
{
public:
RefcountCharPtr(const char * pData ="")
{
//constructor creates a ref pointer
pRef = new VoidRefPtr((void *)pData,strlen(pData)+1);
}
RefcountCharPtr(const RefcountCharPtr &a)
{
//copy constructor increments ref count
pRef = a.pRef->Ref();
}
~RefcountCharPtr()
{
//destructor decrements ref count
pRef ->Derf();
}
const RefcountCharPtr & operator = (const RefcountCharPtr & a)
{
//asignment
//decrement ref count of existing pointer
pRef->Derf();
//increment that of assigned pointer
pRef = a.pRef->Ref();
return * this;
}
RefcountCharPtr & operator =(const char * pData)
{
//char string assignment
//decrement ref count of existing pointer
pRef->Derf();
//make new pointer
pRef = new VoidRefPtr((void *)pData,strlen(pData)+1);
return *this;
}
//type conversion to a char string
operator const char * ()
{
return (char * )pRef->ptr();
}
protected:
private:
VoidRefPtr * pRef;
};
一个同学给出了一个类似的实现：
class RefData
{
public:
RefData(char *s)
{
data = new String(s);
}
int refCount;
String *data;
};
class MyString
{
public:
MyString(const char *s = "");
//...
//...
private:
RefData * value; // 私有指针变量
};
MyString::MyString(const char *s = ""):value(new RefData(s))
{
}
MyString & MyString::operator=(const MyString & str)
{
if (value == str.value) //如果是自己复制给自己
return *this;
if (--(value->refCount) == 0)
delete value;
value = s.value; // 只拷贝指针
++(value->refCount);
return *this;
}
char & MyString::operator[](int dex) //改变值的时候
{
if (value->refCount >1)
{
--value->refCount;
value = new RefData(value->data)
}
return value->data[index];
}
//测试示例
int main()
{
MyString s1 ="hello";
char *p = &s1[1];
MyString s2 = s1;
*p = 'x';
}
虽然引用计数的处理方法貌似不错，但是其亦存在其弊端：在多线程的条件下，其执行效率尤为低下。具体参见（Herb Shutter的在C++ Report杂志中的Guru专栏以及整理后出版的《More Exceptional C++》中专门的讨论）。
最近在看设计模式的一些东东，偶然又发现了下面的一段：
下面是一些可以使用Proxy模式的常见情况：
...
4)智能指引（smart reference）--取代了简单的指针，它在访问对象时执行一些附加操作。它的典型用途包括：
对指向实际对象的引用计数，这样当该对象没有引用时，可以自动释放它（也称为 smartpointers[Ede92]）.
当第一次引用一个持久对象时，将它装入内存。
在访问一个实际对象前，检察是否已经锁定了它，以确保其他对象不能改变它。
以上的叙述的用途好像有些像引用计数，但是具体如何，现在偶还不是很清楚，准备将两者放在一起，看其联系和区别究竟如何。