C++ Primer 4 第十二章类

最新推荐文章于 2021-08-02 21:13:11 发布

原创最新推荐文章于 2021-08-02 21:13:11 发布 · 482 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

标签

#c++ #class #constructor #string #编译器

C++语法、架构、内部机制专栏收录该内容

46 篇文章

订阅专栏

第十二章类

1. 类的定义和声明

成员函数：在类内部定义的函数默认为 inline，在类外部定义的成员函数必须指明它们是在类的作用域中。成员函数有一个附加的隐含实参，将函数绑定到调用函数的对象。将关键字 const 加在形参表之后，就可以将成员函数声明为常量：double avg_price() const; const 成员不能改变其所操作的对象的数据成员。const 必须同时出现在声明和定义中，若只出现在其中一处，就会出现一个编译时错误。

数据抽象是一种依赖于接口和实现分离的编程（和设计）技术。类设计者必须关心类是如何实现的，但使用该类的程序员不必了解这些细节。相反，使用一个类型的程序员仅需了解类型的接口，他们可以抽象地考虑该类型做什么，而不必具体地考虑该类型如何工作。

一个访问标号可以出现的次数通常是没有限制的。每个访问标号指定了随后的成员定义的访问级别。这个指定的访问级别持续有效，直到遇到下一个访问标号或看到类定义体的右花括号为止。

具体类型和抽象类型：并非所有类型都必须是抽象的。标准库中的 pair 类就是一个实用的、设计良好的具体类而不是抽象类。具体类会暴露而非隐藏其实现细节。pair 类型只是将两个数据成员捆绑成单个对象。在这种情况下，隐藏数据成员没有必要也没有明显的好处。在像 pair 这样的类中隐藏数据成员只会造成类型使用的复杂化。

数据抽象和封装提供了两个重要优点：

1）避免类内部出现无意的、可能破坏对象状态的用户级错误。

2）随时间推移可以根据需求改变或缺陷（bug）报告来完美类实现，而无须改变用户级代码。

同一类型的多个数据成员：如果一个类具有多个同一类型的数据成员，则这些成员可以在一个成员声明中指定，这种情况下，成员声明和普通变量声明是相同的：

class Screen {

public:

// interface member functions

private:

std::string contents;

std::string::size_type height, width;

};

类还可以定义自己的局部类型名字：

class Screen {

public:

// interface member functions

typedef std::string::size_type index;

private:

std::string contents;

index height, width;

};

类所定义的类型名遵循任何其他成员的标准访问控制。将 index 的定义放在类的 public 部分，是因为希望用户使用这个名字。Screen 类的使用者不必了解用 string 实现的底层细节。定义 index 来隐藏 Screen 的实现细节。将这个类型设为 public，就允许用户使用这个名字。

像其他 inline 一样，inline 成员函数的定义必须在调用该函数的每个源文件中是可见的。不在类定义体内定义的 inline 成员函数，其定义通常应放在有类定义的同一头文件中。

可以声明一个类而不定义它：

class Screen; // declaration of the Screen class

这个声明，有时称为前向声明（forward declaraton），在程序中引入了类类型的 Screen。在声明之后、定义之前，类 Screen 是一个不完全类型（incompete type），即已知 Screen 是一个类型，但不知道包含哪些成员。不完全类型（incomplete type）只能以有限方式使用。不能定义该类型的对象。不完全类型只能用于定义指向该类型的指针及引用，或者用于声明（而不是定义）使用该类型作为形参类型或返回类型的函数。

在创建类的对象之前，必须完整地定义该类。必须定义类，而不只是声明类，这样，编译器就会给类的对象预定相应的存储空间。同样地，在使用引用或指针访问类的成员之前，必须已经定义类。

只有当类定义已经在前面出现过，数据成员才能被指定为该类类型。如果该类型是不完全类型，那么数据成员只能是指向该类类型的指针或引用。因为只有当类定义体完成后才能定义类，因此类不能具有自身类型的数据成员。然而，只要类名一出现就可以认为该类已声明。因此，类的数据成员可以是指向自身类型的指针或引用：

