我是靠谱客的博主 大气夏天,最近开发中收集的这篇文章主要介绍程序员面试宝典随笔记(一)---构造拷贝构造和赋值函数的细则 1.构造函数 2.拷贝构造函数 3.赋值函数,觉得挺不错的,现在分享给大家,希望可以做个参考。

概述

引申来由:

如果你只是声明一个空类,不做任何事情的话,编译器会自动为你生成一个默认构造函数、一个拷贝默认构造函数、一个默认拷贝赋值操作符和一个默认析构函数(似乎还有一个this指针)。这些函数只有在第一次被调用时,才会别编译器创建。所有这些函数都是inline和public的。

定义一个空的C++类,例如

class Empty
{
}
  • 1
  • 2
  • 3

一个空的class在C++编译器处理过后就不再为空,编译器会自动地为我们声明一些member function,一般编译过去就相当于:


class Empty
{
public:
Empty(); // 缺省构造函数//
Empty( const Empty& ); // 拷贝构造函数//
~Empty(); // 析构函数//
Empty& operator=( const Empty& ); // 赋值运算符//
Empty* operator&(); // 取址运算符
const Empty* operator&() const; // 取址运算符 const
};
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

一般的书上好像都是前面四种:默认构造函数,拷贝构造函数,默认赋值函数以及析构函数,后面两种其实属于,但要需要注意的是,只有当你需要用到这些函数的时候,编译器才会去定义它们。

正文:

C++中一般创建对象,拷贝或赋值的方式有构造函数,拷贝构造函数,赋值函数这三种方法。下面就详细比较下三者之间的区别以及它们的具体实现

1.构造函数

构造函数是一种特殊的类成员函数,是当创建一个类的对象时,它被调用来对类的数据成员进行初始化和分配内存。(构造函数的命名必须和类名完全相同)

首先说一下一个C++的空类,编译器会加入哪些默认的成员函数

·默认构造函数和拷贝构造函数

·析构函数

·赋值函数(赋值运算符)

·取值函数

**即使程序没定义任何成员,编译器也会插入以上的函数! 

注意:构造函数可以被重载,可以多个,可以带参数;

析构函数只有一个,不能被重载,不带参数

 

而默认构造函数没有参数,它什么也不做。当没有重载无参构造函数时,

  A a就是通过默认构造函数来创建一个对象

下面代码为构造函数重载的实现

[cpp]  view plain  copy
  1. <span style="font-size:14px;">class A  
  2. {  
  3. int m_i;  
  4. Public:  
  5.   A()   
  6. {  
  7.  Cout<<”无参构造函数”<<endl;  
  8. }  
  9. A(int i):m_i(i) {}  //初始化列表  
  10. }</span>  

2.拷贝构造函数


拷贝构造函数是C++独有的,它是一种特殊的构造函数,用基于同一类的一个对象构造和初始化另一个对象。

当没有重载拷贝构造函数时,通过默认拷贝构造函数来创建一个对象

A a;

A b(a);

A b=a;  都是拷贝构造函数来创建对象b

强调:这里b对象是不存在的,是用a 对象来构造和初始化b的!!


先说下什么时候拷贝构造函数会被调用:

在C++中,3种对象需要复制,此时拷贝构造函数会被调用

1)一个对象以值传递的方式传入函数体

2)一个对象以值传递的方式从函数返回

3)一个对象需要通过另一个对象进行初始化


什么时候编译器会生成默认的拷贝构造函数:

1)如果用户没有自定义拷贝构造函数,并且在代码中使用到了拷贝构造函数,编译器就会生成默认的拷贝构造函数。但如果用户定义了拷贝构造函数,编译器就不在生成。

2)如果用户定义了一个构造函数,但不是拷贝构造函数,而此时代码中又用到了拷贝构造函数,那编译器也会生成默认的拷贝构造函数。

 

因为系统提供的默认拷贝构造函数工作方式是内存拷贝,也就是浅拷贝。如果对象中用到了需要手动释放的对象,则会出现问题,这时就要手动重载拷贝构造函数,实现深拷贝。

下面说说深拷贝与浅拷贝:

浅拷贝:如果复制的对象中引用了一个外部内容(例如分配在堆上的数据),那么在复制这个对象的时候,让新旧两个对象指向同一个外部内容,就是浅拷贝。(指针虽然复制了,但所指向的空间内容并没有复制,而是由两个对象共用,两个对象不独立,删除空间存在)

深拷贝:如果在复制这个对象的时候为新对象制作了外部对象的独立复制,就是深拷贝。


拷贝构造函数重载声明如下: 

A (const A&other)

下面为拷贝构造函数的实现:

[cpp]  view plain  copy
  1. <span style="font-size:14px;">class A  
  2. {  
  3.   int m_i  
  4.   A(const A& other):m_i(other.m_i)  
  5. {  
  6.   Cout<<”拷贝构造函数”<<endl;  
  7. }  
  8. }</span>  


3.赋值函数

当一个类的对象向该类的另一个对象赋值时,就会用到该类的赋值函数。

