<4D F736F F F696E74202D20B5DA3032BDB25FC0E0BACDB6D4CFF3312E BBCE6C8DDC4A3CABD5D>

Size: px

Start display at page:

Download "<4D F736F F F696E74202D20B5DA3032BDB25FC0E0BACDB6D4CFF3312E BBCE6C8DDC4A3CABD5D>"

圣饮茅
6 years ago
Views:

1 程序设计实习 (I): C++ 程序设计第二讲类和对象 (1)

2 面向对象的程序设计面向对象的程序设计方法, 能够较好解决结构化程序设计中出现的问题面向对象的程序 = 类 + 类 + + 类设计程序的过程, 就是设计类的过程 2

3 面向对象的程序设计面向对象的程序设计方法 : 将某类客观事物共同特点 ( 属性 ) 归纳出来, 形成一个数据结构 ( 可以用多个变量描述事物的属性 ); 将这类事物所能进行的行为也归纳出来, 形成一个个函数, 这些函数可以用来操作数据结构这一步称为抽象通过某种语法形式, 将数据结构和操作该数据结构的构的函数打包在一起, 形成一个类使得数据结构和操作该数据结构的算法呈现出显而易见的紧密关系, 这就是封装 3

4 从客观事物抽象出类的例子写一个程序, 输入矩形的长和宽, 输出面积和周长比如对于矩形这种对象, 要用一个类来表示, 该如何做抽象呢? 矩形的属性就是长和宽因此需要两个变量, 分别代表长和宽可以对矩形进行哪些操作矩形可以有设置长和宽, 计算面积和计算周长这三种行为这三种行为, 可以各用一个函数来实现, 都需要用到长和宽这两个变量 4

5 从客观事物抽象出类的例子将长, 宽变量和设置长, 宽, 求面积, 以及求周长的三个函数封装在一起, 就能形成一个矩形类长宽变量成为该矩形类的成员变量三个函数成为该类的成员函数成员变量和成员函数统称为类的成员类带函数的结构 5

