C++ Primer Plus (6th) Chap10 对象和类 摘录

C++ Primer Plus (6th) Chap10 对象和类 摘录

OOP特性：

        抽象；

        封装和数据隐藏；

        多态；

        继承；

        代码的可重用性；

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

采用过程性编程方法时，首先考虑要遵循的步骤，然后考虑如何表示这些数据。

OOP程序员首先考虑数据--不仅要考虑如何表示数据，还要考虑如何使用数据。

采用OOP方法时，首先从用户的角度考虑对象--描述对象所需的数据以及描述用户与数据交互所需的 *** 作。完成对接口的描述后，需要确定如何实现接口和数据存储。

10.2 抽象和类

在计算中，为了根据信息与用户之间的接口来表示它，抽象是至关重要的。将问题的本质特征抽象出来，并根据特征来描述解决方案。

10.2.1 类型是什么？

指定基本类型完成了三项工作：

        1. 决定数据对象需要的内存数量；

        2. 决定如何解释内存中的位(long 和 float在内存中占用位数一样，但将它们转换为数值的方法不同)；

        3. 决定可使用数据对象执行的 *** 作或方法；

对于内置类型来说，有关 *** 作的信息被内置到编译器中。但对于用户自定义的类来说，必须自己提供这些信息。

#ifndef STOCK00_H_
#deinfe STOCK00_H_

#include 

class Stock
{
private:
    std::string company;
    long shares;
    double share_val;
    double totao_val;
    void set_tot(){total_val = shares * share_val;}
    
public:
    void acquire(const std::string& co, long n, double pr);
    void buy(long unm, double price);
    void sell(long num, double price);
    void uodate(double price);
    void show();
}

#endif

10.2.2 C++中的类

类是一种将抽象转换为用户定义类型的C++工具，它将数据和 *** 纵数据的方法组合成一个整洁的包。

类声明：以数据成员的方式描述数据部分，以成员函数(或称方法)的方式描述公有接口。

类定义：描述如何实现类成员函数。

什么是接口？ 接口时一个共享框架，供两个系统交互时使用。

对于类，我们说公共接口。公共是使用类的程序，交互系统由类对象组成，而接口由编写类的人提供的方法组成。

接口让程序员能够编写与类对象交互的代码，从而让程序能够使用类对象。

类设计禁止公共用户直接访问类，但公共可以使用方法。

要使用类，必须了解其公共接口；要编写类，必须创建公共接口。

C++程序员将接口(类定义)放在头文件中，并将实现(类方法的代码)放在源代码文件中。

为帮助识别类，本书将类名首字母大写。

将数据和方法组合成一个单元是类最吸引人的特性。

关键字private和public描述了对类成员的访问控制。使用类对象的程序都可以直接访问公有部分，但只能通过公有成员函数(或友元函数)来访问对象的私有成员。

公有成员函数是程序和对象的私有成员之间的桥梁，提供了对象和程序之间的接口。

防止程序直接访问数据被称为数据隐藏。

类设计尽可能将公有接口与实现细节分开。公有接口表示设计的抽象组件。将实现细节放在一起并将它们与抽象分开被称为封装。数据隐藏(将数据放在类的私有部分中)是一种封装，将实现的细节隐藏在私有部分中，也是一种封装。将类定义和类声明放在不同的文件中也是一种封装。

数据隐藏不仅可以防止直接访问数据，还让类的用户无需了解数据是如何表示的。

从使用类的角度看，使用哪种方法没有什么区别。所需要知道的只是各种成员函数的功能；也就是说，需要知道成员函数接收什么样的参数以及返回什么类型的值。原则是将实现细节从接口设计分离出来。

由于隐藏数据是OOP的主要目标之一，因此数据项通常放在私有部分，组成类接口的成员函数放在公有部分。

通常，设计类的人使用私有成员函数来处理不属于公有接口的实现细节。

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

类和结构的唯一区别是，结构的默认访问类型是public，而类为private。C++程序员用车使用类来实现类描述，而把结构限制为只表示纯粹的数据对象。

10.2.3 实现类成员函数

普通成员函数定义与常规函数定义非常类似，但它们还有两个特殊的特征：

        1. 定义成员函数时，使用作用域解析运算符::来标识函数所属的类；

        2. 类方法可以直接访问类的private组件；

void Stock::update();

