(完整版)拷贝构造函数

拷贝构造函数
拷贝构造函数的参数⼀定要是本类对象的引⽤，为什么？原因在待会说
拷贝构造函数的调⽤时机：
1）在定义对象时⽤本类对象初始化新定义的对象
2）本类对象作为函数参数时，调⽤函数时，实参对象会对形参进⾏初始化，那么就需要调⽤拷贝构造函数。

（这也是为什么拷贝构造函数参数必须是本类对象的引⽤，因为如果形参时本类对象，那么在调⽤拷贝构造函数时，实参对形参赋值时⼜会调⽤拷贝构造函数，出现递归调⽤拷贝构造函数，并且⼀直递归下去）
3）本类对象作为函数返回值，返回时创建⼀个临时对象，⽤返回的对象初始化临时对象，会调⽤拷贝构造函数。

然后临时对象赋值给主函数中的对象，接着会析构临时对象（调⽤析构函数）。

拷贝构造函数显式定义时机：
当类的构造函数中有动态申请的空间时，需要显式定义⼀个拷贝构造函数，实现“深拷贝”，即对新对象重新申请同样⼤⼩的动态存储空间，并把已知对象的动态存储空间的内容复制到新对象的动态存储空间。

因为当类的数据成员中有动态申请的数据空间，如果不定义拷贝构造函数，⽽使⽤类中默认的拷贝构造函数，对象会进⾏“浅拷贝”，拷贝后，即两个对象的指针会指向同⼀个内存空间，最后在析构对象时，会对同⼀个内存空间析构两次，出现运⾏错误。

第三章（6）拷贝构造函数⼀、拷贝构造函数：对于普通类型的对象来说，他们之间的复制是很简单的，例如：int a = 10;int b =a;⾃⼰定义的类的对象同样是对象，他们之间的特性有相似之处也有不同之处，类对象内部存在成员变量，⽽普通对象是没有的，当同样的复制⽅法发⽣在不同的对象上的时候，那么系统对他们进⾏的操作也是不⼀样的，就类对象⽽⾔，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。

当⽤⼀个已有的对象初始化另⼀个对象时编译器⾃动调⽤拷贝构造函数。

拷贝构造函数只发⽣在初始化阶段。

⼆、⽰例⽰例1：#include <iostream.h>#include <string.h>class Student{public:Student(char* pName="no name",int ssId=0);Student(Student& s); //拷贝构造函数~Student();protected:char name[40];int id;};Student::Student(char* pName, int ssId){strncpy(name,pName,40);name[39]='\0';id = ssId;cout <<"Constructing new student " <<pName <<endl;}Student::Student(Student& s) //拷贝构造函数{cout <<"Constructing copy of " << <<endl;strcpy(name,"copy of ");strcat(name,);id=s.id;}Student::~Student(){cout <<"Destructing " <<name <<endl;}void fn(Student s){cout <<"In function fn()\n";}void main(){Student randy("Randy",1234);cout <<"Calling fn()\n";fn(randy);cout <<"Returned from fn()\n";}分析：上⾯代码中的Student::Student(Student& s)；就是我们⾃定义的拷贝构造函数，拷贝构造函数的名称必须与类名称⼀致，函数的形式参数是本类型的⼀个引⽤变量,且必须是引⽤。

c++拷贝构造函数（重点在内含指针的浅拷贝和深拷贝）今天同事问了⼀个关于拷贝构造函数的问题，类中包含指针的情况，今天就来说说c++的拷贝构造函数。

c++的拷贝构造函数是构造函数的⼀种，是对类对象的初始化，拷贝构造函数只有⼀个参数就是本类的引⽤。

注意，默认构造函数（即⽆参构造函数）不⼀定存在，但是拷贝构造函数总是会存在。

下⾯是⼀个拷贝构造函数的例⼦。

1 #include<iostream>2using namespace std;3class A{4public:5int a;6 A(int value){7 a = value;8 }9void show(){10 cout<<a<<endl;11 }12 };13int main(){14 A test_a(10);15 test_a.show();1617 A test_b(test_a);18 test_b.show();1920return0;21 }输出结果为：1010如果编写了拷贝构造函数，则默认拷贝构造函数就不存在了。

下⾯是⼀个⾮默认拷贝构造函数的例⼦。

