c++构造函数和析构函数杂记

最新推荐文章于 2022-02-25 22:31:36 发布
最新推荐文章于 2022-02-25 22:31:36 发布
阅读量580 收藏
点赞数
分类专栏： C++编程 文章标签： 类 c++ 编程 class vc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bluesky466/article/details/25122911
版权

在使用c++编程的时候你总会自不自觉的用到构造函数还有析构函数（只要你用到了类，不管是你写的还是别人写的都会调用到）。

首先看看它们在哪里会被调用：

#include <stdio.h>
class AClass
{
public:
	AClass()
	{
		printf("AClass()\n");
	}
	~AClass()
	{
		printf("~AClass()\n");
	}
};

int main()
{
	AClass  C1;		    //声明一个类实例的时候会调用“构造函数”
	AClass* pC2 = new AClass(); //new 一个类实例的时候会调用“构造函数”

	delete  pC2;		    //delete 一个类实例的时候会调用“析构函数”
	return 0;
				    //main return 后系统会帮我们释放C1的空间，会调用“析构函数”
}
运行结果：

 

（因为我是在vc6.0写的控制台程序，他这个编译器在debug模式下有个特点:

就是会一直运行完 main 的return 函数后再自动显示 press any key tocontinue 让你看看运行效果,等你按键盘上的任意键退出黑框框.

就是说现在C1已经是被释放掉了，所以我们才能见到两个析构函数）


然后在讲讲一些关于构造函数和析构函数的特殊小知识:


1、定义一个类的时候如果你没有写构造函数，那系统会帮你自动生成一个默认构造函数。但如果你写了一个构造函数，即使不是无参数的构造函数，那系统就不会再为你生成默认构造函数。

我们来看一个具体的例子：

#include <stdio.h>

class AClass
{
	//没有写构造函数
};

int main()
{
	AClass c;
}
这样的程序是可以编译通过的系统会帮你自动生成一个默认构造函数。

但如果你写了一个构造函数

#include <stdio.h>

class AClass
{
public:
	//你写了一个构造函数，它有一个int类型的参数
	AClass(int data)
	{
	}
	
};

int main()
{
	AClass c;
}
这样你运行程序的时候编译器就会报错：

没有找到默认构造函数。因为现在系统不会帮你自动生成一个默认构造函数了。

那你就只好自己在写一个咯：

#include <stdio.h>

class AClass
{
public:
	//你写了一个构造函数，它有一个int类型的参数
	AClass(int data)
	{
	}

	//系统不帮你生成，你就自己写一个
	AClass()
	{
	}
	
};

int main()
{
	AClass c;
}
这样就能编译通过了。

同样的情况是如果你没写默认构造函数，当你继承出来一个子类，它也不能生成

#include <stdio.h>

class BaseClass
{
public:
	//你写了一个构造函数，它有一个int类型的参数
	BaseClass(int data)
	{
	}
};

//ChildClass继承于BaseClass但BaseClass没有默认构造函数
class ChildClass : public BaseClass
{
};

int main()
{
	ChildClass c;
}
这样的代码也不能编译通过



2、如何用构造函数初始化类成员变量：

class AClass
{
public:
	AClass():data(0),data2(0)
	{
	}

private:
	int data1,data2;
};
其实也就是构造函数首部后加 冒号,然后将要初始化的成员变量写在后面，紧更着变量名的后面就放初始化的值，多个变量之间用逗号相隔。
当然你可能会问这样写和放在函数体的 花括号里写有什么区别

别急，先来说说这种用法其实还可以在冒号后面加父类的构造函数，表示要用父类的某一个构造函数

#include <stdio.h>

class BaseClass
{
public:
	BaseClass()
	{
		printf("BaseClass\n");
	}

	~BaseClass()
	{
		printf("~BaseClass\n");
	}

	BaseClass(int data)
	{
		this->data = data;
		printf("BaseClass(int data)\n");
	}
protected:
	int data;
};

class ChildClass : public BaseClass
{
public:
	ChildClass():BaseClass(123)
	{
		printf("ChildClass\n");
	}

	~ChildClass()
	{
		printf("~ChildClass\n");
	}

	void showData()
	{
		printf("data:%d\n",data);
	}
};

int main()
{
	ChildClass c;
	c.showData();
}
运行结果：

（看，先调用父类的构造函数（你选择的那个），然后调用子类的。数据也没错。

如果放花括号里面呢？

#include <stdio.h>

class BaseClass
{
public:
	BaseClass()
	{
		printf("BaseClass\n");
	}