class LinkScreen {

Screen window;

LinkScreen *next;

LinkScreen *prev;

};

定义对象时，将为其分配存储空间，但（一般而言）定义类型时不进行存储分配。

定义了一个类类型之后，可以按以下两种方式使用。

1）将类的名字直接用作类型名。

2）指定关键字 class 或 struct，后面跟着类的名字：

Sales_item item1; // default initialized object of type Sales_item

class Sales_item item1; // equivalent definition of item1

类的定义分号结束。分号是必需的，因为在类定义之后可以接一个对象定义列表。定义必须以分号结束：

class Sales_item { /* ... */ };

class Sales_item { /* ... */ } accum, trans;

2. 隐含的 this 指针

成员函数具有一个附加的隐含形参，即指向该类对象的一个指针。这个隐含形参命名为 this，与调用成员函数的对象绑定在一起。成员函数不能定义 this 形参，而是由编译器隐含地定义。成员函数的函数体可以显式使用 this 指针，但不是必须这么做。如果对类成员的引用没有限定，编译器会将这种引用处理成通过 this 指针的引用。

尽管在成员函数内部显式引用 this 通常是不必要的，但有一种情况下必须这样做：当我们需要将一个对象作为整体引用而不是引用对象的一个成员时。最常见的情况是在这样的函数中使用 this：该函数返回对调用该函数的对象的引用。

返回 *this：

Screen& Screen::set(char c)

{

contents[cursor] = c;

return *this;

}

该函数的返回类型是 Screen&，指明该成员函数返回对其自身类类型的对象的引用。每个函数都返回调用自己的那个对象。使用 this 指针来访问该对象。this 是一个指向非常量 Screen 的指针。

从 const 成员函数返回 *this：在普通的非 const 成员函数中，this 的类型是一个指向类类型的 const 指针。可以改变 this 所指向的值，但不能改变 this 所保存的地址。在 const 成员函数中，this 的类型是一个指向 const 类类型对象的 const 指针。既不能改变 this 所指向的对象，也不能改变 this 所保存的地址。不能从 const 成员函数返回指向类对象的普通引用。const 成员函数只能返回 *this 作为一个 const 引用。

基于 const 的重载：基于成员函数是否为 const，可以重载一个成员函数；同样地，基于一个指针形参是否指向 const，可以重载一个函数。const 对象只能使用 const 成员。非 const 对象可以使用任一成员，但非 const 版本是一个更好的匹配。

class Screen {

public:

Screen& display(std::ostream &os)

{ do_display(os); return *this; }

const Screen& display(std::ostream &os) const

{ do_display(os); return *this; }

…

};

当将 display 嵌入到一个长表达式中时，将调用非 const 版本。当我们 display 一个 const 对象时，就调用 const 版本：

Screen myScreen(5,3);

const Screen blank(5, 3);

myScreen.set('#').display(cout); // calls nonconst version

blank.display(cout); // calls const version

可变数据成员：有时（但不是很经常），我们希望类的数据成员（甚至在 const 成员函数内）可以修改。这可以通过将它们声明为 mutable 来实现。可变数据成员（mutable data member）永远都不能为 const，甚至当它是 const 对象的成员时也如此。因此，const 成员函数可以改变 mutable 成员。要将数据成员声明为可变的，必须将关键字 mutable 放在成员声明之前：

class Screen {

public:

// interface member functions

private:

mutable size_t access_ctr; // may change in a const members

// other data members as before

};

给 Screen 添加了一个新的可变数据成员 access_ctr。使用 access_ctr 来跟踪调用 Screen 成员函数的频繁程度：

void Screen::do_display(std::ostream& os) const

{

++access_ctr; // keep count of calls to any member function

os << contents;

}

尽管 do_display 是 const，它也可以增加 access_ctr。该成员是可变成员，所以，任意成员函数，包括 const 函数，都可以改变 access_ctr 的值。

3. 类作用域

尽管成员是在类的定义体之外定义的，但成员定义就好像它们是在类的作用域中一样。出现在类的定义体之外的成员定义必须指明成员出现在哪个类中：在定义于类外部的成员函数中，形参表和函数体处于类作用域中。

