拷贝构造函数和赋值函数


C++ 中,赋值和拷贝是不同的,

1)拷贝构造函数是对未初始化的内存进行初始化操作

2)而赋值是对现有的已经初始化的对象进行操作。(这里我对“已经初始化”的理解是已经调用了构造函数,并且构造函数体可以未执行,只要调用到即可),赋值函数应该给所有数据成员都初始化。

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

4)可以说,C++中什么时候有临时对象产生,此时刻c++一定要调用拷贝构造函数。(临时对象产生时有一个特例,此时不需要调用拷贝构造函数,例如类A,A a=1000;)

5)理解了拷贝构造函数和赋值函数的作用,相信他们两个的函数体一定会写了。

1.按值拷贝和按位拷贝

了便于说明我们以String类为例:

首先定义String类,而并不实现其成员函数。

1.    Class String{

2.    public:

3.        String(const char *ch=NULL);//默认构造函数

4.        String(const String &str);//拷贝构造函数

5.       ~String(void);

6.       String &operator=(const String &str);//赋值函数

7.    private:

8.       char *m_data;

9.    };

位拷贝拷贝的是地址,而值拷贝则拷贝的是内容。如果定义两个String对象A和B。A.m_data和B.m_data分别指向一段区域,A.m_data=”windows”,B.m_data=“linux”;

如果未重写赋值函数,将B赋给A;则编译器会默认进行位拷贝,A.m_data=B.m_data

则A.m_data和B.m_data指向同一块区域,虽然A.m_data指向的内容会改变成”linux”,但是这样容易出现这些问题:

(1):A.m_data原来指向的内存区域未释放,造成内存泄露。

(2):A.m_data和B.m_data指向同一块区域,任何一方改变都会影响另一方

(3):当对象被析构时,B.m_data被释放两次。

对于编译器,如果不主动编写拷贝函数和赋值函数,它会以“位拷贝”的方式自动生成缺省的函数。

如果重写赋值函数和拷贝构造函数后,

A.m_data=B.m_data,进行的是值拷贝,会将B.m_data的内容赋给A.m_data,A.m_data还是指向原来的内存区域,但是其内容改变。

2. 赋值构造函数的作用

每个类只有一个析构函数,但可以有多个构造函数(包含一个拷贝构造函数,其它的称为普通构造函数)和多个赋值函数(除了同类的赋值以外,还有其他的赋值方法)。对于任意一个类A,如果不想编写上述函数,C++编译器将自动为A产生四个缺省的函数,如

A(void);                    // 缺省的无参数构造函数

A(const A &a);              // 缺省的拷贝构造函数

~A(void);                   // 缺省的析构函数

A & operate =(const A &a);  // 缺省的赋值函数

有几个需要注意的内容:

1). 构造函数与析构函数的另一个特别之处是没有返回值类型

2). 构造从类层次的最顶层的基类开始,在每一层中,首先调用基类的构造函数,然后调用成员对象的构造函数。析构则严格按照与构造相反的次序执行,在析构的时候,最低层的派生类的析构函数最开始被调用,然后调用每个基类的析构函数。

3). “缺省的拷贝构造函数”和“缺省的赋值函数”均采用“位拷贝”而非“值拷贝”的方式来实现,倘若类中含有指针变量,这两个函数注定将出错

   在
C++ 中,赋值和拷贝是不同的,

    1)拷贝构造函数是对未初始化的内存进行初始化操作

    2)而赋值是对现有的已经初始化的对象进行操作。(这里我对“已经初始化”的理解是已经调用了构造函数,并且构造函数体可以未执行,只要调用到即可)

5.关于拷贝构造函数和赋值运算符

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

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

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指向堆中分配的一段内存空间。

1)、拷贝构造函数

当用已有的一个对象去初始化另外一个对象的时候。

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传给构造函数,以用来作复制。

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

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

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

例如

BOOL testfunc(CExample obj);

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

BOOL testfunc(CExample obj)

{

//针对obj的操作实际上是针对复制后的临时拷贝进行的

}

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

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

CTest func()

{

CTest theTest;

return theTest

}

4)赋值符的重载

下面的代码与上例相似

int main(int argc, char* argv[])

{

CExample theObjone;

theObjone.Init(40);

CExample theObjthree;

theObjthree.Init(60);

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

theObjthree=theObjone;

return 0;

}

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

    例如 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

}

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

CExample::CExample(const CExample& RightSides)

{

pBuffer=NULL;

*this=RightSides  //调用重载后的"="

}

CExample& operator = (const CExample& instance)

{

if(this == &instance)  {

return *this;

}

nSize= instance.nSize;

if(NULL != pBuffer) {

delete [] pBuffer;

}

pBuffer = new char[nSize];

if(NULL != pBuffer)  {

strncpy(pBuffer , instance.pBuffer , nSize);

}

return *this;

}

1,char temp=new char[nSize]; //复制指针指向的内容

char* temp = new char[nSize];

2,delete pBuffer;

delete[] pBuffer;

拷贝构造函数和赋值函数,布布扣,bubuko.com