该表示法意味着我们定义的update函数是Stock类的成员。这不仅意味update()标识成成员函数，还意味着我们可以将另一个类的成员函数也命名为update()。

作用域解析运算符确定了方法定义对应的类的身份。Stock类的其他成员函数不必使用作用域解析运算符，就可以使用update()方法，这是因为它们同属于一个类。

类方法的完整名称包含类名。Stock::update()是函数的限定名(qualified name)；而简单的update()是全名的缩写(unqualified name)，它只能在类作用域中使用。

方法可以访问类的私有成员。

由于set_tot()只是实现代码的一种方式，而不是公有接口的组成部分，因此这个类将其声明为私有成员函数(即编写这个类的人可以使用它，但编写代码来使用这个类的人不能使用它)。

其定义于类声明中的函数都将自动成为内联函数。类声明通常将短小的成员函数作为内联函数。

如果愿意，也可以在类声明之外定义成员函数，并使其成为内联函数。只需类实现部分中定义函数时使用inline限定符即可。

inline void Stock::set_tot()
{
    ...
}

内联函数的特殊规则要求在每个使用它们的文件中都对其进行定义。确保内联定义对于多文件程序中的所有文件都可用的，最简便的方法是，将内联定义放在定义类的头文件中。

顺便说一句，根据改写规则(rewrite rule)，在类声明中定义方法等同于用原型替换方法定义，然后在类声明的后面将定义改写为内联函数。

调用成员函数时，它将使用调用它的对象的数据成员。

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

在OOP中，调用成员函数被称为发送消息，因此将同一的消息发送给两个不同的对象架构调用同一个方法，但该方法被用于两个不同的对象。

10.2.4 使用类

C++提供了一些工具，可用于初始化对象，让cin和cout识别对象，甚至在相似的类对象之间进行自动的类型转换。

客户/服务器模型：客户只能通过以公有方式定义的接口使用服务器，这意味着客户唯一的责任时了解该接口。服务器的责任是确保服务器根据该接口可靠并准确地执行。服务器设计人员只能修改类设计地实现细节，而不能修改接口。

10.2.5 修改实现

修改方法的实现时，不应影响客户程序的其他部分。

10.2.6 小结

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

class className
{
private:
    data member declarations
public:
    member function prototypes

};

公有部分的内容构成了设计的抽象部分--公有接口。将数据封装到私有部分可以保护数据的完整性，这被称为数据隐藏。

指定类设计的第二部是实现类成员函数。可以在类声明中提供完整的函数定义，而不是函数原型，但是通常的做法是单独提供函数定义(除非函数很小)。在这种情况下，需要使用作用域解析运算符来指出成员函数属于哪个类。

// 函数头
char* Bozo::Retort()

该函数全名为Bozo::Retort()，而名称Retort()是限定名的缩写，只能在某些特定的环境中使用，如类方法的代码中。

另一种描述这种情况的方式是，名称Retort的作用域是整个类，因此在类声明和类方法之外使用该名称时，需要使用作用域解析运算符进行限定。

要创建类对象时，只需将类名视为类型名就可。

类成员函数可通过类对象来调用，为此，需要使用成员运算符句点.。

10.3 类的构造函数与析构函数

不能像初始化结构的数据成员那样初始化类的数据成员，原因在于类的数据成员是私有的，这意味着程序不能直接访问数据成员。因此需要设计合适的成员函数，才能成功地将对象初始化（如果将数据公开，而不是私有，违背了类的一个设计初衷：数据隐藏）。

在创建对象时，希望自动对它进行初始化。C++提供了一个特殊的成员函数--类构造函数，专门用于构造新对象、将值赋给它们的数据成员。C++为这些成员函数提供了名称和使用语法，而程序员需要提供方法定义。该名称与类名相同。

构造函数的原型和函数头有一个有趣的特征--虽然没有返回值，但没有被声明为void类型。实际上，构造函数没有声明类型。构造函数原型位于类声明的公有部分。

10.3.1 声明和定义构造函数

不熟悉构造函数的您会试图将类成员名称用作构造函数的参数名，如下所示:

// Wrong!
Stock::Stock(const string& company, long shares, double share_val)
{
    ...
}

这是错误的。构造函数的参数表示的不是类成员，而是赋给类成员的值。因此，参数名不能与类成员名相同，否则，最后的代码将是这样的。

