智锐科创基础班总教学纲要.md · SunnyHaze/Cov_basic_teaching

# 智锐科创计算机协会基础班第二学期教学纲要
[toc]
## 第一课 面向对象程序设计方法概述
### 1. 对象
* 对象的定义
  * 对象是人们进行研究的任何事物，是构成系统的基本单位。
  * 可以是具体的事物，也可以是抽象的规则
  * 例：商品销售系统中：**商品**和**顾客**，抽象的数据结构中：**堆栈**和**链表**，它们都是对象。
    * ***教师tips：*** 此处一定要多举例子，生动形象。
  * 对于任何的客体，都具有两个重要的要素：**属性**和**行为**
    * 举例：
### 2.基本原理
1. 抽象
2. 封装
3. 继承
4. 多态性
### 3.概念
1. 类
   
    >一定注意强调，类本身并不是一个对象，是对于对象的一种抽象形式，**对象是类的实例化**，只有定义一个类以后，才能通过这个类去创建具体的对象。
   1. 类的定义方法，实例化方法，使用方法
   2. 举例：
      1. 日期类
           ```cpp
           class Date{
           private:
               int year;
               int month;
               int day;
           public:
               void setDate(int y,int m,ind);
               void print();
           };//注意这个分号
           Date mydate; //实例化
           mydate.setDate(2000,11,22); //使用方法
           ```
            1. 此处引出关于类的访问权限的问题
                |关键字|名称|类本身访问|派生类访问|类外访问|
                |---|---|:---:|:---:|:---:|
                |private|私有访问权限|√|X|X|
                |protected|保护访问权限|√|√|X|
                |public|公有访问权限|√|√|√|
                * 访问不合法的方法或者成员，**无法通过编译**！
                * 私有成员在类的最前面声明，可以省略private（不建议）
                >以**数据**为重心的创建者喜欢将private，即私有数据们放在前面

>以**行为**为重心的创建者喜欢将成员函数，即成员函数写在前面

以上两种方式都可以参考，但对于同一作者要养成良好的代码风格“一贯性”
      2. 学生类
            ```cpp
            class student{
            public:
                int age;
                std::string ID;
                std::string name;
                bool male;
               //.........
           }; //注意分号
           student stu1; //创建student对象，命名为stu1
           int myage = stu1.age; //访问stu1的成员并得到其值
           std::cout << myage << std::endl; //输出    
           ```
   3. 类的成员函数的类内/类外实现方法
   ```cpp

```
   4. 构造函数和析构函数
      1. 构造函数
         1. 特点：**函数名与类名相同**，可以有任意类型的参数，可以重载，也可以带有预置的参数进行重载，**但不具有返回类型**。<br>***生成新对象的时候，系统会自动调用构造函数！！！***
         2. 作用：在对象被创建是为其分配内存空间，利用给定的数值去初始化对象的数据成员，即便没有定义，也会自动生成一个构造函数。
         3. 使用方法
           ```cpp
           //要讲列表法和最基本的
           //定义 Date类的构造函数
           Date::Date(){
               year = 2000;
               month = 1;
               day = 1;
           }
           //Date构造函数的一种重载
           Date::Date(int y,int m,int d){
               year = y;
               month = m;
               day = d;
           }
           //以上的重载还可以用这种方式书写
           Date::Date(int y,int m,int d):
           ```
         4. 特别的，还有一种拷贝构造函数
            ```cpp
            public:
                Date(const& Date &obj);
            ```
            在实现的过程中注意区分 **“深拷贝”，“浅拷贝”** 。
      2. 析构函数
         1. 有创建就会有消亡，创建时往往会通过构造函数为对象分配资源，而当对象消亡的时候这些资源需要被释放，因此可能需要一些扫尾工作，通常指```new、malloc```中分配的堆内存，在对象消失前就要释放掉。
         2. 特点：```~类名();```,没有参数和返回值，一个类中只有一个，所以无法重载，系统在对象销毁时自动调用析构函数。
   
