C++专题: constructor and destructor

最新推荐文章于 2022-01-15 22:26:36 发布
最新推荐文章于 2022-01-15 22:26:36 发布
阅读量1.3k 收藏 1
点赞数 1
文章标签： constructor destructor c++ class iostream 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foxbillcsdn/article/details/752306
版权

1. 构造函数

1.1. 缺省构造函数
  缺省构造函数指不带任何参数的构造函数。
1.1.1. 使用方法
class CA{
public:
  CA() { mi = 0 ; }
  int getMi(){ return mi ; }
private:
  int mi;
};

int main(){
  CA oa;
  CA* poa = new CA;  // 或者 new CA();
  int i;
 
  i = oa.getMi();
  i = poa->getMi();
  delete poa;
  return 0;
}
1.1.2. 隐蔽性
缺省构造函数是非常重要的构造函数，重要性体现在"缺省"2个字上面。它是编译器在缺省情况下所使用的构造函数。缺省情况是指在编译过程中需要使用构造函数而程序中又没有提供任何构造函数的情况，在这种情况下，编译器默默的为CA创建了一个不带参数的构造函数，此构造函数没有做任何的初始化工作，只是为了编译程序的需要而产生。
" 创建没有任何构造函数的类的对象时候
例如：
class CA{
public:
  int getMi(){ return mi ; }
private:
  int mi;
};

int main(){
  CA oa;
   int i = oa.getMi();
    return 0;
}

本例中，类CA没有提供任何构造函数，但是在main函数中还是可以生成一个CA的对象出来。
但是oa对象的成员变量mi的值是不确定的，因为并没有做任何初始化工作。

" 从没有任何构造函数的类派生出子类的时候

class CBase{
public:
  int getMi(){ return mi ; }
private:
  int mi;
};

class CDerived : public CBase {
public:
  int getMj(){ return mj ; }
private:
  int mj;
};

int main(){
  CDerived  oderived;
   int i = oderived.getMi();
   int j = oderived.getMj();
    return 0;
}

在编译过程中，类CDerived的构造函数CDerived( int j)会调用基类CBase的缺省构造函数。

" 一个类中含有一个以另外一个类为类型的成员变量

class CA{
public:
  int getMi(){ return mi ; }
private:
  int mi;
};

class CB{
public:
  int getMj(){ return mj ; }
private:
  CA moa;
  int mj;
};

1.1.3. 将缺省构造函数申明为private
  从上面所说知道，编译器会在需要的时候生成缺省构造函数。但有时候，我们想禁止这样做，不想客户程序通过使用构造函数来创建类的对象，通过将缺省构造函数显式的申明为private可以做到这点。
  典型的一个应用是GOF4的23个设计模式中的单例模式(Singleton)

1.2. 带参数构造函数
  前面的例子中，类CA的缺省构造函数只能静态的初始化成员变量mi,当需要客户程序动态的初始化mi的时候，就需要用到带参数构造函数。
1.2.1. 使用方法
class CA{
public:
  CA( int i) { mi = i ; }
  int getMi(){ return mi ; }
private:
  int mi;
};

int main(){
  CA oa( 8 );
  CA* poa = new CA( 8 );
  int i;
 
  i = oa.getMi();
  i = poa->getMi();
  delete poa;
  return 0;
}

1.2.2. 需要注意的地方
  如果一个类只声明了带参数的构造函数，而没有提供缺省构造函数，那么就不能通过使用缺省构造函数来创建该类的对象。
  如上例的CA类，不能这样来创建CA的对象：
  CA oa;
  CA* poa = new CA();
在编译的过程中编译器将提示错误: 没有构造函数CA()。
上面这点是比较明显的，也很容易更正，但是，如果在有继承的情况下，情况就变得比较隐蔽一些。
考虑下面的例子：
#include <iostream>

class CBase{
public:
  CBase( int i ){ mi = i ; }
  int getMi(){ return mi ; }
private:
  int mi;
};

class CDerived : public CBase {
public:
  CDerived( int j ){  mj = j ; }
  int getMj(){ return mj ; }
private:
  int mj;
};

int main(){
  CDerived  oderived( 8 );
  return 0;
}

在编译的过程中编译器将提示错误: 没有构造函数CBase ()。你不要奇怪说我main函数中并没有使用CBase的缺省构造函数。呵呵，编译器替你做了这个。