6 从客观事物抽象出类的例子 class CRectangle { public: int w, h; int Area() { return w * h; int Perimeter(){ return 2 * ( w + h ); void Init( int w_, int h_ ) { w = w_; h = h_; ; // 必须有分号 6

7 从客观事物抽象出类的例子 int main( ) { int w, h; CRectangle r; //r 是 CRectangle 类的一个对象 cin >> w >> h; r.init(w, h); cout << r.area() << endl << r. Perimeter(); return 0; 通过类, 可以定义变量类定义出来的变量, 也称为类的实例, 就是我们所说的对象 C++ 中, 类的名字就是用户自定义的类型的名字可以象使用的类型的名字基本类型那样来使用它 CRectangle 就是一种用户自定义的类型 7

8 对象的内存分配和结构体变量一样, 对象所占用的内存空间的大小, 等于所有成员变量的大小之和每个对象各有自己的存储空间一个对象的某个成员变量被改变了, 不会影响到另一个对象 8

9 如何使用类的成员变量和成员函数用法 1: 对象名. 成员名 CRectangle r1, r2; r1.w = 5; r2.init(5,4); Init 函数作用在 r2 上, 即 Init 函数执行期间访问的 w 和 h 是属于 r2 这个对象的, 执行 r2.init 不会影响到 r1 用法 2: 指针 -> 成员名 CRectangle r1, r2; CRectangle * p1 = & r1; CRectangle * p2 = & r2; p1->w = 5; p2->init(5,4); //Init 作用在 p2 指向的对象上 9

10 如何使用类的成员变量和成员函数用法 3: 引用名. 成员名 CRectangle r2; CRectangle & rr = r2; rr.w = 5; rr.init(5,4); //rr 的值变了,r2 的值也变 void PrintRectangle(CRectangle & r) { cout << r.area() << ","<< r.perimeter(); CRectangle r3; r3.init(5,4); PrintRectangle(r3); 10

11 引用的概念类型名 & 引用名 = 某变量名 ; 此种写法就定义了一个引用, 并将其初始化为引用某个变量某个变量的引用, 和这个变量是一回事, 相当于该变量的一个别名 int n = 4; int & r = n; r = 4; cout << r; // 输出 4 cout << n; // 输出 4 n = 5; cout << r; // 输出 5 定义引用时一定要将其初始化成引用某个变量, 不初始化编译不过引用只能引用变量, 不能引用常量和表达式 11

12 引用的作用 C 语言中, 要写交换两个整型变量值的函数, 只能通过指针 void swap( int * a, int * b) { int tmp; tmp=*a;*a=*b;*b=tmp; * a = * * b = tmp; int n1, n2; swap(& n1,& n2) ; // n1, n2 的值被交换 12

13 使用引用 : 引用的作用 void swap( int & a, int & b) { int tmp; tmp = a; a = b; b = tmp; int n1, n2; swap(n1, n2) ; // n1, n2 的值被交换 13

14 引用作为函数的返回值函数的返回值可以是引用, 如 : #include <iostream> using namespace std; int n = 4; int & SetValue() { return n; int main() { SetValue() = 40; cout << n; return 0; 程序输出结果是 40 14

15 类的成员函数的另一种写法成员函数体和类的定义分开写 class CRectangle { public: int w, h; int ta Area(); // 成员函数仅在此处声明 int Perimeter() ; void Init( int w_, int h_ ); ; 15

16 类的成员函数的另一种写法 int CRectangle::Area() { return w * h; int CRectangle::Perimeter() { return 2*( w + h); void CRectangle::Init( (int w_,int h_ ) { w = w_; h = h_; CRectangle:: 说明后面的函数是 CRectangle 类的成员函数, 而非普通函数一定要通过对象或对象的指针或对象的引用才能调用 16

17 对象成员的访问权限在类的定义中, 用下列权限关键字来说明对象成员的访问权限 : private: 私有成员, 只能在成员函数内访问 public : 公有成员, 可以在任何地方访问 protected: 保护成员 ( 以后再说 ) 以上三种关键字出现的次数和先后次序都没有限制 17

18 对象成员的访问权限定义一个类 class classname { ; private: 私有属性和函数 public: 公有属性和函数 protected: 保护属性和函数说明类成员的可见性 18

19 对象成员的访问权限如过某个成员前面没有上述关键字, 则缺省地被认为是私有成员 class Man { it int nage; // 私有成员 char szname[20]; // 私有成员 public: void SetName(char * szname){ strcpy( Man::szName, szname); ; 19

20 对象成员的访问权限在类的成员函数内部, 能够访问 : 当前对象的全部属性函数 ; 同类其它对象的全部属性函数在类的成员函数以外的地方, 只能够访问该类对象的公有成员 20

21 class CMan { private: char szname[30]; // 名字 public : float height, weight; // 保存一个人的身高和体重信息 void setname( char * name); void Func1( CMan man); ~CMan(); // 析构函数 ; void CMan :: setname( char * name) { CMan man; strcpy( man.szname, "Lily"); //ok, 此种访问方式可行 strcpy( szname, name); //ok void CMan::Func1(CMan man) { cout << man.szname; //ok CMan:: ~CMan() { 21

22 int main() { CMan man1, man2; strcpy(man1.szname, Tom ); // 错, 不能访 // 问私有成员 man1.setname( "Tom "); // ok man1.height 1h ht= 5; //ok return 0; 设置私有成员的目的是强制对成员变量的访问一定要通过成员函数进行以后成员变量的类型等属性修改后, 只需要更改成员函数即可否则, 所有直接访问成员变量的语句都需要修改设置私有成员的机制, 叫隐藏 22

23 如果将上面的程序内存空间紧张的手持设备上将 szname 改为 char szname[5], 若 szname 不是私有, 那么就要找出所有类似 strcpy(man1.szname, Tom ); 这样的语句进行修改, 以防止数组越界太麻烦! 如果将 szname 变为私有, 那么程序中就不会出现 ( 除非在类的内部 ) strcpy(man1.szname, Tom ); 所有对 szname 的访问都是通过成员函数来进行, 例如 : man1.setname( Tom ); 那么, 就算 szname 改短了, 上面的语句也不需要找出来修改, 只要改 setname 成员函数, 在里面确保不越界即可 23

24 函数重载一个或多个函数, 名字相同而参数个数或参数类型互不相同, 这叫做函数的重载例如 : int Max(double f1, double f2) { int Max(int n1, int n2) { int Max(int n1, int n2, int n3) { 函数重载使得函数命名变得简单 24

25 函数的缺省参数 C++ 中, 写函数的时候可以让参数有缺省值, 那么调用函数的时候, 若不写参数, 参数就是缺省值 void func( int x1 = 2, int x2 = 3) { func( ) ; // 等效于 func(2, 3) func(8) ; // 等效于 func(8, 3) func(, 8) ; // 不行函数参数可缺省的目的在于提高程序的可扩充性即如果某个写好的函数要添加新的参数, 而原先那些调用该函数的语句, 未必需要使用新增的参数, 那么为了避免对原先那些函数调用语句的修改, 就可以使用缺省参数 25

26 void func( int x1 = 2, int x2 = 3){ cout<<x1+x2<<endl; void testfunc(){ int a=1; int b=1; func(a, b); void func( int x1 = 2, int x2 = 3, int x3 = 3){ cout<<x1+x2<<endl; int k=x3; 26

27 成员函数的重载及参数缺省成员函数也可以重载 ( 普通函数也可以 ) 成员函数和构造函数可以带缺省参数 ( 普通函数也可以 ) 27 #include <iostream> using namespace std; class Location { private : int x, y; public: void init( int x=0, int y = 0 ); void valuex( int val ) { x = val ; int valuex() { return x; ; void Location::init( int X, int Y) { x = X; y = Y;

28 int main() { Location A, B; A.init(5); A.valueX(5); cout << A.valueX(); return 0; 28

29 使用缺省参数要注意避免有函数重载时的二义性 class Location { private : int x, y; public: void init( int x =0, int y = 0 ); void valuex( int val = 0 ) { x = val; int valuex() { return x; ; Location A; A.valueX(); // 错误, 编译器无法判断调用哪个 valuex 29

30 成员函数的一种构造函数 (Constructor) 名字与类名相同, 可以有参数, 不能有返回值 (void 也不行 ) 作用是对对象进行初始化, 如给成员变量赋初值如果定义类时没写构造函数, 则编译器生成一个缺省的无参数的构造函数缺省构造函数无参数, 不做任何操作 30

31 如果定义了构造函数, 则编译器不生成缺省的无参数的构造函数对象生成时构造函数自动被调用对象一旦生成, 就再也不能在其上执行构造函数为类编写构造函数是好的习惯, 能够保证对象生成的时候总是有合理的值一个类可以有多个构造函数 31

32 class Complex { private : double real, imag; public: void Set( double r, double i); ; // 缺省构造函数 Complex c1; // 构造函数被调用 Complex * pc = new Complex; // 构造函数被调用 32

33 class Complex { private : double real, imag; public: Complex( double r, double i = 0); ; Complex::Complex( double r, double i){ real = r; imag = i; Complex c1; // error, 没有参数 Complex * pc = new Complex; // error, 没有参数 Complex c1(2); // OK Complex c1(2,4), c2(3,5); Complex * pc = new Complex(3,4); 33

34 可以有多个构造函数, 参数个数或类型不同 class Complex { private : double real, imag; public: void Set( double r, double i ); Complex(double r, double i ); Complex (double r ); Complex (Complex c1, Complex c2); ; Complex::Complex(double r, double i) { real = r; imag = i; 34

35 Complex::Complex(double r) { real = r; imag = 0; Complex::Complex (Complex c1, Complex c2); { real = c1.real+c2.real; real; imag = c1.imag+c2.imag; Complex c1(3), c2 (1,0), c3(c1,c2); // c1 = {3, 0, c2 = {1, 0, c3 = {4, 0; 35

36 构造函数最好是 public 的,private 构造函数不能直接用来初始化对象 class CSample{ private: CSample() { ; main(){ CSample Obj; //err. 唯一构造函数是 private 36

37 构造函数在数组中的使用 class CSample { int x; public: CSample() (){ cout << "Constructor 1 Called" << endl; CSample(int n) { x = n; cout << "Constructor 2 Called" << endl; ; 37

38 void main(){ CSample array1[2]; cout << "step1"<<endl; CSample array2[2] = {4,5; cout << "step2"<<endl; CSample array3[2] = {3; cout << "step3"<<endl; CSample * array4 = new CSample[2]; // 没有 delete, 不好 38

39 构造函数在数组中的使用 class Test { public: Test( int n) { //(1) Test( int n, int m) { //(2) Test() { //(3) ; Test array1[3] = { 1, Test(1,2) ; // 三个元素分别用 (1),(2),(3) 初始化 Test array2[3] = { Test(2,3), Test(1,2), 1; // 三个元素分别用 (2),(2),(1) 初始化 Test * parray[3] = { new Test(4), new Test(1,2) ; // 两个元素分别用 (1),(2) 初始化 40

40 复制构造函数 ( 拷贝构造函数 ) 形如 X::X( X& ), 只有一个参数即对同类对象的引用如果没有定义构造函数, 那么编译器生成缺省复制构造函数缺省的复制构造函数完成复制功能 class Complex { private : double real, imag; ; Complex c1; // 调用缺省构造函数 Complex c2(c1); // 调用缺省的复制构造函数 // 将 c2 初始化成和 c1 一样 41

41 如果定义的自己的复制构造函数, 则缺省的复制构造函数不存在 class Complex { public : double real,imag; Complex(){ Complex( Complex & c ) { real = c.real; imag = c.imag; cout << Copy Constructor called ; ; Complex c1; Complex c2(c1); // 调用自己定义的复制构造函数, // 输出 Copy Constructor called 42

42 不允许有形如 X::X( X ) 的构造函数 class CSample { ; CSample( CSample c ) { // 错, 不允许这样的构造函数 43

43 即使缺省的不带参数的构造函数不存在, 缺省的复制构造函数仍然存在 class C1{ public: C1() { ; C1 c1, c2(c1); 44

44 复制构造函数在以下三种情况被调用 : a. 当用一个对象去初始化同类的另一个对象时 Complex c2(c1); Complex c2 = c1; b. 如果某函数有一个参数是类 A 的对象, 那么该函数被调用时, 类 A 的复制构造函数将被调用 void f( A a ) { a.x = 1; ; A aobj; f(aobj) ; // 导致 A 的复制构造函数被调用, 生成形 // 参传入函数 45

45 c. 如果函数的返回值是类 A 的对象时, 则函数返回时, A 的复制构造函数被调用 : A f( ) { A a; return a; // 此时 A 的复制构造函数被调用, // 即调用 A(a); intmain(){ A b; b = f(); return 0; 46

46 注意 : 对象间用等号赋值并不导致复制构造函数被调用 class CMyclass { public: int n; CMyclass() {; CMyclass( CMyclass & c) { n = 2 * c.n ; ; int main() { CMyclass c1,c2; c1.n = 5; c2 = c1; CMyclass c3(c1); cout <<"c2.n= n=" << c2.n << "";, cout <<"c3.n=" << c3.n << endl; return 0; 输出 : c2.n=5, c3.n=10 47

47 void fun(cmyclass obj_ ) { cout << "fun" << endl; 常量引用参数的使用这样的函数, 调用时生成形参会引发复制构造函数调用, 开销比较大所以可以考虑使用 CMyclass & 引用类型作为参数如果希望确保实参的值在函数中不应被改变, 那么可以加上 const 关键字 : void fun(const CMyclass & obj) { // 函数中任何试图改变 obj 值的语句都将是变成非法 48

48 作业实现一个学生信息处理程序输入数据为一行 : 姓名, 年龄, 学号 ( 整数 ), 第一学年平均成绩, 第二学年平均成绩, 第三学年平均成绩, 第四学年平均成绩输出 : 姓名, 年龄, 学号, 四年平均成绩例如 : 输入 : Tom Hanks, 18, 7817, 80, 80, 90,70 输出 : Tom Hanks, 18, 7817, 80 要求实现一个代表学生的类, 并且所有成员变量都应该是私有的 49

Microsoft PowerPoint - 3. 函数Functionl.ppt [兼容模式]

Microsoft PowerPoint - 3. 函数Functionl.ppt [兼容模式] 函数 Function 如何重用代码 How to reuse code 3 4 = 3*3*3*3 3 4,6 5 : 拷贝 - 粘帖代码 (Copy-paste code) 3 4,6 5,12 10 : 拷贝 - 粘帖代码 (Copy-paste code) Bad! 使用函数 (with a function) 使用函数 (with a function) 使用函数 (with a function)