C++_02

1、类

1.1 什么是类

C++ 中的类（class）是一种编程结构，用于创建对象。这些对象可以拥有属性（即数据成员）和行为（即成员函数或方法）。类的概念是面向对象编程的核心之一，其主要目的是将数据和与数据相关的操作封装在一起。例如，如果你有一个“汽车”类，它可能包含颜色、品牌、型号等属性（数据成员），以及启动、停止、加速等行为（成员函数）。每当你基于这个类创建一个对象时，你就有了一个具体的汽车，具有这些属性和行为。

C++ 类的基本结构通常包含：

（1）数据成员（Attributes）：定义类的属性。这些是类内部的变量，用于存储对象的状态。

（2）成员函数（Methods）：定义类的行为。这些是可以操作对象的数据成员的函数。

（3）构造函数和析构函数：特殊的成员函数。构造函数在创建对象时自动调用，用于初始化对象。析构函数在对象销毁时调用，用于执行清理操作。

（4）访问修饰符：如 public , private , protected ，用于控制对类成员的访问权限。例如， public成员可以在类的外部访问，而 private 成员只能在类内部访问。

（5）继承：允许一个类继承另一个类的特性。这是代码重用和多态性的关键。

通过这些特性，C++ 类提供了一种强大的方式来组织和处理数据，使得代码更加模块化、易于理解和维护。

1.2 从结构体引入类

1.2.1 C中使用结构体

如果用C语言实现上面描述的汽车类，实现代码如下：

#include <stdio.h>
#include <stdlib.h>struct Car{ //汽车“类”char *color; //颜色char *brand; //品牌char *type; //车型int year; //年限void (*printCarInfo)(char *color,char *brand,char *type, int year); //函数指针，指向车介绍函数void (*carRun)(char *type); //函数指针，指向车运行的函数void (*carStop)(char *type); //函数指针，执行车停止的函数
};void bwmThreePrintCarInfo(char *color,char *brand,char *type, int year)
{printf("车的品牌是：%s, 型号是: %s, 颜色是：%s,上市年限是%d\n", brand,type,color,year);
}void A6PrintCarInfo(char *color,char *brand,char *type, int year)
{printf("车的品牌是：%s,型号是: %s, 颜色是：%s, 上市年限是%d\n", brand,type,color,year);
}int main()
{struct Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);struct Car *AodiA6;AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);return 0;
}

1.2.2 C++中使用结构体

新建一个C++文件直接来执行上述代码，会有一些问题。

在C++中字符串用string来表示，要修改所有char *为 string类型；

在修改后，会发现现printf的%s控制位，不能用于string的输出，即使有string构建了即将要输出的字符串；

C++中，通过std::tostring()函数，将整型数转化成字符串；

在printInfo中使用cout输出汽车信息；

发现在C++工程中，使用malloc在堆申请结构体空间有问题，所以直接在此引入类的概念，把struct改成class；

引入新问题，class的成员数据和成员函数在不指定权限的情况下，默认private权限，类的对象无法进行直接访问，因此要添加public属性；

访问权限	类内部	同一个类的对象	派生类（子类）	类外部
public	✔️ 可访问	✔️ 可访问	✔️ 可访问	✔️ 可访问
private	✔️ 可访问	❌ 不可访问	❌ 不可访问	❌ 不可访问
protected	✔️ 可访问	❌ 不可访问	✔️ 可访问	❌ 不可访问

把main函数中的原本结构体变量改成了类的实例化，如果变量类型是指针，把原来的malloc改成new一个对象。

最终修改完的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>using namespace std;class Car{ //汽车“类”
public:string color; //颜色string brand; //品牌string type; //车型int year; //年限void (*printCarInfo)(string color,string brand,string type, int year); //函数指针，指向车介绍函数void (*carRun)(string type); //函数指针，指向车运行的函数void (*carStop)(string type); //函数指针，执行车停止的函数
};void bwmThreePrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void A6PrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}int main()
{Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);Car *AodiA6 = new Car();// AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);return 0;
}

1.2.3 真正的成员函数

在上一小节中的代码中，void (*printCarInfo)(string color,string brand,string type, int year);是一个指针变量，是保存某个函数地址的变量，所以它不是成员函数，是成员数。

真正的成员函数遵守封装特性，在函数体内部访问成员数据的时候，不需要参数传递。