1.3. 基类和子类构造函数的调用顺序
1.3.1. 调用顺序
  当生成子类的对象时候，首先会调用基类的缺省构造函数(如果未指定要调用的基类构造函数)，然后再调用子类的指定构造函数。
下面例子可以说明这点：
#include <iostream>

class CBase{
public:
  CBase(){ std::cout << "base constructor" << endl; }
  int getMi(){ return mi ; }
private:
  int mi;
};


class CDerived : public CBase {
public:
  CDerived(){ std::cout << "derived constructor" << endl; }
  int getMj(){ return mj ; }
private:
  int mj;
};

int main(){
  CDerived  oderived;
  return 0;
}

程序执行后打印的结果：
base constructor
derived constructor

1.3.2. 为什么子类构造函数要调用基类的构造函数
  这是为了保证子类能够正确的初始化所有的成员变量。
注意前面的例子，类CBase有一个private成员变量mi, 这就表示只有类CBase自己可以初始化这个变量。然而，CBase的子类也从CBase继承了这个变量，并且还从CBase继承了getMi()。但是，CBase的子类如何初始化mi呢？
解决方案就是在CBase子类的构造函数中调用CBase的构造函数。


#include <iostream>

class CBase{
public:
  CBase(){ mi = 10 ; }
  int getMi(){ return mi ; }
private:
  int mi;
};

class CDerived : public CBase {
public:
  CDerived() {  mj = 20 ; }
  int getMj(){ return mj ; }
private:
  int mj;
};

int main(){
  CDerived  oderived ;
int i = oderived.getMi();
   int j = oderived.getMj();
  std::cout<< "mi= " << i << ", mj= " << j <<endl;
  return 0;
}

程序执行后打印的结果：
mi= 10, mj= 20

从结果可以看到，CDerived  的构造函数调用了CBase缺省构造函数。
这个调用过程是由编译器自动完成的。
但是，编译器只会自动调用基类的缺省构造函数，如果程序需要在子类的构造函数中指定要调用的基类构造函数，就必须由程序员自己来做了。看看下面的例子：

#include <iostream>

class CBase{
public:
  CBase( int i ){ mi = i ; }
  int getMi(){ return mi ; }
private:
  int mi;
};

class CDerived : public CBase {
public:
  CDerived( int i, int j ) : CBase(i) {  mj = j ; }
  int getMj(){ return mj ; }
private:
  int mj;
};

int main(){
  CDerived  oderived( 10, 20 ) ;
int i = oderived.getMi();
   int j = oderived.getMj();
  std::cout<< "mi= " << i << ", mj= " << j <<endl;
  return 0;
}

程序执行后打印的结果：
mi= 10, mj= 20

看看CDerived( int i, int j ) : CBase(i) {  mj = j ; }，CDerived( int i, int j )调用了CBase(i)来初始化mi。

1.4. 构造函数的initiallist(初始化列表)
  看看上面的例子中CDerived( int i, int j ) : CBase(i) {  mj = j ; }，CDerived( int i, int j )是怎样调用CBase(i)。使用的是initiallist。
  initiallist的一个重要作用就是在子类中调用基类的构造函数。需要注意的是，在JAVA中实现方法不一样，JAVA中是在构造函数体内使用super关键字来实现的，以上面的例子为例，在JAVA中的实现方法是：

class CBase{
public:
  CBase( int i ){ mi = i ; }
  int getMi(){ return mi ; }
private:
  int mi;
}

class CDerived  extends CBase {
public:
  CDerived( int i, int j )  {  super(i); mj = j ; }
  int getMj(){ return mj ; }
private:
  int mj;
}

JAVA对使用super有一个限制： super语句必须是构造函数的第一条语句。

1.4.1. 哪些情况下也必须要用initiallist
除了上面所说的在子类中调用基类的构造函数时需要使用initiallist外，还有另外一些情况下也需要使用initiallist：

" 一个类中含有一个以另外一个类为类型的成员变量，而又不能使用该类的缺省构造函数时

class CA{
public:
  CA( int i) { mi = i ; }
  int getMi(){ return mi ; }
private:
  int mi;
};

class CB{
public:
  CB(int i, int j ) {  mj = j ; }
  int getMj(){ return mj ; }
private:
  CA moa;
  int mj;
};


int main(){
  CB ob( 10, 20 );
 
  return 0;
}

