02_类和对象

1 面向对象

1.1 为什么面向对象

  • 相比于分而治之的结构化程序设计，强调大处着眼的面向对象程序设计思想，更适合于开发大型软件
  • 得益于数据抽象、 代码复用等面向对象的固有特征，软件开发的效率获得极大地提升，成本却大幅降低
  • 面向对象技术在数据库、网络通信、图形界面等领域的广泛应用，已催生出各种设计模式和应用框架
  • 面向对象技术的表现如此出众，以至于那些原本并不直接支持面向对象特性的语言(例如C)，也在越来越多地通过各种方法模拟一些面向对象的软件结构

1.2 什么是面向对象

  • 万物皆对象，这是人类面对世界最朴素，最自然的感觉、想法和观点
  • 把大型软件看成是一个由对象组成的社会
  • 对象拥有足够的智能，能够理解来自其它对象的信息，并以适当的行为作出反应
  • 对象能够从高层对象继承属性和行为，并允许低层对象从自己继承属性和行为等
  • 编写程序的过程就是描述对象属性和行为的过程，凭借这种能力使问题域和解域获得最大程度的统一
  • 面向对象的三大要件：封装、 继承和多态

1.3 怎样面向对象？

– 至少掌握一种面向对象的程序设计语言，如C++
– 深入理解封装、继承和多态等面向对象的重要概念
– 精通一种元语言，如UML，在概念层次上描述设计
– 学习设计模式，源自多年成功经验的积累和总结

2 类和对象

  • 拥有相同属性和行为的对象被分成一组，即一个类
  • 类可用于表达那些不能直接与内置类型建立自然映射关系的逻辑抽象
  • 类是一种用户自定义的复合数据类型，即包括表达属性的成员变量，也包括表达行为的成员函数
  • 类是现实世界的抽象，对象是类在虚拟世界的实例

2.1 类的定义与实例化

2.1.1 类的一般形式

2.1.2 访问控制限定符

  • public
  • protected
  • private

访问控制限定符

  • 在C++中，类(class)和结构(struct)已没有本质性的差别，唯一的不同在于
    • 类的缺省访问控制属性为私有(private)
    • 结构的缺省访问控制属性为公有(public)
  • 访问控制限定符仅作用于类，而非作用于对象，因此同一个类的不同对象，可以互相访问非公有部分
  • 对不同成员的访问控制属性加以区分，体现了C++作为面向对象程序设计语言的封装特性
  1. #include <iostream>
  2. using namespace std;
  3. class Student
  4. {
  5.     int m_age;
  6.     string m_name;
  7.     int m_no;
  8. public:
  9.     Student(const string& name,int age,int no)
  10.     {
  11.         m_name = name;
  12.         m_age = age;
  13.         m_no = no;
  14.     }
  15.     void eat(const string& food)
  16.     {
  17.         cout << "eat " << food << endl;
  18.     }
  19.     void study(const string& course)
  20.     {
  21.         cout << "study " << course << endl;
  22.     }
  23.     void who(void)
  24.     {
  25.         cout << "name: " << m_name << endl;
  26.         cout << "age : " << m_age << endl;
  27.         cout << "school number: " << m_no << endl; 
  28.     }
  29.     void setAge(int age)
  30.     {
  31.         if(age<0)
  32.             cout << "age wrong" << endl;
  33.         else
  34.             m_age = age;
  35.     }
  36.     void setNo(int no)
  37.     {
  38.         if(no < 0)
  39.             cout << "no wrong" << endl;
  40.         else
  41.             m_no = no;
  42.     }
  43.     void setName(const string& name)
  44.     {
  45.         m_name = name;
  46.     }
  47.     void foo(const Student& s)
  48.     {
  49.         cout << s.m_name << endl;
  50.     }
  51. };
  53. class Teacher
  54. {
  55.     string m_name;
  56.     int m_age;
  57. public:
  58.     void who(void)
  59.     {
  60.         cout << m_name << "," << m_age << endl;
  61.     }
  62. };
  63. int main()
  64. {
  66.     /*
  67.     Student s;
  68.     s.setAge(25);
  69.     s.setName("zhang san");
  70.     s.setNo(1001);
  71.     s.who();
  72.     s.eat("noodle");
  73.     s.study("c++");
  74.     */
  75.     Student s("zhang san",24,1001);
  76.     s.eat("noodel");
  77.     s.study("study");
  78.     Student s2("wang wu",35,2003);
  79.     // s2.setName("wang wu");
  80.     s.foo(s2);
  81.     Student* ps = new Student("zhao si",34,5654);
  82.     ps->who();
  83.     ps->eat("ham");
  84.     ps->study("Unix");
  86.     // -----------------------------
  88.     Teacher t1;
  89.     t1.who();
  90.     return 0;
  91. }

2.1.3 构造函数

  • 函数名和类名相同，且没有返回类型
  • 在创建对象时自动被调用，且仅被调用一次
    • 对象定义语句
    • new操作符
  • 为成员变量赋初值，分配资源，设置对象的初始状态
  • 对象的创建过程
    • 为整个对象分配内存空间
    • 以构造实参调用构造函数
      • 构造基类部分
      • 构造成员变量
      • 执行构造代码

2.1.4 类的声明和实例化分开

将类的声明、实现与使用分别放在不同的文件里

