C++运算符重载

2021-04-13

C++运算符重载，主要需要注意流运算符一般是通过友元函数来实现重载，这是因为如果通过成员函数重载，那么对象是在<<或>>的左边，不仅很奇怪，而且无法实现连续调用形式。

运算符重载

不能重载的运算符

. .* :: ?: sizeof

只能作为类成员函数重载

() [] -> =

构造一个类

class Book{
    public:
        Book();
        ~Book();
    private:
        int price;
        int num;
}

下标的重载

class Book{
public:
    Book() : price(0), num(0) {
        memset(author, 0, sizeof(int)*maxSize);
    };
    Book(const Book& book);
    Book& operator = (const Book& book);
    ~Book() {};

    //只能使用成员函数实现
    int operator [](size_t i) const;

private:
    int price;
    int num;
    int author[5];
    int maxSize = 5;
};

int Book::operator[](size_t i) const {
    if(i>=maxSize)
        throw "Index out of range!";
    return author[i];
}

流运算符重载

流运算符只能重载为普通函数，不能重载为成员函数，重载为成员函数需要<<或者>>左侧的对象是我们定义的对象，这样就造成了Object<<cin或者Object>>cout的使用，与常规调用方法不符合，因此一般只重载为普通函数。
重载为一般函数时如果要访问private成员则需要定义为类的友元。

上述的Book类进行流运算符重载

class Book{
public:
    Book() : price(0), num(0) {};
    ~Book() {};
    // 友元函数声明时需要添加friend关键词
    friend ostream& operator <<(ostream& os, const Book& book);
    friend istream& operator >>(istream& is, Book& book);
private:
    int price;
    int num;
};

// 进行友元函数的定义时不需要添加friend，否则会报错
ostream& operator <<(ostream& os, const Book& book){
    os<<"Book price: "<<book.price<<" num: "<<book.num<<endl;
    return os;
}
istream& operator >>(istream& is, Book& book){
    is>>book.price>>book.num;
    return is;
}

单目运算符重载

自增运算符/自减运算符分别重载为类成员函数和普通函数

两种形式都能定义，但是类成员和普通成员函数只能定义一种，否则调用时含义不明

同时能发现对于后置运算符，需要定义拷贝构造函数和拷贝赋值运算符

#include <iostream>
using namespace std;
class Book{
public:
    Book() : price(0), num(0) {};
    Book(const Book& book);
    Book& operator = (const Book& book);
    ~Book() {};

//    Book& operator ++ (); // 前置 允许++++a
//    const Book operator ++ (int n); // 后置 不允许a++++
//    Book& operator --(); // 前置 允许----a
//    const Book operator --(int n); // 后置 不允许a----

    friend Book& operator ++(Book& book);
    friend const Book operator ++(Book& book, int n);

    friend Book& operator --(Book& book);
    friend const Book operator --(Book& book, int n);

    friend ostream& operator <<(ostream& os, const Book& book);
    friend istream& operator >>(istream& is, Book& book);
private:
    int price;
    int num;
};

// 拷贝运算的定义
Book::Book(const Book& book){
    price = book.price;
    num = book.num;
}

Book& Book::operator = (const Book& rhs){
    // 按道理不能运行
    price = rhs.price;
    num = rhs.num;
    return *this;
}

//Book& Book::operator ++(){
//    ++price;
//    ++num;
//    return *this;
//}
//
//// 从这里看出是需要定义拷贝复制运算符的
//const Book Book::operator ++(int n){
//    Book old = *this;
//    ++price;
//    ++num;
//    return old;
//}
//
//Book& Book::operator --(){
//    --price;
//    --num;
//    return *this;
//}
//
//const Book Book::operator--(int n){
//    Book old=*this;
//    --price;
//    --num;
//    return old;
//}

// 友元函数的实现 友元函数就没有域作用符号了，不是类成员
Book& operator ++(Book& book) {
    ++book.price;
    ++book.num;
    return book;
}

const Book operator ++(Book& book, int n) {
    Book old = book;
    ++book.price;
    ++book.num;
    return old;
}

Book& operator --(Book& book) {
    --book.price;
    --book.num;
    return book;
}

const Book operator --(Book& book, int n) {
    Book old = book;
    --book.price;
    --book.num;
    return old;
}

// 进行普通函数的自增、自减的重载 需要定义为友元

ostream& operator <<(ostream& os, const Book& book){
    os<<"Book price: "<<book.price<<" num: "<<book.num;
    return os;
}
istream& operator >>(istream& is, Book& book){
    is>>book.price>>book.num;
    return is;
}

双目运算符重载

同时实现成员函数和友元函数，会优先调用成员函数

class Book{
public:
    Book() : price(0), num(0) {
        memset(author, 0, sizeof(int)*maxSize);
    };
    Book(int price, int num): price(price), num(num) {};
    Book(const Book& book);
    Book& operator = (const Book& rhs);
    // 一般加号返回右值 会优先调用成员函数
    const Book operator + (const Book& rhs);
    // 使用友元函数实现
    friend const Book operator + (const Book& lhs, const Book& rhs);
    ~Book() {};

    friend ostream& operator << (ostream& os ,const Book& rhs);

private:
    int price;
    int num;
    int author[5];
    int maxSize = 5;
};

// 拷贝运算的定义
Book::Book(const Book& book){
    price = book.price;
    num = book.num;
}

Book& Book::operator = (const Book& rhs){
    // 按道理不能运行
    price = rhs.price;
    num = rhs.num;
    return *this;
}

const Book Book::operator+(const Book &rhs) {
    Book book(price+rhs.price, num+rhs.num);
    cout << "member function " << endl;
    return book;
}

const Book operator + (const Book& lhs, const Book& rhs) {
    cout << "friend function " << endl;
    return Book(lhs.price+rhs.price, lhs.num+rhs.num);
}

ostream& operator << (ostream& os, const Book& rhs){
    os << "Book price: " << rhs.price << " " << " num: " << rhs.num;
    return os;
}