PowerPoint Presentation

Transcription

1 C++ 程序设计 第 7 章类 计算机学院黄章进 zhuang@ustc.edu.cn

2 内容 类 7.1 定义抽象数据类型 7.2 访问控制与封装 7.3 类的其他特性 7.4 类的作用域 7.5 构造函数再探 7.6 类的静态成员 2

3 定义抽象数据类型 C++ 中使用类 (class) 定义自己的数据类型 类的基本思想是数据抽象 (data abstraction) 和封装 (encapsulation) 数据抽象是一种依赖于接口 (interface) 和实现 (implementation) 分离的编程及设计技术 类的接口包括类用户所能执行的操作 类的实现包括 : 类的数据成员 实现接口的函数体以及定义类所需的各种私有函数 封装实施类的接口和实现的分离, 隐藏了类的实现细节 采用了数据抽象和封装的类定义了一个抽象数据类型 (abstract data type) 3

4 定义抽象数据类型 第 1 章使用的 Sales_item 类是一个抽象数据类型, 不能直接访问其数据成员 接口 :isbn 成员函数 支持 + = += << 和 >> 运算符 第 2 章定义的 Sales_data 类不是一个抽象数据类型, 只有数据成员, 且能访问 struct Sales_data { std::string bookno; unsigned units_sold = 0; double revenue = 0.0; }; 4

5 设计 Sales_data 类 定义抽象数据类型 Sales_data 类的接口包含如下操作 : 成员函数 isbn, 用于返回对象的 ISBN 编号 成员函数 combine, 用于将一个 Sales_data 对象加到另一个对象上 非成员函数 add, 执行两个 Sales_data 对象的加法 非成员函数 read, 将数据从 istream 读入到 Sales_data 对象中 非成员函数 print, 将 Sales_data 对象的值输出到 ostream 5

