第五章数据的共享与保护.ppt

《第五章数据的共享与保护.ppt》由会员分享，可在线阅读，更多相关《第五章数据的共享与保护.ppt（82页珍藏版）》请在三一文库上搜索。

1、第五章 数据的共享与保护,清华大学,目录,5.1 标识符的作用域与可见性 5.2 对象的生存期 5.3 类的静态成员 5.4 类的友元 5.5 共享数据的保护 5.6 多文件结构和编译预处理命令 5.7 综合实例个人银行账户管理程序 5.8 深度探索 5.9 小结,2,5.1.1 作用域函数原形的作用域,作用域是一个标识符在程序正文中有效的区域。 函数原型中的参数，其作用域始于“(“，结束于“)“。 例如，设有下列原型声明： double area(double radius);,3,5.1 标识符的作用域与可见性,radius 的作用域仅在于此，不能用于程序正文其他地方，因而可有可无。,局部

2、作用域,函数的形参，在块中声明的标识符，其作用域自声明处起，限于块中，例如： void fun(int a) int b = a; cin b; if (b 0) int c; ,4,5.1 标识符的作用域与可见性 5.1.1 作用域,a的作用域,类作用域,类作用域作用于特定的成员名。 类X的成员m具有类作用域，对m的访问方式如下： 如果在X的成员函数中没有声明同名的局部作用域标识符，那么在该函数内可以访问成员m。 通过表达式x.m或者X:m访问。 通过表达式ptr-M,5,5.1 标识符的作用域与可见性 5.1.1 作用域,文件作用域,不在前述各个作用域中出现的声明，就具有文件作用域，这样声

3、明的标识符其作用域开始于声明点，结束于文件尾。,6,5.1 标识符的作用域与可见性 5.1.1 作用域,/5_1.cpp #include using namespace std; int i; /全局变量，文件作用域 int main() i = 5; /为全局变量i赋值 /子块1 int i; /局部变量，局部作用域 i = 7; cout “i = “ i endl;/输出7 cout “i = ” i endl;/输出5 return 0; ,运行结果： i = 7 i = 5,5.1.2 可见性,可见性是从对标识符的引用的角度来谈的概念 可见性表示从内层作用域向外层作用域“看”时能看

4、见什么。 如果标识在某处可见，则就可以在该处引用此标识符。,7,5.1 标识符的作用域与可见性,5.1.2 可见性（续）,标识符应声明在先，引用在后。 如果某个标识符在外层中声明，且在内层中没有同一标识符的声明，则该标识符在内层可见。 对于两个嵌套的作用域，如果在内层作用域内声明了与外层作用域中同名的标识符，则外层作用域的标识符在内层不可见。,8,5.1 标识符的作用域与可见性,同一作用域中的同名标识符,在同一作用域内的对象名、函数名、枚举常量名会隐藏同名的类名或枚举类型名。 重载的函数可以有相同的函数名。,9,5.1 标识符的作用域与可见性 5.1.2 可见性,5.2 对象的生存期,对象从产

5、生到结束的这段时间就是它的生存期。在对象生存期内，对象将保持它的值，直到被更新为止。,10,5.2.1 静态生存期,这种生存期与程序的运行期相同。 在文件作用域中声明的对象具有这种生存期。 在函数内部声明静态生存期对象，要冠以关键字static 。,11,5.2 对象的生存期,5.2.2 动态生存期,块作用域中声明的，没有用static修是的对象是动态生存期的对象（习惯称局部生存期对象）。 开始于程序执行到声明点时，结束于命名该标识符的作用域结束处。,12,5.2 对象的生存期,例5-2 变量的生存期与可见性,#include using namespace std; int i = 1; /

6、 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: “cendl; b = a; ,13,5.2 对象的生存期 5.2.2 动态生存期,int main() static int a;/ 静态局部变量，有全局寿命