shares = shares;

为避免这种混乱，一种常见的做法是在数据成员名中使用m_前缀, 另一种是使用后缀_：

class Stock
{
private:
    std::string m_company;
    long m_shares;
    double m_share_val;
    ...
}

class Stock
{
private:
    std::string company_;
    long shares_;
    double share_val_;
    ...
}

10.3.2 使用构造函数

C++提供两种使用构造函数来初始化对象的方式。第一种是显示地调用构造函数：

Stock food = Stock("World Com", 250, 1.23);

另一种是隐式地调用构造函数：

Stock food("World Com", 250, 1.23);
// 上式等价下式
Stock food = Stock("World Com", 250, 1.23);

每次创建类对象(甚至使用new动态内存分配)时，C++都在使用类构造函数。

利用new与构造函数一起使用案例：

Stock* food = new Stock("World Com", 250, 1.23);

创建一个Stock对象，将其初始化为参数提供的值，并将该对象的地址赋给food指针。在这种情况下，对象可以没有名称，但可以使用指针来管理该对象。

但无法通过对象来调用构造函数，因为在构造函数构造出对象之前，对象是不存在的。因此构造函数被用来创建对象，而不能通过对象来调用。

10.3.3 默认构造函数

默认构造函数是在未提供显示初始值时，用来创建对象的构造函数。比如下面：

Stock fluul;

如果没有提供任何构造函数，则C++将自动提供默认构造函数。它是默认构造函数的隐式版本，不做任何工作。对于Stock类，其默认构造函数可能是如下：

Stock::Stock(){}

奇怪的是，当且仅当没有定义任何构造函数时，编译器才会提供默认构造函数。为类定义了构造函数后，程序员就必须为它提供默认构造函数。如果只提供了非默认构造函数，而没有同时提供默认构造函数，则编译器会报错。

编译器报错的原因可能是想禁止创建未初始化的对象。然而，如果要创建对象，而不显式地初始化，则必须定义一个不接受任何参数地默认构造函数。定义默认构造函数方式有两种。一种是给已有构造函数地所有参数提供默认值，另一种是没有参数地构造函数。

// 默认构造函数的两种形式
Stock(const string& co = "Error", int n = 0, double pr = 0);

Stock();

由于只能有一个默认构造函数，因此不要同时采用两种方式。

通常应初始化所有的对象，以确保所有成员一开始就有已知的合理值。下面是一个Stock的默认构造函数：

Stock::Stock()
{
    company = "no name";
    shares = 0;
    share_val = 0.;
    total_val = 0.;
}

当提供默认构造函数后，便可声明对象变量，而不对它们进行显式初始化。

然而，不要被非默认构造函数的隐式形式所误导，如下代码所示：

Stock first("Concrete name");    // 调用非默认构造函数
Stock second();                  // 声明一个返回类型为Stock的函数
Stock third;                     // 调用默认构造函数

隐式地调用默认构造函数时，不要使用圆括号。

10.3.4 析构函数

对象过期时，程序将自动调用一个特殊的成员函数--析构函数。析构函数完成清理工作。

如果构造函数使用new来分配内存，则析构函数将使用delete来释放这些内存。

和构造函数一样，析构函数的名称也很特殊：在类名前面加上~。因此，Stock类的析构函数为~Stock()。析构函数也可以没有返回值和声明类型。

由于Stock的析构函数不承担任何重要工作，因此可以将它编写为不执行任何 *** 作的函数。

什么时候调用析构函数呢？这由编译器决定，通常不应在代码中显式地调用析构函数。如果创建地静态存储类对象，则其析构函数将在程序结束时自动被调用。如果创建地自动存储类对象，则其析构函数将在程序执行完代码块时自动被调用。如果对象是通过new创建的，则它将驻留在栈内存或自由存储区，当使用delete来释放内存时，其析构函数将自动被调用。最后，程序可以创建临时对象来完成特定 *** 作，在这种情况下，程序将在结束对该对象的使用时自动调用其析构函数。

10.3.5 改进Stock类

#ifndef STOCK00_H_
#deinfe STOCK00_H_

#include 

class Stock
{
private:
    std::string company;
    long shares;
    double share_val;
    double totao_val;
    void set_tot(){total_val = shares * share_val;}
    
public:
    Stock();
    Stock(const string& company, long n = 0, double pr = 0.);
    ~Stock();
    void buy(long unm, double price);
    void sell(long num, double price);
    void uodate(double price);
    void show();
}

