面向对象

基本概念

1. 对象：
2. 特征：
   1. 属性
   2. 行为
3. 类：相同属性和行为对象的抽象
4. 方法和消息：
   1. 实现行为的过程称为方法
   2. 对象之间的通讯称为消息
5. 特征：
   1. 抽象
   2. 封装
   3. 继承
   4. 多态

类与对象

1. 类的定义

class 类名称{
    private:
     私有数据或函数（通过共有函数访问/友元函数/友元类）
    public:
     公用数据或函数
    protected:
     保护型数据或函数(与继承有关)
}

1. 缺省参数

2. 无相应输入时候会引用缺省参数

3. 类的成员函数（方法）定义返回值类型 类名::函数成员名 (参数表){}

4. 可以附带默认的形参值（缺省参数）

5. 不同类可以拥有同名函数

6. 定义于类声明的函数将自动转化为内联函数

7. 对象

8. 类的实例化

9. 说明：类名 对象名
   1. 功能
      1. 给对象一个标识符
      2. 给对象开辟内存空间
      3. 将对象中的数据成员初始化
      4. 同一类下的不同对象使用的函数只占用一个内存块
10. 引用：对象名.共有成员数据（方法）

构造函数及析构函数

初始化方式与结构体不同，不能使用{}来进行初始化，因为数据部分是私有的，因此使用构造函数来对对象进行初始化的操作

1. 构造函数
2. 定义：和类同名的成员函数称为构造函数
3. 作用：为对象进行初始化

4. 说明：

   1. 不能指定返回类型
   2. 类中可以定义多个构造函数（可带或不带参数）
   3. 没有进行构造函数定义时，编译器会自动建立一个构造函数
   4. 对象创建时被自动调用
   5. 可以进行重载操作

5. 拷贝构造函数

6. 定义：X::X (X &)
7. 作用：创建一个相同的对象

8. 说明：

   1. 对象作为函数参数
   2. 函数返回一个对象
   3. 使用函数传参数时，即通过拷贝构造函数传参

9. 析构函数

10. 定义：与类同名，有前缀~
11. 作用：程序结束时自动清理
12. 说明：
    1. 无返回值
    2. 不接受任何参数
    3. 无显式说明时，系统自动生成一个不做任何事的默认析构函数（函数体为空）

静态成员

1. 静态属性
2. 使用static声明static int a;的成员，为所有的对象共有（属于一个类，而不仅仅属于一个对象）
3. 说明：
   1. 静态数据成员具有静态生存期
   2. 用法：类名::标识符
   3. 在类的声明中仅仅对静态成员进行引用说明(初始化需要在类外定义)
4. 静态方法
5. 使用static声明的函数，为所有对象共有
6. 说明：
   1. 静态成员函数可以通过类名或对象名来调用（一般函数仅能使用对象名来调用）
   2. 静态成员必须通过对象名来访问非静态的数据成员
   3. 静态成员函数无this指针

this指针

1. 每个函数都能通过this指针访问自己的地址this->成员，可以在函数内调用对象（或对象里的另一个函数）
2. 友元函数（类）没有this指针，因为友元函数（类）不是类的成员
3. 同样的，也可以定义一个指针指向对象：* 指针名 = new 类名

友元

1. 友元类（函数）可以访问一个类的私有成员
2. 声明友元函数：friend 函数名 (参数表)
3. 声明友元类：friend class 类名
4. 声明友元类中的函数：friend 类名::函数名 (参数表)

继承

1. 派生类

2. 一个类继承另一个类的属性（父类与子类）

3. class 子类名:继承方式 父类名

4. 继承方式： | | public | private | protected | | --------- | --------- | ------- | --------- | | public | public | private | protected | | private | private | private | private | | protected | protected | private | protected |

5. 多重继承

6. 基类名表大于等于二（基类之间用逗号隔开）

多态

1. 一个接口，多个方法

2. 两种多态

3. 编译时多态性：通过不同的参数类型和参数数目达到多态

4. 运行时多态性：虚函数

   1. 关键字：virtual(在基类中只能使用一次)

   #include <iostream>
   using namespace std;
   class Base{
   public:
       virtual void virtualfun(void){
           cout << "this is base\n";
       }
   };
   class Derived:public Base{
   public:
       void virtualfun(void){
           cout << "this is derived class\n";
       }
   };
   
   int main(){
       Base baseobject;
       Derived derivedobject;
       baseobject.virtualfun();
       derivedobject.virtualfun();
   
       return 0;
   }
   

5. 说明

   1. 虚函数需要更大的开销
   2. 静态成员函数不能是虚函数
   3. 虚函数只能是类的成员
   4. 内联函数不能是虚函数
   5. 构造函数不能是虚函数

重载

1. 函数重载

2. 同一个函数名实现不同功能（编译时多态性）

3. 操作符重载

4. 可重载的运算符：单目运算、双目运算、new、delete、引用运算符

5. 声明方式：函数类型 operator 运算符 (形参表);

   #include <iostream>
   using namespace std;
   class opre{
   public:
       opre operator ++(void);
       opre operator ++(int);
       void display();
       opre();       //构造函数
   private:
       int x;
   };
   opre::opre(){
       x = 0;
   }
   void opre:: display(){
       cout << "x = " << x << endl;
   }
   
   opre opre::operator ++(){
       opre a;
   
       ++x;
       a.x = x;
       return a;
   }
   
   opre opre::operator ++(int){
       opre a;
       x++;
       a.x = x;
       return a;
   }
   
   int main(){
       opre X,Y;
       X.display();
       ++X;
       Y = ++X;
       X.display();
       Y.display();
   
       return 0;
   }
   

模板

1. 用来创建一个通用功能的函数

2. 形式:template <typename T>

3. 函数定义:

inline T const& Max(T const& a,T const& b){
    return a < b ? b : a;
}

const

1. 类中的const成员不能被改变
2. 类中的const函数不能改变其他元素的值
3. 仅可以通过构造函数或析构函数对const成员进行初始化
4. 常见的程序错误：
5. 试图修改const对象
6. 试图在const成员函数中修改对象的数据成员
7. 试图在const成员函数中调用非const成员函数
8. 试图通过const对象中调用非const成员函数