41-构造函数/析构函数

一、使用构造函数

**第一种方式：**显式的调用构造函数：

Stock food=Stock{"wordCompany",250,1.25};

**第二种方式：**隐式的调用构造函数

Stock food("wordCompany",250,1.25)

构造函数与new一起用
创建一个stock对象，并初始化，将该对象的地址赋给pstock指针，在这种情况下，该对象没有名称，但是可以使用指针来管理对象

Stock *pstock=new Stock("wordCompany",250,1.25)

**注意：**构造函数的使用方式与其他类成员函数的使用方式不同，
Stock stock1；
其他类成员函数： stock1.show（）；’
但是使用构造函数只能通过上面显式或者隐式的调用，不能通过对象调用构造函数

二、默认的构造函数

**默认构造函数：**是在未提供显式初始值时，用来创建对象的初始函数，
使用方法：Stock food; (编译器会隐式调用默认的构造函数）
**注意：**当我们没有定义任何构造函数时，编译器会提供默认构造函数；
但是当我们定义了非默认构造函数之后，编译器将不会再提供默认构造函数（即 Stock food;会出现错误），需要我们再另外定义一个默认的构造函数

定义默认构造函数的方式：

1）给已有的构造函数的参数提供默认值
Stock(const string &co=“erro”,int n=0,double pr=0.0);
2)通过函数重载来定义另一个构造函数

Stock::Stock()
{company="no name";shares=0;share_val=0.0;total_val=0.0;
}

默认构造函数使用

Stock first;     //隐式的调用默认函数
Stock first=Stock();//显示的调用默认函数
Stock *p=new Stock;    //隐式的调用默认函数

三、析构函数

用构造函数创建对象之后，程序负责跟踪该对象，直到其过期为止，对象过期时，程序调用析构函数。
比如，构造函数使用了new来分配内存，那么析构函数就需要使用delete来释放内存。
其实40面向对象这篇博客中，定义的Stock类没有使用new,那么析构函数没有什么需要完成的任务——那么只需要让析构函数生成一个什么都不需要做的隐式析构函数即可(如下所示）析构函数：~Stock()，没有任何参数

Stock::~Stock()
{}

什么时候调用析构函数？
答：由编译器决定，通常不需要在代码中显示的使用功能析构函数，
如果创建的Stock对象为静态存储类对象，则析构函数在程序运行结束时自动调用；
如果创建的Stock对象为自动存储类对象，则析构函数在程序执行完代码块时自动调用；
如果创建的Stock对象是通过new创建的，那该对象将驻留在栈内存中**（为甚么是栈内存？）**，并且当我们使用delete释放该对象的内存时，析构函数才会自动被调用；

四、例子

//stock.h
#ifndef STACK10_h_
#define STACK10_h_
#include<string>
class Stock
{private:std::string company;long shares;double share_val;double total_val;void set_tot(){ total_val = shares*share_val; }
public:Stock();Stock(const std::string &co, long n = 0, double pr = 0.0);~Stock();void buy(long num, double price);void sell(long num, double price);void update(double price);void show();};
#endif

//stock.cpp
#include<iostream>
#include"stock00.h"
Stock::Stock()
{std::cout << "default constructor called\n";company = "no name ";shares = 0;share_val = 0.0;total_val = 0.0;}Stock::Stock(const std::string &co, long n , double pr)
{std::cout << "constructor using " << co << " called\n";company = co;if (n < 0){std::cout << "number of shares can not be negative"<< company << " shares set to be 0. \n";shares = 0;}elseshares = n;share_val = pr;set_tot();}Stock::~Stock()
{std::cout << "bye, " << company << " !\n";}
void Stock::buy(long num, double price)
{if (num < 0){std::cout << "number of shares can not be negative!.\n"<< "transaction is aborted!" << std::endl;}else{shares+= num;share_val = price;set_tot();}
}void Stock::sell(long num, double price)
{if (num < 0){std::cout << "number of shares can not be negative!.\n"<< "transaction is aborted!" << std::endl;}else if (num>shares){std::cout << "you can not sell more than you have ！"<< "transaction is aborted!\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: " << company<< " shares: " << shares << '\n';cout << " shares price :$ " << share_val;cout.precision(2);cout << " total worth :$ " << total_val << '\n';cout << "\n";cout.setf(orig, ios_base::floatfield);cout.precision(prec);
}

//main.cpp
#include<iostream>
#include"stock00.h"
using namespace std;
int main()
{{using std::cout;cout << "using constructors  to create new object \n\n";Stock stock1("Asmart", 12, 20.0);stock1.show();Stock stock2 = Stock("Bsmart", 2, 2.0);//注意这条语句与下面stock1 = Stock("Csmart", 10, 50.0);的区别stock2.show();cout << "assigning stock1 to stock2 :\n\n";stock2 = stock1;stock1.show();stock2.show();cout << "\n";cout << "unsign a constructor to reset an object: \n\n";stock1 = Stock("Csmart", 10, 50.0);//注意stock1对象已经存在，只是重新使用构造函数改变stock1的值stock1.show();cout << "done\n";}system("pause");return 0;
}

//输出结果
using constructors  to create new objectconstructor using Asmart called
company: Asmart shares: 12shares price :$ 20.000 total worth :$ 240.00constructor using Bsmart called
company: Bsmart shares: 2shares price :$ 2.000 total worth :$ 4.00assigning stock1 to stock2 :company: Asmart shares: 12shares price :$ 20.000 total worth :$ 240.00company: Asmart shares: 12shares price :$ 20.000 total worth :$ 240.00unsign a constructor to reset an object:constructor using Csmart called
bye, Csmart !
company: Csmart shares: 10shares price :$ 50.000 total worth :$ 500.00done
bye, Asmart !
bye, Csmart !
请按任意键继续. . .

程序说明：

1）创建stock对象：
第一种方法：

Stock stock1("Asmart", 12, 20.0);

第二种方法：
这里可能会通过调用构造函数来创建一个临时对象，然后将该临时对象复制到stock2中，并丢弃它（即使用析构函数）。）（注意：也有可能不会创建临时对象，视编译器的不同）

Stock stock2 = Stock("Bsmart", 2, 2.0);

2）使用构造函数重新给stock1赋值
这里是通过构造函数创建一个临时对象，然后将内容复制给stock1，随后程序将调用析构函数，以删除临时对象；（在输出结果中可以看到，当把内容复制到stock1之后，调用了析构函数）

cout << "unsign a constructor to reset an object: \n\n";stock1 = Stock("Csmart", 10, 50.0);

补充1：列表初始化

1）上面例子中类对象的初始化：

Stock stock1("Asmart", 12, 20.0);
或者
Stock stock2 = Stock("Bsmart", 2, 2.0);

2）c++11列表初始化：

Stock stock1={"Asmart", 12, 20.0};
Stock stock1 {"Asmart", 12, 20.0};//等号可以省略
Stock stock {};//使用默认构造函数进行初始化

补充2：const成员函数

下面的代码的第二行是不被编译器允许的，因为show()的代码无法保证调用对象land不被修改。我们之前通过将函数形参声明为const引用或者const指针，来解决这种问题。
但是这里show()没有形参，

const Stock land=Stock("kevin",20,12.0);
land.show();

解决办法：

void show() const;//函数声明void Stock::show() const//函数定义
{...
}