当没有重载赋值函数(赋值运算符)时,通过默认赋值函数来进行赋值操作

A a;

A b;

b=a; 

强调:这里a,b对象是已经存在的,是用a 对象来赋值给b的!!


赋值运算的重载声明如下:

 A& operator = (const A& other)


通常大家会对拷贝构造函数和赋值函数混淆,这儿仔细比较两者的区别:

1)拷贝构造函数是一个对象初始化一块内存区域,这块内存就是新对象的内存区,而赋值函数是对于一个已经被初始化的对象来进行赋值操作。

[cpp]  view plain  copy
  1. <span style="font-size:14px;">class  A;  
  2. A a;  
  3. A b=a;   //调用拷贝构造函数(b不存在)  
  4. A c(a) ;   //调用拷贝构造函数  
  5.   
  6. /****/  
  7.   
  8. class  A;  
  9. A a;  
  10. A b;     
  11. b = a ;   //调用赋值函数(b存在)</span>  

2)一般来说在数据成员包含指针对象的时候,需要考虑两种不同的处理需求:一种是复制指针对象,另一种是引用指针对象。拷贝构造函数大多数情况下是复制,而赋值函数是引用对象

3)实现不一样。拷贝构造函数首先是一个构造函数,它调用时候是通过参数的对象初始化产生一个对象。赋值函数则是把一个新的对象赋值给一个原有的对象,所以如果原来的对象中有内存分配要先把内存释放掉,而且还要检察一下两个对象是不是同一个对象,如果是,不做任何操作,直接返回。(这些要点会在下面的String实现代码中体现)

 

!!!如果不想写拷贝构造函数和赋值函数,又不允许别人使用编译器生成的缺省函数,最简单的办法是将拷贝构造函数和赋值函数声明为私有函数,不用编写代码。如:

[cpp]  view plain  copy
  1. <span style="font-size:14px;">class A  
  2. {  
  3.  private:  
  4.  A(const A& a); //私有拷贝构造函数  
  5.  A& operate=(const A& a); //私有赋值函数  
  6. }</span>  

如果程序这样写就会出错:

[cpp]  view plain  copy
  1. <span style="font-size:14px;">A a;  
  2. A b(a); //调用了私有拷贝构造函数,编译出错  
  3.   
  4. A b;  
  5. b=a; //调用了私有赋值函数,编译出错</span>  

所以如果类定义中有指针或引用变量或对象,为了避免潜在错误,最好重载拷贝构造函数和赋值函数。


下面以string类的实现为例,完整的写了普通构造函数,拷贝构造函数,赋值函数的实现。String类的基本实现见我另一篇博文。

[cpp]  view plain  copy
  1. <span style="font-size:14px;">String::String(const char* str)    //普通构造函数  
  2.   
  3. {  
  4.   
  5.  cout<<construct<<endl;  
  6.   
  7.  if(str==NULL)        //如果str 为NULL,就存一个空字符串“”  
  8.   
  9. {  
  10.  m_string=new char[1];  
  11.  *m_string ='';  
  12. }  
  13.   
  14.  else  
  15.   
  16. {  
  17.   
  18.   m_string= new char[strlen(str)+1] ;   //分配空间  
  19.   strcpy(m_string,str);  
  20.   
  21. }  
  22.   
  23. }  
  24.   
  25.    
  26. String::String(const String&other)   //拷贝构造函数  
  27.   
  28. {  
  29.  cout<<"copy construct"<<endl;  
  30.  m_string=new char[strlen(other.m_string)+1]; //分配空间并拷贝  
  31.  strcpy(m_string,other.m_string);  
  32. }  
  33.   
  34. String & String::operator=(const String& other) //赋值运算符  
  35. {  
  36.  cout<<"operator =funtion"<<endl ;  
  37.  if(this==&other) //如果对象和other是用一个对象,直接返回本身  
  38.  {  
  39.   return *this;  
  40.  }  
  41.  delete []m_string; //先释放原来的内存  
  42.  m_string= new char[strlen(other.m_string)+1];  
  43.  strcpy(m_string,other.m_string);  
  44.  return * this;  
  45. }</span>  

 

一句话记住三者:对象不存在,且没用别的对象来初始化,就是调用了构造函数;

                对象不存在,且用别的对象来初始化,就是拷贝构造函数(上面说了三种用它的情况!)

                 对象存在,用别的对象来给它赋值,就是赋值函数。

转载自ZMyths, C++中构造函数,拷贝构造函数和赋值函数的区别和实现


最后

以上就是大气夏天为你收集整理的程序员面试宝典随笔记(一)---构造拷贝构造和赋值函数的细则 1.构造函数 2.拷贝构造函数 3.赋值函数的全部内容,希望文章能够帮你解决程序员面试宝典随笔记(一)---构造拷贝构造和赋值函数的细则 1.构造函数 2.拷贝构造函数 3.赋值函数所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错,欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(62)

评论列表共有 0 条评论

立即
投稿
返回
顶部