Operator Overloading on Cassius0924 的博客

C++ 类的运算符为什么要使用引用返回

Tue, 25 Jun 2024 22:41:04 +0800

代码

class AClass {
private:
    int _count;

public:
    AClass() : _count(0) {
        std::cout << "Default constructor called\n";
    }

    // 赋值运算符，返回引用
    AClass &operator=(int cnt) {
        _count = cnt;k
        return *this;
    }

    // 后置自增运算符，返回引用
    int &operator++(int) {
        ++_count;
        return *this;
    }
};

如果不使用引用返回，其实也是可以运行的，只不过会在返回时调用拷贝构造函数，生成临时对象，然后再调用析构函数释放临时对象，这样会多出一次拷贝构造和析构的开销。而使用引用返回，可以直接返回对象的引用，避免了这个开销。

需要注意的是，如果我们返回值类型，我们是不能直接修改返回值的：

class AClass {
private:
    int _count;

public:
    // 省略构造函数
    // 赋值运算符，返回引用
    AClass operator=(int cnt) {
        _count = cnt;
        return *this;
    }

    // 后置自增运算符，返回引用
    int operator++(int) {
        ++_count;
        return *this;
    }

    void print() const {
        std::cout << "AClass: count = " << _count << '\n';
    }
};
int main() {
    AClass a;
    a.print();  // 输出 AClass: count = 0
    (a++) = 10;
    a.print();  // 输出 AClass: count = 1
    (a++)++;
    a.print();  // 输出 AClass: count = 2
}

可以看到，如果我们返回值类型，我们是不能直接修改返回值的。虽然 a++ 已经修改了 a 的值，但是 a++ 返回的是一个修改后的 a 对象的拷贝，所以 (a++) = 10; 或者 (a++)++; 修改的是这个拷贝对象，而不是原对象 a。

C++ 类的流插入和流提取运算符为什么要声明为友元函数

Tue, 25 Jun 2024 21:35:40 +0800

友元函数版代码

class AClass {
private:
    int _count;
    std::string _str;
    std::vector<int> _vec;

public:
    friend std::ostream &operator<<(std::ostream &os, const AClass &a) {
        os << "AClass: count = " << a._count << ", str = " << a._str << ", vec size = " << a._vec.size();
        return os;
    }
};

为什么要声明为友元函数

先理解一下友元函数，它实际上是一个普通函数，不属于类成员，但它又是一个特殊的普通函数，因为它可以访问类的私有成员。因此 operator<< 和 operator>> 声明为友元函数的目的很明显，就是为了能够访问类的私有成员。

实际上，如果它们不声明为友元函数，也是可以实现的，例如下面代码：

class AClass {
private:
    int _count;
    std::string _str;
    std::vector<int> _vec;

public:
    std::ostream &operator<<(std::ostream &os) {
        os << "AClass: count = " << _count << ", str = " << _str << ", vec size = " << _vec.size();
        return os;
    }
};

但是这样就需要特殊的方法来调用这个 operator<< 函数，因为它不再是一个普通函数，而是一个类成员函数：

int main() {
    AClass a;
    a << std::cout;    // 错误，不能这样调用
    a.operator<<(std::cout);    // 正确
    return 0;
}

这样显然不够直观，不是一个正常人类写的代码：）

所以，为了代码的可读性和可维护性，我们将 operator<< 和 operator>> 声明为友元函数，这样就可以直接使用 << 和 >> 运算符来操作类的对象了。