此程序编译的时候会提示错误：没有定义CA类的缺省构造函数。
解决方法：
  把CB(int i, int j ) {  mj = j ; } 改为CB(int i, int j ): moa(i) {  mj = j ; }

" 一个类中含有const成员变量

class CA{
public:
  CA( int i) { mi = i; ; mi2 = 20; }
  int getMi(){ return mi }
  int getMi2(){ return mi2 ; }
private:
  int mi;
  const int mi2;
};

int main(){
  CA oa( 10 );
  int i, i2;
 
  i = oa.getMi();
  i2 = oa.getMi2();
 
  return 0;
}

上面这个程序在编译的时候会提示错误： 不能给const成员变量mi2赋值。const成员变量只能初始化而不能赋值。语句mi2 = 20;虽然是在构造函数中，但它还是一条赋值语句。
解决方案：
  改CA( int i) { mi = i; ; mi2 = 20; } 为 CA( int i) : mi2( 20 ) { mi = i; }。

" 一个类中含有引用成员变量

class CA{
public:
  CA( int i, int i2 ) : mi2( i2 ){ mi = i; }
  int getMi(){ return mi ;  }
  int getMi2(){ return mi2 ; }
private:
  int mi;
  int& mi2;
};

int main(){
  int i = 10 , i2 = 20;
  CA oa( i, i2 );
 
  i = oa.getMi();
  i2 = oa.getMi2();
 
  return 0;
}

1.4.2. 需要注意的地方

每个成员在成员初始化表中只能出现一次。且初始化的顺序不是由名字在初始化表中的顺序决定而是由成员在类中被声明的顺序决定的。例如：

class CA{
public:
  CA( int i ) : mi(i), mi2( mi + 1 ){ ; }
  int getMi(){ return mi ;  }
  int getMi2(){ return mi2 ; }
private:
  int mi2;
  int mi;
};

int main(){
  CA oa( 10 );
  int i, i2;
 
  i = oa.getMi();
  i2 = oa.getMi2();
 
  return 0;
}
在此例中， mi2声明在mi之前。然而，在initiallist中，先初始化mi，而mi2的初始化有依赖于mi，结果是，mi正确的初始化，而mi2是不能正确的初始化的，其值是不确定的。
1.5. copy构造函数
  copy构造函数的重要性类似于缺省构造函数，体现在它的隐藏性。
以一个非常简单的，非常常见的，而又让很多初学者倍感郁闷的bug：

class CA{
public:
  CA(){ pmi = new int( 10 ) ; }
  virtual ~CA(){delete pmi; }
private:
  int* pmi;
};

void fun( CA oa){

  return;
}

int main(){
    CA  oa;
    fun(oa);
   return 0;
}

这个非常简单的程序一运行就会coredump。

2个解决方法：
1． 把void fun( CA oa) 改为void fun( CA &oa)
2. 在CA中增加如下的copy构造函数：
  CA( const CA &oa) {  pmi = new int( *oa.pmi ) ; }

1.5.1. 隐藏性体现
1.5.1.1. 函数参数体现
  如上的例子，函数void fun( CA oa)，以CA类为参数，而且是传值方式，这样，编译器会在函数体内插入一个CA类的临时对象，此对象使用CA的copy构造函数来初始化，因为CA没有提供copy构造函数，所以编译器采用默认的copy构造函数，即bitcopy方式，这样，内部临时对象的pmi和参数对象oa的pmi的值是一样的，即指向同一个地址。如此，在函数fun执行完毕之后，编译器会要求调用这个对象的析构函数,把这个临时对象的pmi 变量delete掉。然后，在main函数执行完之后，参数对象oa也会被执行它的析构函数,把oa的pmi 变量delete掉。然而，因为2个pmi是指向同一个地址，只能delete一次，所以，在第二次delete的时候就出错了。
  解决方案1，把参数改为CA &oa，即按引用传递参数，这样，就避免了编译器创建临时对象。但是，这个方法治标不治本，因为在其他的时候其他的人来使用CA类的时候，很可能再犯这个错误。
  解决方案2彻底解决了这个隐藏的错误。定义CA的copy构造函数，重新创建pmi，使得2个pmi不指向同一个地址，从而避免了这个错误。

1.5.1.2. 函数返回值体现
  道理和使用函数参数一样。看下面的例子：

class CA{
public:
  CA(){ pmi = new int( 10 ) ; }
  virtual ~CA(){delete pmi; }
private:
  int* pmi;
};

