C++Primer Plus第十章对象和类 构造函数和析构函数的使用，（析构函数的正确理解）

在上面代码的基础上只需要添加构造函数和 析构函数即可，这里直接上代码
stock10.h,stock10.cpp,usestock2.cpp

#ifndef STOCK10_H_
#define STOCK10_H_
#define CLASS2 1
#if CLASS2
//stock10.h
#include<string>	
class Stock //class declaration 
{
private:
	std::string company; //公司
	long shares;//股票数量
	double share_val;//股票单价
	double total_val;//总市值
	void set_tot()//内联函数，和inline同理，定义位于类申明中的函数自动成为内联韩式
	{
		total_val = shares * share_val;
	}
public:
	//两个构造函数
	Stock();//默认的构造函数
	Stock(const std::string& co, long n = 0, double pr = 0.0);
	~Stock();//析构函数
	void acquire(const std::string& co, long n, double pr);
	void buy(long num, double price);
	void sell(long num, double price);
	void update(double price);
	void show();
};
#endif // CLASS2

//stock10.cpp--using class with constructors,destructor added
//version 00
#include<iostream>
#include"stock10.h"
//add
//默认无参的构造函数
Stock::Stock()
{
	std::cout << "默认的构造函数执行\n";
	company = "no name";
	shares = 0;
	share_val = 0.0;
	total_val = 0.0;
}
//add
Stock::Stock(const std::string& co, long n , double pr)
{
	std::cout << "用构造函数创建：" << co << "公司\n";
	company = co;
	if (n < 0)
	{
		std::cout << "持股数量不能小于0" << company << "公司的股票";
		shares = 0;
	}
	else
		shares = n;
	share_val = pr;
	set_tot();
}
//add,析构函数对象
Stock::~Stock()
{
	std::cout << "Bye," << company << "!\n";
}
//其他的方法
void Stock::acquire(const std::string& co, long n, double pr)
{
	company = co;
	if (n<0)
	{
		std::cout << "输入股票的数量不正确" << company << "被设置为0";
		shares = 0;
	}
	else
	{
		shares = n;
	}
	share_val = pr;
	set_tot();
}

void Stock::buy(long num, double price)
{
	if (num<0)
	{
		std::cout << "股票的数量不能是负数" << "请求终止";
	}
	else
	{
		shares += num;
		share_val = price;
		set_tot();
	}
}
void Stock::sell(long num, double price)
{
	using std::cout;
	if (num<0)
	{
		cout << "股票的数量不能是负数" << "请求终止";
	}
	else if (num>shares)
	{
		cout << "你输入的数量超过你持有的数量" << "请求终止"<<"\n";
	}
	else
	{
		shares -= num;
		share_val = price;
		set_tot();
	}
}

void Stock::update(double price)
{
	share_val = price;
	set_tot();
}

void Stock::show()
{
	using std::cout;
	using std::ios_base;

	//设置输入格式 #.###
	ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
	std::streamsize prec = cout.precision(3);

	cout << "公司：" << company<<"\n"
		<< "股票：" << shares << "\n"
		<< "股价：$" << share_val<<"\n";

		//设置输出格式 #.##
		cout.precision(2);
		cout<< "总值：$" << total_val << "\n";

		//回复原始格式
		cout.setf(orig, ios_base::floatfield);
		cout.precision(prec);
}

#pragma region 练习1.10.3
//usestck1.cpp -- using the Stock class
//compile with stock10.cpp
#if 1
#include <iostream>
#include"stock00.h"
int main()
{
	{
		using std::cout;
		cout << "用构造函数创建新的对象\n";
		Stock stock1("阿里巴巴", 20, 12.50);
		stock1.show();
		Stock stock2("腾讯", 2, 2);
		stock2.show();

		cout << "赋值stock1 to stock2:\n";
		stock2 = stock1;
		cout << "显示stock1,stock2\n";
		stock1.show();
		stock2.show();

		cout << "用构造函数复位对象\n";
		stock1 = Stock("微软", 10, 50.0);//temp object，从新创建的时候，会释放原来的赋值，故而执行析构函数，打印出来，在给创建
		cout << "析构函数释放stock1:\n";
		stock1.show();
		cout << "Done\n";
	}
	return 0;
}
#endif 
#pragma endregion

这里为了大家理解构造函数和析构函数，我这里把打印的情况截屏吹来

1，我们看到在创建对象stock1的时候，带参数的构造函数被调用，之后通过show的方法打印出来，stock2创建的时候，也被打印出来。
2，对象stock1,stock2可以进行赋值操作。打印的结果看赋值是成功的。
3，stock1,再一次被创建的时候，发现析构函数把微软抛出来了。
4，但最后show的时候，微软的信息是正常打印出来的，所以可以得出结论，直接赋值是不会执行析构函数的，通过析构函数创建对象后，执行析构函数，这里并没有推出本（main()）函数体
5,打印完成“Done\n”之后，两个析构函数再执行， 可以理解为推出本函数体，析构函数执行一次
综合4，5：可以理解为对象被销毁的时候析构函数执行一次。如果这样的话，可以打印一下两次生成的stock1的地址是否是同一个地址，打印的结果可以知道地址是没有变化的，但是这是否也理解为对象被销毁了呢。暂时留一个疑问（后来发现，这个删除的是临时变量，删除临时变量的时候，析构函数就执行了，这里要理解一下，不是整个函数体退出执行析构函数）