C++深入探究类与对象之友元与运算符重载

友元（friend）是 C++ 中比较特殊的概念，它可以使一个类中的非成员函数访问类的私有成员，非常适合于一些特殊的应用场景。本文将深入讲解 C++ 中友元的使用方法并结合示例进行说明。

友元的概念

在 C++ 中，我们可以使用关键字 friend 定义友元，其作用是允许其他类或者函数访问该类的私有成员。简而言之，友元关系特指的是在某类内部所定义的非成员函数以及其他类，与该类对象有特殊的访问权限。

友元的使用方法

我们可以将友元函数作为该类的友元，也可以将其他类作为该类的友元。为了使用友元，需要遵守以下两点：

1. 友元函数的声明必须放在目标类（被授权）的定义内部。
2. 友元类的声明必须放在目标类（被授权）的定义内部，而其定义可以在任意位置。

具体使用方法如下：

1. 友元函数的使用方法

class A {
    friend void B(A&);  // 在类内声明B为友元函数
    ...
};
void B(A &a){ ... }    // 友元函数B的定义

1. 友元类的使用方法

class A {
    friend class B;  // 在类内声明B为友元类
    ...
};
class B {
    ...
};    // 注意：B类的定义可以在定义A类之后

运算符重载

运算符重载是 C++ 独有的一种特性，它允许我们对 C++ 已经定义好的运算符进行重新定义。我们可以为任意数据类型定义自己的运算符行为，使其支持加减乘除等各种运算。

为了实现这个特性，我们需要为自定义类型定义运算符重载函数，将要重载的运算符作为函数名，同时使用 operator 作为前缀，示例如下：

class Vector {
public:
    ...
    Vector operator + (const Vector &rhs) const;  // 定义加法运算符
    ...
};

以上定义重载了 + 运算符，使得 Vector 类型支持加法运算。运算符重载函数可以被设计为类的成员函数，也可以是非成员函数，其中成员函数一般用于比较两个类的对象，非成员函数一般用于实现新的类型或实现更高效的算法。具体示例如下：

class MyInt {
public:
    ...
    MyInt operator + (const MyInt &rhs) const;  // 作为类成员函数
};
MyInt operator + (const MyInt& lhs, const MyInt& rhs) {  // 作为非成员函数
    return MyInt(lhs.m_value + rhs.m_value);
}

示例说明

友元示例

以下示例定义了一个 Point 类，其中包含 x 和 y 坐标，同时包含了一个私有的构造函数 Point(int, int) 和一个友元函数 distance(const Point&, const Point&)。

class Point {
public:
    Point(int x = 0, int y = 0) : m_x(x), m_y(y) {}
    friend double distance(const Point& p1, const Point& p2);
private:
    int m_x, m_y;
};
double distance(const Point& p1, const Point& p2) {
    int dx = p1.m_x - p2.m_x;
    int dy = p1.m_y - p2.m_y;
    return sqrt(dx * dx + dy * dy);
}

int main() {
    Point p1(1, 2);
    Point p2(3, 4);
    cout << distance(p1, p2) << endl;  // 输出距离为2.82843
    return 0;
}

本示例中，我们定义了一个 distance 函数，该函数通过使用友元关系，实现了访问 Point 类的私有成员。在主函数中，我们通过调用该函数计算了两个 Point 对象之间的距离并输出。

运算符重载示例

以下示例定义了一个 MyString 类，并对加法运算符进行了重载。

class MyString {
public:
    MyString(const char* str) {
        m_data = new char[strlen(str) + 1];
        strcpy(m_data, str);
    }
    MyString operator + (const MyString &rhs) const {
        char* new_data = new char[strlen(m_data) + strlen(rhs.m_data) + 1];
        strcpy(new_data, m_data);
        strcat(new_data, rhs.m_data);
        return MyString(new_data);
    }
    char* get_data() const { return m_data; }
private:
    char* m_data;
};

int main() {
    MyString s1("Hello ");
    MyString s2("world!");
    MyString s3 = s1 + s2;
    cout << s3.get_data() << endl;  // 输出结果为"Hello world!"
    return 0;
}

以上示例中，我们定义了一个 MyString 类，它包含一个 char* 类型的指针用来保存字符串数据。我们在该类中定义了加法运算符 + 的重载函数，实现了两个 MyString 对象的字符串相加。在主函数中，我们实例化了两个 MyString 对象，并通过重载的加法运算符把它们相加，最终输出结果为 "Hello world!"，验证了重载函数的正确性。