第10章 对象和类

10.1 过程性编程和面相对象编程

采用OOP方法时，首先从用户的角度考虑对象——描述对象所需的数据以及描述用户与数据交互所需的操作。完成对接口的描述后，需要确定如何实现接口和数据存储。最后，使用新的设计方案创建出程序。

10.2 抽象和类

将问题的本质特征抽象出来，并根据特征来描述解决方案。
抽象是通往用户定义类型的捷径。在C++中，用户定义类型指的是实现抽象接口的类设计。

10.2.1 类型是什么

指定基本类型完成了三项工作：
（1）决定数据对象需要的内存数量
（2）决定如何解释内存中的位（long和float在内存中占用的位数相同，但将它们转换为数值的方法不同）
（3）决定可使用数据对象执行的操作或方法
对于内置类型来说，有关操作的信息被内置到编译器中。但在C++中定义用户自定义的类型时，必须自己提供这些信息。

10.2.2 C++中的类

类是一种将抽象转换为用户定义类型的C++工具，它将数据表示和操纵数据的方法组合成一个整洁的包。
类规范由两个部分组成：
（1）类声明：以数据成员的方式描述数据部分，以成员函数（被称为方法）的方式描述公有接口
（2）类方法定义：描述如何实现类成员函数
通常，C++程序员将接口（类定义）放在头文件中，并将实现（类方法的代码）放在源代码文件中。

// 程序清单10.1 stock00.h--Stock class interface
#ifndef STOCK00_H_
#define STOCK00_H_

#include 

class Stock
{
    private:
        std::string company;
        long shares;
        double share_val;
        double total_val;
        void set_tot()
        {

            total_val = shares * share_val;
        }

    public:
        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

一、访问控制
访问控制关键字：private、public、protected，它们描述了对类成员的访问控制。
使用类对象的程序都可以直接访问公有部分，但只能通过公有成员函数（或友元函数）来访问对象的私有成员。防止程序直接访问数据被称为数据隐藏。

类设计尽可能将公有接口与实现细节分开。公有接口表示设计的抽象组件。将实现细节放在一起并将它们与抽象分开被称为封装。
封装的例子：
（1）数据隐藏是一种封装，将实现的细节隐藏在私有部分中
（2）将类函数定义和类声明放在不同的文件中
二、控制对成员的访问：公有还是私有
无论类成员是数据成员还是成员函数，都可以在类的公有部分或私有部分中声明它。但由于隐藏数据是OOP主要的目标之一，因此数据项通常放在私有部分，组成类接口的成员函数放在公有部分；也可以把成员函数放在私有部分中，不能直接从程序中调用这种函数，但公有方法可以使用它们。通常，程序员使用私有成员函数来处理不属于公有接口的实现细节。
结构的默认访问类型是public，类的默认访问类型是private。

10.2.3 实现类成员函数

（1）定义成员函数时，使用作用域解析运算符（::）来标识函数所属的类，类方法的完整名称中包括类名。
（2）类方法可以访问类的private组件。

// 程序清单10.2 stock00.cpp--implementing the Stock class
#include 
#include "stock00.h"

// Stock::acquire()是函数的限定名
// acquire()是全名的缩写，非限定名，只能在类作用域中使用
void Stock::acquire(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." << std::endl;
        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." << 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 sold can't be negative. Transaction is aborted." << std::endl;
    } else if (num > shares) {
        std::cout << "You can't sell more than you have! Transaction is aborted." << std::endl;
    } else {
        shares -= num;
        share_val = price;
        set_tot();
    }
}

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

void Stock::show()
{
    std::cout << "Company: " << company << std::endl;
    std::cout << "Shares: " << shares << std::endl; 
    std::cout << "Share Price: $" << share_val << std::endl;
    std::cout << "Total Worth: $" << total_val << std::endl;
}

一、成员函数说明
二、内联方法
其定义位于类声明中的函数都将自动成为内联函数，类声明常将短小的成员函数作为内联函数。也可以在类声明之外定义成员函数，并使其成为内联函数。为此，只需在类实现部分中定义函数时使用inline限定符即可。内联函数的特殊规则要求在每个使用它们的文件中都对其进行定义。确保内联定义对多文件程序中的所有文件都可用的最简单的方法是：将内联定义放在定义类的头文件中。

class Stock
{
private:
	void set_tot();	
};
inline void Stock::set_tot()
{
	total_val = shares * share_val;
}

三、方法使用哪个对象
调用成员函数时，它将使用被用来调用它的对象的数据成员。
所创建的每个新对象都有自己的存储空间，用于存储其内部变量和类成员；但同一个类的所有对象共享同一组类方法，即每种方法只有一个副本。

10.2.4 使用类

// 程序清单10.3 usestock0.cpp--the client program
#include 
#include "stock00.h"

int main(void)
{
    Stock fluffy_the_cat;
    fluffy_the_cat.acquire("NanoSmart", 20, 12.5);
    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();

    return 0;
}