操作符重载 | 摹本易写 而墨香不退与你同留余味
Cobb 538 0

知识储备

注意事项: 链表的构造函数,节点初始化也需要构造,这是C++的写法

报错: 写少量代码,出大量错误 // 1、没有包含头文件 // 2、没有做 运算符重载函数

func().对象 错误 对象.func() 正确

C++ 运算符重载:让对象的运算表现的和内置类型一样 int 运算符重载函数: 1.在类体内提供运算符重载函数 2.在全局提供运算符重载函数 注意: 1.函数调用,实参传递对象,形参按引用来接收 2.函数return的内容,出了函数还在,优先返回引用;如果return的内容在函数的栈上,只能返回值,不能返回引用

后置++ : operator++(int) 前置++ : operator++()

class Student
{
private:
    char name_[20];
    int age_;
    char sex_[20];
};
Student s1, s2;
s1 = s2; // 默认做内存拷贝
s1 > s2; s1.operator>(s2)  // name   
operator>
 return strcmp(this->name, src.name);

s1 - s2;


#include <iostream>
using namespace std;

// 复数类  实部 和 虚部
class CComplex
{
public:
    // CComplex c; CComplex c(10);  CComplex c(10, 20)
    // 参数带默认值的拷贝构造函数   三种对象的构造
    CComplex(int r = 0, int i = 0)
    {
        this->real_ = r;
        this->image_ = i;
    }

    // 析构函数
    ~CComplex()
    {
    }

    // 拷贝构造函数
    CComplex(const CComplex& src)
    {
        this->real_ = src.real_;
        this->image_ = src.image_;
    }

    // 赋值函数
    CComplex& operator=(const CComplex& src)
    {
        if (this == &src)
            return *this;

        this->real_ = src.real_;
        this->image_ = src.image_;
        return *this;
    }

    // +=运算符的重载函数
    // src引用的对象的real和image,加到this指针指向的当前对象的real和image上
    // comp4.+=(comp1)
    void operator+=(const CComplex& src)
    {
        this->real_ += src.real_;
        this->image_ += src.image_;
    }

    void operator-=(const CComplex& src)
    {
        this->real_ -= src.real_;
        this->image_ -= src.image_;
    }

    // 后置++操作
    CComplex operator++(int)
    {
        /*CComplex tmp(this->real_, this->image_);
        this->real_++;
        this->image_++;
        return tmp;*/
        return CComplex(this->real_++, this->image_++);
    }
    // 前置++操作
    CComplex& operator++()
    {
        this->real_++;
        this->image_++;
        return *this;
    }

    void Show()
    {
        cout << "real:" << this->real_ << " image:" << this->image_ << endl;
    }
    /*
    方法一:
    外部无法直接访问对象的private成员,可以提供相应的public方法,
    返回private成员变量的值
    int GetReal() { return real_; }
    int GetImage() { return image_; }*/
private:
    int real_;
    int image_;

    // 方法二:定义友元函数
    friend ostream& operator<<(ostream& out, const CComplex& src);
    friend istream& operator>>(istream& in, CComplex& src);
};




// 全局的operator<<重载函数  告诉编译器怎么输出一个CComplex对象的
ostream& operator<<(ostream& out, const CComplex& src)
{
    out << "real:" << src.real_ << " image:" << src.image_;
    return out;
}

istream& operator>>(istream& in, CComplex& src)
{
    cout << "real:";
    in >> src.real_;
    cout << "image:";
    in >> src.image_;
    return in;
}




int main()
{
    CComplex comp1(10, 10);
    CComplex comp2(20, 20);

    CComplex comp3 = comp1; // CComplex comp4(comp1);
    comp2 = comp3;

    // 编译器优化 临时对象拷贝构造新对象,临时对象的生成就被优化掉了
    // 临时对象不再生成,直接构造新对象就可以了
    // CComplex comp4(30, 30);
    CComplex comp4 = CComplex(30, 30);

    // 实际上是一个函数的调用,左边对象调用+=函数,右边的对象作为参数传递进去
    // comp4.+=(comp1)
    // void operator+=(const CComplex &src)
    comp4.Show();
    comp4 += comp1;
    comp4.Show();

    // comp4.operator-=(comp1)
    // void operator-=(const CComplex &src)
    comp4 -= comp1;
    comp4.Show();

    cout << "------------------------" << endl;
    //      comp4.operator++(int)
    comp1 = comp4++;
    //comp1.Show();
    //comp4.Show();
    cout << comp1 << endl;
    cout << comp4 << endl;

    //      comp4.operator++()
    comp1 = ++comp4;
    //comp1.Show();
    //comp4.Show();

    // cout ::operator<<(cout, comp1)
    // ostream operator<<(ostream &out, const CComplex &src)
    // ::operator<<(cout, comp1) => cout
    // cout << endl;
    cout << comp1 << endl;
    cout << comp4 << endl;

    // ::operator>>(cin, comp4)
    // istream& operator>>(istream &in, CComplex &src)
    cin >> comp4;  // real:  image:
    cout << comp4 << endl;
}
评论区