6 定义 Sales_data 类 定义抽象数据类型 Sales_data 类的定义如下 : struct Sales_data { // operations on Sales_data objects std::string isbn() const { return bookno; } Sales_data& combine(const Sales_data&); double avg_price() const; // data members std::string bookno; unsigned units_sold = 0; double revenue = 0.0; }; // nonmember Sales_data interface functions Sales_data add(const Sales_data&, const Sales_data&); std::ostream &print(std::ostream&, const Sales_data&); std::istream &read(std::istream&, Sales_data&); 6

7 定义 Sales_data 类 定义抽象数据类型 类以关键字 struct 开始, 紧跟着类名和类体, 最后必须写一个分号 类体由花括号包围, 形成一个类作用域 类体定义类的成员, 有数据成员 (data member) 和函数成员 (function member) 等 类内部定义的名字必须唯一, 但可与类外部定义的名字重复 struct Sales_data { /*... */ } accum, trans, *salesptr; // equivalent, but better way to define these objects struct Sales_data { /*... */ }; Sales_data accum, trans, *salesptr; 7

8 使用 Sales_data 类 Sales_data total; // variable to hold the running sum if (read(cin, total)) { // read the first transaction Sales_data trans; // variable to hold data for the next transaction while(read(cin, trans)) { // read the remaining transactions if (total.isbn() == trans.isbn()) // check the isbns total.combine(trans); // update the running total else { print(cout, total) << endl; // print the results total = trans; // process the next book } } print(cout, total) << endl; // print the last transaction } else { // there was no input cerr << "No data?!" << endl; // notify the user } 8

9 定义数据成员 定义 Sales_data 类 类的数据成员定义类的对象的内容 每个对象有自己的一份数据成员拷贝 定义数据成员的方法和普通变量一样 : 基本类型后紧跟一个或多个声明符 struct Sales_data { // operations on Sales_data objects... // data members std::string bookno; unsigned units_sold = 0; double revenue = 0.0; }; 9

10 定义数据成员 定义 Sales_data 类 C++11 中, 可以为数据成员提供一个类内初始值 (in-class initializer) 类内初始值或者放在花括号里, 或者放在等号右边, 但不能放在圆括号里 struct Sales_data {... // data members std::string bookno; unsigned units_sold = 0; double revenue = 0.0; }; 创建对象时, 类内初始值将被用于初始化数 据成员, 没有初始值的成员将被默认初始化 Sales_data total; // variable to hold the running sum 10

11 定义成员函数 定义 Sales_data 类 定义和声明成员函数的方式与普通函数差不多 成员函数的声明必须在类的内部, 但成员函数体可以定义在类内也可以定义在类外 成员函数体也是一个块 struct Sales_data { // operations on Sales_data objects std::string isbn() const { return bookno; } Sales_data& combine(const Sales_data&); double avg_price() const;... }; isbn 函数如何获得 bookno 成员所依赖的对象? 11

12 this 指针 定义 Sales_data 类 考察对 isbn 成员函数的调用 : total.isbn(); // Sales_data total; 使用点运算符来访问 total 对象的 isbn 成员 调用成员函数时, 实际上是替某个对象调用它 如果 isbn 访问 Sales_data 的某个成员, 那么它隐式地访问调用该函数的对象的成员 std::string isbn() const { return bookno; } isbn 返回 bookno 时, 实际上它隐式地返回 total.bookno 12

13 this 指针 定义 Sales_data 类 成员函数通过一个额外的隐式形参 this 来访问调用它的那个对象 定义名为 this 的形参或变量是不合法的 编译器把 this 指针初始化成调用成员函数的对象的地址 调用 total.isbn() 等价于如下伪代码 : // pseudo-code illustration of how a call to a member function is translated Sales_data::isbn(&total) 成员函数体内任何对类成员的直接访问都可以看做 this 指针的隐式引用 std::string isbn() const { return this->bookno; } 13

14 const 成员函数 定义 Sales_data 类 std::string isbn() const { return bookno; } C++ 允许把 const 关键字放在成员函数的参数列表之后, 声明一个常量成员函数 (const member function) 默认情况下,this 的类型是指向类类型非常量对象的常量指针 :Sales_data *const 常量成员函数的 this 是指向常量的常量指针 :const Sales_data *const 常量成员函数不能改变调用它的对象的内容 14

15 const 成员函数 定义 Sales_data 类 std::string isbn() const { return bookno; } 可以把 isbn 的函数体想象成如下形式 : // pseudo-code illustration of how the implicit this pointer is used // this code is illegal: we may not explicitly define the this pointer ourselves // note that this is a pointer to const because isbn is a const member std::string Sales_data::isbn(const Sales_data *const this) { return this->bookno; } 常量对象, 以及常量对象的引用或指针都只能调用常量成员函数 15

16 类作用域和成员函数 定义 Sales_data 类 类成员函数的定义嵌套在类作用域内 isbn 函数用到的 bookno 就是定义在类 Sales_data 内的数据成员 成员函数体可以随意使用类中的其他成员而无须在意这些成员出现的位置 即使 bookno 定义在 isbn 之后,isbn 还是能够使用 bookno 编译器分两步处理类 : 首先编译成员的声明 然后处理成员函数体 ( 如果有的话 ) 16

17 在类外定义成员函数 定义 Sales_data 类 在类外部定义成员函数时, 成员函数的定义必须与它在类内的声明匹配 类外定义的成员的名字必须包含它所属的类名 double Sales_data::avg_price() const { } if (units_sold) else return revenue/units_sold; return 0; 17

18 定义返回 this 对象的函数 定义 Sales_data 类 函数 combine 的设计初衷类似于复合赋值运算符 += 调用该函数的对象代表的是赋值运算符的左侧运算对象, 即 *this 右侧运算对象通过显式的实参传入函数 内置赋值运算符把其左侧运算对象作为左值返回,combine 函数必须返回引用类型 Sales_data& Sales_data::combine(const Sales_data &rhs) { units_sold += rhs.units_sold; // add the members of rhs into revenue += rhs.revenue; // the members of ''this'' object return *this; // return the object on which the function was called } 18

19 定义类相关的非成员函数 定义抽象数据类型 // nonmember Sales_data interface functions Sales_data add(const Sales_data&, const Sales_data&); std::ostream &print(std::ostream&, const Sales_data&); std::istream &read(std::istream&, Sales_data&); 经常需要定义一些类的辅助函数, 这些函数从概念上来说属于类的接口的组成部分, 但它们并不属于类本身 这些函数一般声明 ( 而非定义 ) 在类所在的头文件中 19

20 定义 read 和 print 函数 定义类相关的非成员函数 // input transactions contain ISBN, number of copies sold, and sales price istream &read(istream &is, Sales_data &item) { double price = 0; is >> item.bookno >> item.units_sold >> price; item.revenue = price * item.units_sold; return is; } ostream &print(ostream &os, const Sales_data &item) { os << item.isbn() << " " << item.units_sold << " " << item.revenue << " " << item.avg_price(); return os; } 20

21 定义 read 和 print 函数 定义类相关的非成员函数 read 和 print 分别接受一个各自 IO 类型的引用作为其参数 IO 类属于不能被拷贝的类型, 只能通过引用来传递 读取和写入会改变流的内容, 所以两个函数接受的是普通引用, 而非常量引用 print 函数不负责换行 一般执行输出任务的函数应该尽量减少对格式的控制 21

22 定义 add 函数 定义类相关的非成员函数 add 函数接受两个 Sales_data 对象作为其参数, 返回值是一个表示它们和的新的 Sales_data 对象 默认情况下, 拷贝类的对象其实是拷贝对象的数据成员 Sales_data add(const Sales_data &lhs, const Sales_data &rhs) { Sales_data sum = lhs; // copy data members from lhs into sum sum.combine(rhs); sum return sum; } // add data members from rhs into 22

23 构造函数 定义抽象数据类型 类通过名为构造函数 (constructor) 的成员函数来控制其对象的初始化过程 只要类的对象被创建, 就会执行构造函数 构造函数的任务是初始化类的数据成员 构造函数的名字和类名相同 构造函数没有返回类型 类可以包含多个构造函数 必须在形参数量或类型上有所区别 构造函数不能声明成 const 构造函数在 const 对象的初始化过程向其写值 23

24 合成的默认构造函数 构造函数 Sales_data total; // variable to hold the running sum 如果类没有显式地定义构造函数, 那么编译器会隐式地定义一个默认构造函数 (default constructor) 默认构造函数是一个没有参数的构造函数 编译器创建的默认构造函数称为合成的默认构造函数 (synthesized default constructor), 其初始化规则为 : 如果存在类内初始值, 用它来初始化成员 否则, 默认初始化该成员 24

25 不能依赖于合成的默 认构造函数 构造函数 一般地, 类必须定义自己的默认构造函数, 不能依赖于合成默认构造函数 只有当类没有声明任何构造函数时, 编译器才自动生成默认构造函数 合成的默认构造函数可能执行错误的操作 默认初始化的内置类型或复合类型的数据成员的值是未定义的 有时编译器无法合成默认的构造函数 例如, 类中含有一个类类型的成员且该类没有默认构造函数时 25

26 定义 Sales_data 的构 造函数 构造函数 定义 4 个构造函数使用如下参数 : 1 个 istream&, 从中读取一条交易信息 1 个 const string&, 表示 ISBN 编号 ;1 个 unsigned, 表示售出的图书数量 ; 以及 1 个 double, 表示图书的售价 1 个 const string&, 表示 ISBN 编号 ; 编译器将赋予其他成员默认值 一个空参数列表 ( 即默认构造函数 ) 如果定义了其他构造函数, 那么必须定义一个默认构造函数 26

27 定义 Sales_data 的构 造函数 构造函数 struct Sales_data { // constructors added Sales_data() = default; Sales_data(const std::string &s): bookno(s) { } Sales_data(const std::string &s, unsigned n, double p) : bookno(s), units_sold(n), revenue(p*n) { } Sales_data(std::istream &); // other members as before std::string isbn() const { return bookno; } Sales_data& combine(const Sales_data&); double avg_price() const; std::string bookno; unsigned units_sold = 0; double revenue = 0.0; }; 27

28 =default 的含义 构造函数 默认构造函数定义如下 : Sales_data() = default; 在 C++11 中, 如果需要默认行为, 通过在参数列表后写上 =default 来要求编译器生成合成默认构造函数 =default 既可以和声明一起出现在类内部, 也可以作为定义出现在类外 如果 =default 出现在类内部, 则默认构造函数是内联函数 ; 如果在类外, 则该成员默认情况下不是内联的 28

29 构造函数初始值列表 构造函数 类中定义的其他两个构造函数 : Sales_data(const std::string &s): bookno(s) { } Sales_data(const std::string &s, unsigned n, double p): bookno(s), units_sold(n), revenue(p*n) { } 冒号以及冒号与左花括号之间的代码称为构造函数初始值列表 (constructor initializer list), 为新创建对象的一个或多个数据成员赋初值 构造函数初始值是逗号分隔的成员名列表, 每个名字后紧跟括号或花括号括起来的成员初始值 29

30 构造函数初始值列表 构造函数 对未出现在初始值列表中的成员, 将以与合成默认构造函数相同的方式隐式初始化 只接受 1 个 string 参数的构造函数等价于 : // has the same behavior as the original constructor defined above Sales_data(const std::string &s): bookno(s), units_sold(0), revenue(0){ } 如果编译器不支持类内初始值, 那么所有的构造函数都应该显式地初始化每个内置类型的成员 30

31 在类外定义构造函数 构造函数 在类外定义构造函数时, 必须指明该构造函数是哪个类的成员 Sales_data::Sales_data(std::istream &is) { read(is, *this); // read will read a transaction from is into this object } 即使构造函数初始值列表是空的, 对象的成员仍然会在函数体执行前被初始化 31

32 拷贝 赋值和析构 定义抽象数据类型 除了定义类的对象如何初始化外, 还需要控制拷贝 (copy) 赋值 (assign) 和销毁 (destroy) 对象时的行为 初始化变量以及以传值方式传递或返回一个对象时, 对象被拷贝 使用赋值运算符时, 发生对象的赋值 当对象不再存在时, 执行销毁的操作 32

33 拷贝 赋值和析构 定义抽象数据类型 如果不定义这些操作, 编译将替我们合成它们 编译器生成的版本对对象的每个成员执行拷贝 赋值和销毁操作 编译器执行如下赋值语句时, total = trans; // process the next book 其行为与下面的代码相同 : // default assignment for Sales_data is equivalent to: total.bookno = trans.bookno; total.units_sold = trans.units_sold; total.revenue = trans.revenue; 33

34 访问控制与封装 在 C++ 中, 使用访问说明符 (access specifiers) 实施类的封装 定义在 public 说明符之后的成员在整个程序内可被访问 public 成员定义类的接口 定义在 private 说明符之后的成员可被类的成员函数访问, 但不能被使用该类的代码访问 private 部分封装 ( 隐藏 ) 了类的实现 34

35 封装 Sales_data 类 class Sales_data { public: // access specifier added Sales_data() = default; Sales_data(const std::string &s, unsigned n, double p): bookno(s), units_sold(n), revenue(p*n) { } Sales_data(const std::string &s): bookno(s) { } Sales_data(std::istream&); std::string isbn() const { return bookno; } Sales_data &combine(const Sales_data&); private: // access specifier added double avg_price() const { return units_sold? revenue/units_sold : 0; } std::string bookno; unsigned units_sold = 0; double revenue = 0.0; }; 35

36 访问控制与封装 作为接口的构造函数和部分成员函数跟在 public 说明符之后 数据成员和作为实现的部分成员函数跟在 private 说明符之后 一个类可以包含 0 或多个访问说明符, 且某个说明符出现的次数没有限制 每个访问说明符指定了随后成员的访问级别, 其有效范围直到出现下一个访问说明符或到达类的结尾处为止 36

37 使用 class 或 struct 访问控制与封装 可以使用 class 或 struct 来定义一个类, 区别在于它们的默认访问权限不同 使用 struct 关键字, 则定义在第一个访问说明符之前的成员是 public 的 一般地, 若定义的类的所有成员是 public 时, 使用 struct 使用 class 关键字, 则定义在第一个访问说明符之前的成员是 private 的 若定义的类有 private 成员时, 使用 class 37

38 友元 访问控制与封装 Sales_data 的数据成员是 private 的, 于是 read print 和 add 函数无法正常编译 类可以允许其他类或函数访问它的非公有成员, 方式是令其他类或函数成为它的友元 (friend) 如果类想把一个函数作为它的友元, 只需要在类内增加一条以 friend 关键字开始的该函数声明语句 38

39 友元 访问控制与封装 class Sales_data { // friend declarations for nonmember Sales_data operations added friend Sales_data add(const Sales_data&, const Sales_data&); friend std::istream &read(std::istream&, Sales_data&); friend std::ostream &print(std::ostream&, const Sales_data&); // other members and access specifiers as before... }; // declarations for nonmember parts of the Sales_data interface Sales_data add(const Sales_data&, const Sales_data&); std::istream &read(std::istream&, Sales_data&); std::ostream &print(std::ostream&, const Sales_data&); 39

40 友元的声明 友元 友元声明 (friend declaration) 只能出现类定义的内部 一般地, 最好在类定义开始或结束的位置集中声明友元 友元不是类的成员, 也不受它所在区域访问控制权限的约束 友元声明不是通常意义上的函数声明 为了使友元对类的用户可见, 通常把友元的声明 ( 在类外 ) 与类放在同一个头文件 40

41 类的其他特性 类成员再探 类型成员 内联成员函数 重载成员函数 可变数据成员 类类型成员的类内初始值 返回 *this 的成员函数 类类型 友元类 41

42 定义类型成员 类成员再探 假设 Screen 类表示显示器中的一个窗口 1 个保存屏幕窗口内容的 string 成员 3 个 string::size_type 成员, 分别表示光标位置以及窗口的高和宽 class Screen { public: typedef std::string::size_type pos; private: pos cursor = 0; pos height = 0, width = 0; std::string contents; }; 42

43 定义类型成员 类成员再探 除了定义数据和函数成员, 类还可以定义类型成员 (type member)-- 某种类型在类内的别名 类定义的类型名字和其他成员一样存在访问限制, 可以是 public 或 private 之一 声明类型别名时, 可以使用 typedef 或 using 形式 using pos = std::string::size_type; 不同于普通成员, 类型成员必须先定义后使用 类型成员通常出现在类定义的开始位置 43

44 Screen 类的成员函数 类成员再探 class Screen { public: typedef std::string::size_type pos; Screen() = default; // needed because Screen has another constructor // cursor initialized to 0 by its in-class initializer Screen(pos ht, pos wd, char c): height(ht), width(wd), contents(ht * wd, c) { } char get() const // get the character at the cursor { return contents[cursor]; } // implicitly inline inline char get(pos ht, pos wd) const; // explicitly inline Screen &move(pos r, pos c); // can be made inline later private: pos cursor = 0; pos height = 0, width = 0; std::string contents; }; 44

45 内联成员函数 类成员再探 定义在类内的成员函数是自动 inline 的 定义在类外的成员函数也可以 inline 可以在类内显式地声明成员函数为 inline 的, 也可在类外定义函数时说明是 inline 的 在声明和定义时同时说明 inline 是合法的 一般只在类外定义函数时说明 inline, 可使类更容易理解 45

46 内联成员函数 类成员再探 inline // we can specify inline on the definition Screen &Screen::move(pos r, pos c) { pos row = r * width; // compute the row location cursor = row + c ; // move cursor to the column within that row return *this; // return this object as an lvalue } char Screen::get(pos r, pos c) const // declared as inline in the class { pos row = r * width; // compute row location return contents[row + c]; // return character at the given column } 46

47 重载成员函数 成员函数也可以被重载, 只要函数之间在形参的数量和 / 或类型上有所区别 类成员再探 编译器根据实参来决定运行哪个版本的成员函数 Screen myscreen; // calls default constructor char ch = myscreen.get();// calls Screen::get() ch = myscreen.get(0,0); // calls Screen::get(pos, pos) 47

48 可变数据成员 类成员再探 可变数据成员 (mutable data member) 永远不会是 const, 即使它是 const 对象的成员 在数据成员的声明中加入 mutable 关键字 任何成员函数, 包括 const 成员函数都可以改变一个可变数据成员的值 48

49 可变数据成员 类成员再探 class Screen { public: void some_member() const; private: }; mutable size_t access_ctr; // may change even in a const object // other members as before void Screen::some_member() const { ++access_ctr; // keep a count of the calls to any member function } // whatever other work this member needs to do 49

50 类类型数据成员的初始值 类成员再探 定义窗口管理类 Window_mgr 表示显示器上的一组 Screen 对象 包含一个 vector<screen> 成员 默认情况下, 希望 Window_mgr 类对象创建时有一个默认初始化的 Screen 对象 最好的方式是把这个默认值声明为类内初始值 class Window_mgr { private: // Screens this Window_mgr is tracking // by default, a Window_mgr has one standard sized blank Screen std::vector<screen> screens{screen(24, 80, ' ') }; }; 50

51 返回 *this 的成员函数 类成员再探 添加函数设置当前光标或指定位置处的字符 class Screen { public: Screen &set(char); Screen &set(pos, pos, char); // other members as before }; inline Screen &Screen::set(char c) { contents[cursor] = c; // set the new value at the current cursor location return *this; // return this object as an lvalue } inline Screen &Screen::set(pos r, pos col, char ch) { contents[r*width + col] = ch; // set specified location to given value return *this; // return this object as an lvalue } 51

52 返回 *this 的成员函数 类成员再探 和 move 操作一样,set 成员函数返回调用它们的对象的引用 返回引用的函数是左值 (lvalue) 的 // move the cursor to a given position, and set that character myscreen.move(4,0).set('#'); 上面代码中的操作作用在同一个对象 myscreen 上, 等价于 myscreen.move(4,0); myscreen.set('#'); 52

53 从 const 成员函数返回 *this 返回 *this 的成员函数 如果 const 成员函数以引用的形式返回 *this, 那么返回类型是常量引用 增加 const 成员函数 display, 负责打印 Screen 的内容 const Screen &display(std::ostream &os) const; 不能将 display 嵌入到一组动作的序列中 Screen myscreen; // if display returns a const reference, the call to set is an error myscreen.display(cout).set('*'); 53

54 基于 const 的重载 返回 *this 的成员函数 通过区分成员函数是否是 const 的, 可以对其进行重载 原因同根据指针形参是否指向 const 而重载 常量对象只能调用 const 成员函数 非常量对象可以调用常量版本或非常量版本, 但非常量版本是更好的匹配 定义私有成员 do_display 负责打印的实际工作, 重载的 display 操作调用该函数然后返回执行操作的对象 54

55 基于 const 的重载 返回 *this 的成员函数 class Screen { public: // display overloaded on whether the object is const or not Screen &display(std::ostream &os) { do_display(os); return *this; } const Screen &display(std::ostream &os) const { do_display(os); return *this; } private: // function to do the work of displaying a Screen void do_display(std::ostream &os) const {os << contents;} // other members as before }; 55

56 基于 const 的重载 返回 *this 的成员函数 在某个对象上调用 display 时, 对象是否是 const 决定了调用哪个版本的 display Screen myscreen(5,3); const Screen blank(5, 3); myscreen.set('#').display(cout); // calls non const version blank.display(cout); // calls const version 56

57 类类型 每个类定义了唯一的类型 类成员再探 即使两个类定义的成员完全一样, 也是不同类型 struct First { int memi; int getmem(); }; struct Second { int memi; int getmem(); }; First obj1; Second obj2 = obj1; // error: obj1 and obj2 have different types 57

58 类类型 类成员再探 可以把类名直接作为类类型的名字, 也可以把类名跟在 struct 或 class 关键字后面 (C 风格方式 ) Sales_data item1; type Sales_data // default-initialized object of class Sales_data item1; // equivalent declaration 58

59 类的声明 类类型 可以仅声明类而暂时不定义它 : class Screen; // declaration of the Screen class 这种声明被称作前向声明 (forward declaration) 在声明之后定义之前, 类型 Screen 是一个不完全类型 (incomplete type) 知道 Screen 是一个类类型, 但是不清楚它到底有哪些成员 可以定义指向不完全类型的指针或引用, 也可以声明 ( 但不能定义 ) 以不完全类型作为形参或者返回类型的函数 59

60 类的声明 类类型 创建类的对象之前必须先定义该类 仅通过声明, 编译器无法确定对象需要多少存储空间 类也必须先被定义, 才能用引用或指针访问其成员 类先被定义后, 才能声明该类类型的数据成员 一个类的数据成员的类型不能是该类自己 类可以包含指向自身的指针或引用类型的数据成员 一旦类名出现后, 就认为该类已被声明 class Link_screen { Screen window; Link_screen *next; Link_screen *prev; }; 60

61 友元再探 类成员再探 类除了把普通的非成员函数定义成友元外 还可以把其他的类定义成友元 也可以把 ( 已定义过的 ) 其他类的成员函数定义成友元 友元函数能定义在类的内部 这样的函数是隐式 inline 的 61

62 类之间的友元关系 友元再探 如果一个类指定了友元类 (friend class), 则友元类的成员函数可以访问该类包括非公有成员在内的所有成员 class Screen { // Window_mgr members can access the private parts of class Screen friend class Window_mgr; //... rest of the Screen class }; 为 Window_mgr 类添加 clear 成员, 负责把指定 Screen 的内容置为空白 62

63 类之间的友元关系 友元再探 class Window_mgr { public: // location ID for each screen on the window using ScreenIndex = std::vector<screen>::size_type; // reset the Screen at the given position to all blanks void clear(screenindex); private: std::vector<screen> screens{screen(24, 80, ' ')}; }; void Window_mgr::clear(ScreenIndex i) { // s is a reference to the Screen we want to clear Screen &s = screens[i]; // reset the contents of that Screen to all blanks s.contents = string(s.height * s.width, ' '); } 63

64 成员函数作为友元 除了令整个类作为友元外, 可以把其他类的成员函数作为友元 友元再探 当把一个成员函数声明成友元时, 必须明确指出该成员函数属于哪个类 class Screen { // Window_mgr::clear must have been declared before class Screen }; friend void Window_mgr::clear(ScreenIndex); //... rest of the Screen class 64

65 成员函数作为友元 友元再探 令某个成员函数作为友元, 必须仔细组织程序的结构以满足声明和定义的彼此依赖关系 首先定义 Window_mgr 类, 其中声明但不定义 clear 函数 接下来定义 Screen 类, 包含对于 clear 的友元声明 最后定义 clear 函数, 此时它才可以访问 Screen 的成员 65

66 函数重载和友元 友元再探 如果一个类想把一组重载函数声明为它的友元, 它必须对这组函数中的每一个分别声明 // overloaded storeon functions extern std::ostream& storeon(std::ostream &, Screen &); extern BitMap& storeon(bitmap &, Screen &); class Screen { // ostream version of storeon may access the private parts of Screen objects friend std::ostream& storeon(std::ostream &, Screen &); //... }; 66

67 友元声明和作用域 友元再探 类和非成员函数的声明不是必须在它们的友元声明之前 当一个名字第一次出现在友元声明中时, 隐式地假定该名字在当前作用域中可见 友元本身不一定真的声明在当前作用域中 即使在类内定义友元函数, 也必须在类外提供相应的声明使得该函数可见 就算只被声明友元函数的类的成员来调用 友元声明只影响访问权限, 不是普通意义上的声明 67

68 友元声明和作用域 友元再探 struct X { friend void f() { /* friend function can be defined in the class body */ } X() { f(); } // error: no declaration for f void g(); void h(); }; void X::g() { return f(); } // error: f hasn't been declared void f(); // declares the function defined inside X void X::h() { return f(); } // ok: declaration for f is now in scope 68

69 类的作用域 一个类定义了它自己的作用域 在类作用域之外, 普通的数据和函数成员只能由对象 引用或指针使用成员访问运算符来访问 ; 类型成员使用作用域运算符访问 Screen::pos ht = 24, wd = 80; // use the pos type defined by Screen Screen scr(ht, wd, ' '); Screen *p = &scr; char c = scr.get(); // fetches the get member from the object scr c = p->get(); which p points // fetches the get member from the object to 69

70 作用域和定义在类外 的成员 在类外部, 成员的名字被隐藏起来了 类的作用域 一旦遇到类名, 定义的剩余部分 ( 包括形参列表和函数体 ) 就在类的作用域内了 void Window_mgr::clear(ScreenIndex i) { } Screen &s = screens[i]; s.contents = string(s.height * s.width, ' '); 70

71 作用域和定义在类外 的成员 当成员函数定义在类外时, 返回类型中使用的名字位于类作用域之外 返回类型必须指明它是哪个类的类型成员 class Window_mgr { public: using ScreenIndex = std::vector<screen>::size_type; // add a Screen to the window and returns its index ScreenIndex addscreen(const Screen&); // other members as before }; // return type is seen before we're in the scope of Window_mgr Window_mgr::ScreenIndex Window_mgr::addScreen(const Screen &s) { screens.push_back(s); return screens.size() - 1; 类的作用域 } 71

72 练习 类的作用域 练习 7.33: 为 Screen 类添加如下定义的 size 成员函数是否有问题? class Screen { public: typedef std::string::size_type pos; inline pos size() const; private: pos height = 0, width = 0; // other members as before }; pos Screen::size() const { return height * width; } 72

73 类作用域与名字查找 类的作用域 一般的名字查找 (name lookup) 过程 : 首先, 在名字所在的块内寻找其声明语句 只考虑在名字使用之前出现的声明 如果没找到, 继续查找外层作用域 如果最终未找到匹配的声明, 程序报错 类的成员函数中名字的解析方式不大一样, 因为类的定义分两步处理 : 首先, 编译成员的声明 直到类全部可见后才编译函数体 成员函数体中可使用类中定义的任何名字 73

74 类成员声明的名字查找 类作用域与名字查找 声明 ( 包括返回类型和形参列表中的名字 ) 中使用的名字, 都必须在使用前确保可见 两步处理方式只适用于成员函数体中使用的名字 typedef double Money; string bal; class Account { public: Money balance() { return bal; } private: }; Money bal; //... 74

75 类型名要特殊处理 类作用域与名字查找 一般地, 内层作用域可以重定义外层作用域中的名字, 即使该名字已在内层作用域中使用过 在类中, 如果成员使用了外层作用域中的类型名字, 那么类不能在之后重新定义该名字 如果未使用, 可以重新定义 一般把类型名的定义放在类开始处 75

76 类型名要特殊处理 类作用域与名字查找 typedef double Money; class Account { public: Money balance() { return bal; } // uses Money from the outer scope private: typedef double Money; // error: cannot redefine Money }; Money bal; //... 76

77 成员定义内普通块作 用域名字查找 类作用域与名字查找 成员函数体中使用的名字按如下方式解析 : 首先, 在成员函数内查找该名字的声明 只考虑函数体内该名字使用前出现的声明 如果在成员函数内没有找到声明, 则在类内继续查找 考虑类的所有成员 如果类内也没找到该名字的声明, 则在成员函数定义之前的外层作用域内继续查找 77

78 成员定义内普通块作 用域名字查找 类作用域与名字查找 // note: this code is for illustration purposes only and reflects bad practice // it is generally a bad idea to use the same name for a parameter and a member int height; // defines a name subsequently used inside Screen class Screen { public: typedef std::string::size_type pos; void dummy_fcn(pos height) { cursor = width * height; // which height? the parameter } private: pos cursor = 0; pos height = 0, width = 0; }; 78

79 成员定义内普通块作 用域名字查找 类作用域与名字查找 上例中,height 形参隐藏了同名的成员 如果想使用 height 成员, 可采用如下两种方法 // bad practice: names local to member functions shouldn't hide member names void Screen::dummy_fcn(pos height) { cursor = width * this->height; // member height // alternative way to indicate the member cursor = width * Screen::height; // member height } 更好的方式是给形参起个其他名字 // good practice: don't use a member name for a parameter or other local variable void Screen::dummy_fcn(pos ht) { cursor = width * height; // member height } 79

80 在外层作用域中查找 类作用域与名字查找 如果编译器在函数和类作用域中都没有找到名字, 将接着在外层作用域中查找 如果想使用外层作用域中的名字, 可以显式地通过作用域运算符来请求 // bad practice: don't hide names that are needed from surrounding scopes void Screen::dummy_fcn(pos height) { cursor = width * ::height;// which height? the global one } 80

81 在外层作用域中查找 类作用域与名字查找 当成员函数定义在类外时, 名字查找的第三步不仅要考虑类定义所在作用域中的声明, 还要考虑函数定义所在作用域中的声明 int height; // defines a name subsequently used inside Screen class Screen { public: typedef std::string::size_type pos; void setheight(pos); pos height = 0; // hides the declaration of height in the outer scope }; Screen::pos verify(screen::pos); void Screen::setHeight(pos var) { // var: refers to the parameter, height: refers to the class member // verify: refers to the global function } height = verify(var); 81

82 练习 类作用域与名字查找 练习 7.35: 说明下面代码中 Type 和 initval 分别使用哪个定义? 如果代码存在错误, 尝试修改它 typedef string Type; Type initval(); class Exercise { public: typedef double Type; Type setval(type); Type initval(); private: Type val; }; Type Exercise::setVal(Type parm) { val = parm + initval(); return val; } 82

83 构造函数再探 如果成员在构造函数初始值列表中没有显式地初始化, 且无类内初始值, 则该成员将在构造函数体执行之前被默认初始化 // legal but sloppier way to write the Sales_data constructor: no constructor initializers Sales_data::Sales_data(const string &s, unsigned cnt, double price) { bookno = s; units_sold = cnt; revenue = cnt * price; } 83

84 构造函数初始值列表 构造函数再探 如果成员是 const 引用或者属于某种未提供默认构造函数的类类型, 必须通过构造函数初始值列表来提供初值 class ConstRef { public: ConstRef(int ii); private: int i; const int ci; int &ri; }; 84

85 初始值有时必不可少 构造函数初始值列表 常量或引用成员必须被初始化 // error: ci and ri must be initialized ConstRef::ConstRef(int ii) { // assignments: i = ii; // ok ci = ii; // error: cannot assign to a const ri = i; // error: ri was never initialized } 只能通过构造函数初始值列表来初始化 // ok: explicitly initialize reference and const members ConstRef::ConstRef(int ii): i(ii), ci(ii), ri(i) { } 85

86 成员初始化的顺序 构造函数初始值列表 在构造函数初始值列表中, 每个成员只能出现一次 成员的初始化顺序与它们在类定义中出现的顺序一致 最好令构造函数初始值的顺序与成员声明的顺序一致, 且尽量避免使用某些成员初始化其他成员 class X { int i; int j; public: // undefined: i is initialized before j X(int val): j(val), i(j) { } }; 86

87 默认实参和构造函数 构造函数初始值列表 构造函数中可以使用默认实参 若构造函数为所有形参提供了默认实参, 则它实际上也定义了默认构造函数 class Sales_data { public: // defines the default constructor as well as one that takes a string argument Sales_data(std::string s = ""): bookno(s) { } // remaining constructors unchanged Sales_data(std::string s, unsigned cnt, double rev): bookno(s), units_sold(cnt), revenue(rev*cnt) { } Sales_data(std::istream &is) { read(is, *this); } // remaining members as before }; 87

88 练习 构造函数初始值列表 练习 7.36: 找出并修改代码中的问题 struct X { X (int i, int j): base(i), rem(base % j) { } int rem, base; }; 88

89 委托构造函数 构造函数再探 委托构造函数 (delegating constructor) 使用它所属类的其他构造函数执行其初始化过程 委托构造函数也有成员初始值列表和函数体 在委托构造函数内, 成员初始值列表只有一个唯一的入口, 就是类名本身 : 类名后面紧跟圆括号括起来的实参列表 实参列表必须与类中另外一个构造函数匹配 89

90 委托构造函数 构造函数再探 class Sales_data { public: // nondelegating constructor initializes members from corresponding arguments Sales_data(std::string s, unsigned cnt, double price): bookno(s), units_sold(cnt), revenue(cnt*price) { } // remaining constructors all delegate to another constructor Sales_data(): Sales_data("", 0, 0) {} Sales_data(std::string s): Sales_data(s, 0,0) {} Sales_data(std::istream &is): Sales_data() { read(is, *this); } // other members as before }; 90

91 默认构造函数的作用 构造函数再探 当对象被默认初始化或值初始化时自动执行默认构造函数 在以下情况下发生默认初始化 : 在块作用域中不使用任何初始值定义一个非静态变量或者数组时 当类含有使用合成默认构造函数的类类型成员时 当类类型的成员在构造函数初始值列表中没有被显式地初始化, 且无类内初始值时 91

92 默认构造函数的作用 构造函数再探 值初始化在以下情况下发生 : 在数组初始化过程中, 如果提供的初始值数量少于数组的大小时 当定义全局对象或局部静态对象而不提供初始值时 当通过形如 T() 的表达式显式地请求值初始化时, 其中 T 是类型名 vector<t> vec(10); 在上述情况下, 类必须包含一个默认构造函数 92

93 默认构造函数的作用 构造函数再探 class NoDefault { public: NoDefault(const std::string&); // additional members follow, but no other constructors }; struct A { // my_mem is public by default NoDefault my_mem; }; A a; // error: cannot synthesize a constructor for A struct B { B() {} // error: no initializer for b_member NoDefault b_member; }; 93

94 使用默认构造函数 默认构造函数的作用 下面代码试图声明一个默认初始化的对象 : Sales_data obj(); // ok: but defines a function, not an object if (obj.isbn() == Primer_5th_ed.isbn()) // error: obj is a function 如果想定义一个使用默认构造函数进行初始化的对象, 正确方法是去掉对象名后的空括号对 // ok: obj is a default-initialized object Sales_data obj; 94

95 隐式的类类型转换 构造函数再探 能用一个实参调用的构造函数也称为转换构造函数 (converting constructor) class Sales_data { public: // access specifier added Sales_data() = default; Sales_data(const std::string &s, unsigned n, double p): bookno(s), units_sold(n), revenue(p*n) { } Sales_data(const std::string &s): bookno(s) { } Sales_data(std::istream&); Sales_data &combine(const Sales_data&); // other members as before }; 95

96 隐式的类类型转换 构造函数再探 转换构造函数定义了一条从构造函数的形参类型到类类型的隐式转换规则 // Sales_data(const std::string &s); // Sales_data &combine(const Sales_data&); string null_book = " "; // constructs a temporary Sales_data object // with units_sold and revenue equal to 0 and bookno equal to null_book item.combine(null_book); 96

97 只允许一步类类型转换 隐式的类类型转换 编译器只会自动地应用一步类型转换 无法隐式地使用两次转换 // error: requires two user-defined conversions: // (1) convert " " to string // (2) convert that (temporary) string to Sales_data item.combine(" "); 可以显式地把字符串转换成 string 或者 Sales_data 对象 // ok: explicit conversion to string, implicit conversion to Sales_data item.combine(string(" ")); // ok: implicit conversion to string, explicit conversion to Sales_data item.combine(sales_data(" ")); 97

98 抑制构造函数定义的 隐式转换 隐式的类类型转换 可以通过把构造函数声明为 explicit 来阻止隐式转换 class Sales_data { public: }; Sales_data() = default; Sales_data(const std::string &s, unsigned n, double p): bookno(s), units_sold(n), revenue(p*n) { } explicit Sales_data(const std::string &s): bookno(s) { } explicit Sales_data(std::istream&); // remaining members as before 98

99 抑制构造函数定义的 隐式转换 隐式的类类型转换 声明为 explicit 之后, 没有构造函数能用于隐式地创建 Sales_data 对象 string null_book = " "; item.combine(null_book); // error: string constructor is explicit item.combine(cin); // error: istream constructor is explicit 关键字 explicit 只对能用一个实参调用的构造函数有意义 只有在类内声明构造函数时能使用 explicit, 在类外定义时不能重复 // error: explicit allowed only on a constructor declaration in a class header explicit Sales_data::Sales_data(istream& is) { read(is, *this); } 99

100 explicit 构造函数只能 用于直接初始化 隐式的类类型转换 拷贝初始化 (= 号形式 ) 会发生隐式转换 explicit 构造函数只能用于直接初始化 string null_book = " "; Sales_data item1 (null_book); // ok: direct initialization // error: cannot use the copy form of initialization with an explicit constructor Sales_data item2 = null_book; 100

101 显式地使用构造函数转换 隐式的类类型转换 可以显式地使用 explicit 构造函数进行强制类型转换 string null_book = " "; // ok: the argument is an explicitly constructed Sales_data object item.combine(sales_data(null_book)); // ok: static_cast can use an explicit constructor item.combine(static_cast<sales_data>(cin)); 101

102 有显式构造函数的标 准库类 隐式的类类型转换 string 类的单参数构造函数 string(const char *) 不是 explicit 的 接受容量参数的 vector 构造函数 vector<t>(size_type n) 是 explicit 的 vector<int> ivec(10); // ten elements, each initialized to 0 vector<int> vi = 10; // error: must use direct initialization to supply a size 102

103 练习 隐式的类类型转换 练习 7.48: 假定 Sales_data 的构造函数 Sales_data(const std::string &s) 不是 explicit 的, 则下述定义将执行什么样的操作? string null_isbn(" "); Sales_data item1(null_isbn); Sales_data item2(" "); 如果是 explicit 的, 又发生什么呢? 103

104 练习 隐式的类类型转换 练习 7.49: 对于 combine 函数的三种不同声明, 调用 i.combine(s) 时分别发生什么情况? 其中,i 是一个 Sales_data 对象, 而 s 是一个 string 对象 (a) Sales_data &combine(sales_data); (b) Sales_data &combine(sales_data&); (c) Sales_data &combine(const Sales_data&) const; 104

105 聚合类 构造函数再探 聚合类 (aggregate class) 满足如下条件 : 所有数据成员都是 public 的 没有定义任何构造函数 没有类内初始值 没有基类和 virtual 函数 struct Data { int ival; string s; }; 105

106 聚合类的初始化 聚合类 可以用花括号括起来的初始值列表来初始化聚合类的数据成员 // val1.ival = 0; val1.s = string("anna") Data val1 = { 0, "Anna" }; 初始值的顺序必须与数据成员的声明顺序一致 // error: can't use "Anna" to initialize ival, or 1024 to initialize s Data val2 = { "Anna", 1024 }; 如果初始值列表中的元素个数少于数据成员数, 则靠后的成员被值初始化 初始值列表的元素个数不能多于成员数 106

107 练习 聚合类 练习 7.52: 第 2 章中 Sales_data 类定义为 struct Sales_data { }; std::string bookno; unsigned units_sold = 0; double revenue = 0.0; 解释下面的初始化过程 若存在问题, 尝试修改它 Sales_data item = {" ", 25, 15.99}; 107

108 类的静态成员 类 有时候, 类需要一些成员来表征自身的类属性, 而不是其个体对象的属性 实现同一个类的不同对象之间的数据和函数共享 例如, 一个银行账户类可能需要一个表示当前基准利率的数据成员 109

109 声明静态成员 类的静态成员 在成员声明前加关键字 static 来表示类属性 静态成员可以是 public 或 private 的 静态数据成员可以是 const 常量 引用 数组 类类型等 class Account { public: void calculate() { amount += amount * interestrate; } static double rate() { return interestrate; } static void rate(double); private: std::string owner; double amount; static double interestrate; static double initrate(); }; 110

110 声明静态成员 类的静态成员 类的静态成员存在于任何对象之外 对象中不包含与静态数据成员相关的数据 静态成员函数不绑定到任何对象, 即不包含 this 指针 静态成员函数不能声明为 const 不能在静态成员函数体内使用 this 指针 限制适用于 this 的显式使用, 以及调用非静态成员的隐式使用 必须通过对象来访问非静态成员 111

111 使用静态成员 类的静态成员 在类外使用类名和作用域运算符访问静态成员 double r; r = Account::rate(); // access a static member using the scope operator 也可以使用类的对象 引用或指针来访问静态成员 Account ac1; Account *ac2 = &ac1; // equivalent ways to call the static member rate function r = ac1.rate(); // through an Account object or reference r = ac2->rate(); // through a pointer to an Account object 112

112 使用静态成员 类的静态成员 成员函数不用通过作用域运算符就能直接使用静态成员 class Account { public: void calculate() { amount += amount * interestrate; } private: static double interestrate; // remaining members as before }; 113

113 定义静态成员 类的静态成员 可以在类内也可以在类外定义静态成员函数 在类外定义静态成员时, 不能重复 static static 关键字只出现在类内的声明语句中 void Account::rate(double newrate) { } interestrate = newrate; 114

114 定义静态成员 类的静态成员 静态数据成员不属于类的任何一个对象, 必须在类外定义和初始化每个静态数据成员 静态数据成员定义在任何函数之外, 具有静态生存期 // define and initialize a static class member double Account::interestRate = initrate(); 和其他成员的定义一样, 定义静态成员也可以访问类的私有成员 115

115 静态数据成员的类内 初始化 类的静态成员 一般情况下, 类的静态成员不能在类内初始化 但可以为 const 整数类型静态成员提供类内初始值, 且必须为字面值类型的 constexpr 静态成员提供类内初始值 初始值必须是常量表达式 如果静态成员的应用场景仅限于编译器可以替换其值的情况, 则初始化的 const 或 constexpr 静态成员可以不在类外定义 116

116 静态数据成员的类内 初始化 类的静态成员 class Account { public: static double rate() { return interestrate; } static void rate(double); private: static constexpr int period = 30; // period is a constant expression double daily_tbl[period]; }; 如果在类内提供了初始值, 则成员定义时不能再指定初始值 // definition of a static member with no initializer constexpr int Account::period; // initializer provided in the class definition 117

117 只静态成员可用的场景 类的静态成员 静态数据成员可以是不完全类型 特别地, 静态数据成员的类型可以是它所属的类类型 class Bar { public: //... private: static Bar mem1; // ok: static member can have incomplete type Bar *mem2; incomplete type Bar mem3; complete type }; // ok: pointer member can have // error: data members must have 118

118 只静态成员可用的场景 类的静态成员 静态和普通数据成员的另外一个区别是静态数据成员可以作为默认实参 class Screen { public: // bkground refers to the static member // declared later in the class definition Screen& clear(char = bkground); private: }; static const char bkground; 119

119 练习 类的静态成员 练习 7.58: 下面静态数据成员的声明和定义是否有错? // example.h class Example { public: static double rate = 6.5; static const int vecsize = 20; static vector<double> vec(vecsize); }; // example.c #include "example.h" double Example::rate; vector<double> Example::vec; 120