函数返回类型不一定在类作用域中：与形参类型相比，返回类型出现在成员名字前面。如果函数在类定义体之外定义，则用于返回类型的名字在类作用域之外。如果返回类型使用由类定义的类型，则必须使用完全限定名：

class Screen {

public:

typedef std::string::size_type index;

index get_cursor() const;

};

inline Screen::index Screen::get_cursor() const

{

return cursor;

}

如果在类定义体之外定义 get_cursor，则在函数名被处理之前，代码在不在类作用域内。当看到返回类型时，其名字是在类作用域之外使用。必须用完全限定的类型名 Screen::index 来指定所需要的 index 是在类 Screen 中定义的名字。

类成员声明的名字查找：检查出现在名字使用之前的类成员的声明。如果查找不成功，则检查包含类定义的作用域中出现的声明以及出现在类定义之前的声明。

typedef double Money;

class Account {

public:

Money balance() { return bal; }

private:

Money bal;

// ...

};

在处理 balance 函数的声明时，编译器首先在类 Account 的作用域中查找 Money 的声明。编译器只考虑出现在 Money 使用之前的声明。因为找不到任何成员声明，编译器随后在全局作用域中查找 Money 的声明。只考虑出现在类 Account 的定义之前的声明。找到全局的类型别名 Money 的声明，并将它用作函数 balance 的返回类型和数据成员 bal 的类型。编译器按照成员声明在类中出现的次序来处理它们。通常，名字必须在使用之前进行定义。而且，一旦一个名字被用作类型名，该名字就不能被重复定义：

typedef double Money;

class Account {

public:

Money balance() { return bal; } // uses global definition of Money

private:

// error: cannot change meaning of Money

typedef long double Money;

Money bal;

// ...

};

按以下方式确定在成员函数的函数体中用到的名字：首先检查成员函数局部作用域中的声明。如果在成员函数中找不到该名字的声明，则检查对所有类成员的声明。如果在类中找不到该名字的声明，则检查在此成员函数定义之前的作用域中出现的声明。

4. 构造函数

构造函数不能声明为 const：const 构造函数是不必要的。创建类类型的 const 对象时，运行一个普通构造函数来初始化该 const 对象。构造函数的工作是初始化对象。不管对象是否为 const，都用一个构造函数来初始化化该对象。

在构造函数初始化列表中没有显式提及的每个成员，使用与初始化变量相同的规则来进行初始化。运行该类型的默认构造函数，来初始化类类型的数据成员。内置或复合类型的成员的初始值依赖于对象的作用域：在局部作用域中这些成员不被初始化，而在全局作用域中它们被初始化为 0。

在构造函数初始化列表中初始化成员，还是在构造函数函数体中对它们赋值，不同之外在于：使用构造函数初始化列表的版本初始化数据成员，没有定义初始化列表的构造函数版本在构造函数函数体中对数据成员赋值。这个区别的重要性取决于数据成员的类型。

构造函数初始化只在构造函数的定义中而不是声明中指定。

使用构造函数初始化列表能够使得省略初始化列表在构造函数的函数体内对数据成员赋值是合法的：

Sales_item::Sales_item(const string &book)

{

isbn = book; // no constructor initializer

units_sold = 0;

revenue = 0.0;

}

这个构造函数隐式使用默认的 string 构造函数来初始化 isbn。执行构造函数的函数体时，isbn 成员已经有值了。该值被构造函数函数体中的赋值所覆盖。

有些成员必须在构造函数初始化列表中进行初始化。对于这样的成员，在构造函数函数体中对它们赋值不起作用。没有默认构造函数的类类型的成员，以及 const 或引用类型的成员，不管是哪种类型，都必须在构造函数初始化列表中进行初始化。

可以初始化 const 对象或引用类型的对象，但不能对它们赋值。在开始执行构造函数的函数体之前，要完成初始化。初始化 const 或引用类型数据成员的唯一机会是构造函数初始化列表中。

下面的构造函数是错误的：

class ConstRef {

public:

ConstRef(int ii);

private:

int i;

const int ci;

int &ri;

};