2.1.5 对象的创建与销毁

  • 在栈中创建单个对象
    类名 对象; // 注意不要加空括号
    类名 对象 (实参表);

  • 在栈中创建对象数组
    类名 对象数组[元素个数];
    类名 对象数组[元素个数] = {类名 (实参表), …};
    类名 对象数组[] = {类名 (实参表), …};

  • 在堆中创建/销毁单个对象
    类名* 对象指针 = new 类名;
    类名* 对象指针 = new 类名 ();
    类名* 对象指针 = new 类名 (实参表);
    delete 对象指针;

  • 在堆中创建/销毁对象数组
    类名* 对象数组指针 = new 类名[元素个数];
    类名* 对象数组指针 = new 类名[元素个数] {类名 (实参表),…};
    // 上面的写法需要编译器支持C++11标准
    delete[] 对象数组指针;

实例：
student.h

  1. // 声明Student类
  2. #ifndef _STU_H
  3. #define _STU_H
  4. #include <string>
  5. using namespace std;
  6. class Student
  7. {
  8.     string m_name;
  9.     int m_age;
  10.     int m_no;
  11. public:
  12.     Student(const string& name,int age,int no);
  13.     Student();
  14.     void who();
  15.     void eat(const string& food);
  16.     void study(const string& course);
  17. };
  18. #endif // _STU_H

student.cpp

  1. // 实现Student类
  2. #include "02stu.h"
  3. #include <iostream>
  4. using namespace std;
  5. Student::Student(const string& name,int age,int no)
  6. {
  7.     m_name = name;
  8.     m_age = age;
  9.     m_no = no;
  10. }
  11. Student::Student()
  12. {
  13.     m_name = "no name";
  14.     m_age = 34;
  15.     m_no = 234;
  16. }
  17. void Student::who()
  18. {
  19.     cout << "name: " << m_name << endl;
  20.     cout << "age: " << m_age << endl;
  21.     cout << "no : " << m_no << endl;
  22. }
  24. void Student::eat(const string& food)
  25. {
  26.     cout << "eat " << food << endl;
  27. }
  29. void Student::study(const string& course)
  30. {
  31.     cout << "study " << course << endl;
  32. }

main.cpp

  1. #include "02stu.h"
  2. #include <iostream>
  3. using namespace std;
  4. int main()
  5. {
  6.     Student s("zhang san",24,2002);
  7.     Student s2;
  8.     s.who();
  9.     s.study("c++");
  10.     s.eat("noodle");
  11.     s2.who();
  13.     Student sa[5];
  14.     sa[0].who();
  15.     sa[4].who();
  16.     Student sa2[3] = {
  17.         Student("zhao si",34,33),
  18.         Student("li si",54,24)
  19.         };
  20.     sa2[0].who();    
  21.     sa2[1].who();
  22.     sa2[2].who();
  23.     cout << sizeof(s) << endl;
  24.     Student *ps1 = new Student("wang wu",34,3566);
  25.     ps1->who();
  26.     delete ps1;
  27.     ps1 = new Student[5];
  28.     ps1[0].who();
  29.     ps1[4].who();
  30.     delete[] ps1;
  31.     ps1 = new Student[3] {
  32.         Student("wang yi",34,234),
  33.         Student("wang er",35,355),
  34.         Student("wang san",36,356)
  35.     };
  36.     ps1[0].who();
  37.     ps1[2].who();
  38.     delete[] ps1;
  39.     return 0;
  40. }

练习：
实现一个电子时钟类，其构造函数接受当前系统时间，以秒为单位持续运行

  1. #include <iostream>
  2. #include <cstdio>
  3. using namespace std;
  4. class Clock {
  5. public:
  6.     Clock (time_t t) {
  7.         tm* local = localtime (&t);
  8.         m_hour = local->tm_hour;
  9.         m_min  = local->tm_min;
  10.         m_sec  = local->tm_sec;
  11.         setbuf (stdout, NULL);
  12.     }
  13.     void run (void) {
  14.         for (;;) {
  15.             show ();
  16.             tick ();
  17.         }
  18.     }
  19. private:
  20.     void show (void) {
  21.         printf ("\r%02d:%02d:%02d",
  22.             m_hour, m_min, m_sec);
  23. //        fflush (stdout);
  24.     }
  25.     void tick (void) {
  26.         sleep (1);
  27.         if (++m_sec == 60) {
  28.             m_sec = 0;
  29.             if (++m_min == 60) {
  30.                 m_min = 0;
  31.                 if (++m_hour == 24)
  32.                     m_hour = 0;
  33.             }
  34.         }
  35.     }
  36.     int m_hour, m_min, m_sec;
  37. };
  38. int main (void) {
  39.     Clock clock (time (NULL));
  40.     clock.run ();
  41.     return 0;
  42. }

2.2 构造函数和初始化表

2.2.1 构造函数的重载

  • 构造函数也可以通过参数表的差别化形成重载
  • 重载的构造函数通过构造实参的类型选择匹配
  • 不同的构造函数版本表示不同的对象创建方式
  • 使用缺省参数可以减少构造函数重载版本数量
  • 某些构造函数具体特殊的意义
    • 缺省构造函数：按缺省方式构造
    • 类型转换构造函数：从不同类型的对象构造
    • 拷贝构造函数：从相同类型的对象构造

2.2.2 缺省构造函数

  • 缺省构造函数亦称无参构造函数，但其未必真的没有任何参数，为一个有参构造函数的每个参数都提供一个缺省值，同样可以达到无参构造函数的效果
  • 如果一个类没有定义任何构造函数，那么编译器会为其提供一个缺省构造函数
    • 对基本类型的成员变量，不做初始化
    • 对类类型的成员变量和基类子对象，调用相应类型的缺省构造函数初始化
  • 对于已经定义至少一个构造函数的类，无论其构造函数是否带有参数，编译器都不会为其提供缺省构造函数




posted @ 2017-03-02 23:12  烟云123  阅读(494)  评论(0)    收藏  举报