前言：C++入门day2-面向对象编程（上）-CSDN博客
运算符重载
我们接触过函数重载，就是同名的函数有不同的功能。那么运算符重载，顾名思义也是赋予运算符其他的功能。在这里，我个人以为，运算符就是特殊函数的简写。我们先以加法切入本知识点：
+加法运算符重载
如果我们想定义两数相加的函数我们该怎么办。第一时间我们就想到了这样写：
int add(int a,int b){
return a+b;
}但是人各有志，我不想把这个函数叫做add，我想叫Add，他想叫其他的，那么使用起来就非常麻烦，为此，C++为我们提供了一个统一的名称operator+。此时我们就可以定义：
int operator+(int a,int b){
return a+b;
}但是int类型本身就有加法的操作，我们也没有其它重载方向，重点还是类类型的加法：
class A {
public:
A add(A& num) {
A ans;
ans.a = this->a + num.a;
ans.b = this->b + num.b;
return ans;
}
A operator+(A& num) {
A ans;
ans.a = this->a + num.a;
ans.b = this->b + num.b;
return ans;
}
int a;
int b;
};虽然它变了个样子，但是我们应该不难猜到它的调用方法：
int main(){
A ma;
ma.a=1;
ma.b=2;
A tmp;
tmp.a=1;
tmp.b=2;
//普通函数调用
tmp=tmp.add(ma);
//运算符重载的调用
tmp = tmp.operator+(ma);//函数式调用
tmp = tmp + ma;//简化形式
return 0;
}同样的不仅仅只有+可以重载，常见的运算符+-*/%等都可以重载。此外还有一些特殊的运算符，在下面我们会依次讲解
++自增运算符重载
自增运算符分为后置自增和前置自增。
后置自增
通常来讲，后置自增是，返回自增前的数据，然后将自身数据自增。为了实现该效果，我们通常会设置临时变量储存自增之前的值，然后将自身数据自增。
A operator++()
{
A tmp = *this;
(this->a)++;
(this->b)++;
return tmp;
}前置自增
前置自增，会将自增后的值返回。但是为了对同名函数进行重载，我们规定在后置自增时参数列表增加一个整型占位(匿名变量，无法使用，但是为重载的条件提供了便利)。而且，只能是整型，像double什么的，其它数据类型都不行。
A& operator++()
{
(this->a)++;
(this->b)++;
return *this;
}
==关系运算符重载
了解过上面运算符的重载之后，我们分析完功能后直接给大家看一下条件运算符的重载。
==就是判断左右两边的数据是否相等
bool operator==(A& other)
{
return (this->a == other.a && this->b == other.b);
}=赋值运算符重载
赋值运算符是为了将自定义的类类型赋给同类或不同类的类型。
同类赋值
class A{
public:
int a;
A operatpor=(A& other){
this->a=other.a;
return *this;
}
};异类赋值
就相当于int赋给double
class B{
public:
int b;
};
class A{
public:
int a;
A operator=(B& other){
this->a=other.b;
return *this;
}
};
<<左移运算符重载
我们的左移运算符可以用来重载输出。（即目的：输出自定义类型的数据）
那我们按照之前的方式来进行重载：
void operator<<(ostream& cout){
cout<< this->a << " " << this->b;
}
调用方式：
A ma;
ma.operator<<(std::cout);
简化版本：
ma << std::cout;
很明显，输出的方式不对。我们想要的是cout<<ma;
那么我们尝试将运算符重载函数单独写出去，利用友元的技术来将运算符重载函数绑定到类上。
请看VCR:
class Person{
friend void operator<<(ostream& out,Person& p);
public:
string name;
int age;
};
void operator<<(ostream& out,Person& p){
out<<p.name<<" "<<p.age;
}此时看我们能不能输出;
实验证明，可以的。我们再来做个实验：
cout << p << p <<endl;
怎么回事呢，让我们来看：
cout << *p是operator(cout,*p)的缩写，对于这个函数返回值是void，那么void << endl是怎么个事呢？显然不行。那怎么解决呢？不要着急，我们有链式编程技巧：
将函数返回值设为引用类型：
对于上述问题，这样写的话就是：
cout输出完person后，又返回了cout本身，也就是 operator<<(operator<<(cout,p),p);这个函数的返回值还是ostream类型的cout，此时cout << endl，就是普通的输出换行。从而使我们的问题得到了合理的实现。
注意点：
1.重载符滥用：重载加法运算符，内部实现是减法操作，这就是滥用。（滥用给人一种逻辑混乱的感觉，写出来迷惑人可以）
2.链式编程：对于返回值是否是引用类型需要特别注意
3.占位参数：自增运算符的前置后置时特别注意
初识:封装特性
封装的意义
1.将属性和行为作为一个整体，表现生活中的事物；
2.将属性和行为加以权限控制 (先看目录->访问权限修饰符->定义时的修饰符)
语法：class 类名{访问权限：属性/行为};
#include <iostream>
#include <string>
using namespace std;
class People {//class：定义类的关键字People为类名
private:
string name;
int age;
public:
void setMsg() {
cin >> name >> age;
}
void work();
};
void People::work() {
cout << age << "岁的" << name << "仍在工作" << endl;
}
int main() {
People peo;
peo.setMsg();
peo.work();
return 0;
}
成员属性设置为私有：
优点1.将所有成员属性设置为私有，可以自己控制读写权限。
优点2.对于写权限，我们可以检测数据的有效性。
区别struct与class
在C++中struct 和class的唯一区别就在于默认的访问权限和默认的继承权限不同
struct：默认权限公共的public
class：默认权限私有的private
class A{
int m_A;//缺省修饰符为默认权限private
};
struct B{
int m_B;//缺省修饰符为默认权限public
};
int main(){
A a;
a.m_A=10;//error,错误，访问权限为私有，不可通过对象访问成员
B b;
b.m_B=10;//bingo,正确，访问权限为公共，可以通过对象访问成员
return 0;
}本节我们主要讲了运算符的重载和封装的意义。感谢大家！