在C++ 中，双冒号 :: 称为 "作用域解析运算符"（Scope Resolution Operator）。它用于指定一个成员（如函数或变量）属于特定的类或命名空间。例如，在类的外部定义成员函数时， :: 用于指明该函数属于哪个类。

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>using namespace std;class Car{ //汽车“类”
public://成员数据string color; //颜色string brand; //品牌string type; //车型int year; //年限//其实也是成员数据，指针变量，指向函数的变量，并非真正的成员函数void (*printCarInfo)(string color,string brand,string type, int year); //函数指针，指向车介绍函数void (*carRun)(string type); //函数指针，指向车运行的函数void (*carStop)(string type); //函数指针，执行车停止的函数void realPrintCarInfo();//声明成员函数
};void Car::realPrintCarInfo() //在类的外部进行成员函数的实现
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void bwmThreePrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void A6PrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}int main()
{Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);BWMthree.realPrintCarInfo();Car *AodiA6 = new Car();// AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);AodiA6->realPrintCarInfo();return 0;
}

1.3 组合

在C++中，一个类包含另一个类的对象称为组合（Composition）。这是一种常见的设计模式，用于表示一个类是由另一个类的对象组成的。这种关系通常表示一种"拥有"（"has-a"）的关系。

普通变量访问成员变量或者成员函数，使用 “ . ” 运算符；

指针变量访问成员变量或者成员函数，使用“ -> ”运算符，像C语言的结构体用法

#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>using namespace std;class Wheel
{
public:string brand;int year;void wheelPrintInfo();
};void Wheel::wheelPrintInfo()
{cout << "我的轮胎品牌是：" << brand << endl;cout << "我的轮胎日期是：" << year << endl;
}//在 C++中，一个类包含另一个类的对象称为组合（Composition）。
class Car{ //汽车“类”
public://成员数据string color; //颜色string brand; //品牌string type; //车型int year; //年限Wheel wl;Wheel *pwl;//其实也是成员数据，指针变量，指向函数的变量，并非真正的成员函数void (*printCarInfo)(string color,string brand,string type, int year); //函数指针，指向车介绍函数void (*carRun)(string type); //函数指针，指向车运行的函数void (*carStop)(string type); //函数指针，执行车停止的函数void realPrintCarInfo();//声明成员函数
};void Car::realPrintCarInfo() //在类的外部进行成员函数的实现
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void bwmThreePrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}void A6PrintCarInfo(string color,string brand,string type, int year)
{string str = "车的品牌是：" + brand+ ",型号是: " + type+ ",颜色是：" + color+ ",上市年限是:" + std::to_string(year);cout << str << endl;
}int main()
{Car BWMthree;BWMthree.color = "白色";BWMthree.brand = "宝马";BWMthree.type = "3系";BWMthree.year = 2023;//类里面的对象如果是指针，也要new一下BWMthree.pwl = new Wheel();BWMthree.pwl->brand = "米其林";BWMthree.pwl->year = 2023;//BWMthree.wl.brand = "米其林";//BWMthree.wl.year = 2023;BWMthree.printCarInfo = bwmThreePrintCarInfo;BWMthree.printCarInfo(BWMthree.color,BWMthree.brand,BWMthree.type,BWMthree.year);BWMthree.realPrintCarInfo();//BWMthree.wl.wheelPrintInfo();Car *AodiA6 = new Car();// AodiA6 = (struct Car*)malloc(sizeof(struct Car));AodiA6->color = "黑色";AodiA6->brand = "奥迪";AodiA6->type = "A6";AodiA6->year = 2008;AodiA6->printCarInfo = A6PrintCarInfo;AodiA6->pwl = new Wheel;AodiA6->pwl->brand = "普利司通";AodiA6->pwl->year = 2012;//AodiA6->wl.brand = "马牌";//AodiA6->wl.year = 2023;AodiA6->printCarInfo(AodiA6->color,AodiA6->brand,AodiA6->type,AodiA6->year);AodiA6->realPrintCarInfo();//AodiA6->wl.wheelPrintInfo();AodiA6->pwl->wheelPrintInfo();return 0;
}

2、权限初识

2.1 基本介绍

C++的访问权限主要分为三种： public 、 private 和 protected 。这些权限决定了类成员（包括数据成员和成员函数）的可访问性。

访问权限	类内部	同一个类的对象	派生类（子类）	类外部
public	✔️ 可访问	✔️ 可访问	✔️ 可访问	✔️ 可访问
private	✔️ 可访问	❌ 不可访问	❌ 不可访问	❌ 不可访问
protected	✔️ 可访问	❌ 不可访问	✔️ 可访问	❌ 不可访问

使用权限（如 public 、 private 和 protected ）在C++中是一种关键的封装手段，它们旨在控制对类成员的访问。下面是一个表格，总结了使用权限的主要好处和潜在缺点：