2. 方法和消息
   1. 定义：类中行为的实现方法，即类的成员函数。
   2. 可以有私有成员（方便编程），也可以有共有成员供外部访问
   3. 这些抽象的方法，一般是**类与外界沟通的途径**，这点在c++和java这样的面向对象语言程序设计中尤为常见。
### 4.练习
1. date类
2. 圆类
3. 学生类
4. 课堂类

##  第二课 类的进阶介绍
1. 类对象数组
   1. 数组里每一个元素都是同一个类的对象，例：管理一个班的学生。
   2. 代码实现：
    ```cpp
        class Student{
            //......
        };
        Student stu[45]; //最基本的初始化方式；
        Student *st = new Student[45]; //安全简洁的初始化，要求定义了无参构造函数，或者带默认参数的构造函数
        //这种方法为它们分配了堆内存，并默认初始化。
    ```
2. 类对象指针
   1. 对象指针，即指向对象所在地址的指针，
   2. 其大小取决于类需要分配的大小，可以通过指针加加来看某个类对象的大小。
        ```cpp
            class Date{
                int year;
                int month;
                int day;
            };
            Date* ptr = 0;
            std::cout << ptr << std::endl;
            ptr++;
            std::cout << ptr << std::endl; 
            // 返回的值是0和0xC，对应12，即3个字长为4的int指针的长度。可以自己尝试double等等转换。
        ```
    3.当我们有一个指向Date类的对象的指针ptr的时候，如果要访问该对象的成员函数/成员变量，直观来想需要通过这样的方式去访问
    ```cpp
        *ptr.setDate();
         // 这样会报错！因为.运算符优先级比*要高
        
        (*ptr).setDate();
        //可以正常的调用该函数

```
    那么为了简化这种复杂的书写，c++使用了新的箭头操作符 **“->”**作为访问一个**某对象指针所指对象的成员**的运算符
    ```cpp
        ptr->setDate();
    ```
3. this指针
   1. 对于同类对象来说，每个对象都拥有一套数据成员，并且分别占用相同大小的存储空间，比如刚才的Student类，每一个人都有自己单独的姓名、学号以及性别，它们都有对应的存储地址。
   2. 但是类的成员函数则不同，它对于类生成的所有对象来说只有一个，假如调用了```setName()```函数要修改姓名，那么所有的同学调用的都将是**同一个函数**(函数指针相同)。那么系统如何判断每个请求该函数的成员，到底是谁呢，该取用谁数据成员呢？
   3. 每个类，都有一个，**自动生成，自动隐藏的私有成员**，存在于类的非静态成员函数中，用于指向正在调用某个成员函数的对象的地址，这个就是```this```指针。
    ```cpp
      #include <iostream>
      class Date
      {
      private:
          int year;
          int month;
          int day;
      public:
          void setdate(){
              ;
          } 
          void printThis(){
              std::cout << this << std::endl;
          }
      };
      int main()
      {
          Date mydate[5];
          Date *ptr = &mydate[2];
          std::cout << "直接输出mydate[2]的指针："<< ptr << std::endl;
          std::cout << "输出mydate[2]的this地址：";
          mydate[2].printThis();
      }
    ```
    4. 注意this的作用域一般只在类内部，编译器会自动添加this指针，对各成员的访问均通过this进行，以此标识**数据成员**归属于哪个地址中的对象。
    5. 如果this指针被显式地在函数内表达，应该是以这种形式
    ```cpp
    class Date{
        int year;
        int month;
        int day;
    public:
        Date(int y,int m,int d);
    };
    Date::Date(int y,int m,int d){
        this->year = y;
        this->month = m;
        this->day = d;
    }

```
4. 重温重载运算符（属于复习＋引申）
    1. 导师自由发挥，两个类相加，需要返回一个值，需要重载加号和等号运算符(可以用复数，可以用坐标点)
    2. 要复习重载运算符的方法，以及应用到类中的方法
    3. **重点要体现出可以使用:**
        ```cpp
           return *this;
        ```
        这个东西的作用。然后就可以收回来了
    4. 特别的，如果参数与数据成员同名，比如：
        ```cpp
        Date::setDate(int year,int month,int day){
            this->year = year;
            this->month = month;
            this->day = day;
        }
        ```
   可以通过这种方式增强程序的可读性（不加不影响编译，思考一下为什么）