	~BaseClass()
	{
		printf("~BaseClass\n");
	}

	BaseClass(int data)
	{
		this->data = data;
		printf("BaseClass(int data)\n");
	}
protected:
	int data;
};

class ChildClass : public BaseClass
{
public:
	ChildClass()
	{
		BaseClass(123);//注意这里，现在把父类构造函数放在这里
		printf("ChildClass\n");
	}

	~ChildClass()
	{
		printf("~ChildClass\n");
	}

	void showData()
	{
		printf("data:%d\n",data);
	}
};

int main()
{
	ChildClass c;
	c.showData();
}
现在得到的结果是：

（程序没有调用我们选择的那个父类构造函数，而是用了父类的默认构造函数,然后数据也没有被正确赋值。）

很奇怪的一点事为什么在调用BaseClass和ChildClass直接输出了BaseClass(int data)和~BaseClass呢？

原来如果我们把父类的构造函数放在子类构造函数的花括号里面的话，就相当于在子类构造函数里声明出一个父类对象（这个父类对象是一个临时变量，作用域只在函数里），在退出函数时，系统会自动释放临时变量，于是就调用了父类的析构函数。

于是我们只是把临时变量的data设为123，而不是把自己的data设为123.。故后面会打印data:-858993460这个乱码，因为它根本就没有被赋值！


3、不要在构造函数和析构函数里面使用虚函数

看看这个例子：

#include <stdio.h>

class BaseClass
{
public:
	BaseClass()
	{
		Func();//构造函数里调用虚函数
	}

	virtual void Func()
	{
		printf("Func In BaseClass\n");
	}

	void CallFunc()
	{
		Func();//其他函数里调用虚函数
	}
};

class ChildClass : public BaseClass
{
public:
	void Func()
	{
		printf("Func In ChildClass\n");
	}
};

int main()
{
	ChildClass c; //构造函数和析构函数里调用的虚函数是 BaseClass 里的版本
	c.CallFunc(); //其他函数里调用的虚函数是 ChildClass 里的重载版本
}
（在构造函数里面调用的虚函数还是本类的原来版本，但在其他函数调用的虚函数可能是子类的重载版本。同样的事情也发生在析构函数里面）


4、拷贝构造函数和重载“=”操作符

#include <stdio.h>

class AClass
{
public:
	AClass()
	{
	}

	//拷贝构造函数
	AClass(const AClass& c)
	{
		printf("AClass(const AClass& c)\n");
	}

	//重载“=”操作符
	void operator = (const AClass& c)
	{
		printf("void operator = (const AClass& c)\n");
	}
};


int main()
{
	AClass c1;

	AClass c2 = c1; //这样调用的是拷贝构造函数

	AClass c3;
	c3 = c1;	//这样调用的是重载“=”操作符
}
运行结果：

（在声明变量的时候赋值是“初始化”，调用拷贝构造函数。在变量声明完成之后再赋值就是“赋值”，调用重载“=”操作符）


5、构造函数的隐式转换与explicit关键字

如果你自己写的构造函数只有一个参数（或者只有一个参数没有默认值），你可以在声明是用“=”去调用这个构造函数，而不是拷贝构造函数。

例子：

#include <stdio.h>

class AClass
{
public:
	AClass(int data)
	{
		printf("AClass, data:%d\n",data);
	}
};


int main()
{
	AClass c = 123;
}
程序可以正常运行：


这种情况叫做构造函数的隐式转换。


你可以用explicit关键字去禁止它

#include <stdio.h>

class AClass
{
public:
	//用explicit关键字禁止构造函数的隐式转换
	explicit AClass(int data)
	{
		printf("AClass, data:%d\n",data);
	}
};


int main()
{
	AClass c = 123;
}
这样程序就不能编译通过，编译器会报错：



6.将析构函数声明为虚函数(这部分的内容我是直接复制我的上一篇博客《c++中的虚函数与纯虚函数》的，有兴趣的可以去看看)

#include <stdio.h>  
class BaseClass  
{  
public:  
    virtual ~BaseClass()//析构函数是虚函数  
    {  
        printf("Func In BaseClass\n");  
    }  
};  
  
class ChildClass1 : public BaseClass  
{  
public:  
    ~ChildClass1()  
    {  
        printf("Func In ChildClass\n");  
    }  
};  
  
int main()  
{  
    ChildClass1* child = new ChildClass1();  
    BaseClass*  pClass = child;  
    delete pClass;  
  
        return 0;  
}

我们会的到结果：

