面向对象程序设计（OOP）

面向对象程序设计（OOP）

前言

有朋友问我，七天的C语言系列怎么更到第六篇就一直不更了，怎么说呢，其实我的C语言学到后面也学的不是很扎实，像是结构体和文件操作，我都掌握的不太牢固，必须要看着操作手册才能写一写。而且，确实自从C语言期末考试结束之后，我也很少进行C语言的学习了，除了有学弟学妹问我的时候我可能才会回顾一下。再加上，从去年十二月开始，我一方面要准备自己的期末考试，回家之后紧接着就是美赛，还有科创，所以，就有点抽不开身。请允许我小小的烂个尾。

接下来，大一的下学期，我们就要开始学习面向对象程序设计了，采用的是C++语言描述。我觉得这门课还是蛮重要的，当然，如果你只是单纯想拿高分的话，那你其实背一背hs的经典题型就问题不大，但是，考虑到下学期的数据结构和java，那么，我还是建议要好好学一下的。

首先，大家可以先看看书，把C++对于C语言的扩充了解一下，其实在咱们学校的学习过程之中，大概了解一些输入输出流，以string的方式表示字符串，还有动态数组的new和delete就足够进行初步的学习了。

函数重载

什么是函数重载？

函数重载是指在同一个作用域内，可以定义多个名称相同但参数列表不同的函数。这意味着我们可以使用相同的函数名来执行不同的任务，只要它们的参数列表不同即可。（注意，只有参数与重载有关，而返回值的类型和函数重载无关）

为什么需要函数重载？

函数重载使得代码更加灵活和易于理解。通过为相似但不完全相同的功能定义一个通用的函数名，可以提高代码的可读性和可维护性。此外，函数重载还可以使代码更具可扩展性，因为我们可以通过添加新的重载函数来处理新的情况。

让我们以OOP实习的第一题为例，分析一下函数重载的作用：

题目描述

设计一菜单程序，利用函数重载实现员工月工资的计算，计算方法如下：

（1）管理人员的月工资 ＝ 月薪 － 缺勤天数× 月薪÷ 22；

（2）销售人员的月工资 ＝ 底薪 + 销售金额 × 提成比例；

（3）计件工人的月工资 ＝ 产品件数× 每件报酬；

（4）计时工人的月工资 ＝ 工作小时 × 小时报酬；

我们发现，我们要设计四个函数，而这四个函数都是用来计算工资的，那么这个时候，我们可以通过函数重载机制，使用不同的传参来分别实现这四个函数：

#include<iostream>
using namespace std;

// 管理人员的月工资 ＝ 月薪 － 缺勤天数× 月薪÷ 22
double getEarning(double salary, int absenceDays) {
    return salary - absenceDays * salary / 22;
}

// 销售人员的月工资 ＝ 底薪 + 销售金额 × 提成比例
double getEarning(double baseSalary, double salesSum, double rate) {
    return baseSalary + salesSum * rate;
}

// 计件工人的月工资 ＝ 产品件数× 每件报酬
double getEarning(int workPieces, double wagePerPiece) {
    return workPieces * wagePerPiece;
}

// 计时工人的月工资 ＝ 工作小时 × 小时报酬
double getEarning(double hours, double wagePerHour) {
    return hours * wagePerHour;
}

int main(){
    int kind  = 0 ;
    cout << "Please select..." << endl;
    cout << "1: Manager." << endl;
    cout << "2: Sales Man." << endl;
    cout << "3: Pieces Worker." << endl;
    cout << "4: Hour-Worker." << endl;
    cout << "Others: Quit" << endl;
    cin >> kind ;
    switch(kind)
    {
        case 1:
        {
            double salary ;
            int abDays;
            cin>>salary>>abDays;
            cout<<getEarning(salary,abDays);
            break;
        }
        case 2:
        {
            double base ;
            double salesSum;
            double rate;
            cin>>base>>salesSum>>rate;
            cout<<getEarning(base,salesSum,rate);
            break;
        }
        case 3:
        {
            int workPieces;
            double wagePerPiece;
            cin>>workPieces>>wagePerPiece;
            cout<<getEarning(workPieces,wagePerPiece);
            break;
        }
        case 4:
        {
            double hours;
            double wagePerHour;
            cin>>hours>>wagePerHour;
            cout<<getEarning(hours,wagePerHour);
            break;
        }
        default:
            break;
    }
    return 0;
}