5. 静态成员
   1. 静态数据成员
      1. 为了解决数据共享的问题，比如“计数器”，统计该类已经生成过多少个对象。
      2. 想要在**同类**的多个对象之间实现数据共享，并且需要避免使用全局变量，那么可以使用类的静态数据成员实现
      3. 使用方法
       ```cpp
           //类内声明
           //static 数据类型 静态数据成员名
           static int counter;

//类外初始化，必须！
           int 类名::counter = 0;

//思考为什么不能类内初始化（不属于任何一个成员，防止在创建类的时候被“刷新”掉）
       ```
       1. 静态成员的生命周期与整个程序相同，保存在静态数据区，该类的所有对象共享这块静态存储空间。
       2. 可以是```private```保护封装性，如果设置为```public```，则可以通过```类名::静态数据成员名```的方式来访问。以二元点类Point类（两个double x,y作为成员）举例：
       ```cpp
           cout <<"已经创建的点数是：" << Point::counter << endl;
       ```
    2. 静态成员函数
       1. 定义的特殊的成员函数，用来负责对于静态成员的存取
       2. 同样的，是在普通函数前面加```static```关键字
       3. 特别的！静态成员函数不拥有```this```指针！可以通过类名实现访问。
        ```cpp
        //类内定义
        static int getCounter(){
            return counter; //专门读取counter的值
        }
        //类外访问
        std::cout << Point::getCounter() << std::endl; 
        ```
6. 友元关系
   1. 友元函数，由```friend```修饰，在类中声明，但是不是该类的成员函数，可以是一个普通的函数，也可以是**其他类的成员函数**
   2. 简单来说就是为一个类设定“朋友”,该类中所有的私有数据成员对于该类公开，对于特定的类关系，省去了通过函数访问私有成员再返回给函数的时间开销，适用于频繁进行数据交换相互访问的两个类（函数）。
   3. “朋友“是函数：友元函数。<br>”朋友“是类：   友元类
   4. 友元函数具体实现
   ```cpp
   #include <iostream>
   #include <math.h>
   using namespace std;

class point {
       public:
       point(double xx = 0 , double yy = 0){
           x = xx;
           y = yy;
       }
       double getx(){
           return x;
       }
       double gety(){
           return y;
       }
       friend double fDist(point *p1,point *p2);//利用友元函数方便直接访问类对象的私有成员 X y，但因为没有this指针，所以需要传递对象名或者指针去访问私有数据成员。
       private:
           double x,y;
   };
   double fDist(point *p1,point *p2){  //它不是point的成员函数，只是一个普通的函数，所以定义时并不需要声明point::fdist
       double x = p1 -> x - p2 -> x;
       double y = p1 -> y - p2 -> y;
       return sqrt(x * x + y * y);
   }

int main(){
       point *p1 = new point (1,1);
       point *p2 = new point (2,2);
       cout << "两点间距离为：";
       cout << fDist(p1,p2) << endl;
       delete p1;
       delete p2;
       return 0;
   }
   ```
   5. 友元类具体实现 更加简单
   ```cpp
    #include <iostream>
   #include <cstring>
   using namespace std;
   class A
   {
       private:
           friend class B;
           string *name;
           int age;
       public:
           A(const char *str,int n){
               name = new string(str);
               age = n;
           }
   };
   class B{
       public:
           void show(A x){
               cout << "name:" << *x.name << endl;
               cout << "age:" << x.age << endl;
           }
   };
   int main(){
       string myname("Mike"); //避免字符串和string转换带来的警告
       A a(myname.c_str(),99);
       B b;
       b.show(a);
       return 0;
   }
   ```
    大家可以看到，上面的程序里有一个const，这里就要引出下一个知识点，共享数据保护