看我们 delete 掉 BaseClass* 类型的 pClass ,因为 pClass  的值是由 ChildClass1* 类型的 child 复制得到的,所以会调用ChildClass1的析构函数（就是说他不只调用了父类的析构函数,也会调用子类的析构函数）


如果不是虚函数呢？

#include <stdio.h>  
class BaseClass  
{  
public:  
    ~BaseClass() //注意：现在不是虚函数  
    {  
        printf("Func In BaseClass\n");  
    }  
};  
  
class ChildClass1 : public BaseClass  
{  
public:  
    ~ChildClass1()  
    {  
        printf("Func In ChildClass\n");  
    }  
};  
  
int main()  
{  
    ChildClass1* child = new ChildClass1();  
    BaseClass*  pClass = child;  
    delete pClass;  
  
        return 0;  
}
 结果只调用了父类的析构函数


有时候我们会在子类里 new 一些变量出来，很多时候都是在子类的析构函数里才把他们 delete 掉。

而如果你 new 一个这样的子类出来，然后将它转型为父类指针 delete 掉，就需要将基类的析构函数声明为虚函数。

Sky落羽
关注
专栏目录
[C++杂记] 构造函数初始化列表
yishaxiaoyao的专栏
05-11 391
C++构造函数初始化列表的语法：
C++——虚函数(virtual)
zy2317878的博客
07-20 425
写在前面 这一篇博客记录一下自己理解的虚函数的相关内容。虚函数在刚开始学习C++的时候并不理解为什么需要这个东西？现在觉得要理解这个概念，需要对面向对象编程这个软件设计模式要有了解。学习C++不光要能理解语法特征，还要明白一些常用的软件设计模式。 这篇博客我也还是会结合一些网络上的资料，加上自己的理解阐述一下对虚函数的理解。 参考资料 c++ 深入理解虚函数 C++ 虚函数表解析 对于...
VS2013 小黑框不显示析构函数中的输出
qq_28256625的博客
07-13 1224
请按任意键继续...是调用system("pause"); 的结果，但析构函数的调用要在return之后。析构函数的输出看不到。 可在析构函数实现的定义文件中添加 头文件：#include 语句：fstream fout("destructor.txt", ios::app); 析构函数中的输出改为：fout 在文件夹中找到destructor.txt，里面有
VC++析构函数
wmnmtm的专栏
04-25 365
  析构函数的作用正好与构造函数相反，对象超出其作用范围，对应的内存空间被系统收回或被程序用delete删除时，析构函数被调用。   根据析构函数的这种特点，我们可以在构造函数中初始化对象的某些成员变量，给其分配内存空间（堆内存），在析构函数中释放对象运行期间所申请的资源。   C++函数的重载 函数的参数类型不同，参数个数不同，才能构成函数的重载。  void output() ...
