第五讲 C++程序的结构

Size: px

Start display at page:

Download "第五讲 C++程序的结构"

十都
5 years ago
Views:

1 第五章数据的共享与保护

2 本章主要内容作用域与可见性对象的生存期数据与函数静态成员共享数据的保护友元编译预处理命令多文件结构和工程深度探索 2

3 命名空间作用域作用域与可见性标识符的作用域标识符在程序正文中有效的区域函数原型作用域局部作用域类作用域 3

4 作用域与可见性函数原型的作用域函数原型中的参数, 其作用域始于 "(", 结束于 ")" 例如, 设有下列原型声明 : double area(double radius); radius 的作用域仅在于此, 不能用于程序正文其他地方, 因而可有可无 4

5 作用域与可见性局部作用域函数的形参, 在块中声明的标识符, 其作用域自声明处起, 限于块中, 例如 : void fun(int a) { int b = a; cin >> b; if (b > 0) { int c; c 的作用域... 块 : 一对大括号括起来的一段程序 a 的作用域 b 的作用域 5

6 作用域与可见性类作用域类作用域作用于特定的成员名类 X 的成员 m 具有类作用域, 对 m 的访问方式如下 : 如果在 X 的成员函数中没有声明同名的局部作用域标识符, 那么在该函数内可以访问成员 m 通过表达式 x.m 或者 X::m 访问 X::m 的形式访问类的静态成员通过表达式 ptr->m,ptr 为指向类 X 的一个对象的指针 6

7 作用域与可见性命名空间命名空间可以解决类名函数名等的命名冲突命名空间的声明 namespace 命名空间名 { 例各种声明 ( 函数声明类声明 ) namespace SomeNs { class SomeClass {... ; 7

8 作用域与可见性匿名命名空间 : 对每个源文件是唯一的命名空间命名空间允许嵌套 namespace OuterNs { namespace InnerNs { class SomeClass {... ; 特殊的命名空间全局命名空间 : 默认的命名空间在显式声明的命名空间外声明的标识符都在全局命名空间中 8

9 作用域与可见性9 命名空间作用域一个命名空间确定了一个命名空间作用域引用其它命名空间作用域中的标识符命名空间名 :: 标识符名例 : 声明一个 SomeClass 型的对象 SomeNs::SomeClass obj1; OuterNs::InnerNs::SomeClass obj2; 将其它命名空间作用域的标识符暴露于当前作用域对指定标识符 using 命名空间名 :: 标识符名 ; 对所有标识符 using namespace 命名空间名 ;

10 作用域与可见性可见性可见性是从对标识符的引用的角度来谈的概念可见性表示从内层作用域向外层作用域看时能看见什么如果标识在某处可见, 则就可以在该处引用此标识符命名空间作用域类作用域块作用域 10

11 作用域与可见性可见性标识符应声明在先, 引用在后如果某个标识符在外层中声明, 且在内层中没有同一标识符的声明, 则该标识符在内层可见对于两个嵌套的作用域, 如果在内层作用域内声明了与外层作用域中同名的标识符, 则外层作用域的标识符在内层不可见 11

12 作用域与可见性同一作用域中的同名标识符在同一作用域内的对象名函数名枚举常量名会隐藏同名的类名或枚举类型名重载的函数可以有相同的函数名 12

13 作用域与可见性例 5.1 #include <iostream> using namespace std; int i; // 在全局命名空间中的全局变量 namespace Ns { int j; // 在 Ns 命名空间中的全局变量 int main() { i = 5; // 为全局变量 i 赋值 Ns::j = 6; // 为全局变量 j 赋值 { // 子块 1 using namespace Ns; // 当前块中可以直接引用 Ns 中的标识符 int i; // 局部变量, 局部作用域 i = 7; cout << "i = " << i << endl;// 输出 7 cout << "j = " << j << endl;// 输出 6 cout << "i = " << i << endl; // 输出 5 return 0; 13

14 对象的生存期对象从产生到结束的这段时间就是它的生存期在对象生存期内, 对象将保持它的值, 直到被更新为止 14

15 对象的生存期静态生存期这种生存期与程序的运行期相同在命名空间作用域中声明的对象具有这种生存期在函数内部声明静态生存期对象, 要冠以关键字 static 定义时未指定初值的基本类型静态生存期变量, 会被赋 0 值初始化 15

16 对象的生存期例 #include<iostream> using namespace std; int i = 5; // 命名空间作用域 int main() { cout << "i=" << i << endl; return 0; i 具有静态生存期 16

17 对象的生存期动态生存期块作用域中声明的, 没有用 static 修是的对象是动态生存期的对象 ( 习惯称局部生存期对象 ) 开始于程序执行到声明点时, 结束于命名该标识符的作用域结束处 17

18 对象的生存期例 #include <iostream> using namespace std; void fun(); 运行结果 : int main() { fun(); i=6, a=2 fun(); i=6, a=3 void fun() { i 是动态生存期 static int a=1; int i=5; a 是静态生存期 a++; i++; cout<<"i="<<i<<",a="<<a<<endl; 18

19 象的生存期例 5-2 变量的生存期与可见性 #include<iostream> using namespace std; int i = 1; // i 为全局变量, 具有静态生存期 void other() { static int a = 2; static int b; // a,b 为静态局部变量, 具有全局寿命, 局部可见 // 只第一次进入函数时被初始化 int c = 10; // C 为局部变量, 具有动态生存期, // 每次进入函数时都初始化 a += 2; i += 32; c += 5; cout<<"---other---\n"; cout<<" i: "<<i<<" a: "<<a<<" b: "<<b<<" c: "<<c<<endl; b = a; 对19

20 int main() { static int a;// 静态局部变量, 有全局寿命, 局部可见 int b = -10; // b, c 为局部变量, 具有动态生存期 int c = 0; cout << "---MAIN---\n"; cout<<" i: "<<i<<" a: "<<a<<" b: "<<b<<" c: "<<c<<endl; c += 8; other(); cout<<"---main---\n"; cout<<" i: "<<i<<" a: "<<a<<" b: "<<b<<" c: "<<c<<endl; i += 10; other(); return 0; 20

21 运行结果 : ---MAIN--- i: 1 a: 0 b: -10 c: 0 ---OTHER--- i: 33 a: 4 b: 0 c: MAIN--- i: 33 a: 0 b: -10 c: 8 ---OTHER--- i: 75 a: 6 b: 4 c: 15 21

22 对象的生存期; 例 5-3 具有静态动态生存期对象的时钟程序 #include<iostream> using namespace std; class Clock { public: Clock(); // 外部接口 // 时钟类定义 void settime(int newh, int newm, int news); // 三个形参均具有函数原型作用域 void showtime(); private: // 私有数据成员 int hour, minute, second; 22

23 Clock::Clock() : hour(0), minute(0), second(0) { // 构造函数 void Clock::setTime(int newh, int newm, int news) { // 三个形参均具有局部作用域 hour = newh; minute = newm; second = news; void Clock::showTime() { cout << hour << ":" << minute << ":" << second << endl; 23

24 Clock globclock;// 声明对象 globclock, // 具有静态生存期, 命名空间作用域 int main() { // 主函数 cout << "First time output:" << endl; // 引用具有命名空间作用域的对象 : globclock.showtime();// 对象的成员函数具有类作用域 globclock.settime(8,30,30); Clock myclock(globclock); // 声明具有块作用域的对象 myclock cout<<"second time output:"<<endl; myclock.showtime(); // 引用具有块作用域的对象 return 0; 24

25 程序的运行结果为 : First time output: 0:0:0 Second time output: 8:30:30 25

26 数据与函数数据与函数数据存储在局部对象中, 通过参数传递实现共享函数间的参数传递数据存储在全局对象中将数据和使用数据的函数封装在类中 26

27 据与函数使用全局对象 #include<iostream> using namespace std; int global; void f() { global=5; void g() { cout << global << endl; int main() { f(); g(); // 输出 5 return 0; 数27

28 数据与函数将函数与数据封装 #include<iostream> using namespace std; class Application { public: void f(); void g(); private: int global; ; void Application::f() { global = 5; void Application::g() { cout << global << endl; int main() { Application MyApp; MyApp.f(); MyApp.g(); return 0; 28

29 静态成员静态成员实例属性类属性 : 用 static 声明为静态成员实现同一个类的不同对象之间的数据和函数共享 29

30 静态成员静态成员静态数据成员该类的所有对象维护该成员的同一个拷贝必须在类内声明并在类外定义和初始化, 用 (::) 来指明所属的类具有静态生存期静态成员函数类外代码可以使用类名 ( 或对象名 ) 和作用域操作符来调用静态成员函数静态成员函数可以直接访问该类的静态数据和函数成员访问非静态成员, 必须通过对象名 30

31 态成员例 5-4 具有静态数据成员的 Point 类 #include <iostream> using namespace std; class Point { public: Point(int xx=0, int yy=0) : x(xx), y(yy) { count++; Point(Point &p); int getx() { return x; int gety() { return y; void showcount() { cout << " Object count= << count << endl; private: int x,y; static int count; ; 静31

32 Point::Point(Point &p) { x = p.x; x = p.y; count++; int Point::count=0; int main() { Point a(4,5); cout<<"point A:"<<a.getX()<<","<<a.getY(); a.showcount(); Point b(a); cout<<"point B:"<<b.getX()<<","<<b.getY(); b.showcount(); return 0; 32

33 态成员静态成员函数举例 #include <iostream> using namespace std; class Application { public: static void f(); static void g(); private: static int global; ; int Application::global=0; void Application::f() { global=5; void Application::g() { cout << global << endl; int main() { Application::f(); Application::g(); return 0; 静33

34 静态成员静态成员函数举例 class A { public: static void f(a a); private: int x; ; void A::f(A a) { cout << x; // 对 x 的引用是错误的 cout << a.x; // 正确 34

35 静态成员; C++ 语言程序设计具有静态数据函数成员的 Point 类 #include <iostream> using namespace std; class Point { //Point 类定义 public: // 外部接口 Point(int x = 0, int y = 0) : x(x), y(y) { count++; Point(Point &p); ~Point() { count--; int getx() { return x; int gety() { return y; static void showcount() { // 静态函数成员 cout << " Object count = " << count << endl; private: // 私有数据成员 int x, y; static int count; // 静态数据成员声明 35

36 Point::Point(Point &p) { x = p.x; y = p.y; count++; int Point::count=0; int main() { // 主函数实现 Point a(4,5); // 声明对象 A cout<<"point A,"<<a.getX()<<","<<a.getY(); Point::showCount(); // 输出对象个数 Point b(a); // 声明对象 B cout<<"point B,"<<b.GetX()<<","<<b.GetY(); Point:: showcount(); // 输出对象个数 return 0; 36

37 友元友元是 C++ 提供的一种破坏数据封装和数据隐藏的机制通过将一个模块声明为另一个模块的友元, 一个模块能够引用到另一个模块中本是被隐藏的信息可以使用友元函数和友元类为了确保数据的完整性, 及数据封装与隐藏的原则, 建议尽量不使用或少使用友元友元37

38 访问对象中的成员必须通过对象名友元友元函数友元函数是在类声明中由关键字 friend 修饰说明的非成员函数, 在它的函数体中能够通过对象名访问 private 和 protected 成员作用 : 增加灵活性, 使程序员可以在封装和快速性方面做合理选择 38

39 ; 友元例 5-6 使用友元函数计算两点距离 #include <iostream> #include <cmath> class Point { //Point 类声明 public: // 外部接口 Point(int x=0, int y=0) : x(x), y(y) { int getx() { return x; int gety() { return y; friend float dist(point &a, Point &b); private: // 私有数据成员 int x, y; 39

40 float dist( Point& a, Point& b) { double x = a.x - b.x; double y = a.y - b.y; return static_cast<float>(sqrt(x * x + y * y)); int main() { Point p1(1, 1), p2(4, 5); cout <<"The distance is: "; cout << dist(p1, p2) << endl; return 0; 40

41 友元类若一个类为另一个类的友元, 则此类的所有成员都能访问对方类的私有和保护成员声明语法 : 将友元类名在另一个类中使用 friend 修饰说明友元41

42 ; 友元友元类举例 class A { friend class B; public: void display() { cout << x << endl; private: int x; class B { public: void set(int i); void display(); private: A a; 42

43 void B::set(int i) { a.x=i; void B::display() { a.display(); 43

44 友元关系友元关系是不能传递的 B 类是 A 类的友元,C 类是 B 类友元, 如无声明,C 类和 A 类之间没有任何友元关系友元关系是单向的如果声明 B 类是 A 类的友元,B 类的成员函数就可以访问 A 类的私有和保护数据, 但 A 类的成员函数却不能访问 B 类的私有保护数据友元关系是不被继承的如果类 B 是类 A 的友元, 类 B 的派生类 BB 并不会自动成为类 A 的友元友元44

45 共享数据的保护常类型常类型的对象必须进行初始化, 而且不能被更新常对象 : 必须进行初始化, 不能被更新 const 类名对象名常引用 : 被引用的对象不能被更新 const 类型说明符 & 引用名常数组 : 数组元素不能被更新 ( 下一章介绍 ) 类型说明符 const 数组名 [ 大小 ]... 常指针 : 指向常量的指针 ( 下一章介绍 ) 45

46 共享数据的保护常对象举例 class A { public: A(int i,int j) {x=i; y=j;... private: int x,y; ; A const a(3,4); //a 是常对象, 不能被更新 46

47 共享数据的保护构造函数初始化时只能通过初始化列表用 const 修饰的对象成员常成员函数使用 const 关键字说明的函数常成员函数不更新对象的数据成员常成员函数说明格式 : 类型说明符函数名 ( 参数表 )const; 这里,const 是函数类型的一个组成部分, 因此在实现部分也要带 const 关键字 const 关键字可以被用于参与对重载函数的区分通过常对象只能调用它的常成员函数常数据成员使用 const 说明的数据成员 47

48 享数据的保护例 5-7 常成员函数举例 #include<iostream> using namespace std; class R { public: R(int r1, int r2) : r1(r1), r2(r2) { void print(); void print() const; private: int r1, r2; ; 共48

49 void R::print() { cout << r1 << ":" << r2 << endl; void R::print() const { cout << r1 << ";" << r2 << endl; int main() { R a(5,4); a.print(); // 调用 void print() const R b(20,52); b.print(); // 调用 void print() const return 0; 49

50 共享数据的保护; 例 5-8 常数据成员举例 #include <iostream> using namespace std; class A { public: A(int i); void print(); private: const int a; static const int b; // 静态常数据成员 50

51 const int A::b=10; A::A(int i) : a(i) { void A::print() { cout << a << ":" << b <<endl; int main() { /* 建立对象 a 和 b, 并以 100 和 0 作为初值, 分别调用构造函数, 通过构造函数的初始化列表给对象的常数据成员赋初值 */ A a1(100), a2(0); a1.print(); a2.print(); return 0; 51

52 共享数据的保护常引用常引用 : 被引用的对象不能被更新非 const 引用只能绑定到普通的对象, 不能绑定要常对象常引用可以绑定到普通对象和常对象在函数中无须改变值的参数, 不宜使用普通引用方式传递传值传递常引用 : 常用在大对象和复制构造函数 52

53 共享数据的保护; 例 5-9 常引用作形参 #include <iostream> #include <cmath> using namespace std; class Point { //Point 类定义 public: // 外部接口 Point(int x = 0, int y = 0) : x(x), y(y) { int getx() { return x; int gety() { return y; friend float dist(const Point &p1, const Point &p2); private: // 私有数据成员 int x, y; 53

54 享数据的保护例 5-9 常引用作形参共float dist(const Point &p1, const Point &p2) { double x = p1.x - p2.x; double y = p1.y - p2.y; return static_cast<float>(sqrt(x * x + y * y)); int main() { // 主函数 const Point myp1(1, 1), myp2(4, 5); cout << "The distance is: "; cout << dist(myp1, myp2) << endl; return 0; 54

55 多文件结构多文件结构 ( 例 5-10) 一个源程序可以划分为多个源文件 : 类声明文件 (.h 文件 ) 类实现文件 (.cpp 文件 ) 类的使用文件 (main() 所在的.cpp 文件 ) 利用工程来组合各个文件 55

56 多文件结构外部变量定义性声明命名空间作用域中, 不用 extern 关键字声明的变量用 extern 关键字声明的变量, 同时指定初值引用性声明命名空间作用域中, 用 extern 关键字声明的变量, 但未指定初值 56

57 多文件结构外部函数在所有类之外声明的函数, 都是具有命名空间作用域的在不同源文件中调用前, 要进行引用性声明 ( 即声明函数原型 ) 57

58 文件结构外部变量与外部函数 // 源文件 1 int i=3; void other() void next(); int main(){ i++; next(); return 0; void next(){ i++; other(); 多// 源文件 2 extern int i; void other(){ i++; 58

59 文件结构把变量和函数限制在编译单元内命名空间作用域中声明的变量和函数, 在默认情况下都可以被其他编译单元访问把函数和变量的定义限制在源文件内安全性多防止重名 59

60 多文件结构60 把变量和函数限制在编译单元内方法一 : 定义全局变量和函数时使用 static 关键字方法二 : 使用匿名的命名空间 namespace { int n; void f(){ n++; n = 4; f();

61 编译预处理命令 #include 包含指令将一个源文件嵌入到当前源文件中该点处 #include< 文件名 > 按标准方式搜索, 文件位于 C++ 系统目录的 include 子目录下 #include" 文件名 " 首先在当前目录中搜索, 若没有, 再按标准方式搜索 #define 宏定义指令定义符号常量, 很多情况下已被 const 定义语句取代定义带参数宏, 已被内联函数取代 #undef 删除由 #define 定义的宏, 使之不再起作用 61

62 编译预处理命令... 条件编译指令 #if 常量表达式 #if 和 #endif // 当常量表达式非零时编译 #endif 程序正文 62

63 编译预处理命令条件编译指令 #else #if 常量表达式 // 当常量表达式非零时编译程序正文 1 #else // 当常量表达式为零时编译程序正文 2 #endif 63

64 编译预处理命令条件编译指令 #if 常量表达式 1 #elif 程序正文 1 // 当常量表达式 1 非零时编译 #elif 常量表达式 2 #else #endif 程序正文 2 // 当常量表达式 2 非零时编译程序正文 3 // 其他情况下编译 64

65 编译预处理命令条件编译指令 #ifdef 标识符程序段 1 #else 程序段 2 #endif 如果标识符经 #defined 定义过, 且未经 undef 删除, 则编译程序段 1, 否则编译程序段 2 65

66 编译预处理命令条件编译指令 #ifndef 标识符 #else 程序段 1 程序段 2 #endif 如果标识符未被定义过, 则编译程序段 1, 否则编译程序段 2 66

67 多文件结构不使用条件编译的头文件 //main.cpp #include "file1.h" #include "file2.h" int main() { //file1.h #include "head.h" //file2.h #include "head.h" //head.h class Point { 67

68 多文件结构使用条件编译的头文件 //head.h #ifndef HEAD_H #define HEAD_H class Point { #endif 68

69 常成员函数的声明原则深适当地将成员函数声明为常成员函数, 能够提高代码质量度凡是不会改变对象状态的函数, 都应当声明为常成员函数探什么是改变对象状态? 索改变对象状态, 不简单地等同于改变成员数据的值只要一个成员函数执行与否, 不会影响以后接口函数的调用结果, 都可以认为它不会改变对象状态 69

70 常成员函数的声明原则 class Line { //Line 类的定义 public: // 外部接口 Line(const Point &p1, const Point &p2) : p1(p1), p2(p2), len(-1) { double getlen(); private: // 私有数据成员 Point p1, p2; //Point 类的对象 p1,p2 double len; 深度探索; double Line::getLen() { if (len < 0) { double x = p1.getx() - p2.getx(); double y = p1.gety() - p2.gety(); len = sqrt(x * x + y * y); return len; 70 改变数据成员, 但不改变对象状态

71 常成员函数的声明原则在原则上, 应当将 getlen 声明为常成员函数, 但由于修改了数据成员的值, 语言规则不允许怎么办? 使用 mutable 关键字深度探索 mutable 关键字使得被修饰的成员对象无视常对象的成员对象被视为常对象这一语言原则 71 mutable 须慎用

72 修改后的程序代码 class Line { //Line 类的定义 public: // 外部接口 Line(const Point &p1, const Point &p2) : p1(p1), p2(p2), len(-1) { double getlen() const; private: // 私有数据成员 Point p1, p2; //Point 类的对象 p1,p2 mutable double len; ; double Line::getLen() const { if (len < 0) { double x = p1.getx() - p2.getx(); double y = p1.gety() - p2.gety(); len = sqrt(x * x + y * y); return len; 72 深度探索

73 代码的编译编译 : 源文件目标文件源文件的函数代码目标文件的代码段源文件的静态对象目标文件的数据段分为初始化的数据段和未初始化的数据段深度探索符号表 : 将静态对象和函数的名字与地址关联重定位信息其它信息 73

74 示例代码 (1) a.cpp extern int y; int func(int v); int main() { int z = 1; y = func(z); 深度探索return 0; 代码段 (.text) (main 的代码 ) lea 0x4(%esp),%ecx and $0xfffffff0,%esp 符号表 main _Z4funci y a.o 未定义未定义 74

75 深度探索示例代码 (2) b.cpp int x = 3; int y; int func(int v) { return v + x; 代码段 (.text) (func 的代码 ) push %ebp mov %esp,%ebp 初始化的数据段 (.data) (x 的初值 ) 3 未初始化的数据段 (.bss) (y) 符号表 _Z4funci x y b.o 75

76 代码的连接与执行连接深将各段合并度将符号表综合根据重定位信息, 确定代码中用到的全局地探址索代码的执行操作系统首先将文件从磁盘读入, 初始化各段一些静态数据就在此时被初始化从引导代码开始执行, 引导代码启动 main, main 返回后, 引导代码通知操作系统程序结束 76

77 小结与复习建议主要内容作用域与可见性对象的生存期数据的共享与保护友元编译预处理命令多文件结构和工程达到的目标深入理解程序的结构模块间的关系数据共享 77

OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数

OOP with Java Yuanbin Wu cs@ecnu OOP with Java 通知 Project 4: 4 月 18 日晚 9 点关于抄袭没有分数复习类的复用组合 (composition): has-a 关系 class MyType { public int i; public double d; public char c; public void set(double