7、，局部可见。 int b = -10; / b, c为局部变量，具有动态生存期。 int c = 0; cout “-MAIN-n“; cout“ i: “i“ a: “a“ b: “b“ c: “cendl; c += 8; other(); cout“-MAIN-n“; cout“ i: “i“ a: “a“ b: “b“ c: “cendl; i += 10; other(); return 0; ,14,5.2 对象的生存期 5.2.2 动态生存期,例5-2 续,运行结果： -MAIN- i: 1 a: 0 b: -10 c: 0 -OTHER- i: 33 a: 4 b: 0 c:

8、15 -MAIN- i: 33 a: 0 b: -10 c: 8 -OTHER- i: 75 a: 6 b: 4 c: 15,例5-2（续）,5.2 对象的生存期 5.2.2 动态生存期,例 5-3 具有静态、动态生存期对象的时钟程序,#include using namespace std; class Clock /时钟类定义 public: /外部接口 Clock(); /三个形参均具有函数原型作用域 void setTime(int newH, int newM, int newS); void showTime(); private: /私有数据成员 int hour, minute

9、, second; ;,16,5.2 对象的生存期 5.2.2 动态生存期,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; ,17,5.2 对象的生存期 5.2.2 动态生存期,例5-3 续,Clock glob

10、Clock;/声明对象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; ,18,5.2 对象的生存期 5

11、.2.2 动态生存期,例5-3 续,程序的运行结果为： First time output: 0:0:0 Second time output: 8:30:30,例5-3（续）,5.2 对象的生存期 5.2.2 动态生存期,数据与函数,数据存储在局部对象中，通过参数传递实现共享函数间的参数传递。 数据存储在全局对象中。 将数据和使用数据的函数封装在类中。,使用全局对象,#include int global; void f() global=5; void g() coutglobalendl; int main() f(); g(); /输出“5” return 0; ,数据与函数,将函数与

12、数据封装,#include class Application public: void f();void g(); private: int global; ; void Application:f() global=5; void Application:g() coutglobalendl;,int main() Application MyApp; MyApp.f(); MyApp.g(); return 0; ,数据与函数,5.3.1 静态数据成员,静态数据成员 用关键字static声明 该类的所有对象维护该成员的同一个拷贝，静态数据成员具有静态生存期。 必须在类外定义和初始化，用(

13、:)来指明所属的类。,23,5.3 类的静态成员,例5-4 具有静态数据成员的Point类,24,5.3 类的静态成员 5.3.1 静态数据成员,/5_4.cpp #include using namespace std; class Point /Point类定义 public: /外部接口 Point(int x = 0, int y = 0) : x(x), y(y) /构造函数 /在构造函数中对count累加，所有对象共同维护同一个count count+; Point(Point ,25,例5-4 静态成员举例,5.3 类的静态成员 5.3.1 静态数据成员,void showCou

14、nt() /输出静态数据成员 cout “ Object count = “ count endl; private: /私有数据成员 int x, y; static int count; /静态数据成员声明，用于记录点的个数 ; int Point:count = 0;/静态数据成员定义和初始化，使用类名限定 int main() /主函数 Point a(4, 5); /定义对象a，其构造函数回使count增1 cout “Point A: “ a.getX() “, “ a.getY(); a.showCount(); /输出对象个数 Point b(a); /定义对象b，其构造函数回

15、使count增1 cout “Point B: “ b.getX() “, “ b.getY(); b.showCount(); /输出对象个数 return 0; ,26,例5-4 续,5.3 类的静态成员 5.3.1 静态数据成员,例5-4 （续）,运行结果： Point A: 4, 5 Object count=1 Point B: 4, 5 Object count=2,27,5.3 类的静态成员 5.3.1 静态数据成员,5.3.2 静态函数成员,静态函数成员 类外代码可以使用类名和作用域操作符来调用静态成员函数。 静态成员函数只能引用属于该类的静态数据成员或静态成员函数。,28,5

16、.3 类的静态成员,例5-5具有静态数据、函数成员的 Point类,29,5.3 类的静态成员 5.3.2 静态函数成员,静态成员函数举例,#include 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() coutglobalendl; int main() Application:f(); Applicati