CA  fun(){
  CA oa;

  return oa;
}


int main(){
    fun();
  return 0;
}
同样的，这个程序一运行就会崩溃。
原因也是： 如果一个函数的返回值是一个类的对象，那么在return出这个函数是，会调用这个类的copy构造函数来为要返回的对象初始化。解决方法有3个： 第一个就是返回对象的引用而不是返回对象值(但是这个方法有很大的缺陷，参看effective c++)。另一个方法就是提供自定义的copy构造函数。
第三个方法是：
把函数fun改为
 CA  fun(){
  return CA();
}
这样做，避免了return的时候产生临时对象，从而不会使程序出错。

1.5.2. 与assignment 的关系
1.区分2者
CA oa;
CA ob;
CA oc = oa;  // 使用了copy 构造函数
ob = oa;     //使用了assignment

2. effective c++中的建议： 当你实现了类的copy构造函数，也应该实现该类的assignment


2. 析构函数
析构函数比较简单，只提醒一点: [effective c++] Item 14:  Make sure base classes have virtual destructors
即：保证基类的virtual的析构函数是virtual的。
详细信息参看effective c++。

#include <iostream>

class CBase{
public:
  CBase(){ std::cout << "base constructor" << endl; }
  CBase(){ std::cout << "base destructor" << endl; }
  int getMi(){ return mi ; }
private:
  int mi;
};


class CDerived : public CBase {
public:
  CDerived(){ std::cout << "derived constructor" << endl; }
  ~CDerived(){ std::cout << "derived destructor" << endl; }
  int getMj(){ return mj ; }
private:
  int mj;
};

int main(){
  CBase* poderived = new CDerived() ;
  delete poderived;
  return 0;
}

执行结果，打印：
base constructor
derived constructor
base destructor

为什么运行了derived constructor而没有运行derived destructor？那么在derived constructor中分配的资源就没有被释放掉。

把CBase的析构函数改为
virtual  ~CBase(){ std::cout << "base destructor" << endl; }
执行结果，打印：
base constructor
derived constructor
derived destructor
base destructor