// no explicit constructor initializer: error ri is uninitialized

ConstRef::ConstRef(int ii)

{ // assignments:

i = ii; // ok

ci = ii; // error: cannot assign to a const

ri = i; // assigns to ri which was not bound to an object

}

编写该构造函数的正确方式为

// ok: explicitly initialize reference and const members

ConstRef::ConstRef(int ii): i(ii), ci(i), ri(ii) { }

必须对任何 const 或引用类型成员以及没有默认构造函数的类类型的任何成员使用初始化式。当类成员需要使用初始化列表时，通过常规地使用构造函数初始化列表，就可以避免发生编译时错误。

构造函数初始化列表仅指定用于初始化成员的值，并不指定这些初始化执行的次序。成员被初始化的次序就是定义成员的次序。初始化的次序常常无关紧要。然而，如果一个成员是根据其他成员而初始化，则成员初始化的次序是至关重要的。

初始化类类型的成员时，要指定实参并传递给成员类型的一个构造函数。可以使用该类型的任意构造函数。可以将 isbn 初始化为由 10 个 9 构成的串：

// alternative definition for Sales_item default constructor

Sales_item(): isbn(10, '9'), units_sold(0), revenue(0.0) {}

合成的默认构造函数（synthesized default constructor）使用与变量初始化相同的规则来初始化成员。具有类类型的成员通过运行各自的默认构造函数来进行初始化。内置和复合类型的成员，如指针和数组，只对定义在全局作用域中的对象才初始化。当对象定义在局部作用域中时，内置或复合类型的成员不进行初始化。只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。

假定有一个 NoDefault 类，它没有定义自己的默认构造函数，却有一个接受一个 string 实参的构造函数。因为该类定义了一个构造函数，因此编译器将不合成默认构造函数。NoDefault 没有默认构造函数，意味着：

1.具有 NoDefault 成员的每个类的每个构造函数，必须通过传递一个初始的 string 值给 NoDefault 构造函数来显式地初始化 NoDefault 成员。

2.编译器将不会为具有 NoDefault 类型成员的类合成默认构造函数。如果这样的类希望提供默认构造函数，就必须显式地定义，并且默认构造函数必须显式地初始化其 NoDefault 成员。

3.类型不能用作动态分配数组的元素类型。

4.类型的静态分配数组必须为每个元素提供一个显式的初始化式。

5.如果有一个保存 NoDefault 对象的容器，例如 vector，就不能使用接受容器大小而没有同时提供一个元素初始化式的构造函数。

使用默认构造函数：

Sales_item myobj(); // ok: but defines a function, not an object

if (myobj.same_isbn(Primer_3rd_ed)) // error: myobj is a function

使用默认构造函数定义一个对象的正确方式是去掉最后的空括号：

// ok: defines a class object ...

Sales_item myobj;

另一方面，下面这段代码也是正确的：

// ok: create an unnamed, empty Sales_itemand use to initialize myobj

Sales_item myobj = Sales_item();

在这里，创建并初始化一个 Sales_item 对象，然后用它来按值初始化 myobj。编译器通过运行 Sales_item 的默认构造函数来按值初始化一个 Sales_item

可以用单个实参来调用的构造函数定义了从形参类型到该类类型的一个隐式转换：

class Sales_item {

public:

// default argument for book is the empty string

Sales_item(const std::string &book = ""):

isbn(book), units_sold(0), revenue(0.0) { }

Sales_item(std::istream &is);

// as before

};

这里的每个构造函数都定义了一个隐式转换。因此，在期待一个 Sales_item 类型对象的地方，可以使用一个 string 或一个 istream：

string null_book = "9-999-99999-9";

item.same_isbn(null_book);

item.same_isbn(cin);

新生成的（临时的）Sales_item 被传递给 same_isbn。一旦 same_isbn 结束，就不能再访问它。

可以通过将构造函数声明为 explicit，来防止在需要隐式转换的上下文中使用构造函数：