#endif

Stock stock1("Name", 12, 20.1); // 创建stock1对象，并将其数据成员初始化为指定的值

// 编译器有两种方法来编译下式，第1种与上式一样，第2种先创建临时对象Stock，然后在赋值给stock2
Stoock stock2 = Stock ("sdqw", 12, 1.2); 

在默认情况下，将一个对象赋给同类型的另一个对象时，C++将源对象的每个数据成员的内容复制到目标对象中相应的数据成员中。

Stock stock1 = Stock ("Bp", 2, 1.2); // 初始化
stock2 = Stock("Bp", 2, 1.2);        // 赋值

第一条语句是初始化，它创建有指定值的对象，可能会创建临时对象；第二条语句是赋值。赋值语句中使用构造函数总会导致在赋值前创建一个临时对象。

如果既可以通过初始化，也可以通过赋值来设置对象的值，则应采用初始化方式。因为效率更高。

C++ 11可以将列表初始化语法应用于类，只需要提供与某个构造函数的参数列表匹配的内容，并用大括号将其括起即可。

Stock stock1 = {"Bp", 2, 1.2};
Stock stock1 {"Bp", 2, 1.2};

之前通过将函数参数声明为const引用或指向const的指针来确保调用对象不被修改。但对于无参类成员函数而言，没有参数来加const，C++的解决方法是将const关键字放到函数括号后面。

void show() const;

函数定义也开头也应该变为：

void Stock::show() const;

以上述方法声明或定义的类函数被称为const成员函数。就像尽可能将const引用和指针用作函数形参一样，只要类方法不修改调用对象，就应该将其声明为const。

10.3.6 构造函数和析构函数小结

构造函数是一种特殊的类成员函数，在创建类对象时被调用。构造函数的名称和类名相同，但通过函数重载，可以创建多个同名的构造函数，条件是每个函数的特征标(参数列表)都不同。另外，构造函数没有声明类型。通常，构造函数用于初始化类对象的成员，初始化应与构造函数的参数列表匹配。

Bozo(const char* fname, const char* lname);

// 初始化对象
Bozo bozetta = Bozo("Bz", "Bigh");
Bozo fufu("Fufu", "Uks");
Bozo* pt = new Bozo("Bz", "Bigh");

// 初始化列表
Bozo bozetta = Bozo{"Bz", "Bigh"};
Bozo fufu{"Fufu", "Uks"};
Bozo* pt = new Bozo{"Bz", "Bigh"};

接收一个参数的构造函数允许使用赋值语法将对象初始化为一个值。

默认构造函数可以没有任何参数；如果有，则必须给所有参数都提供默认值。

对于未被初始化的对象，程序将使用默认构造函数来创建。

// 调用默认构造函数来创建类对象。
Bozo bubi;

就像对象被创建时程序将调用构造函数一样，当对象被删除时，程序将调用析构函数。每个类都只能有一个析构函数。析构函数没有返回类型(连void都没有)，也没有参数，其名称为类名称前加上~。

例如：

~Bozo();

如果构造函数使用了new，则必须提供使用delete的析构函数。

10.4 this指针

若类成员函数涉及到两个类对象时，需要使用到this指针。

const Stock& topval(const Stock& s) const
{
    if (s.total_val > total_val) // total_val 只不过是this->total_val的简写
        retern s;
    else
        return *this;

}

该函数隐式地访问一个对象，而显示的访问另一个对象，并返回其中一个对象的引用。括号中const表明不会修改被显示访问的对象；而括号后的const表明不会修改被隐式访问的对象，由于该函数返回了两个const对象之一的引用，因此返回类型也应该是const。

this指针指向用来调用成员函数的对象(this被作为隐藏参数传递给方法)。

所有的类方法都将this指针设置为调用它的对象的地址。

每个成员函数(包括构造和析构函数)都有一个this指针。this指针指向调用对象。如果方法需要引用整个调用对象，则可以使用*this。

10.5 对象数组

声明对象数组的方法与声明标准类型数组相同。

Stock myStuf[4];

当程序创建为被显式初始化的类对象时，总是调用默认构造函数。

Stock stcokcs[2] = {{...}, {...}};

