目录
- 类的构造函数和析构函数
- 构造函数
- 声明构造函数
- 定义构造函数
- 使用构造函数
- 默认构造函数
- 析构函数
- 析构函数的声明
- 析构函数的定义
- 改进Stock类(加入构造函数和析构函数)
类的构造函数和析构函数
构造函数
常规的初始化语法不适用类的初始化
例如：
int a = 10;//整型的初始化
struct thing
{
char *str;
int m;
};
//结构体初始化
struct thing t1 = {"test",666};
class Test
{
private:
int a;
int b；
public：
};
Test t1 = {22,33};//编译错误
不能像结构体一样初始化Test对象的原因是数据部分的访问状态是私有的，这意味着程序不能直接访问数据成员。
如果将数据成员成为公有，而不是私有，就可以像刚才那样初始化类对象，但使数据成为公有的违背了类的一个主要初衷:数据隐藏。
一般来说，最好是在创建对象时对它进行初始化。
声明构造函数
Stock(const std::string & co,long n = 0,double pr = 0.0);//设置默认值
定义构造函数
//构造函数,没有返回值
Stock::Stock(const std::string & co,long n,double pr)
{
company = co;
if(n<0)
{
std::cout << "Number of shares can't be nagative;"
<< company << " shares set to 0.\n";
shares = 0;
}
else
shares = n;
share_val = pr;
set_tot();
}
使用构造函数
Stock food = Stock("World Cabbage",250,1.25);//显示地调用
Stock food("World Cabbage",250,1.25);//隐式地调用
Stock *p1 = new Stock("games",18,19.0);//new动态分配内存
构造函数的使用方式不同于其他类方法，一般来说，使用对象来调用方法
food.show();
但无法使用对象来调用构造函数，因为在构造函数构造出对象之前，对象是不存在的，因此构造函数被用来创建对象，而不能通过对象来调用。
默认构造函数
Stock fluffy_the_cat;
如果没有提供任何构造函数，则C++将自动提供默认构造函数。它是默认构造函数的隐式版本。默认构造函数没有参数，因为声明中不包含值。
Stock::Stock(){ }
注意的是：
当没有定义任何构造函数时，编译器才会提供默认构造函数，为类定义了构造函数后，就必须为它提供默认构造函数，否则将出错。
#ifndef STOCK00_H_
#define STOCK00_H_
#include <string>
class Stock
{
private://可不写，默认是private
std::string company;
long shares;
double share_val;
double total_val;
void set_tot(){total_val = shares * share_val;}//内联函数
public:
Stock(const std::string & co,long n = 0,double pr = 0.0);//设置默认值
Stock(){}//默认构造函数
};
#endif
#include<iostream>
#include"stock00.h"
//构造函数,没有返回值
Stock::Stock(const std::string & co,long n,double pr)
{
company = co;
if(n<0)
{
std::cout << "Number of shares can't be nagative;"
<< company << " shares set to 0.\n";
shares = 0;
}
else
shares = n;
share_val = pr;
set_tot();
}
析构函数
用构造函数创建对象后，程序负责跟踪该对象，直到过期为止。对象过期时，程序将自动调用一个特殊的成员函数，即析构函数。
析构函数的声明
在类名前加上~
~Stock();
析构函数的定义
//析构函数
Stock::~Stock()
{
using std::cout;
cout << "Bye" << "!\n";
}
改进Stock类(加入构造函数和析构函数)
#ifndef STOCK00_H_
#define STOCK00_H_
#include <string>
class Stock
{
private://可不写，默认是private
std::string company;
long shares;
double share_val;
double total_val;
void set_tot(){total_val = shares * share_val;}//内联函数
public:
Stock(const std::string & co,long n = 0,double pr = 0.0);//设置默认值
Stock(){}//默认构造函数
~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
#include<iostream>
#include"stock00.h"
//定义成员函数时，使用作用域解析运算符::来标识函数所属的类
//构造函数,没有返回值
Stock::Stock(const std::string & co,long n,double pr)
{
company = co;
if(n<0)
{
std::cout << "Number of shares can't be nagative;"
<< company << " shares set to 0.\n";
shares = 0;
}
else
shares = n;
share_val = pr;
set_tot();
}
//析构函数
Stock::~Stock()
{
using std::cout;
cout << "Bye, " << company << "!\n";
}
void Stock::acquire(const std::string & co,long n,double pr)
{
company = co;
if(n<0)
{
std::cout << "Number of shares can't be nagative;"
<< company << " shares set to 0.\n";
shares = 0;
}
else
shares = n;
share_val = pr;
set_tot();
}
void Stock::buy(long num,double price)
{
if(num<0)
{
std::cout << "Number of shares purchased can't be negative. "
<< "Transaction is aborted.\n";
}
else
{
shares += num;
share_val = price;
set_tot();
}
}
void Stock::sell(long num,double price)
{
using std::cout;
if (num<0)
{
cout << "Number of shares sold can't be negative. "
<< "Transaction is aborted.\n";
}
else if(num > shares)
{
cout << "You can't 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;
cout << "Company: " << company << "Shares: "
<< shares << '\n' << "Share Price: $"
<< share_val << " Total Worth: $"
<< total_val << '\n';
}
#include<iostream>
#include"stock00.h"
int main()
{
/*
food.Sock(); 不能使用对象来调用构造函数
*/
#if 0
Stock food = Stock("World Cabbage",250,1.25);//显示地调用
Stock food("World Cabbage",250,1.25);//隐式地调用
food.show();
#endif
#if 1
/*
当没有定义任何构造函数时，编译器才会提供默认构造函数；假如定义了构造函数，没有定义默认构造函数，则 "Stock fluffy_the_cat"
这样的形式创建对象时会出错，默认构造函数是形参为空的函数，例如"Stock(){}"
*/
Stock fluffy_the_cat;
fluffy_the_cat.acquire("NanoSmart",20,12.50);
fluffy_the_cat.show();
fluffy_the_cat.buy(15,18.125);
fluffy_the_cat.show();
fluffy_the_cat.sell(400,20.00);
fluffy_the_cat.show();
fluffy_the_cat.buy(300000,40.125);
fluffy_the_cat.show();
fluffy_the_cat.sell(300000,0.125);
fluffy_the_cat.show();
#endif
return 0;
}
