运算符重载

在c++中运算符重载通过两种方式：1.友元函数的方式 2.成员函数的方式

五种运算符不可以重载 点运算符. 域名解析符：： 点星运算符.* 三目运算符：？ 求大小运算符sizeof

不能使用成员重载的运算符>>  <<

不能通过友元的方式重载的运算符 赋值运算符= 括号运算符（）下标运算符 [] 箭头运算符->

双目运算符推荐使用友元 单目运算符 推荐使用成员

友元函数是单项传递的 A是B的友元类 在B中不申明 ，B不是A的友元类 A是B的友元类 B是C的友元类 A不一定是C的友元类 需要在C中申明

友元方法和成员方法的区别是 友元方法不能使用this调用成员变量而成员方法可以调用this

#pragma once
#include<iostream>
using namespace std;
class A
{
    int data;
    static int x;
    int arr[10];
public:
    A(int data = 0);//构造函数，可缺省
    A(const A&other);//调用拷贝构造
    ~A();
    int getData();
    void setData(int data);
    friend int addA(const A&a, const A&b);//在申明的时候使用友元在类外定义 
    friend A operator+(const A&a, const A&b);//通过友元 运算符加法重载

    A operator-(const A&b);//通过成员的方法重载减号运算符通过this
    A operator-()//重载负号运算符
    {
        A C;
        C.data = -this->data;
        return 0;
    }

    A& operator++(){//前加加运算符 通过返回值修改这个对象
        ++this->data;
        return *this;//返回当前对象
    }
    A operator++(int)//区分于前++ 里面放一个参数表示后++
    {
        A c(this->data);//c保存A的数据
        ++this -> data;//data自增
        return c;//c返回之前保存的数据
    }
    //重载输出输入运算符 
    friend ostream& operator<<(ostream& os,const A& a)//引用a防止被修改加上const
    {
        os << a.data;
        return os;
    }
    friend istream& operator>>(istream& is, A& a)//不加const表可以修改a的值，a的值为键盘输入的值
    {
        is >> a.data;
        return is;
    }
    int& operator*()        //重载解引用运算符
    {
        return *arr;
    }
    int& operator[](int index)    //重载下标运算符
    {
        return arr[index];
    }

    operator bool()    //强转bool类型   没有返回值类型
    {
        return arr[0] == 0;//函数体按照自己的需求写就行 
    }
    friend A operator*(const A& a, const A& b)//使用友元方法对乘法运算符重载
{
    A c;
    c.data = a.data * b.data;
    return c;
}
};

头文件中通过类A申明需要使用的重载运算符

#include "A.h"


A::A(int data)
{
    this->data = data;//将形参值给类中私有变量使用
}
A::A(const A&other)
{
    data = other.data;//调用不可修改的other给类内赋值
}


A::~A()
{
}
int A::getData()    //get方法
{
    return data;
}

void A::setData(int data)//set方法
{
    this->data = data;
}
int addA(const A& a, const A& b)
{
    return a.data + b.data;//通过对象访问私有成员返回私有成员 类似于两个对象相加 引入加发运算符的重载
}

A operator+(const A& a, const A& b)//使用友元方法对加法运算符重载
{
    A c;
    c.data = a.data + b.data;
    return c;
}
A A::operator-(const A&b)//利用成员方法 对运输符进行重载
{
    A c;
    c.data = this->data - b.data;
    return c;
}

在A.cpp文件中在类外定义需要使用到的函数以及重载运算符

#include<iostream>
#include"A.h"
#include<string>//存放字符串
int main()
{

    A a(3);    //调用普通构造
    A b = a;//调用拷贝构造    隐式调用
    A c(b); //调用拷贝构造    显式调用
    

    //得到a和b的data 相加之后 交给新的变量 
    c;//c的值是a中的值和b中的值的相加
    c.setData(a.getData() + b.getData());//如果需要经常使用到私有成员
    //利用set方法将a中的值和b中的值相加
    c.setData(addA(a, b));    //a+b两个类相加

    c = a - b;            //使用的时候直接用运算符此处的运算符是重载减号运算符
    c = a.operator-(b);    //不用函数调用的形式
    
    c++;//重载后++运算符
    ++c;//重载前++运算符
    c = a*b;    //尝试重载* 运算符
    cout <<"a+b的结果是"<< c.getData() << endl;
    cout << c << endl;
    cout << "输入一个data" << endl;
    cin >> c;

    cout << "输入的结果是" << c << endl;
    //运算符和函数

    A d;
    *d=1;//  d.arr[0]
    d[0] = 1;
    d[2] = 0;

    (int)3.14;//  前面是类型  后面值 这样进行强转
    
    if (d)//此时d是布尔值 可以直接放置判断是否执行
    {

    }
    cin.get();
    return 0;
}