类

面向对象编程（OOP）

• 抽象；
• 封装和数据隐藏；
• 多态；
• 继承；
• 代码的可重用性

C++中的类

一般来说，类由两部分组成：

• 类声明：以数据成员的方式描述数据部分，以成员函数（被称为方法）的方式描述公有接口；
• 类方法定义：描述如何实现类成员函数。

通常 ，将接口（类定义）放在头文件中，将实现（类方法的代码）放在源代码文件中。

程序10.1 stock00.h

#ifndef STOCK00_H_
#define STOCK00_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:
    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 // !STOCK00_H_

1.访问控制
public private protected描述了对类成员的访问控制。
使用类对象的程序都可以直接访问公有部分，但只能通过公有成员函数（或友元函数）来访问对象的私有成员。

类设计尽可能将公有接口与实现细节分开。公有接口表示设计的抽象组件。将实现细节放在一起并将它们与抽象分开称为封装。
数据隐藏（将数据放在类的私有部分）是一种封装，将实现的细节隐藏在私有部分中也是一种封装。

2.控制对成员的访问：公有还是私有

无论类成员是数据成员还是成员函数，都可以在类的公有部分或私有部分中声明它。
但由于隐藏数据是OOP的主要目标之一，因此数据项通常放在私有部分，组成类接口的成员函数放在公有部分。

不必在类声明中使用关键字private，因为这是类对象的默认访问控制。

实现类成员函数

成员函数和常规函数，都有函数头和函数体，也可以由返回类型和参数，但还有两个特殊的特征：

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

程序10.2 stock00.cpp

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

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.\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()
{
    std::cout << "Company: " << company
        << " Shares: " << shares << '\n'
        << " Share Price: $" << share_val
        << " Total Worth: $" << total_val << '\n';
}

定义位于类声明中的函数都将自动成为内联函数，因此Stock::set_tot()是一个内联函数。类声明常将短小的成员函数作为内联函数。

也可以在类声明之外定义成员函数，使之成为内联函数。为此，只需在类实现部分定义函数时使用inline即可。

3.使用类
C++的目标是使得使用类与使用基本的内置类型尽可能相同。

程序10.3 usestock0.cpp

#include <iostream>
#include "stock00.h"
int main()
{
    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();
    system("pause");
    return 0;
}

可以修改Stock::show():

void Stock::show()
{
    using std::cout;
    using std::ios_base;
    //set format to #.###
    ios_base::fmtflags orig =
        cout.setf(ios_base::fixed, ios_base::floatfield);
    std::streamsize prec = cout.precision(3);

    cout << "Company: " << company
         << " Shares: " << shares << '\n'
         << " Share Price: $" << share_val;
    cout.precision(2);
    cout << " Total Worth: $" << total_val << '\n';

    //restore orginal format
    cout.setf(orig, ios_base::floatfield);
    cout.precision(prec);
}

重新编译，得到：

---

指定类设计的第一步是提供类声明。类声明类似结构声明，可以包括数据成员和函数成员。声明私有部分，在其中声明的成员只能通过成员函数进行访问；声明还有公有部分，在其中声明的成员可以被使用类对象的程序直接访问。通常，数据成员被放在私有部分，成员函数被放在公有部分，典型的类声明格式如下：

class className
{
private:
    data member declarations
public:
    member function prototype
};

公有部分的内容构成了设计的抽象部分——公有接口。将数据封装到私有部分中可以保护数据的完整性，这被称为数据隐藏。C++通过类使得实现抽象、数据隐藏和封装等OOP特性很容易。

指定类设计的第二步是实现类成员函数。可以在类声明中提供完整的函数定义，而不是函数原型，但是通常的做法是单独提供函数定义（除非函数很小）。