C++ 构造函数与析构函数 杂记
weiyuanzhang123的博客
06-15 71
C++提供了一个特殊的成员函数——类构造函数，专门用于构造新对象、将值赋给它们的数据成员。更准确地说，C++为这些成员函数提供了名称和使用语法，而程序员需要提供方法定义和实现。
【C++杂记】C++构造函数失败怎么办，智能指针+异常处理防止内存泄漏
春播秋忙
08-11 2883
概述 C++构造函数失败后，其对应的析构函数会被自动调用吗？ 答案是不会。 能在构造函数中抛出异常，然后在外面捕获吗？ 可以，但不建议这样做。C++之父和herb sutter这样的最顶级专家建议不要把容易出错的代码放在构造函数中，当然如果非要在构造函数做一些容易失败的事，那就在构造里throw异常吧。另外对于析构函数，Herb Sutter在Exceptional c++ 中也说过说：“...
C++杂记：继承与构造函数的调用
m_LeonWANG的专栏
06-04 807
在创建子类对象时，系统需要调用父类的构造方法。     如果没有显式的构造函数，编译器会给一个默认的构造函数，并且该默认的构造函数仅仅在没有显式地声明构造函数情况下创建。 构造原则如下：     1. 如果子类没有定义构造方法，则调用父类的无参数的构造方法。     2. 如果子类定义了构造方法，不论是无参数还是带参数，在创建子类的对象的时候,首先执行父类无参数的构造方法，
自考 C++ 杂记 —— 多态性及虚函数
Big Fish 大鱼 的个人博客
04-21 279
1.多态性 静态联编：编译时的多态性，函数重载实现 动态联编：运行时的多态性，虚函数实现 2.虚函数的定义 只能是一个成员函数，不能是静态成员，用virtual关键字声明。 一旦基类定义了虚函数，该基类的派生类中的同名函数（返回值、参数列表与基类中的同名虚函数完全一致）那么也自动成为虚函数。 虚函数的调用规则是：根据当前对象，优先调用对象本身的虚成员函数。 3.虚函数实现多态性的条件...
CPP杂记——移动构造函数中需要注意的问题
01-08
默认的拷贝构造函数执行浅拷贝，这意味着如果对象含有动态分配的资源，这些资源会在临时对象析构时被释放，可能会影响到其他仍然使用这些资源的对象。在C++11之前，程序员通常会编写深拷贝构造函数来解决这个问题，...
C/C++杂记 虚函数的实现的基本原理(图文)
12-31
B的虚函数表中存放着B::foo和B::bar两个函数指针。 D的虚函数表中存放的既有继承自B的虚函数B::foo，又有重写（override）了基类虚函数B::bar的D::bar，还有新增的虚函数D::quz。 提示：为了描述方便，本文在探讨...
7. 吴恩达机器学习课程-作业7-Kmeans and PCA
wujing1_1的博客
02-22 1056
fork了别人的项目，自己重新填写，我的代码如下 https://gitee.com/fakerlove/machine-learning/tree/master/code 代码原链接 文章目录7. 吴恩达机器学习课程-作业7-Kmeans and PCA7.1 k-means7.1.1 题目介绍7.1.2 算法流程7.1.3 实现k-means7.1.4 测试7.2 图像压缩与k-均值7.3 PCA7.3.1 题目介绍7.3.2 算法流程7.3.3 代码1) 示例数据集2) 实现PCA3) 脸图像数据集
算法提高分类学习刷题——1.动态规划——1.3背包模型
m0_51474171的博客
02-25 3525
（1）01背包 模型 题目介绍 有 N件物品和一个容量为 V 的背包，每件物品有各自的价值且只能被选择一次，要求在有限的背包容量下，装入的物品总价值最大。 「0-1 背包」是较为简单的动态规划问题，也是其余背包问题的基础。 动态规划是不断决策求最优解的过程，「0-1 背包」即是不断对第 i个物品的做出决策，「0-1」正好代表不选与选两种决定。 二维 （1）状态f[i][j]定义：前i个物品，背包容量j下的最优解（最大价值）： 当前的状态依赖于之前的状态，可以理解为从初始状态f[0][0] = 0开.
算法提高分类学习刷题——1.动态规划——1.2.最长上升子序列模型
m0_51474171的博客
02-21 1489
最长上升子序列模型 1.最长上升子序列 题目描述 给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 输入格式 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出格式 输出一个整数，表示最大长度。 数据范围 1≤N≤1000， −109≤数列中的数≤109 输入样例： 7 3 1 2 1 8 5 6 输出样例： 4 解题思路 因为以i结尾的子序列，一定是由前i-1个数结尾的子序列长度加一取max 比如一个子序列a[j]a[i] ,那么当a[j]<a[i
类和对象进阶
sqjddb的博客
02-23 536
/关于访问限定符的几点说明 /类的实例化 /计算类对象的大小 /深入理解this指针 /六大默认成员函数 /const修饰成员函数 /细谈成员函数 /对象成员的初始化 /static成员 /友元 /内部类
经典的图像分类模型
最白の白菜的博客
02-22 5377
目录经典的图像分类模型AlexNetAlexNet的网络架构手写数字势识别数据读取模型编译模型训练模型评估VGGVGG的网络架构手写数字势识别数据读取模型编译模型训练模型评估GoogLeNetInception 块GoogLeNet模型B1模块B2模块B3模块B4模块B5模块手写数字识别数据读取模型编译模型训练模型评估延伸版本InceptionV2InceptionV3ResNet残差块ResNet模型手写数字势识别数据读取模型编译模型训练模型评估 经典的图像分类模型 AlexNet 学习目标 知道Ale
年薪20W的自动化测试工程师教你用Postman做接口测试
02-23 2046
The higher your test coverage, the more flexible and bug-resistant your code will be, and the less time you’ll spend debugging hot fixes in production. 测试覆盖率越高，代码就越灵活，生产中调试修补程序所花费的时间就越少。 首先，比较遗憾的一点是，Postman对并发测试并不好，但支持指定次数与间隔时间的串行测试。 官方文档链接：Postman .
c++构造函数和析构函数
最新发布
06-07
C++中的构造函数和析构函数是用来初始化和清理类对象的特殊成员函数。构造函数在对象被创建时自动调用，而析构函数则在对象被销毁时自动调用。 构造函数的名称与类名称相同，没有返回类型，可以有参数，分为默认...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值