class Sales_item {

public:

// default argument for book is the empty string

explicit Sales_item(const std::string &book = ""):

isbn(book), units_sold(0), revenue(0.0) { }

explicit Sales_item(std::istream &is);

// as before

};

explicit 关键字只能用于类内部的构造函数声明上。在类的定义体外部所做的定义上不再重复它：

// error: explicit allowed only on constructor declaration in class header

explicit Sales_item::Sales_item(istream& is)

{

is >> *this; // uses Sales_iteminput operator to read the members

}

现在，两个构造函数都不能用于隐式地创建对象。前两个使用都不能编译：

item.same_isbn(null_book); // error: string constructor is explicit

item.same_isbn(cin); // error: istream constructor is explicit

为转换而显式地使用构造函数：只要显式地按下面这样做，就可以用显式的构造函数来生成转换：

string null_book = "9-999-99999-9";

// ok: builds a Sales_itemwith 0 units_soldand revenue from

// and isbn equal to null_book

item.same_isbn(Sales_item(null_book));

显式使用构造函数只是中止了隐式地使用构造函数。任何构造函数都可以用来显式地创建临时对象。

通常，除非有明显的理由想要定义隐式转换，否则，单形参构造函数应该为 explicit。将构造函数设置为 explicit 可以避免错误，并且当转换有用时，用户可以显式地构造对象。

直接初始化简单的非抽象类的数据成员仍是可能的。对于没有定义构造函数并且其全体数据成员均为 public 的类，可以采用与初始化数组元素相同的方式初始化其成员：

struct Data {

int ival;

char *ptr;

};

// val1.ival = 0; val1.ptr = 0

Data val1 = { 0, 0 };

// val2.ival = 1024;

// val2.ptr = "Anna Livia Plurabelle"

Data val2 = { 1024, "Anna Livia Plurabelle" };

这种形式的初始化从 C 继承而来，支持与 C 程序兼容。显式初始化类类型对象的成员有三个重大的缺点。

1）要求类的全体数据成员都是 public。

2）将初始化每个对象的每个成员的负担放在程序员身上。这样的初始化是乏味且易于出错的，因为容易遗忘初始化式或提供不适当的初始化式。

3）如果增加或删除一个成员，必须找到所有的初始化并正确更新。

5. 友元

友元机制允许一个类将对其非公有成员的访问权授予指定的函数或类。友元的声明以关键字 friend 开始。它只能出现在类定义的内部。友元声明可以出现在类中的任何地方：友元不是授予友元关系的那个类的成员，所以它们不受声明出现部分的访问控制影响。

友元可以是普通的非成员函数，或前面定义的其他类的成员函数，或整个类。将一个类设为友元，友元类的所有成员函数都可以访问授予友元关系的那个类的非公有成员。

当我们将成员函数声明为友元时，函数名必须用该函数所属的类名字加以限定：

class Screen {

// Window_Mgrmust be defined before class Screen

friend Window_Mgr&

Window_Mgr::relocate(Window_Mgr::index,

Window_Mgr::index,

Screen&);

// ...restofthe Screen class

};

为了正确地构造类，需要注意友元声明与友元定义之间的互相依赖。在前面的例子中，类 Window_Mgr 必须先定义。否则，Screen 类就不能将一个 Window_Mgr 函数指定为友元。然而，只有在定义类 Screen 之后，才能定义 relocate 函数——毕竟，它被设为友元是为了访问类 Screen 的成员。更一般地讲，必须先定义包含成员函数的类，才能将成员函数设为友元。另一方面，不必预先声明类和非成员函数来将它们设为友元

友元声明将已命名的类或非成员函数引入到外围作用域中。此外，友元函数可以在类的内部定义，该函数的作用域扩展到包围该类定义的作用域。

class X {

friend class Y;

friend void f() { /* ok to define friend function in the class body */ }

};

class Z {

Y *ymem; // ok: declaration for class Y introduced by friend in X

void g() { return ::f(); } // ok: declaration of f introduced by X

};

6. static 类成员

类也可以定义 static 成员函数。static 成员函数没有 this 形参，它可以直接访问所属类的 static 成员，但不能直接使用非 static 成员。

使用类的 static 成员的优点：