九. 对象和类
面向对象编程（OOP）是一种特殊的、设计程序的概念性方法。下面是最重要的OOP特性：
· 抽象；
· 封装和数据隐藏；
· 多态；
· 继承；
· 代码的可重用性。
为了实现这些特性并将它们组合在一起，C++所做的最重要的改进就是提供了类。
9.1 过程性编程和面向对象编程
采用OOP方法时，首先从用户的角度考虑对象——描述对象所需的数据以及描述用户与数据交互所需的操作。完成对接口的描述后，需要确定如何实现接口和数据存储。最后，使用新的设计方案创建出程序。
9.2 抽象和类
在C++中，用户定义类型指的是实现抽象接口的类设计。
9.2.1 类型是什么
指定基本类型完成了三项工作：
· 决定数据对象需要的内存数量；
· 决定如何解释内存中的炜（long和float在内存中占用的位数相同，但将它们转换为数值的方法不同）；
· 决定可使用数据对象执行的操作或方法。
9.2.2 C++中的类
类是一种将抽象转换为用户定义类型的C++工具，它将数据表示和操纵数据的方法组合成一个整洁的包。下面来看一个表示股票的类。
可执行的操作有：
· 获得股票；
· 增持；
· 卖出股票；
· 更新股票价格；
· 显示关于所持股票的信息。
可以根据上述清单定义stock类的共有接口，为支持该接口，将存储下面的信息：
· 公司名称；
· 所持股票的数量；
· 每股的价格；
· 股票总值。
接下来定义类。一般来说，类规范由两个部分组成。
· 类声明：以数据成员的方式描述数据部分，以成员函数（被称为方法）的方式描述共有接口。
· 类方法定义：描述如何实现类成员函数。
简单地说，类声明提供了类的蓝图，而方法定义则提供了细节。
接口
接口是一个框架，供两个系统（如在计算机和打印机之间或者用户和计算机程序之间）交互时使用。对于类，我们说公共接口。在这里，公众（public）时使用类的程序，交互系统由类对象组成，而接口由编写类的人提供的方法组成。接口让程序员能够编写与类对象交互的代码，从而让程序能够使用类对象。例如，要计算string对象中包含多少个字符，您无需打开对象，而只需使用string类提供的size()方法。类设计禁止公共用户直接访问类，但公众可以使用方法size()。方法size()是用户和string类对象之间的公共接口的组成部分。
通常，C++程序员将接口（类定义）放在头文件中，并将实现（类方法的代码）放在源代码文件中。
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首先，C++关键字class指出这些代码定义了一个类设计。这种语法指出，Stock是这个新类的类型名。该声明让我们能够声明Stock类型的变量——称为对象或实例。每个对象都表示一支股票。
1. 访问控制
关键字private和public也是新的，它们描述了对类成员的访问控制。使用类对象的程序都可以直接访问共有部分，但只能通过公有成员函数（或友元函数）来访问对象的私有成员。因此，共有成员函数是程序和对象的私有成员之间的桥梁，提供了对象和程序之间的接口。防止程序直接访问数据被称为数据隐藏。C++还提供了第三个访问控制关键字protected，后续在介绍类继承时讨论。
类设计尽可能将共有接口与实现细节分开。共有接口表示设计的抽象组件，将实现细节放在一起并将它们与抽象分开被称为封装。数据隐藏（将数据放在类的私有部分中） 是一种封装，将实现的细节隐藏在私有部分中（就像Stock类对set_tot()所做的那样），也是一种封装。封装的另一个例子是 ，将类函数定义和类声明放在不同的文件中。
2. 控制对成员的访问：共有还是私有
无论类成员是数据成员还是成员函数，都可以在类的公有部分或私有部分中声明它。但由于隐藏数据是OOP 主要的目标之一，因此数据项通常放在私有部分，组成类接口的成员函数放在公有部分；否则，就无法从程序中调用这些函数。正如 Stock 声明所表明的，也可以把成员函数放在私有部分中。不能直接从程序中调用这种函数，但公有方法却可以使用它们。通常，程序员使用私有成员函数来处理不属于公有接口的实现细节。
类和结构
类描述看上去很像是包含成员函数以及 public 和 private 可见性标签的结构声明。实际上，C++对结构进行了扩展，使之具有与类相同的特性。它们之间唯一的区别是，结构的默认访问类型是 public，而类为private。C++程序员通常使用类来实现类描述，而把结构限制为只表示纯粹的数据对象(常被称为普通老式数据(POD，Plain Old Data)结构)。
9.2.3 实现类成员函数
还需创建类描述的第二部分：为那些由类声明中的原型表示的成员函数提供代码。成员函数定义与常规函数定义非常相似，它们有函数头和函数体，也可以有返回类型和参数。但是它们还有两个特殊的特征：
· 定义类成员函数时，使用作用域解析运算符（::）来标识函数所属的类；
· 类方法可以访问类的private组件。
首先，成员函数的函数头使用作用域解析运算符（::）来指出函数所属的类。例如，update()成员函数的函数头如下：
void Stock::update(double price)
这种表示法意味着我们定义的update()函数是Stock类的成员，这不仅将update()标识为成员函数，还意味着我们可以将另一个类的成员函数也命名为update()。例如，Buffoon()类的update()函数的函数头如下：
void Buffoon::update()
因此，作用域解析运算符确定了方法定义对应的类的身份。我们说，标识符update()具有类作用域（class scope）。Stock类的其他成员函数不必使用作用域解析运算符，就可以使用update()方法，这是因为它们属于同一个类，因此update()是可见的。然而，在类声明和方法定义之外使用update() 时，需要采取特殊措施，后面将介绍。
类方法的完整名称中包括类名，Stock::update()是函数的限定名；而简单的update()是全名的缩写，它只能在类作用域中使用。
方法的第二个特点是，方法可以访问类的私有成员。
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 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. "
<< "Translation 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. "
<< "Translation is aborted.\n";
}
else if (num > shares) {
cout << "You can't sell more than you have: "
<< "Traslation 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';
}settot()被声明为私有成员函数，这种方法的主要价值在于，通过使用函数调用，而不是每次重新输入计算代码，可以确保执行的计算完全相同。另外，如果必须修订计算代码，则只需在一个地方进行修改即可。
其定义位于类声明中的函数都将自动成为内联函数，因此Stock::set_tot()是一个内联函数。类声明常将短小的成员函数作为内联函数，set_tot()符合这样的要求。
如何将类方法应用于对象
下面的代码使用了一个对象的shares成员：
shares += num;
首先来看看如何创建对象。最简单的方式是声明类变量：
Stock kate, joe;
接下来，看看如何使用对象的成员函数。和使用结构成员一样，通过成员运算符：
kate.show();
jow.show();
第一条语句调用kate对象的show()成员，这意味着show()方法把shares解释为kate.shares，将share_val解释为kate.share_val。即调用成员函数时，它将使用被用来调用它的对象的数据成员。
所创建的每个新对象都有自己的存储空间，用于存储其内部变量和类成员；但同一个类的所有对象共享同一组类方法，即每种方法只有一个副本。在OOP中，调用成员函数被称为发送消息，因此将同样的消息发送给两个不同的对象将调用同一个方法，但该方法被用于两个不同的对象。
9.2.4 使用类
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();
return 0;
}客户/服务器模型
OOP 程序员常依照客户/服务器模型来讨论程序设计。在这个概念中，客户是使用类的程序。类声明（包括类方法)构成了服务器，它是程序可以使用的资源。客户只能通过以公有方式定义的接口使用服务器这意味着客户(客户程序员)唯一的责任是了解该接口。服务器(服务器设计人员)的责任是确保服务器根据该接口可靠并准确地执行。服务器设计人员只能修改类设计的实现细节，而不能修改接口。这样程序员独立地对客户和服务器进行改进，对服务器的修改不会客户的行为造成意外的影响。
9.2.6 小结
指定类设计的第一步是提供类声明。类声明类似结构声明，可以包括数据成员和函数成员。声明有私有部分，在其中声明的成员只能通过成员函数进行访问；声明还具有公有部分，在其中声明的成员可以被使用类对象的程序直接访问。通常，数据成员被放在私有部分中，成员函数被放在共有部分中，因此典型的声明格式如下：
class MyClass {
public:
// 构造函数和析构函数
MyClass();
~MyClass();
// 成员函数声明
void myFunction();
// 声明静态变量
static int myStaticVariable;
private:
// 成员变量声明
int myVariable;
};公有部分的内容构成了设计的抽象部分——共有接口。将数据封装到私有部分可以保护数据的完整性，这被称为数据隐藏。因此，C++通过类使得实现抽象、数据隐藏和封装等OOP特性很容易。
指定类设计的第二步是实现类成员函数。可以在类声明中提供完整的函数定义，而不是函数原型，但是通常的做法是单独提供函数定义（除非函数很小）。在这种情况下，需要使用域解析运算符来指出成员函数属于哪个类。如下所示：
char* Bozo::Retot()
要创建对象（类的实例），只需将类名视为类型名即可。
类成员函数（方法）可通过类对象来调用，通过使用成员运算符句点。
9.3 类的构造函数和析构函数
对于Stock类，还有其他一些工作要做，应为类提供被称为构造函数和析构函数的标准函数。C++的目标之一是让使用类对象就像使用标准类型一样，不能像初始化标准类型那样来初始化Stock对象，因为数据部分的访问时私有的，这意味着程序不能直接访问数据成员。程序只能通过成员函数来访问数据成员，因此需要设计合适的成员函数，才能成功地将对象初始化。
一般来说，最好是在创建对象时对它进行初始化，为此，C++提供了一个特殊的成员函数——类构造函数，专门用于构造新对象、将值赋给它们的数据成员。名称与类名相同。例如，Stock类一个可能的构造函数是名为Stock()的成员函数。构造函数的原型和函数头有一个有趣的特征——没有返回值，也没有被声明为void类型。实际上，构造函数没有声明类型。
9.3.1 声明和定义构造函数
Stock的构造函数原型：
Stock(const string& co, long n = 0, double pr = 0.0);
注意，没有返回类型，原型位于类声明的公有部分。程序声明对象时，将自动调用构造函数。
成员名和参数名
以下做法是错误的：
Stock::Stock(const string& company, long shares, double share_val) {
}
构造函数的参数表示的不是类成员，而是赋给类成员的值。因此，参数名不能与类成员相同，否则最终的代码将是这样的：
shares = shares;
为避免这种混乱，一种常见的做法是在数据成员名中使用m_前缀：
class Stock{
private:
string m_company;
long m_shares;
...
另一种常见的做法是，在成员名中使用后缀_：
class Stock{
private:
string company_;
lonf shares_;
9.3.2 使用构造函数
C++提供了两种使用构造函数来初始化对象的方式。第一种方式是显式地调用构造函数：
Stock food = Stock("World Cabbage", 250, 1.25);
另一种方式是隐式地调用构造函数：
Stock food("World Cabbage", 250, 1.25);
这种格式更紧凑，它与上面的显式调用等价。
每次创建类对象（甚至使用new动态分配内存）时，C++都使用类构造函数。下面是将构造函数与new一起使用地方法：
Stock* pstock = new Stock( "Electoshock Games", 18, 19.0 );
这条语句创建一个Stock对象，将其初始化为参数提供的值，并将该对象的地址赋给pstock指针。在这种情况下，对象没有名称，但可以使用指针来管理对象。
构造函数的使用方式不同于其他类方法。一般来说，使用对象来调用方法：
stock1.show();
但无法使用对象来调用构造函数，因为在构造函数构造出对象之前，对象时是不存在的，因此构造函数被用来创建对象，而不能通过对象来调用。
9.3.3 默认构造函数
默认构造函数是在未提供显式初始值时，用来创建对象的构造函数。也就是说，它是用于下面这种声明的构造函数：
stock fluffy_the_cat;
如果没有提供任何构造函数，则C++将自动提供默认构造函数，它是默认构造函数的隐式版本。当且仅当没有定义任何构造函数时，编译器才会提供默认构造函数。为类定义了构造函数后，程序员就必须为它提供默认构造函数。
定义默认构造函数的方式有两种，一种是给已有构造函数的所有参数提供默认值：
Stock(const string& co = "Error", int n = 0, double pr = 0.0);
另一种方式是通过函数重载来定义另一个构造函数——一个没有参数的构造函数：
stock();
实际上，通常应初始化所有的对象，以确保所有的成员一开始就有已知的合理值。因此，用户定义的默认构造函数通常给所有成员提供隐式初始值。例如，下面是为Stock类定义的一个默认构造函数：
Stock::Stock(){
company = "no name";
shares = 0;
share_val = 0.0;
total_val = 0.0;
}
在设计类时，通常应提供对所有类成员做隐式初始化的默认构造函数。
使用上述任何一种方式（没有参数或所有参数都有默认值）创建了默认构造函数后，便可以声明对象变量，而不对它们进行显式初始化：
Stock first;
Stock first = Stock();
Stock* prelief = new stock;
9.3.4 析构函数
用构造函数创建对象后，程序负责跟踪对象，直到其过期为止，此时程序将调用一个特殊的成员函数——析构函数，来完成清理工作。
和构造函数一样，析构函数的名称也很特殊：在类名前加上~。因此，Stock类的析构函数为~Stock()。另外，和构造函数一样，析构函数也可以没有返回值和声明类型。与构造函数不同的是，析构函数没有参数，因此Stock析构函数的原型必须是这样的：
~Stock();
由于析构函数不承担任何重要工作，因此可以将它编写为不执行任何操作的函数。
什么时候应调用析构函数呢?这由编译器决定，通常不应在代码中显式地调用析构函数。如果创建的是静态存储类对象，则其析构函数将在程序结束时自动被调用。如果创建的是自动存储类对象(就像前面的示例中那样)，则其析构函数将在程序执行完代码块时(该对象是在其中定义的)自动被调用。如果对象是通过new 创建的，则它将驻留在栈内存或自由存储区中，当使用delete 来释放内存时，其析构函数将自动被调用。最后，程序可以创建临时对象来完成特定的操作，在这种情况下，程序将在结束对该对象的使用时自动调用其析构函数。
由于在类对象过期时析构函数将自动被调用，因此必须有一个析构函数。如果程序员没有提供析构函数，编译器将隐式地声明一个默认析构函数，并在发现导致对象被删除的代码后，提供默认析构函数的定义。
9.3.5 改进Stock类
stock10.h
#ifndef STOCK10_H_
#define STOCK10_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();
Stock(const std::string& co, 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();
};
#endifstock10.cpp
#include <iostream>
#include "stock10.h"
Stock::Stock() {
std::cout << "Default constructor called\n";
company = "no name";
shares = 0;
share_val = 0.0;
total_val = 0.0;
}
Stock::Stock(const std::string& co, long n, double pr) {
std::cout << "Constructor using " << co << " called\n";
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() {
std::cout << "Bye, " << company << "!\n";
}
void Stock::buy(long num, double price) {
if (num < 0) {
std::cout << "Number of shares purchased can't be negative. "
<< "Translation 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. "
<< "Translation is aborted.\n";
}
else if (num > shares) {
cout << "You can't sell more than you have: "
<< "Traslation 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;
using std::ios_base;
ios_base::fmtflags orig =
cout.setf(ios_base::fixed, ios_base::floatfield);
std::streamsize prec = cout.precision(3);
cout << "Company: " << company
<< " Shares: " << shares << '\n';
cout << " Share price: $" << share_val;
cout.precision(2);
cout << " Total Worth: $" << total_val << '\n';
cout.setf(orig, ios_base::floatfield);
cout.precision(prec);
}usestock2.cpp
#include <iostream>
#include "stock10.h"
int main() {
{
using std::cout;
cout << "Using constructors to create new objects\n";
Stock stock1("NanoSmart", 12, 20.0);
stock1.show();
Stock stock2 = Stock("Bofo Objects", 2, 2.0);
stock2.show();
cout << "Assigning stock1 to stock2:\n";
stock2 = stock1;
cout << "Listing stock1 and stock2:\n";
stock1.show();
stock2.show();
cout << "Using a constructor to reset an object\n";
stock1 = Stock("Nifty Foods", 10, 50.0);
cout << "Revised stock1:\n";
stock1.show();
cout << "Done\n";
}
return 0;
}在默认情况下，将一个对象赋给同类型的另一个对象时，C++将源对象的每个数据成员的内容复制到目标对象中相应的数据成员中。
const成员函数
为了保证函数不会修改调用对象，C++将const关键字放在函数的括号后面：
void show() const;
同样，函数的定义：
void stock::show() const;
以这种方式声明和定义的类函数被称为const成员函数，只要类方法不修改调用对象，就应将其声明为const。
9.3.6 构造函数和析构函数小结
构造函数是一种特殊的类成员函数，在创建类对象时被调用。构造函数的名称和类名相同，但通过函数重载，可以创建多个同名的构造函数，条件是函数的特征标（参数列表）都不同。另外，构造函数没有声明类型。通常，构造函数用于初始化类对象的成员，初始化应与构造函数的参数列表匹配。
默认构造函数没有参数，因此如果创建对象时没有进行显式地初始化，则将调用默认构造函数。如果程序中没有提供任何构造函数，则编译器会为程序定义一个默认构造函数；否则，必须自己提供默认构造函数。默认构造函数可以没有任何参数；如果有，则必须给所有参数都提供默认值。
对于未被初始化的对象，程序将使用默认构造函数来创建。
就像对象被创建时将调用构造函数一样，当对象被删除时，程序将调用析构函数，每个类都只能有一个析构函数。析构函数没有返回类型，也没有参数，其名称为类名称前加上~。
如果构造函数使用了new，则必须提供使用delete的析构函数。
9.4 this指针
对于Stock类，还有很多工作要做。到目前为止，每个类成员都只涉及一个对象，即调用它的对象。但有时候方法可能涉及到两个对象，在这种情况下需要使用C++的this指针。
this指针指向用来调用成员函数的对象（this被作为隐藏参数传递给方法）。一般来说，所有的类方法都将this指针设置为调用它的对象的地址。
每个成员函数（包括构造函数和析构函数）都有一个this指针。this指针指向调用对象。如果方法需要引用整个调用对象，则可以使用表达式*this。在函数的括号后面使用const限定符将this限定为const，这样将不能使用this来修改对象的值。
然而，要返回的并不是this，因为this是对象的地址，而不是对象本身，即*this（将解除引用运算符*用于指针，将得到指针指向的值）。现在，可以将*this作为调用对象的别名来完成前面的方法定义。
stock20.h
#ifndef STOCK20_H_
#define STOCK20_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();
Stock(const std::string& co, 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 Stock& topval(const Stock& s) const;
};
#endifstock20.cpp
#include <iostream>
#include "stock20.h"
Stock::Stock() {
std::cout << "Default constructor called\n";
company = "no name";
shares = 0;
share_val = 0.0;
total_val = 0.0;
}
Stock::Stock(const std::string& co, long n, double pr) {
std::cout << "Constructor using " << co << " called\n";
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() {
std::cout << "Bye, " << company << "!\n";
}
void Stock::buy(long num, double price) {
if (num < 0) {
std::cout << "Number of shares purchased can't be negative. "
<< "Translation 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. "
<< "Translation is aborted.\n";
}
else if (num > shares) {
cout << "You can't sell more than you have: "
<< "Traslation 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;
using std::ios_base;
ios_base::fmtflags orig =
cout.setf(ios_base::fixed, ios_base::floatfield);
std::streamsize prec = cout.precision(3);
cout << "Company: " << company
<< " Shares: " << shares << '\n';
cout << " Share price: $" << share_val;
cout.precision(2);
cout << " Total Worth: $" << total_val << '\n';
cout.setf(orig, ios_base::floatfield);
cout.precision(prec);
}
const Stock& Stock::topval(const Stock& s) const {
if (s.total_val > total_val)
return s;
else
return *this;
}9.5 对象数组
usestock2.cpp
#include <iostream>
#include "stock20.h"
const int STKS = 4;
int main() {
Stock stocks[STKS] = {
Stock("NanaSmart",12,20.0),
Stock("Boffo Objects",200,2.0),
Stock("Monolithic Obelisks",130,3.25),
Stock("Fleep Enterprises",60,6.5)
};
std::cout << "Stock holding:\n";
int st;
for (st = 0; st < STKS; st++)
stocks[st].show();
const Stock* top = &stocks[0];
for (st = 1; st < STKS; st++)
top = &top->topval(stocks[st]);
std::cout << "\nMost valuable holding:\n";
top->show();
return 0;
}9.6 类作用域
在类中定义的名称（如类数据成员名和类成员函数名）的作用域都为整个类，作用域为整个类的名称只在该类中是已知的，在类外是不可知的。因此，可以在不同类中使用相同的类成员名而不会引起冲突。另外类作用域意味着不能从外部直接访问类的成员，公有成员函数也是如此。也就是说，调用公有成员函数，必须通过对象。
同样，在定义成员函数时，必须使用作用域解析运算符。
9.6.1 作用域为类的常量
作用域为类的常量指的是在类的范围内定义且值不可改变的常量，这些常量通常是静态的，意味着它们属于类本身而不是类的任何实例。这种常量通常用来定义应在类中所有实例之间共享且不应更改的数据。
在C++中，常量可以通过在类内部使用static const关键字来定义。如果是整型或枚举类型的常量，还可以在类定义中初始化：
class Bakery{
private:
static const int Months =12;
double costs[Months];
...
这将创建一个名为Months的常量，该常量将与其他静态变量存储在一起，而不是存储在对象中。因此，只有一个Months常量，被所有Bakery对象共享。
9.6.2 作用域内枚举
在 C++11 中引入了一个新的枚举类型，称为“作用域内枚举”（scoped enumerations），也被称为“强类型枚举”（strongly typed enumerations）。这种枚举类型通过关键字 enum class 来声明，不同于传统的 C++ 枚举（使用 enum 关键字声明），作用域内枚举提供了更好的类型安全性和作用域管理。
声明和使用
enum class Color : char {
Red,
Green,
Blue
};
enum class ErrorCode {
NotFound,
NoAccess,
OutOfMemory
};
在这个例子中，Color 枚举指定了 char 作为底层类型，而 ErrorCode 默认使用 int 作为底层类型。
要访问作用域内枚举的成员，需要使用枚举类型的名称作为限定符：
Color myColor = Color::Red;
if (myColor == Color::Green) {
// 处理绿色的情况
}
ErrorCode ec = ErrorCode::NoAccess;
switch (ec) {
case ErrorCode::NotFound:
// 处理未找到的情况
break;
case ErrorCode::NoAccess:
// 处理无访问权限的情况
break;
case ErrorCode::OutOfMemory:
// 处理内存溢出
break;
}
9.7 抽象数据类型
Stock 类非常具体。然而，程序员常常通过定义类来表示更通用的概念。例如，就实现计算机专家们所说的抽象数据类型(abstract data type，ADT)而言，使用类是一种非常好的方式。顾名思义，ADT以通用的方式描述数据类型，而没有引入语言或实现细节。例如，通过使用栈，可以以这样的方式存储数据，即总是从堆顶添加或删除数据。例如，C++程序使用栈来管理自动变量。当新的自动变量被生成后，它们被添加到堆顶;消亡时，从栈中删除它们。
下面简要地介绍一下栈的特征。首先，栈存储了多个数据项(该特征使得栈成为一个容器一一一种更为通用的抽象);其次，栈由可对它执行的操作来描述。
· 可创建空栈。
· 可将数据项添加到堆顶(压入)。
· 可从栈顶删除数据项(弹出)。
· 可查看栈否填满。
· 可查看栈是否为空。
可以将上述描述转换为一个类声明，其中公有成员函数提供了表示栈操作的接口，而私有数据成员负责存储栈数据。类概念非常适合于ADT方法。
私有部分必须表明数据存储的方式。例如，可以使用常规数组、动态分配数组或更高级的数据结构(如链表)。然而，公有接口应隐藏数据表示，而以通用的术语来表达，如创建栈、压入等。下面将演示一种方法，它假设系统实现了 bool类型。
stack.h
#ifndef STACK_H_
#define STACK_H_
typedef unsigned long Item;
class Stack {
private:
enum {MAX = 10};
Item items[MAX];
int top;
public:
Stack();
bool isempty() const;
bool isfull() const;
bool push(const Item& item);
bool pop(Item& item);
};
#endifstack.cpp
#include "stack.h"
Stack::Stack() {
top = 0;
}
bool Stack::isempty() const {
return top == 0;
}
bool Stack::isfull() const {
return top == MAX;
}
bool Stack::push(const Item& item) {
if (top < MAX) {
items[top++] = item;
return true;
}
else
return false;
}
bool Stack::pop(Item& item) {
if (top > 0) {
item = items[--top];
return true;
}
else
return false;
}
stacker.cpp
#include <iostream>
#include <cctype>
#include "stack.h"
int main() {
using namespace std;
Stack st;
char ch;
unsigned long po;
cout << "Please enter A to add a purchase order,\n"
<< "P to process a PO, or Q to quit.\n";
while (cin >> ch && toupper(ch) != 'Q') {
while (cin.get() != '\n')
continue;
if (!isalpha(ch)) {
cout << '\a';
continue;
}
switch (ch) {
case 'A':
case 'a': cout << "Enter a PO number to add: ";
cin >> po;
if (st.isfull())
cout << "stack already full\n";
else
st.push(po);
break;
case 'P':
case 'p':
if (st.isempty())
cout << "stack already empty\n";
else {
st.pop(po);
cout << "PO #" << po << " popped\n";
}
break;
}
cout << "Please enter A to add a purchase order,\n"
<< "P to process a PO, or Q to quit.\n";
}
cout << "Bye\n";
return 0;
}9.8 总结
面向对象编程强调的是程序如何表示数据。使用OOP方法解决编程问题的第一步是根据它与程序之间的接口来描述数据，从而指定如何使用数据。然后，设计一个类来实现该接口。一般来说，私有数据成员存储信息，公有成员函数(又称为方法）提供访问数据的唯一途径。类将数据和方法组合成一个单元，其私有性实现数据隐藏。
通常，将类声明分成两部分组成，这两部分通常保存在不同的文件中。类声明(包括由函数原型表示的方法)应放到头文件中。定义成员函数的源代码放在方法文件中。这样便将接口描述与实现细节分开了。从理论上说，只需知道公有接口就可以使用类。当然，可以查看实现方法(除非只提供了编译形式)，但程序不应依赖于其实现细节，如知道某个值被存储为int。只要程序和类只通过定义接口的方法进行通信，程序员就可以随意地对任何部分做独立的改进，而不必担心这样做会导致意外的不良影响。
类是用户定义的类型，对象是类的实例。这意味着对象是这种类型的变量，例如由 new 按类描述分配的内存。C++试图让用户定义的类型尽可能与标准类型类似，因此可以声明对象、指向对象的指针和对象数组。可以按值传递对象、将对象作为函数返回值、将一个对象赋给同类型的另一个对象。如果提供了构造函数，则在创建对象时，可以初始化对象。如果提供了析构函数方法，则在对象消亡后，程序将执行该函数。
每个对象都存储自己的数据，而共享类方法。如果 mr_object 是对象名，try_me()是成员函数，则可以使用成员运算符句点调用成员函数：mr_object.try_me()。在OOP中这种函数调用被称为将try_me消息发送给mr_object对象。在try_me()方法中引用类数据成员时，将使用mr_object 对象相应的数据成员。同样，函数调用i_object.try_me()将访问i_object对象的数据成员。
如果希望成员函数对多个对象进行操作，可以将额外的对象作为参数传递给它。如果方法需要显式地引用调用它的对象，则可以使用 this 指针。由于 this 指针被设置为调用对象的地址，因此*this 是该对象的别名。
类很适合用于描述ADT。公有成员函数接口提供了ADT 描述的服务，类的私有部分和类方法的代码提供了实现，这些实现对类的客户隐藏。
625
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