17、on:g(); return 0; ,静态成员,静态成员函数举例,class A public: static void f(A a); private: int x; ; void A:f(A a) coutx; /对x的引用是错误的 couta.x; /正确 ,静态成员,/5_5.cpp #include using namespace std; class Point /Point类定义 public: /外部接口 Point(int x = 0, int y = 0) : x(x), y(y) /构造函数 /在构造函数中对count累加，所有对象共同维护同一个count count+;

18、 Point(Point ,32,5.3 类的静态成员 5.3.2 静态函数成员,例5-5 静态成员举例,private: /私有数据成员 int x, y; static int count; /静态数据成员声明，用于记录点的个数 ; int Point:count = 0; /静态数据成员定义和初始化，使用类名限定 int main() /主函数 Point a(4, 5); /定义对象a，其构造函数回使count增1 cout “Point A: “ a.getX() “, “ a.getY(); a.showCount(); /输出对象个数 Point b(a); /定义对象b，其构造

19、函数回使count增1 cout “Point B: “ b.getX() “, “ b.getY(); Point:showCount(); /输出对象个数 return 0; ,33,5.3 类的静态成员 5.3.2 静态函数成员,例5-5 （续）,5.4 类的友元,友元是C+提供的一种破坏数据封装和数据隐藏的机制。 通过将一个模块声明为另一个模块的友元，一个模块能够引用到另一个模块中本是被隐藏的信息。 可以使用友元函数和友元类。 为了确保数据的完整性，及数据封装与隐藏的原则，建议尽量不使用或少使用友元。,34,5.4.1 友元函数,友元函数是在类声明中由关键字friend修饰说明的非成员

20、函数，在它的函数体中能够通过对象名访问 private 和 protected成员 作用：增加灵活性，使程序员可以在封装和快速性方面做合理选择。 访问对象中的成员必须通过对象名。,35,5.4 类的友元,例5-6 使用友元函数计算两点间的距离,#include #include 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 ,36,5.4 类的友元 5.4.1 友元

21、函数,例5-6 （续）,float dist( Point ,37,5.4 类的友元 5.4.1 友元函数,运行结果： The distance is: 5,5.4.2 友元类,若一个类为另一个类的友元，则此类的所有成员都能访问对方类的私有成员。 声明语法：将友元类名在另一个类中使用friend修饰说明。,38,5.4 类的友元,友元类举例,class A friend class B; public: void display() cout x endl; private: int x; class B public: void set(int i); void display(); pri

22、vate: A a; ;,39,5.4 类的友元 5.4.2 友元类,void B:set(int i) a.x=i; void B:display() a.display(); ,友元关系是单向的,如果声明B类是A类的友元，B类的成员函数就可以访问A类的私有和保护数据，但A类的成员函数却不能访问B类的私有、保护数据。,40,5.4 类的友元 5.4.2 友元类,5.5.1 常对象,常类型的对象必须进行初始化，而且不能被更新。 常对象：必须进行初始化,不能被更新。 const 类名 对象名 常引用：被引用的对象不能被更新。 const 类型说明符 &引用名 常数组：数组元素不能被更新(下一章介

23、绍)。 类型说明符 const 数组名大小. 常指针：指向常量的指针(下一章介绍)。,41,5.5 共享数据的保护,常对象举例,class A public: A(int i,int j) x=i; y=j; . private: int x,y; ; A const a(3,4); /a是常对象，不能被更新,42,5.5 共享数据的保护 5.5.1 常对象,5.5.2用const修饰的对象成员,常成员函数 使用const关键字说明的函数。 常成员函数不更新对象的数据成员。 常成员函数说明格式： 类型说明符 函数名（参数表）const; 这里，const是函数类型的一个组成部分，因此在实现部分

24、也要带const关键字。 const关键字可以被用于参与对重载函数的区分 通过常对象只能调用它的常成员函数。 常数据成员 使用const说明的数据成员。,43,5.5 共享数据的保护,例5-7 常成员函数举例,#include using namespace std; class R public: R(int r1, int r2) : r1(r1), r2(r2) void print(); void print() const; private: int r1, r2; ;,44,5.5 共享数据的保护 5.5.2 用const修饰的对象成员,例5-7（续）,void R:print()

25、 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; ,45,5.5 共享数据的保护 5.5.2 用const修饰的对象成员,运行结果： 5:4 20;52,例5-8 常数据成员举例,#include using namespace std; class A public: A(int i); void p

26、rint(); private: const int a; static const int b; /静态常数据成员 ;,46,5.5 共享数据的保护 5.5.2 用const修饰的对象成员,例5-8（续）,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; ,47,5

27、.5 共享数据的保护 5.5.2 用const修饰的对象成员,运行结果： 100:10 0:10,5.5.3 常引用,如果在声明引用时用const修饰，被声明的引用就是常引用。 常引用所引用的对象不能被更新。 如果用常引用做形参，便不会意外地发生对实参的更改。常引用的声明形式如下： const 类型说明符 ,48,5.5 共享数据的保护,例5-9 常引用作形参,#include #include using namespace std; class Point /Point类定义 public: /外部接口 Point(int x = 0, int y = 0) : x(x), y(y) in

28、t getX() return x; int getY() return y; friend float dist(const Point ,49,5.5 共享数据的保护 5.5.3 常引用,例5-9 （续）,float dist(const Point ,50,5.5 共享数据的保护 5.5.3 常引用,5.6.4 编译预处理,#include 包含指令 将一个源文件嵌入到当前源文件中该点处。 #include 按标准方式搜索，文件位于C+系统目录的include子目录下 #include“文件名“ 首先在当前目录中搜索，若没有，再按标准方式搜索。 #define 宏定义指令 定义符号常量，

29、很多情况下已被const定义语句取代。 定义带参数宏，已被内联函数取代。 #undef 删除由#define定义的宏，使之不再起作用。,51,5.6多文件结构和编译预处理命令,条件编译指令#if 和 #endif,#if 常量表达式 /当“ 常量表达式”非零时编译 程序正文 #endif ,52,5.6多文件结构和编译预处理命令 5.6.4 编译预处理,条件编译指令#else,#if 常量表达式 /当“ 常量表达式”非零时编译 程序正文1 #else /当“ 常量表达式”为零时编译 程序正文2 #endif,53,5.6多文件结构和编译预处理命令 5.6.4 编译预处理,条件编译指令#elif

30、,#if 常量表达式1 程序正文1 /当“ 常量表达式1”非零时编译 #elif 常量表达式2 程序正文2 /当“ 常量表达式2”非零时编译 #else 程序正文3 /其他情况下编译 #endif,54,5.6多文件结构和编译预处理命令 5.6.4 编译预处理,条件编译指令（续）,#ifdef 标识符 程序段1 #else 程序段2 #endif 如果“标识符”经#defined定义过，且未经undef删除，则编译程序段1，否则编译程序段2。,55,5.6多文件结构和编译预处理命令 5.6.4 编译预处理,条件编译指令（续）,#ifndef 标识符 程序段1 #else 程序段2 #endif

31、 如果“标识符”未被定义过，则编译程序段1，否则编译程序段2。,56,5.6多文件结构和编译预处理命令 5.6.4 编译预处理,5.6.1 C+程序的一般组织结构,一个源程序可以划分为多个源文件： 类声明文件（.h文件） 类实现文件（.cpp文件） 类的使用文件（main()所在的.cpp文件） 利用工程来组合各个文件。,57,5.6多文件结构和编译预处理命令,例 5-10具有静态数据、函数成员的 Point类，多文件组织,/文件1，类的定义，Point.h class Point /类的定义 public: /外部接口 Point(int x = 0, int y = 0) : x(x),

32、y(y) Point(const Point ,58,5.6多文件结构和编译预处理命令 5.6.1 C+的一般组织结构,例 5-10（续）,/文件2，类的实现，Point.cpp #include “Point.h“ #include using namespace std; int Point:count = 0; /使用类名初始化静态数据成员 Point:Point(const Point ,59,5.6多文件结构和编译预处理命令 5.6.1 C+的一般组织结构,例 5-10（续）,/文件3，主函数，5_10.cpp #include “Point.h“ #include using na

33、mespace std; int main() Point a(4, 5); /定义对象a，其构造函数回使count增1 cout “Point A: “ a.getX() “, “ a.getY(); Point:showCount(); /输出对象个数 Point b(a); /定义对象b，其构造函数回使count增1 cout “Point B: “ b.getX() “, “ b.getY(); Point:showCount(); /输出对象个数 return 0; ,60,5.6多文件结构和编译预处理命令 5.6.1 C+的一般组织结构,例5-10（续）,61,5.6多文件结构和编

34、译预处理命令 5.6.1 C+的一般组织结构,不使用条件编译的头文件,/main.cpp #include “file1.h“ #include “file2.h“ int main() /file1.h #include “head.h“ ,/file2.h #include “head.h“ /head.h class Point ,多文件结构,使用条件编译的头文件,/head.h #ifndef HEAD_H #define HEAD_H class Point #endif,多文件结构,外部变量,如果一个变量除了在定义它的源文件中可以使用外，还能被其它文件使用，那么就称这个变量是外部变

35、量。 文件作用域中定义的变量，缺省情况下都是外部变量，但在其它文件中如果需要使用这一变量，需要用extern关键字加以声明。,64,5.6多文件结构和编译预处理命令 5.6.2 外部变量与外部函数,外部函数,在所有类之外声明的函数（也就是非成员函数），都是具有文件作用域的。 这样的函数都可以在不同的编译单元中被调用，只要在调用之前进行引用性声明（即声明函数原型）即可。也可以在声明函数原型或定义函数时用extern修饰，其效果与不加修饰的缺省状态是一样的。,65,5.6多文件结构和编译预处理命令 5.6.1 C+的一般组织结构,将变量和函数限制在编译单元内,使用匿名的命名空间：在匿名命名空间中定

36、义的变量和函数，都不会暴露给其它的编译单元。 namespace /匿名的命名空间 int n; void f() n+; 这里被“namespace ”括起的区域都属于匿名的命名空间。,66,5.6多文件结构和编译预处理命令 5.6.1 C+的一般组织结构,5.6.3 标准C+库,标准C+类库是一个极为灵活并可扩展的可重用软件模块的集合。标准C+类与组件在逻辑上分为6种类型： 输入/输出类 容器类与ADT（抽象数据类型） 存储管理类 算法 错误处理 运行环境支持,67,5.6多文件结构和编译预处理命令,5.7综合实例个人银行账户管理程序,/account.h #ifndef _ACCOUNT

37、_H_ #define _ACCOUNT_H_ class SavingsAccount /储蓄账户类 private: int id; /账号 double balance; /余额 double rate; /存款的年利率 int lastDate; /上次变更余额的时期 double accumulation; /余额按日累加之和 static double total; /所有账户的总金额 /记录一笔帐，date为日期，amount为金额，desc为说明 void record(int date, double amount); /获得到指定日期为止的存款金额按日累积值 double

38、accumulate(int date) const return accumulation + balance * (date - lastDate); ,68,public: /构造函数 SavingsAccount(int date, int id, double rate); int getId() const return id; double getBalance() const return balance; double getRate() const return rate; static double getTotal() return total; /存入现金 void

39、deposit(int date, double amount); /取出现金 void withdraw(int date, double amount); /结算利息，每年1月1日调用一次该函数 void settle(int date); /显示账户信息 void show() const; ; #endif /_ACCOUNT_H_,69,例5-11（续）,5.7综合实例个人银行账户管理程序,/account.cpp #include “account.h“ #include #include using namespace std; double SavingsAccount:tot

40、al = 0; /SavingsAccount类相关成员函数的实现 SavingsAccount:SavingsAccount(int date, int id, double rate) : id(id), balance(0), rate(rate), lastDate(date), accumulation(0) cout date “t#“ id “ is created“ endl; void SavingsAccount:record(int date, double amount) accumulation = accumulate(date); lastDate = date;

41、 amount = floor(amount * 100 + 0.5) / 100;/保留小数点后两位 balance += amount; total += amount; cout date “t#“ id “t“ amount “t“ balance endl; ,70,例5-11（续）,5.7综合实例个人银行账户管理程序,void SavingsAccount:deposit(int date, double amount) record(date, amount); void SavingsAccount:withdraw(int date, double amount) if (a

42、mount getBalance() cout “Error: not enough money“ endl; else record(date, -amount); void SavingsAccount:settle(int date) /计算年息 double interest = accumulate(date) * rate / 365; if (interest != 0) record(date, interest); accumulation = 0; void SavingsAccount:show() const cout “#“ id “tBalance: “ balan

43、ce; ,71,例5-11（续）,5.7综合实例个人银行账户管理程序,/5_11.cpp #include “account.h“ #include using namespace std; int main() /建立几个账户 SavingsAccount sa0(1, 21325302, 0.015); SavingsAccount sa1(1, 58320212, 0.015); /几笔账目 sa0.deposit(5, 5000); sa1.deposit(25, 10000); sa0.deposit(45, 5500); sa1.withdraw(60, 4000); /开户后第9

44、0天到了银行的计息日，结算所有账户的年息 sa0.settle(90); sa1.settle(90); /输出各个账户信息 sa0.show(); cout endl; sa1.show(); cout endl; cout “Total: “ SavingsAccount:getTotal() endl; return 0; ,72,例5-11（续）,5.7综合实例个人银行账户管理程序,例5-11（续）,运行结果： 1 #21325302 is created 1 #58320212 is created 5 #21325302 5000 5000 25 #58320212 10000 1

45、0000 45 #21325302 5500 10500 60 #58320212 -4000 6000 90 #21325302 27.64 10527.6 90 #58320212 21.78 6021.78 #21325302 Balance: 10527.6 #58320212 Balance: 6021.78 Total: 16549.4,73,5.7综合实例个人银行账户管理程序,5.8.1 常成员函数的声明原则,适当地将成员函数声明为常成员函数，能够提高代码质量。 凡是不会改变对象状态的函数，都应当声明为常成员函数。 什么是改变对象状态？ 改变对象状态，不简单地等同于改变成员数据的

46、值。 只要一个成员函数执行与否，不会影响以后接口函数的调用结果，都可以认为它不会改变对象状态。,74,5.8 深度探索,5.8.1 常成员函数的声明原则（续）,class Line /Line类的定义 public: /外部接口 Line(const Point ,75,5.8 深度探索,改变数据成员，但不改变对象状态,5.8.1 常成员函数的声明原则（续）,在原则上，应当将getLen声明为常成员函数，但由于修改了数据成员的值，语言规则不允许 怎么办？使用mutable关键字 mutable关键字使得被修饰的成员对象无视“常对象的成员对象被视为常对象”这一语言原则 Mutable须慎用,76

47、,5.8 深度探索,修改后的代码,class Line /Line类的定义 public: /外部接口 Line(const Point ,77,5.8 深度探索 5.8.1 常成员函数的声明原则,代码的编译,编译：源文件目标文件 源文件的函数代码目标文件的代码段 源文件的静态对象目标文件的数据段 分为初始化的数据段和未初始化的数据段 符号表：将静态对象与函数的名字与地址关联 重定位信息、其它信息,78,5.8 深度探索 5.8.2 代码的编译连接与执行过程,代码的编译（续）,a.cpp extern int y; int func(int v); int main() int z = 1; y = func(z); return 0; ,79,5.8 深度探索 5.8.1 代码的编译连接与执行过程,代码的编译（续）,b.cpp int x = 3; int y; int func(int v) return v + x; ,80,5.8 深度探索 5.8.2 代码的编译连接与执行过程,代码的连接与执行,连接 将各段