7. 共享数据保护
   1. 常引用
      1. 声明引用时用const修饰,比如
      ```const int &age```
      2. 以常引用作为**形参**，可以保证**实参**不会被意外修改
   2. 常对象
      1. 自创建起，就不再更改其内容，所有试图对该对象进行修改的成员函数，以及直接修改数据成员的操作均为非法
      2. 声明的同时必须被初始化，并且从此无法修改
      ```cpp
        const Date mybirthday(2000,11,22);
        mybirthday.setDate() // 该函数调用非法！
        mybirthday.Print()  //该函数调用非法！print函数的this指针无法指向常对象！
      ```
      3. 常对象的使用方法一般以常对象的引用出现，保证减小开销的同时，又不会更改原来的数据，如友元章节中：
        ```cpp
        double fDist(const point *p1,const point *p2)
        {  //它不是point的成员函数，只是一个普通的函数，所以定义时并不需要声明point::fdist
        double x = p1 -> x - p2 -> x;
        double y = p1 -> y - p2 -> y;
        return sqrt(x * x + y * y);
        }
        ```
        用该方式调用可以确保 **“只取用，不修改！”**
    3. 常成员
       1. 常成员函数
       2. 常数据成员
          1. 使用const修饰的数据成员
          2. 任何函数都不能对该成员赋值
          3. 在该数据成员初始化时，只能通过初始化列表完成
            ```cpp
            #include<iostream>
            class A{
            private:
                const int a;
                static const int b;
            public:
                A(int i): a(i){ } //只能通过初始化列表初始化const
                void Print() const{
                    std::cout << a <<":" << b << std::endl;
                }
            };
            const int A::b = 10; //类外初始化静态const成员
            int main(){
                A a1(100),a2(0);
                a1.Print();
                a2.Print();
            }
            //a,b均无法改写，但是a随着变量初始化时不同，在不同的对象里有不同的取值，但是b会一直保持公有的10的值不变，即便没有对其赋值。
            ```
## 第三课 继承
>实现以原有类为基础来创建新类，即定义一个新类时，让它继承一个已经定义好的类的所有成员，只在该类中添加新的成员

>尽可能复用原有类的代码，提高软件开发的效率
### 感觉这块不太需要赘述，就把java课的图形类的不断继承派生说明白就好，仅罗列知识点
### 类的继承与派生
1. 继承与派生的概念
   1. 基类（父类）
   2. 派生类（子类）
2. 派生类该如何定义
### 继承方式
1. 三种方式
   1. 公有继承
   2. 私有继承
   3. 保护继承