我们发现，在上面这道题的代码实现之中，我们使用了四个传入参数不同的getEarning函数实现了四种类型的薪资计算。

OOP基础概念

类（Class）
类是一种用来描述具有相同属性（数据）和行为（方法）的对象的模板或蓝图。它定义了对象的结构和行为。

对象（Object）：
对象是类的一个实例，它具有类定义的属性和方法。每个对象都是独立的，可以拥有不同的状态。

这样读起来感觉很抽象，让我们来举一个例子，假如，现在有一个类，叫做学生类，我们大家都是学生，因为我们都有相同的特征和属性，比如，我们都有名字、学号、专业类似这样的属性。接下来，让我们拿出一个具体的学生，比如说，这个人的名字叫张三，他的学号是xxx，他的专业是计算机。这样相比较而言，我们刚才说的学生类，就很抽象，而张三这个学生，就很具体。

在面向对象程序设计中，我们把这种抽象的概念叫做类（例如上面的学生类），像张三那样是学生类的一个具体的体现，我们把他叫做对象。

那么，我们该如何创建一个类和一个对象呢。

结合我们对于C语言的学习，有这样一个语句：

int num = 10;

当然我们很熟悉这句话了，声明了一个int类型的变量，这个变量的名字叫num，初始化值为10。

对于对象而言依然如此

学生 张三 = （初始化语句）

可是，我们发现，int类型是语言规定的，而学生类计算机并不知道，所以这个时候我们就要先告诉计算机，我们有一个什么样子的类。

第一种办法就是写一个结构体，把学生类的基本属性封装起来（在C语言里面也有过这样的题目）

在C++之中的新结构体，不同于C语言的结构体，语法规则如下

struct student{  //struct 类名 不用加typedef
    int ID;		//数据类型 成员变量
    char name[20];
    char profession[50];
    void setStu(int id,char* n,char* pro); //可以声明成员函数,这里实现了一个对属性初始化的操作
    void print(char* name){
        cout << name;
    }
};

void student::setStu(int id,char* n,char* pro){
    ID = id;
    strcpy(name,n);
    strcpy(profession,pro);
} //成员函数的实现

让我们来看看这段代码之中有没有什么不方便的地方：

1.数据和函数是分离的，并且封装性很差，在struct结构体中，默认情况下，所有成员都是公共的，这意味着结构体的数据成员可以被外部代码直接访问和修改，而不受到封装的保护。这缺乏了封装性，使得数据的修改不受到控制，增加了代码的不稳定性。举个例子

struct Point {
    int x;
    int y;
    
    void setCoordinates(int newX, int newY) {
        x = newX;
        y = newY;
    }
};

int main() {
    Point p;
    p.x = 5;  // 直接访问结构体的数据成员
    p.setCoordinates(10, 15);  // 通过成员函数修改数据
    return 0;
}

2.当我们使用全局函数的时候有可能会引起命名冲突。

3.当我们调用ADT函数（操作抽象数据类型的函数）的时候需要参数传递，不直观，例如，对于栈这种抽象数据类型，常见的ADT函数包括压栈（push）、出栈（pop）、获取栈顶元素（top）等。这些函数定义了栈的基本操作，而具体的实现可以使用数组、链表等不同的数据结构来完成。

基于以上，及更多的原因，我们更多使用class来描述类。

使用class来描述一个类的时候，要遵循如下的语法规则：

class classname{
  private:
    //在这里声明私有属性/私有成员函数，只允许在class内调用
  public:
    //在这里声明公共属性/公共成员函数，全局都可以调用
  protected:
    //在这里声明受保护的属性/成员函数，在接触到继承和派生之前可以认为就是私有的
  //声明和实现构造函数与析构函数（这个概念我们后续再说）

};

在没有private、public、protected这样的修饰词时，class会把属性和成员函数都默认为私有的，而struct会认为是公共的，这也是我们选择使用class来实现封装性的原因。