c++ primer plus总结

chapter 10

类的定义和实例化

1.类是一种自定义类型，类似于结构体，不同的是结构体是将各种所需的数据类型封装在一个结构体中，而类除了封装数据类型，还有对于这些数据类型的操作方法（函数），类结构分为私有部分和公有部分。
外界使用类的实例化对象只能访问共有部分，私有部分通过共有成员函数来间接访问私有部分。
通常将数据类型封装在私有部分，来保证数据安全性

//类定义
//类函数申明
//数据对象默认属于私有
class Stock {
private:
	std::string company;
	long shares;
	double share_val;
	double total_val;
	void set_tot() { total_val = share_val * share_val; }//在类申明时定义的函数，称作内联函数
public:
//这五个不是内联函数，只是对函数进行申明，未在类申明中实现函数定义
	void Stock(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();
};
//可以在类声明之外定义，加上inline限定符，表明内联函数
/*
inline void set_tot() { total_val = share_val * share_val; }
*/

//类的实例化,类似于结构体的定义
Stock sally;

2.函数功能通常单独书写，作为类描述文件的第二部分

• 定义类成员函数时，使用解析运算符：：来表明函数所属类。同时可以允许不同类有相同名称的成员函数。
• 在类的成员函数内部调用其他函数，则可以直接调用。

#include "Stack.h"
#include<iostream>
using namespace std;
void Stock::acquire(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		cout << "Number of the shares can not be negative " << company << "shares set to be zero" << endl;
		shares = 0;
	}
	else {
		shares = n;
	}
	share_val = pr;
	set_tot();
}
void Stock::buy(long num, double price) {
	if (num < 0) {
		cout << "Number of the shares can not be negative,trannsaction is aborted" << endl;
	}
	else {
		shares += num;
		share_val = price;
		set_tot();
	}
}
void Stock::sell(long num, double price) {
	if (num < 0) {
		cout << "Number of the shares can not be negative,trannsaction is aborted" << endl;
	}
	else if (num > shares)
	{
		cout << "Number of the shares are not enough,trannsaction is aborted" << endl;
	}
	else {
		shares-=num;
		share_val = price;
		set_tot();
	}
}
void Stock::update(double price) {
	share_val = price;
	set_tot();
}
void Stock::show() {
	cout << "company:" << company << endl;
	cout << "shares" << shares << endl;
	cout << "share price:" << share_val << endl;
	cout << "total worth:" << total_val<<endl;
}

类构造函数和析构函数

构造函数

1.定义构造函数
通过成员函数对类内部数据进行初值设置

//构造函数定义
//函数名与类名同名
//无返回值
Stock::Stock(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		cout << "Number of the shares can not be negative " << company << "shares set to be zero" << endl;
		shares = 0;
	}
	else {
		shares = n;
	}
	share_val = pr;
	set_tot();
}

需要注意的是，构造函数的参数表示的并不是类成员，而是赋给类成员的值，即用构造函数的形参给类成员赋值。因此，参数名不能与类对象相同
避免混乱1.在数据成员名称前用m_前缀 2.在成员名后使用后缀_

2.自定义构造函数
两种调用方式

	Stock stock1=Stock("worldCabbage",250,1.26);//显式调用
	Stock garment("Furry MAson", 50, 1.3);//隐式调用
    Stock tubby = 32; //构造函数只有一个参数时,不推荐

3.默认构造函数
在没有提供构造函数时，提供默认构造函数，用于下面这种声明

    Stock flufyy;

默认构造函数定义

/*-------方法一---------*/
//默认构造函数在函数声明时，赋予参数初值
    Stock(const std::string &co="ERROR", long n=0, double pr=1.25)；

//函数定义不变
Stock::Stock(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		cout << "Number of the shares can not be negative " << company << "shares set to be zero" << endl;
		shares = 0;
	}
	else {
		shares = n;
	}
	share_val = pr;
	set_tot();
}

/*-------方法二---------*/

//声明时不带参数
Stock()；
//定义时赋予
Stock::Stock() {
	company="NULL";
    shares=0;
    share_val=1.0;
    total_val=1.0;
}

//在创建对象，未赋初值时，会自动调用默认构造函数
	Stock stockl;

两种调用方式

Stock first;//隐式调用
Stock first = Stock();//显式调用
Stock *pre=new Stock;//开辟内存空间的同时，隐式调用

//容易误导的形式
Stock first("contrest");//这是调构造函数的方式，向内传递了自定义值
Stock second();//这是函数，不带参数，返回值为Stock类类型
Stock thirdl;//调用默认构造函数

析构函数

析构函数负责追踪对象，在对象结束后，完成清理工作。例如构造函数用new来分配内存，则析构函数使用delete来释放内存
命名方式：在构造函数前加上~

~Stock();
//Stock类不承担工作，所以为不进行任何操作的函数 
Stock::~Stock(){
}

const成员函数

//对于const修饰的类对象，调用其成员函数时，同样需要在函数定义与声明时加上const限定
void show() const;
void Stock::show() const
{
}

const Stock land=Stock("klu",3,3.0);
land.show();