使用标准格式对数组进行初始化：用括号括起、以逗号分隔的值列表。

初始化对象数组的方案是，首先使用默认构造函数创建数组元素，然后花括号中的构造函数将创建临时对象，然后将临时对象的内容复制到相应的元素中。

10.6 类作用域

C++ 引入了一种新的作用域：类作用域。

在类中定义的名称(如类数据成员和类成员函数名)的作用域都为整个类，作用域为整个类的名称只在该类中是已知的，在类外是不可知的。

类作用域意味着不能从外部直接访问类成员，公有成员函数也是如此。也就是说，要调用公有成员函数，必须通过对象。

Stock sleep {...};
sleep.show(); // 通过对象sleep调用成员函数

void Stock::show(...){...}    // 通过作用域解析符::来定义成员函数

同样，在定义成员函数时，必须使用作用域解析运算符。

10.6.1 作用域为类的常量

class Bakery
{
private:
    const int Months = 12; // 失败，行不通的！
    ...
}

有时候，使符号常量的作用域为类很有用。但直接在类声明中定义符号常量是不可行的。因为类声明只是描述了对象的形式，并没有创建对象。因此，在创建对象前，将没有用于存储值的空间。然而，有两种方式能实现这个目标，且效果相同。

第一种方式是咋类中声明一个枚举。在类声明中声明的枚举的作用域为整个类，因此可以用枚举为整型常量提供作用域为整个类的符号名称。

class Bakery
{
private:
    enum { Months = 12}; // OK!
    ...
}

注意，用这种方式声明的枚举并不会创建类数据成员。也就是说，所有对象都不包含枚举。另外，Months只是一个符号名称，在作用域为整个类的代码遇到它，编译器将用12来代替它。

C++另一种在类中提供定义常量的方法--使用关键字static。

class Bakery
{
private:
    static const int Months = 12; // OK!
    ...
}

这将创建一个名为Months的常量，该常量将与其他静态变量存储在一起，而不是存储在对象中。因此，只有一个Months常量，被所有Bakery对象共享。

10.6.2 作用域中枚举(C++11)

假设一个处理鸡蛋和T恤的项目，其中包含下列代码：

// 这是无法通过编译的
enum egg {Small, Medium, Large};
enum t_shirt {Small, Medium, Large};

这将无法通过编译，因为egg Small和t_thirt Small位于相同作用域内，它们将发生冲突。为避免以上问题，C++11 提供一种新枚举，其枚举量的作用域为类：

enum class egg {Small, Medium, Large};
enum class t_shirt {Small, Medium, Large};

枚举量的作用域为类后，不同枚举定义中的枚举量就不会发生名称冲突了。

在某些情况下，常规枚举将自动转换为整型，而作用域为类的枚举不能隐式地转换为整型。但在必要时，可以显式地类型转换。

10.7 抽象数据类型

就实现ADT(abstract data type)而言，使用类是一种非常友好的方式。

ADT以通用的方式描述数据类型，而没有引入语言或实现细节。

如果头文件使用typedef用Item代替unsigned long。如果需要double来表示Item，则只需要修改typedef语句，而类声明和方法定义保持不变。

10.8 总结

使用OOP方法解决编程问题的第一步是根据它与程序之间的接口来描述数据，从而指定如何使用数据。然后，设计一个类来实现该接口。一般来说，私有数据成员存储信息，公有成员函数提供访问数据的唯一途径。类将数据和方法组成一个单元，其私有性实现数据隐藏。

通常，将类声明分成两部分组成，这俩部分通常保存咋不同的文件中。类声明(包括函数原型表示的方法)应放到头文件中。定义成员函数的源代码放在方法文件中。这由便将接口和描述实现细节分开了。

只需程序和类只通过定义接口的方法进行通信，程序员就可以随意地对任何部分做独立的改进，而不必担心这样做会导致意外的不良影响。

每个对象都存储自己的数据，而共享类方法。

如果希望成员函数对多个类对象 *** 作，可以将额外的对象作为参数传递给它。如果方法需要显式地引用调用它地对象，则可以使用this指针。由于this指针被设置为调用对象地地址，因此*this是该对象地别名。

类很适合用于描述ADT。公有成员函数提供了ADT描述的服务，类的私有部分和类方法的代码提供了实现，这些实现对类的客户隐藏。