好处 / 缺点	描述
好处
封装性	通过隐藏类的内部实现（私有和受保护成员），提高了代码的安全性和健壮性。
接口与实现的分离	公开接口（公开成员）与私有实现分离，有助于用户仅关注于如何使用类而不是如何实现。
易于维护	修改类的内部实现不会影响使用该类的代码，从而降低了维护成本。
控制读写访问	通过设置访问权限，可以精确控制类成员的读写访问。
继承的灵活性	protected 成员在派生类中是可访问的，使得继承更加灵活。
缺点
增加复杂性	过度使用或不当使用权限可能导致代码结构复杂，难以理解。
测试难度	私有成员的测试比公共成员更困难，因为它们不能从类的外部访问。
灵活性降低	过于严格的封装可能限制了某些有效的用法，降低了灵活性。
可能导致紧耦合	过多依赖 friend 类或函数可能导致类之间的耦合过紧。

2.2 简单示例

public权限相当于我们学习C语言结构体一样，不考虑访问权限的存在，但是要注意，类中不写权限，默认是私有权限。

假设一个场景：银行的账户是一个模板，是一个类，有存款人信息和账户额度，而具体的存款人视为一个对象，一个对象不能私自修改账户额度，需要通过一个操作流程，比如去ATM或者柜台进行操作才能修改到账户额度，所以，存款人信息和账户额度设计成私有权限，通过公有的操作流程，也就是公有函数去操作私有变量。基于这个场景，我们编程实现代码。

#include <iostream>
#include <string>using namespace std;class BankAccount{
private://有存款人信息和账户额度string name;string addr;int age;double balance;public:string bankAddr;//比如去ATM或者柜台进行操作才能修改到账户额度void registerMes(string newName, string newAddr,int newAge,double newBalance);void withdraw(double amount);void deposit(double amount);double getBalance();void printUserInfo();
};void BankAccount::printUserInfo()
{string mesTem = "账户名：" + name + "，地址：" + addr +",年龄："+ std::to_string(age) + ",存款：" + std::to_string(balance);cout << mesTem << endl;
}void BankAccount::registerMes(string newName, string newAddr,int newAge,double newBalance)
{name = newName;addr = newAddr;age = newAge;balance = newBalance;
}// 存款方法
void BankAccount::deposit(double amount) {if (amount > 0) {balance += amount;} else {cerr << "Deposit amount must be positive." << endl;}
}// 取款方法
void BankAccount::withdraw(double amount) {if (amount > balance) {cerr << "Insufficient funds." << endl;} else if (amount <= 0) {cerr << "Withdrawal amount must be positive." << endl;} else {balance -= amount;}
}// 获取当前余额的方法
double BankAccount::getBalance() {return balance;
}int main()
{BankAccount user1;user1.registerMes("老A","深圳光明区",35,100);user1.printUserInfo();user1.deposit(1000);cout << user1.getBalance() << endl;user1.withdraw(30);cout << user1.getBalance() << endl;return 0;
}

在这个示例中， balance 是一个 private 成员变量，它不能被类的外部直接访问。这保证了账户余额只能通过类提供的方法（如 deposit , withdraw , 和 getBalance ）来修改和查询，从而防止了不合适的修改，比如直接设置余额为负数或任意值。这样的设计保证了类的封装性和数据的完整性。

3、引用

3.1 引用和指针的区别

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

在C语言中，一个数据对应一个内存，通过由一个变量名来访问这个内存空间的数据，叫做直接访问，相对直接访问，有个间接访问的说法，叫做指针。

而引用相当于又给这个内存中的数据提供了一个新的变量名，而且这个变量名功能比传统变量名更特殊，是直达地址的。

主要区别：

（1）不存在空引用。引用必须连接到一块合法的内存。

（2）一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。

（3）引用必须在创建时被初始化。指针可以在任何时间被初始化。

//使用 & 进行引用
int& r = i;    //r 是一个初始化为 i 的整型引用
double& s = d;    //s 是一个初始化为 d 的 double 型引用

#include <iostream>using namespace std;int main ()
{// 声明简单的变量int i;double d;// 声明引用变量int& r = i;double& s = d;i = 5;cout << "Value of i : " << i << endl;cout << "Value of i reference : " << r << endl;d = 11.7;cout << "Value of d : " << d << endl;cout << "Value of d reference : " << s << endl;return 0;
}

3.2 将引用作为参数