foxbillcsdn
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
cajce:Constructora Cajce页面
05-01
自述文件 该自述文件通常会记录启动和运行应用程序所需的所有步骤。 您可能要讲的内容： Ruby版本 系统依赖 配置 数据库创建 数据库初始化 如何运行测试套件 服务（作业队列，缓存服务器，搜索引擎等） ...
C++箴言：资源管理类的拷贝行为
07-26
// Copy constructor and copy assignment operator are deleted to prevent copying. Lock(const Lock &) = delete; Lock &operator=(const Lock &) = delete; private: Mutex *mutexPtr; }; ``` #### 拷贝...
C++的constructor和destructor
清梦的博客
01-15 444
默认constructor的删除，构建自己的constructor，destructor调用
C++_ConstructorAndDestructor
qq_28915885的博客
12-14 1632
其实，在C++中，构造函数和析构函数并无其他的难处，在应用中只需要注意以下几点即可： 构造函数和析构函数： 构造函数引入：        在C++中，不能直接对数据成员在声明时就赋初值，必须在函数中对其赋初值，一般在构造函数中对其进行赋值。如果将类看作一个封闭的个体，那么构造函数就是作为对这个封闭的个体的对外的接口，用户可以通过它（它们）对其内部的成员进行初始化。当然，也可以是普通成员函数。
Constructor and Destructor in C++
weixin_30951389的博客
05-03 204
Can we make copy constructor private?Yes, a copy constructor can be made private. When we make a copy constructor private in a class, objects of that class become non-copyable. This is particularly us...
【C++】类和对象--constructor和destructor
onlyongwang的博客
06-03 3415
Constructor：人称构造函数，用来初始化class，在class内部或外部都可以定义，在实例化class的时候会被调用。 Constructor的写法一般会有： 1. 默认的构造函数，也就是实例化的时候不带任何变量就能调用的构造函数；（这种情况有可能是构造函数就没给默认值，也可能是给了固定的默认值） 2. 重载构造函数，在有或者没有默认构造函数的基础上，带有相关变量，用来初始化cla...
C++ 学习之旅（14）——构造函数constructors和析构函数destructors
自动化研究生在读，此博客记录了我的学习与刷题经验，欢迎大家阅读交流
09-30 492
首先我们看下一个简单的类： #include <iostream> class Entity { public: float X, Y; void Print() { std::cout << X << "," << Y << std::endl; } }; int main() { Entity e; e.Print(); std::cin.get(); } 输出结果如下： 这个很奇怪的数字，实际上就是系统随机分配的
wordpress主题WordPress主题:Constructor
最新发布
03-02
根据提供的文件信息，我们可以深入探讨有关“WordPress主题：Constructor”的相关知识点。首先，从标题可以看出，这是一款专门针对WordPress平台的主题。WordPress是一个非常流行的开源内容管理系统（CMS），它支持...
js-konstr：JavaScriptConstructor
02-16
JavaScriptConstructor，或者简称"js-konstr"，是一种在JavaScript中创建对象的构造函数机制，它是面向对象编程的基础。在JavaScript中，构造函数主要用于初始化一个新创建的对象，它定义了对象的属性和方法。理解这...
C++ 构造函数constructor 与 析构函数destructor 的区别
菜鸟的学习笔记
04-17 562
构造函数constructor 析构函数destructor 1 目的purpose 初始化一个类实例constructor is used to initialize the instance of a class 摧毁实例对象,释放资源.destructor destroys the objects when they are no longer needed
constructor / destructor
weixin_33767813的博客
11-17 197
2019独角兽企业重金招聘Python工程师标准>>> ...
Java中的destructor
SalmonellaVaccine的专栏
10-25 1261
http://stackoverflow.com/questions/171952/is-there-a-destructor-for-java Because Java is a garbage collected language you cannot predict when (or even if) an object will be destroyed. Hence t
构造函数和析构函数（constructor and destructor）
Tech in Pieces
10-27 417
构造函数是绝大多数面向对象编程的语言都有的，其目的就是为用户初始化一个新的对象。 比较正规一些的定义是：类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。 而析构函数的定义如下：类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。 简单明了。但是由于Java Python等语言拥有自己的垃圾回收机制 可以自动的进行垃圾回收，所以并不需要析构函数 而想C或者C++ 需要自己进行垃圾回收，所以析构函数很重要 ...
constructor and destructor
lbbb的专栏
08-09 488
::= C1   # complete object constructor                  ::= C2   # base object constructor                  ::= C3   # complete object all
构造函数（Constructor）析构函数（Destructor）怎么用？
Cod
01-22 1340
构造函数是创建类对象时必须要调用的函数，析构函数是当对象脱离作用域（eg：类的函数调用完毕）时必须要调用的函数。 即使不显式声明，系统也会创建一个缺省的构造函数和析构函数，它们只是保证程序可执行，并不会把类的变量初始化为0。 构造函数的函数名与<类名>相同，析构函数的函数名为 ~<类名>。 /*构造函数、析构函数举例*/ class _MyClass { public: _MyClass()
constructor和destructor概述（c++ only)
热门推荐
Magicpang
10-28 1万+
原文请参考http://publib.boulder.ibm.com/infocenter/lnxpcomp/v8v101/index.jsp?topic=/com.ibm.xlcpp8l.doc/language/ref/cplr374.htmconstructor和destructor概述（c++ only)对象的初始化和清除比简单的数据结构复杂的多，这是因为类有比较复杂的内部
C++中的构造器（constructor）
vc8023ve的博客
04-17 3956
什么是构造器(constructor)? 构造函数是初始化类对象的类的成员函数。在C ++中，当对象（类的实例）创建时，将自动调用构造函数。它是该类的特殊成员函数。 构造函数与普通成员函数有何不同？ 构造函数与以下方式的常规函数​​不同： 构造函数与类本身具有相同的名称 构造函数没有返回类型 创建对象时会自动调用构造函数。 如果我们没有指定构造函数，C ++编译器会为我们生成一个默认构造函数（不...
C++——构造函数 constructor
weixin_34406086的博客
08-05 315
What is constructor C++中，如果你想要创建一个object，有一个函数会自动被调用（不需要programmer显式调用 ），这个函数就是constructor; constructor的写法很独特，其function name必须和class name相同; constructor通过arguments上的差异进而形成ctor的overloading，当然和norm...
C++课程：函数重载详解与实践
例如，类中的成员函数可以通过形参类型和数量重载，比如构造函数（`constructor`）和析构函数（`destructor`）可以根据传入参数的差异有不同的实现。 5. **使用场景**: 函数重载有助于简化代码，提高代码的可读性...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值