时间: 2024-10-12 11:51:48

拷贝构造函数和赋值函数的相关文章

C++中拷贝构造函数和赋值函数被调用的时机

一.拷贝构造函数被调用的时机: 1. 当用类的一个对象去初始化该类的另一个对象(或引用)时系统自动调用拷贝构造函数实现拷贝赋值. 2. 若函数的形参为类对象,调用函数时,实参赋值给形参,系统自动调用拷贝构造函数. 3. 当函数的返回值是类对象时,系统自动调用拷贝构造函数. 二.赋值函数被调用的时机: 当用一个对象赋值给另一个对象时 注意一.二中初始化和赋值的区别 C++中拷贝构造函数和赋值函数被调用的时机,布布扣,bubuko.com

拷贝构造函数和赋值函数的一些知识

/*******************拷贝构造函数和赋值运算符重载有以下两个不同之处***************************/ 1.拷贝构造函数生成新的类对象,而赋值运算符不能. 2.由于拷贝构造函数是直接构造一个新的类对象,所以在初始化这个对象之前不用检验源对象是否和新对象相同,而复制操作符需要这个操作,另外赋值运算符中如果原来对象中有内存分配,要先把内存释放掉. 下面是String类的一个实现的部分函数,可以看出二者的区别. 1 class String{ 2 public:

C++中:默认构造函数、析构函数、拷贝构造函数和赋值函数——转

对于一个空类,编译器默认产生4个成员函数:默认构造函数.析构函数.拷贝构造函数和赋值函数.1.构造函数:构造函数是一种特殊的类成员,是当创建一个类的时候,它被调用来对类的数据成员进行初始化和分配内存.构造函数的命名必须和类名完全相同,构造函数可以被重载,可以多个,可以带参数. eg: class A { public: A(){cout<<"无参构造函数";} A(int i){cout<<"带参构造函数";} }; A();//调用默认构造

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

由于并非所有的对象都会使用拷贝构造函数和赋值函数,程序员可能对这两个函数 有些轻视.请先记住以下的警告,在阅读正文时就会多心: 本章开头讲过,如果不主动编写拷贝构造函数和赋值函数,编译器将以"位拷贝" 的方式自动生成缺省的函数.倘若类中含有指针变量,那么这两个缺省的函数就隐 含了错误.以类 String 的两个对象 a,b 为例,假设 a.m_data 的内容为"hello", b.m_data 的内容为"world". 现将 a 赋给 b,缺省

CPP_类默认函数:构造函数,拷贝构造函数,赋值函数和析构函数

类默认函数:构造函数,拷贝构造函数,赋值函数和析构函数 class Person{ public : Person():age(10), name(NULL); Person(int myage, char *myname); Person(const Person &a); ~Person(void); void set_age(int myage); void get_age(void); void set_other_age(Person &a, int b); private: i

C++ 拷贝构造函数与赋值函数的区别(很严谨和全面)

这里我们用类String 来介绍这两个函数: 拷贝构造函数是一种特殊构造函数,具有单个形参,该形参(常用const修饰)是对该类类型的引用.当定义一个新对象并用一个同类型的对象对它进行初始化时,将显式使用拷贝构造函数.为啥形参必须是对该类型的引用呢?试想一下,假如形参是该类的一个实例,由于是传值参数,我们把形参复制到实参会调用拷贝构造函数,如果允许拷贝构造函数传值,就会在拷贝构造函数内调用拷贝构造函数,从而形成无休止的递归调用导致栈溢出. 赋值函数,也是赋值操作符重载,因为赋值必须作为类成员,那

拷贝构造函数与赋值函数的区别

1.从概念上区分:复制构造函数是构造函数,而赋值操作符属于操作符重载范畴,它通常是类的成员函数 2.从原型上来区分:复制构造函数原型ClassType(const ClassType &);无返回值赋值操作符原型ClassType& operator=(const ClassType &);返回值为ClassType的引用,便于连续赋值操作 3.从使用的场合来区分:复制构造函数用于产生对象,它用于以下几个地方:函数参数为类的值类型时.函数返回值为类类型时以及初始化语句,例如(示例了

类string的拷贝构造函数与赋值函数

//参考高质量c++编程 复制构造函数 1 String ::String (const String &other) 2 { 3 4 5 int length=strlen(other.m_date); 6 //other对象的字符长度,其不包括‘\0’ 7 m_data=new char[length+1]; 8 //在堆上开辟一块内存,内存大小包括'\0' 9 strcpy(m_data, other.m_data); 10 11 } 赋值构造函数 1 String &String

复制构造函数 与 赋值函数 的区别(转)

转自:jihite 构造函数.析构函数.赋值函数是每个类最基本的的函数.每个类只有一个析构函数和一个赋值函数.但是有很多构造函数(一个为复制构造函数,其他为普通构造函数.对于一个类A,如果不编写上述四个函数,c++编译器将自动为A产生四个默认的函数,即: A(void)                                    //默认无参数构造函数 A(const A &a)                         //默认复制构造函数 ~A(void);