#include <iostream>using namespace std;// 函数声明
void swap(int& x, int& y);int main ()
{// 局部变量声明int a = 100;int b = 200;cout << "交换前，a 的值：" << a << endl;cout << "交换前，b 的值：" << b << endl;/* 调用函数来交换值 */swap(a, b);cout << "交换后，a 的值：" << a << endl;cout << "交换后，b 的值：" << b << endl;return 0;
}// 函数定义
void swap(int& x, int& y)
{int temp;temp = x; /* 保存地址 x 的值 */x = y; /* 把 y 赋值给 x */y = temp; /* 把 x 赋值给 y */return 0;
}

3.3 将引用作为返回值

通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似。

当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。

#include <iostream>using namespace std;double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};double& setValues(int i) {double& ref = vals[i];return ref; // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i]
}// 要调用上面定义函数的主函数
int main ()
{cout << "改变前的值" << endl;for ( int i = 0; i < 5; i++ ){cout << "vals[" << i << "] = ";cout << vals[i] << endl;}setValues(1) = 20.23; // 改变第 2 个元素setValues(3) = 70.8; // 改变第 4 个元素cout << "改变后的值" << endl;for ( int i = 0; i < 5; i++ ){cout << "vals[" << i << "] = ";cout << vals[i] << endl;}return 0;
}

当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。

int& func() {int q;//! return q; // 在编译时发生错误static int x;return x; // 安全，x 在函数作用域外依然是有效的
}

4、重载

4.1 函数重载

在同一个作用域内，可以声明几个功能类似的同名函数，这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同，不能仅通过返回类型的不同来重载函数。

在下面的例子中，同名函数 print() 被用于输出不同的数据类型：

#include <iostream>using namespace std;class printData
{public:void print(int i) {cout << "整数为: " << i << endl;}void print(double f) {cout << "浮点数为: " << f << endl;}void print(char c[]) {cout << "字符串为: " << c << endl;}
};int main(void)
{printData pd;// 输出整数pd.print(5);// 输出浮点数pd.print(500.263);// 输出字符串char c[] = "Hello C++";pd.print(c);return 0;
}

4.2 运算符重载

在C++中，运算符重载是一个允许程序员自定义各种运算符（如 + , - , == , != 等）在自定义类型（类或结构体）上的行为的特性。这意味着你可以定义类似于内置类型的运算符行为，使你的自定义类型更加直观和易于使用。

基本原则：
（1）不可以创建新的运算符：只能重载已经存在的运算符。

（2）至少有一个操作数是用户定义的类型：不能重载两个基本类型的运算符。

（3）不能更改运算符的优先级：重载的运算符保持其原有的优先级和结合性。

示例1：假设我们有一个Person 类，我们可以重载 == 运算符来实现两个Person是否相等的判断。

#include <iostream>using namespace std;class Person
{public:string name;int inNumberTail;bool operator==(Person pTmp);
};bool Person::operator==(Person pTmp){return pTmp.name == name && pTmp.inNumberTail == inNumberTail;
}int main()
{//假设我们认定名字和身份证尾号6位一样的两个对象是同一个人！Person p1;p1.name = "张三";p1.inNumberTail = 412508;Person p2;p2.name = "张三";p2.inNumberTail = 412508;bool ret = p1 == p2;cout << ret << endl;return 0;
}

示例2：假设我们有一个简单的 Point 类，我们可以重载 + 运算符来实现两个点的加法。

class Point {public:int x, y;// 重载 + 运算符Point operator+(const Point& other) const {return Point(x + other.x, y + other.y);}
};int main() {Point p1;p1.x = 1;p1.y = 2;Point p2;p2.x = 2;p2.y = 3;Point p3 = p1 + p2; // 使用重载的 + 运算符std::cout << "p3.x: " << p3.x << ", p3.y: " << p3.y << std::endl; // 输出p3.x: 4, p3.y: 6return 0;
}

在示例2中，operator+ 被重载为一个成员函数，接受一个 Point 类型的常量引用作为参数，并返回两个点相加的结果。

这里的 const 表明这个 operator+ 函数不会修改调用它的 Point 对象。它只是读取对象的 x 和 y成员，并返回一个新的 Point 对象。这种做法在设计类的时候是很有用的，因为它可以确保某些函数不会意外地改变对象的状态，同时也使得这个函数可以在常量对象上被调用。

注：（1）一致性：重载的运算符应与其原始意图和常见用法保持一致。例如， + 运算符通常应该实现加法，而不是其他意外的操作。

（2）复杂性：过度使用运算符重载可能导致代码难以理解和维护。确保它们的使用直观且合理。

运算符重载是C++中提高代码可读性和表达力的强大工具，但需要谨慎使用，以保证代码的清晰性和维护性。