1 #include<iostream>2using namespace std;3class A{4public:5int a;6 A(int value){7 a = value;8 }9 A(A& tmp){10 a = tmp.a;11 cout<<"call copy construct"<<endl;12 }13void show(){14 cout<<a<<endl;15 }16 };17int main(){18 A test_a(10);19 test_a.show();2021 A test_b(test_a);22 test_b.show();2324return0;25 }输出结果为：10call copy construct10拷贝构造函数在以下三种情况下会被调⽤。

c++ 复制构造函数拷贝构造函数C++复制构造函数，也被称为拷贝构造函数，在对象被复制时被调用。

它用于将一个对象的值传递给另一个对象，以便它们具有相同的值，但是在不同的内存位置。

复制构造函数是由编译器自动生成的，但是也可以手动编写。

如果没有手动编写复制构造函数，C++编译器会自动生成一个默认的复制构造函数，该函数执行逐个复制对象的每个成员变量。

但是，如果类中有指针、动态内存分配或其他资源，可能需要手动编写复制构造函数。

否则，在复制对象时，新对象和旧对象将共享指针和资源，从而导致不可预测的结果。

使用以下格式定义复制构造函数：类名（const 类名& 对象名）{// 复制构造函数的代码}其中，const类名&对象名表示传递的参数是一个常量引用，因为不会对该对象进行修改。

使用复制构造函数的示例：#include<iostream>using namespace std;class Person{public:int age;string name;//构造函数Person(int a, string n){age=a;name=n;}//复制构造函数Person(const Person &p){age=p.age;name=;}};int main(){//创建对象p1Person p1(20,'Tom');//将p1的值复制给p2Person p2=p1;//输出p2的值cout<<p2.age<<' '<<<<endl;return 0;}上述示例中，当p1的值复制给p2时，复制构造函数被调用，将p1的值复制到p2中。

最后，输出p2的值，以验证复制构造函数的正确性。

总之，复制构造函数是C++中一个重要的概念，用于在对象被复制时保持对象的数据完整性和相对独立性。

•如果将与自己同类的对象的引用作为参数时，该构造函数就称为拷贝构造函数。

•拷贝构造函数的特点：–首先，它是一个构造函数，当创建对象时系统会自动调用它。

–其次，它将一个已经创建好的对象作为参数，根据需要将该对象中的数据成员逐一对应地赋值给新对象。

void main(){Point obj1( 5, 15);Point obj2(obj1);Point obj3=obj2;}//调用Point(float , float )//调用Point(Point&)//调用Point(Point&)class Point{private: float x, y;public:Point(float a, float b){x=a; y=b;}Point(Point &obj){x=obj.x;y=obj.y;}};•如果没有定义拷贝构造函数，那么编译器会为该类产生一个缺省的拷贝构造函数。

•缺省的拷贝构造函数使用位拷贝的方法来完成对象到对象的复制。

Bit Copya_obj b_obj将第一个对象中的数据成员的值原封不class Point{private: float x, y;public:Point(float a, float b){x=a; y=b;}};void main(){Point obj1( 5, 15); //调用A(float, float)Point obj2(obj1); //调用缺省的拷贝构造函数Point obj3=obj2; //调用缺省的拷贝构造函数}缺省的拷贝构造函数的缺点•在大多数情况下，缺省拷贝构造函数工作得很好，但在一些特殊的场合，它的表现将不尽人意。

class CString{private:int len;char *buf;public:CString(int n);~CString( );void copy(char *src); };CString::CString( int n){len=n;buf=new char[n];}void CString::copy(char *src){strcpy(buf,src);}CString::~CString( ){delete [ ]buf;}void func(){CString obj1( 64 );obj1.copy(“helloworld”);CString obj2=obj1;}void main(){func( );由于调用的是默认的拷贝构造函数，因此obj1和obj2中的buf指向同一内存空间，当它们被释放时，该内存空间将被释放两次class CString{public:CString(int n);CString(CString&obj);……};CString::CString(CString&obj) {len= obj.len;buf=new char[ len];strcpy( buf, obj.buf);}拷贝构造函数起作用的地方•拷贝构造函数除了在创建新对象时被调用外，还在以下情况被调用：–对象作为函数参数–函数返回对象class Counter{private:int value;public:Counter(int v){value=v;}void add(int v){value+=v;}void show( ){cout<<value<<endl;}};Counter func(Counter obj) {obj.add(6);return obj;}void main( ){Counter b1=5;Counter b2=func(b1);b1.show();b2.show();}•调用func(b1)时调用默认的拷贝构造函数•调用return obj 时调用默认的拷贝构造函数•将func()返回值赋给b2时调用默认的拷贝构造函数b2=func(b1)5b111temp 11b25(11)obj func(b1)return obj。

C++拷贝构造函数和赋值构造函数转⾃：⼀、拷贝构造函数int main(int argc, char * argv[]){CExample A;A.Init40);CExample B=A; //把B初始化为A的副本...}B = A ; 此语句的具体过程:⾸先建⽴对象theObjtwo，并调⽤其构造函数，然后成员被拷贝。

语句"CExample B=A;" ⽤ A 初始化 B。

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

完成后，A.pBuffer = B.pBuffer, 即它们将指向同样的地⽅，指针虽然复制了，但所指向的空间并没有复制，⽽是由两个对象共⽤了。

这样不符合要求，对象之间不独⽴了，并为空间的删除带来隐患。

所以需要采⽤必要的⼿段(拷贝构造函数)来避免此类情况。

拷贝构造函数的格式为 : 构造函数名(对象的引⽤) 提供了拷贝构造函数后的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 B=A; ” 时，CExample(const CExample& RightSides)将被调⽤，⽽已有对象⽤别名RightSides传给构造函数，以⽤来作复制。

拷贝构造函数默认拷贝构造函数拷贝构造函数调用几种情况一、拷贝构造函数如果类中没有说明拷贝构造函数，则系统自动生成一个缺省复制构造函数，作为该类的公有成员也可以进行自定义拷贝构造函数自定义拷贝构造函数的例子：Test::Test(const Test& other) : num_(other.num_){//num_ = other.num_;cout<<"Initializing with other "<<num_<<endl;< p="">}//尽量将变量或者是对象的初始化动作写在初始化列表里面现在有一个类T，先创建了一个对象t1，然后又创建了一个对象t2，创建t2的方法如下T t2 = t1;这时就相当于T t2 = T(t1);要是没有创建默认的拷贝构造函数的话则执行系统默认的拷贝构造函数，【这与前面讲解的有一个参数的构造函数进行初始化的情形是一样的】在这里要定义拷贝构造函数的时候需要注意的是拷贝构造函数要传递的参数上面可以看出来是将一个同类型的对象传递过来了，因此在接受的时候要用一个对象或者是引用要是这里对象来接，那么就出现了用传递过来的对象来初始化对象，这又涉及到了用对象来初始化对象，这样的话有需要调用拷贝构造函数，调用之后又要进行拷贝，这样递归下去无法完结因此在此处要使用引用来传递参数，无需拷贝对象二、使用拷贝构造函数的几种情况1、将对象作为参数进行传递的时候，要是参数是引用类型的则不需要，要是参数是这个类的一个对象，则这时就需要调用拷贝构造函数进行拷贝2、要是将函数返回值的类型定义为类的对象的话，这时就要使用拷贝构造函数将返回值进行拷贝，然后将临时对象传递给main函数中接受的对象，要是在这时将返回值传递给一个还没有创建的对象的话，也就是说要使用返回类型进行初始化的话，这是就不会调用析构函数将这个临时的对象进行销毁，只会将这个临时对象的名字改成是要初始化的对象的名字具体的实现例子如下所示：Test TestFun4(const Test& t){return t;}Test t2 = TestFun4(t);这时就不会将返回创建的临时对象进行销毁。

拷贝构造函数复制构造函数（原创版）目录1.拷贝构造函数和复制构造函数的定义2.拷贝构造函数和复制构造函数的区别3.拷贝构造函数和复制构造函数的应用场景正文在 C++编程语言中，拷贝构造函数和复制构造函数是两个重要的构造函数类型，它们分别用于实现对象之间的拷贝和复制操作。

下面，我们将详细介绍这两个构造函数的定义、区别以及应用场景。

拷贝构造函数是一种特殊的构造函数，它的主要作用是创建一个新对象，并将已存在对象的数据成员拷贝到新对象中。

拷贝构造函数的参数是一个同类对象的引用。

通过拷贝构造函数，我们可以实现对象之间的拷贝操作，从而简化代码的编写。

复制构造函数与拷贝构造函数类似，也是一种特殊的构造函数。

不过，它主要用于实现对象之间的复制操作。

复制构造函数的参数是一个同类对象的常量引用。

通过复制构造函数，我们可以在创建新对象时，将已存在对象的数据成员复制到新对象中。

虽然拷贝构造函数和复制构造函数都用于实现对象之间的拷贝和复制操作，但它们之间仍存在一定的区别。

首先，拷贝构造函数的参数是一个同类对象的引用，而复制构造函数的参数是一个同类对象的常量引用。

其次，拷贝构造函数用于创建新对象并拷贝数据成员，而复制构造函数用于在创建新对象时复制数据成员。

在实际编程中，拷贝构造函数和复制构造函数有着广泛的应用。

当我们需要根据已存在对象创建一个新对象，并使新对象的数据成员与原对象相同时，可以使用拷贝构造函数。

而当我们需要在创建新对象时复制已存在对象的数据成员时，可以使用复制构造函数。

总之，拷贝构造函数和复制构造函数是 C++编程语言中重要的构造函数类型，它们分别用于实现对象之间的拷贝和复制操作。

C++中的拷贝构造函数与参数指针相关1. 拷贝构造函数的介绍拷贝构造函数是C++中的一种特殊构造函数，它用于在创建对象时，通过使用同一类的另一个对象来初始化新创建的对象。

拷贝构造函数的函数原型如下：```cppclass_name (const class_name obj)```其中，class_name为类名，obj为同一类的另一个对象。

在使用拷贝构造函数时，会将obj中的数据成员的值分别复制到新对象的对应数据成员中。

2. 参数指针的使用在C++中，指针是一种特殊的数据类型，它存储了变量的位置区域。

当我们需要在函数中传递大量数据时，使用指针作为参数可以减少内存的占用和提高函数的执行效率。

在函数参数中使用指针时，我们可以通过操作指针来改变实参的值，从而达到在函数外部改变变量的效果。

3. 拷贝构造函数中的参数指针在C++中，拷贝构造函数也可以接受参数指针作为参数，这种情况通常发生在需要拷贝动态分配内存的对象时。

通过使用参数指针，在拷贝构造函数中可以正确地复制动态分配的内存，而不是简单地复制指针本身。

4. 实例分析下面通过一个简单的例子来说明拷贝构造函数中参数指针的使用：```cpp#include <iostream>using namespace std;class Test {private:int *ptr;public:Test(int i) {ptr = new int(i);}Test(const Test obj) {ptr = new int(*obj.ptr);}void show() {cout << "The value of ptr is: " << *ptr << endl;}};int main() {Test obj1(10);Test obj2 = obj1; // 调用拷贝构造函数obj1.show();obj2.show();return 0;}```在上面的例子中，我们定义了一个类Test，其中包含了一个int型的指针ptr。

c++类的拷贝构造函数C++中的拷贝构造函数是一种特殊类型的构造函数，其作用是在创建对象时，将已经存在的一个对象中的数据成员复制到另一个对象中，通常用于对象间的赋值或传递对象参数。

本文将总结C++中的拷贝构造函数的语法及使用方式，以及相关的注意事项。

```class ClassName{public:ClassName(const ClassName &obj); // 拷贝构造函数};```上述代码中，`ClassName`是类名，`&obj`表示需要拷贝的另一个对象。

在函数体中，通常将需要拷贝的对象的数据成员一一复制到新对象中。

拷贝构造函数通常用于三个场景：1. 对象间赋值```class Student {public:Student(int id, string name);Student(const Student &obj); // 拷贝构造函数private:int id_;string name_;};```如果我们现在定义了一个名为`stu1`的`Student`对象，并将它的值复制给另一个名为`stu2`的`Student`对象：```Student stu1(1, "Tom");Student stu2 = stu1; // 调用拷贝构造函数进行复制```那么，在执行`Student stu2 = stu1`这行代码的时候，会调用拷贝构造函数将`stu1`的数据成员拷贝到`stu2`中。

2. 传递对象参数当我们将一个类的对象作为实参传递给一个函数时，通常是将这个对象的值复制一份作为函数的形参。

这样，在函数内部对形参对象的修改不会影响到实参原有的值。

上述代码中，在调用`print`函数时，拷贝构造函数会被自动调用，将`stu`对象的值复制给`obj`形参。

在函数内部，对`obj`对象的修改不会影响到`stu`对象的值。

3. 返回对象1. 可以定义多个拷贝构造函数如果一个类存在多个类型的构造函数，那么也可以为每一种类型的构造函数定义一个对应的拷贝构造函数，使得在创建对象时可以同时传入不同的值。