C++入门day3-面向对象编程（中）

 前言：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++(int)
	{
		(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;
}

---

本节我们主要讲了运算符的重载和封装的意义。感谢大家！