2. [特点](https://www.cnblogs.com/xiaochi/p/8603008.html):
   **注意以下表格的主语宾语关系**

### 派生类函数重载
1. 重载构造函数和析构函数
2. 重载需要重载的函数

### 多继承
一个子类拥有多个父类
1. 多继承的声明方法
2. 多继承的构造函数
3. 多继承的二义性
### 虚基类和虚继承
1. 为了消除菱形继承的二义性

### 组合类
一个类，它的数据成员中含有一个或者多个类对象
1. 辨析组合与继承的关系
   1. 交通工具和汽车算继承关系
      1. 汽车的基本属性和交通工具的基本属性有共性
   2. 发动机和汽车算包含关系
      1. 发动机是汽车的一个“成员","一个组成部分"
2. 在编写构造函数时，要逐一调用数据成员的构造函数，并逐一对其进行初始化，保证信息的完整性。
   
## 第四课 面向对象程序设计中的多态性
### 多态性的概念
1. 概念：
2. 实现：
### 虚函数
在基类中定义，其派生类的同名函数也会是虚函数
1. 特点：实现了动态调用，根据传入虚函数的指针类型，决定调用从基类到子类的所有类中哪一个对应类的对应函数。
2. 必须使用虚函数的例子
   1. 图形们 shape 派生{circle，rectangle，square} 的show函数要用虚函数编写
3. 虚函数重载
4. 特别的，虚析构函数！
   1. 因为要保证在多重继承关系下，将对象的所有成员完全销毁
   2. 反之，只调用基类的析构函数，就会导致新派生的类的“新成员”没有被销毁，导致内存泄露。
### 抽象类
1. 纯虚函数
   1. 具有动态多态性，但是没有、也不需要实现（shape类中的show）
   2. 就仅仅起个名字占个坑
   3. 需要在子类中得到实现
2. 定义了纯虚函数的类，就只能定义为抽象类
   1. 抽象类不能实例化，因为缺乏定义。
### 函数重载
1. 成员函数重载
   1. 通过函数参数的个数，参数类型不同加以区分
   2. 利用相同的函数命名，表达不同的函数实现，实现相似的功能，丰富函数的内容
   3. 全局函数重载
   4. 可以设置函数的默认参数
2. 运算符重载（前面讲过了）
   1. 可以罗列一下能重载和不能重载的运算符
   2. 特殊的只能重载为类的非成员运算符’>>’，’<<‘
   3. 成员运算符重载
   4. 非成员运算符重载
      1. 即声明为友元函数进行重载
   5. 注意单目和双目运算符重载的先后顺序以及语法特点
      1. ‘++‘ ’--‘对应的```operator```的前后位置以及参数个数
3. 赋值运算符和拷贝运算符重载

## 第五课 模板
### 模板的基本概念和作用
### 函数模板和模板函数
1. 函数模板定义和实例化
2. 重载函数模板
   1. 必须以参数个数的差异来区别
### 类模板和模板类
>用**类模板**生成的类叫**模板类**
1. 类模板定义及其实例化
2. 类模板的派生！！！！

## 第六课 标准模板库及跌倒器
### 标准模板库STL
1. 主要内容罗列
   vector...
2. 迭代器（智能指针）
STL的核心技术，提供了统一访问容器元素的方法，为编制通用算法打下了坚实的基础
3. 函数对象
   1. 通过重载运算符“()”实现函数对象，可以对容器中的数据进行各种各样的操作
4. 常用通用容器的介绍
   1. vector
   2. stack
   3. list
   4. queue
   5. deque
5. STL常用算法
   1. sort()
   2. find()

## 第七课 输入输出流
### 输入输出流基础
1. 简介
   1. 标准输入输出
   2. 文件输入输出
   3. I/O库的常用流类继承关系，头文件
### 标准输出流和输入流对象
1. cin cout
2. put() get()
3. getline() ***常用***
4. eof()   即***end of file***的缩写
### 文件流以及文件操作的基础
1. 打开外存文件
2. 关闭外存文件
3. 如何利用>> << 读写流内的数据
### 重载cin cout以实现类的直接输入和输出

## 第八课 C++进阶应用
### 动态内存管理
1. 重载```new```和```delete```
2. 分析常见动态内存错误情况
   1. 分配失败的情况```if(ptr==NULL)```
   2. 动态内存没有初始化就直接操作
   3. 动态内存空间越界使用
   4. 内存泄漏
   5. 继续使用已经释放的动态内存空间
### 类型转换
### 异常处理
1. try catch 语句的语法
2. 异常的数据格式，以及和终端的交互
   
# 结课！

SunnyHaze/Cov_basic_teaching

简介

发行版

贡献者

近期动态

SunnyHaze/Cov_basic_teaching .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

SunnyHaze/Cov_basic_teaching