C++ 知识点记录（4）对象和类（Cap10）

1. 抽象和类

1.1 C++中的类

        访问控制：（防止程序直接访问数据被称为数据隐藏）

public：使用类对象的程序都可以直接访问公有部分。公有成员函数是程序和对象的私有成员之间的桥梁，提供了对象和程序之间的接口。

private：只能通过共有成员函数（或友元函数）来访问对象的私有成员。不用使用关键字private，因为这是类对象的默认访问控制。

protected：

        类设计尽可能将公有接口和实现细节分开，公有接口表示设计的抽象组件。将实现细节放在一起并将它们与抽象分开被称为封装。

封装：数据隐藏；将实现的细节隐藏在私有部分中；将类函数定义和类声明放在不同的文件中。

1.2 实现类成员函数

        成员函数和常规函数的区别：

• 定义成员函数时，使用作用域解析运算符（::）来标识函数所属的类；（类作用域）
• 类方法可以访问类的private组件

        创建的每个新对象都有自己的存储空间，用于存储其内部变量和类成员，但同一个类的所有对象共用一组类方法，即每种方法只有一个副本。

2. 类的构造函数和析构函数

        注意看代码：

// stock.h
#ifndef STOCK_H_
#define STOCK_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(const std::string& co, long n = 0, double pr = 0.0);
	// 默认构造函数
	Stock();
	// 默认构造函数第二种方法：
//	Stock(const std::string& co = "Error", 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() const;
};

#endif

// stock.cpp

#include <iostream>
#include "stock.h"

// 构造函数，程序声明对象时，将自动调用构造函数
// 注意，参数名不能与类成员相同
// 接受一个参数的构造函数允许使用赋值语法将对象初始化为一个值
Stock::Stock(const std::string& co, long n, double pr) {
	company = co;
	if (n < 0) {
		std::cout << "Number of shares can't be negative; "
			<< company << " shares set to 0.\n";
		shares = 0;
	}
	else
		shares = n;
	share_val = pr;
	set_tot();
}

// 默认构造函数
Stock::Stock() {
	company = "no name";
	shares = 0;
	share_val = 0.0;
	total_val = 0.0;
}

// 析构函数
Stock::~Stock() {

}

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() const {
	using std::cout;
	using std::ios_base;
	// 设置定点表示法
	ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
	// 使用定点表示法时，显示3位小数
	std::streamsize prec = cout.precision(3);

	cout << "Company: " << company
		<< " Shares: " << shares << '\n'
		<< " Shares Price: $" << share_val;
	// 显示2位小数
	cout.precision(2);
	cout << " Total Worth: $" << total_val << std::endl;
	// 恢复原始格式设置
	cout.setf(orig, ios_base::floatfield);
	cout.precision(prec);	
}

#include <iostream>
#include "stock.h"

int main() {
	// 显示调用构造函数
	Stock food = Stock("World Cabbage", 250, 1.25);
	// 隐式调用构造函数
	Stock garment("Furry Mason", 50, 2.5);
	// 每次创建类对象，甚至使用new动态内存分配时，C++都使用类构造函数
	Stock* pstock = new Stock("Electroshock Games", 18, 19.0);
	// 如果没有提供任何构造函数，则C++将自动提供默认构造函数，它是默认构造函数的隐式版本
	// 注意：只有没有定义任何构造函数时，编译器才会提供默认构造函数；如果定义了构造函数，程序员需要自己提供默认构造函数，否则出错

	// 注意：输出表明，下面两条语句有根本性的差别：