友元

友元(friend)是C++中的一种特殊机制，它允许一个类将对其非公有成员(private和protected)的访问权授予指定的函数或类。友元打破了类的封装性，但提供了更高的灵活性和运行效率。

友元分为三种类型：

1. 友元函数

2. 友元类

3. 友元成员函数

友元函数

友元函数是定义在类外部，但有权访问类的所有私有(private)成员和保护(protected)成员的非成员函数。

在类中声明友元函数的语法如下：

​x
1
class ClassName {
2
    // 可以在任何访问修饰符下声明
3
    friend 返回类型 函数名(参数列表);
4
};
5

6
// 类外定义友元函数（不需要friend关键字）
7
返回类型 函数名(参数列表) {
8
    // 函数体
9
}

xxxxxxxxxx
33
1
#include <iostream>
2
#include <cmath>
3
using namespace std;
4

5
class Point {
6
private:
7
    double x, y;
8

9
public:
10
    Point(double xx, double yy) { x = xx; y = yy; }
11
    void Getxy() {
12
        cout << "(" << x << "," << y << ")" << endl;
13
    }
14
    
15
    // 声明友元函数
16
    friend double Distance(Point &a, Point &b);
17
};
18

19
// 定义友元函数
20
double Distance(Point &a, Point &b) {
21
    double dx = a.x - b.x; // 可以直接访问私有成员
22
    double dy = a.y - b.y;
23
    return sqrt(dx*dx + dy*dy);
24
}
25

26
int main() {
27
    Point p1(3.0, 4.0), p2(6.0, 8.0);
28
    p1.Getxy();
29
    p2.Getxy();
30
    double d = Distance(p1, p2); // 调用友元函数
31
    cout << "Distance is " << d << endl;
32
    return 0;
33
}

友元类

友元类是指一个类可以访问另一个类的所有成员（包括私有成员和保护成员）的类。当一个类被声明为另一个类的友元时，这个类的所有成员函数都成为另一个类的友元函数。

xxxxxxxxxx
15
1
class ClassA {
2
    // 声明ClassB为友元类
3
    friend class ClassB;
4

5
private:
6
    int data;
7
};
8

9
class ClassB {
10
public:
11
    void func(ClassA &a) {
12
        // 可以访问ClassA的私有成员
13
        a.data = 100;
14
    }
15
};

xxxxxxxxxx
32
1
#include <iostream>
2
using namespace std;
3

4
class CCar; // 前向声明
5

6
class CDriver {
7
public:
8
    void ModifyCar(CCar *pCar); // 改装汽车
9
};
10

11
class CCar {
12
private:
13
    int price;
14
    
15
    // 声明CDriver为友元类
16
    friend class CDriver;
17
};
18

19
void CDriver::ModifyCar(CCar *pCar) {
20
    pCar->price += 1000; // 可以访问CCar的私有成员
21
    cout << "Car price after modification: " << pCar->price << endl;
22
}
23

24
int main() {
25
    CCar car;
26
    CDriver driver;
27
    
28
    // 通过友元类访问私有成员
29
    driver.ModifyCar(&car);
30
    
31
    return 0;
32
}

友元成员函数

友元成员函数是指将一个类的某个成员函数声明为另一个类的友元，使该成员函数可以访问另一个类的私有成员。

xxxxxxxxxx
33
1
#include <iostream>
2
using namespace std;
3

4
class A; // 前向声明
5

6
class B {
7
public:
8
    void set_show(int x, A &a); // 该函数将成为类A的友元函数
9
};
10

11
class A {
12
public:
13
    // 声明B类的set_show方法为友元
14
    friend void B::set_show(int x, A &a);
15
    
16
private:
17
    int data;
18
};
19

20
// 定义B类的set_show方法
21
void B::set_show(int x, A &a) {
22
    a.data = x; // 可以访问A的私有成员
23
    cout << "A's data: " << a.data << endl;
24
}
25

26
int main() {
27
    A a;
28
    B b;
29
    
30
    b.set_show(100, a);
31
    
32
    return 0;
33
}

友元的使用场景

1. 运算符重载

当需要重载某些运算符（如<<、>>等）时，这些运算符通常需要访问类的私有成员，此时可以将它们声明为友元函数。

xxxxxxxxxx
16
1
class Complex {
2
private:
3
    double real, imag;
4
    
5
public:
6
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
7
    
8
    // 声明重载的<<运算符为友元
9
    friend ostream& operator<<(ostream& os, const Complex& c);
10
};
11

12
// 重载<<运算符
13
ostream& operator<<(ostream& os, const Complex& c) {
14
    os << c.real << "+" << c.imag << "i"; // 访问私有成员
15
    return os;
16
}

2. 需要访问多个类的私有成员

当一个函数需要同时访问多个类的私有成员时，可以将该函数声明为这些类的友元。

3. 提高性能

在某些情况下，特别是在对某些成员函数多次调用时，由于参数传递、类型检查和安全性检查等都需要时间开销，使用友元可以提高程序的运行效率。

4. 辅助类和工具类

当设计辅助类或工具类来操作主类的内部数据时，可以将辅助类声明为主类的友元。

友元的特性

1. 友元关系不能被继承：如果类B是类A的友元，类C继承自类B，类C不会自动成为类A的友元。

2. 友元关系是单向的：如果类B是类A的友元，类A不一定是类B的友元，除非有明确声明。

3. 友元关系不具有传递性：如果类B是类A的友元，类C是类B的友元，类C不会自动成为类A的友元。

4. 友元声明位置：友元声明可以出现在类中的任何地方（private、protected或public部分），不受访问控制影响。

优点

1. 提高程序运行效率：减少了类型检查和安全性检查等时间开销。

2. 增加灵活性：使程序可以在封装和快速性方面做合理选择。

3. 便于实现需要访问多个类私有成员的功能：可以灵活地实现需要访问若干类的私有或受保护成员才能完成的任务。

4. 便于与非面向对象语言混合编程：便于与其他不支持类概念的语言(如C语言、汇编等)进行混合编程。

缺点

1. 破坏封装性：友元机制破坏了类的封装性和数据隐藏性，使得非成员函数可以访问类的私有成员。

2. 降低可维护性：过度使用友元会使代码结构变得复杂，难以维护。

3. 增加耦合性：友元增加了类之间的耦合度，不利于代码的模块化。

运算符重载

+运算符重载

加号(+)是一个典型的双目运算符，需要两个操作数：一个在加号前，一个在加号后。在C++中，我们可以通过两种方式实现+运算符的重载：

1. 类成员函数方式

2. 全局函数方式

通过类成员函数实现+运算符重载

当使用类成员函数实现+运算符重载时，函数原型如下：

xxxxxxxxxx
1
1
Class_Name operator+(const Class_Name& other);

这种方式下，左操作数是调用该成员函数的对象(this)，右操作数作为参数传入。

xxxxxxxxxx
32
1
#include <iostream>
2
using namespace std;
3

4
class Person {
5
public:
6
    Person();
7
    Person(int val);
8
    Person operator+(const Person& p); // 运算符重载函数声明
9
private:
10
    int m_age;
11
};
12

13
int main() {
14
    Person p1;
15
    Person p2;
16
    Person p3 = p1 + p2; // 重载后的效果
17
    return 0;
18
}
19

20
Person::Person() :m_age(10) {
21
    cout << "无参构造函数" << endl;
22
}
23

24
Person::Person(int val) : m_age(val) {
25
    cout << "有参构造函数" << endl;
26
}
27

28
Person Person::operator+(const Person& p) { // 运算符重载实现
29
    Person tmp;
30
    tmp.m_age = this->m_age + p.m_age;
31
    return tmp;
32
}

在上面的例子中，执行p1 + p2时，实际上调用的是p1.operator+(p2)，返回一个新的Person对象，其m_age值为p1和p2的m_age之和。

通过全局函数实现+运算符重载

全局函数方式的运算符重载函数原型如下：

xxxxxxxxxx
1
1
Class_Name operator+(const Class_Name& left, const Class_Name& right);

这种方式下，左右操作数都作为参数传入函数。

xxxxxxxxxx
25
1
#include <iostream>
2
using namespace std;
3

4
class xiMeng {
5
public:
6
    int M_A;
7
    int M_B;
8
    // 这里不使用成员函数重载
9
};
10

11
// 通过全局函数实现运算符重载
12
xiMeng operator+(xiMeng& p1, xiMeng& p2) {
13
    xiMeng temp;
14
    temp.M_A = p1.M_A + p2.M_A;
15
    temp.M_B = p1.M_B + p2.M_B;
16
    return temp;
17
}
18

19
// 运算符重载也可以发生函数重载
20
xiMeng operator+(xiMeng& p, int num) {
21
    xiMeng temp;
22
    temp.M_A = p.M_A + num;
23
    temp.M_B = p.M_B + num;
24
    return temp;
25
}

我将搜索关于C++中+=运算符重载的相关信息，以便提供详细的解释和示例代码。

toolName: web_search
status: success
query: C++ += 运算符重载 示例

+=运算符重载

重载+=运算符的基本语法是：

xxxxxxxxxx
1
1
returnType operator+=(const ParameterType& param);

作为类成员函数

作为成员函数重载+=运算符时，左操作数隐式地是当前对象（this指针），右操作数作为参数传入。

xxxxxxxxxx
23
1
class MyClass {
2
private:
3
    int value;
4

5
public:
6
    MyClass(int val) : value(val) {}
7
    
8
    // 重载 += 运算符作为成员函数
9
    MyClass& operator+=(const MyClass& other) {
10
        this->value += other.value;
11
        return *this;
12
    }
13
    
14
    // 也可以重载不同类型的参数
15
    MyClass& operator+=(int num) {
16
        this->value += num;
17
        return *this;
18
    }
19
    
20
    int getValue() const {
21
        return value;
22
    }
23
};

作为友元函数

虽然+=运算符通常作为成员函数实现，但在某些情况下也可以作为友元函数实现：

xxxxxxxxxx
19
1
class MyClass {
2
private:
3
    int value;
4

5
public:
6
    MyClass(int val) : value(val) {}
7
    
8
    friend MyClass& operator+=(MyClass& left, const MyClass& right);
9
    
10
    int getValue() const {
11
        return value;
12
    }
13
};
14

15
// 作为友元函数实现 += 运算符
16
MyClass& operator+=(MyClass& left, const MyClass& right) {
17
    left.value += right.value;
18
    return left;
19
}

xxxxxxxxxx
42
1
#include <iostream>
2
using namespace std;
3

4
class Complex {
5
private:
6
    double real;
7
    double imag;
8

9
public:
10
    Complex(double r = 0, double i = 0) : real(r), imag(i) {}
11
    
12
    // 重载 += 运算符
13
    Complex& operator+=(const Complex& other) {
14
        this->real += other.real;
15
        this->imag += other.imag;
16
        return *this;
17
    }
18
    
19
    // 显示复数
20
    void display() const {
21
        cout << real << " + " << imag << "i" << endl;
22
    }
23
};
24

25
int main() {
26
    Complex c1(3.0, 4.0);
27
    Complex c2(1.5, 2.5);
28
    
29
    cout << "c1 = ";
30
    c1.display();
31
    
32
    cout << "c2 = ";
33
    c2.display();
34
    
35
    // 使用重载的 += 运算符
36
    c1 += c2;
37
    
38
    cout << "c1 += c2 的结果: ";
39
    c1.display();
40
    
41
    return 0;
42
}

运行结果：

xxxxxxxxxx
3
1
c1 = 3 + 4i
2
c2 = 1.5 + 2.5i
3
c1 += c2 的结果: 4.5 + 6.5i         

++运算符重载

++运算符有两种形式：前置++（如++a）和后置++（如a++）。这两种形式在行为和实现上有明显区别。

1. 前置++：先增加变量的值，然后返回增加后的变量

2. 后置++：先返回变量的当前值，然后再增加变量的值

C++通过函数参数来区分前置和后置++运算符重载

• 前置++：T& operator++()，返回对象的引用（T&），这样可以支持连续操作，如++(++a)

• 后置++：T operator++(int) - 这里的int参数是一个哑参数，仅用于区分后置版本，返回对象的值（T），通常是修改前的对象副本

xxxxxxxxxx
57
1
#include <iostream>
2
using namespace std;
3

4
class Age {
5
private:
6
    int years;
7

8
public:
9
    // 构造函数
10
    Age(int age = 0) : years(age) {}
11
    
12
    // 前置++运算符重载
13
    Age& operator++() {
14
        // 先增加值
15
        ++years;
16
        // 返回增加后的对象引用
17
        return *this;
18
    }
19
    
20
    // 后置++运算符重载
21
    Age operator++(int) {
22
        // 保存当前状态
23
        Age temp = *this;
24
        // 增加值
25
        years++;
26
        // 返回原始值（修改前的副本）
27
        return temp;
28
    }
29
    
30
    // 用于输出的友元函数
31
    friend ostream& operator<<(ostream& os, const Age& obj) {
32
        os << "Age: " << obj.years;
33
        return os;
34
    }
35
};
36

37
int main() {
38
    Age age(25);
39
    
40
    // 测试后置++
41
    cout << "原始年龄: " << age << endl;
42
    Age oldAge = age++;
43
    cout << "后置++后: " << age << endl;
44
    cout << "后置++返回: " << oldAge << endl;
45
    
46
    // 测试前置++
47
    cout << "\n当前年龄: " << age << endl;
48
    Age& newAge = ++age;
49
    cout << "前置++后: " << age << endl;
50
    cout << "前置++返回: " << newAge << endl;
51
    
52
    // 验证前置++返回的引用
53
    ++age = Age(30);
54
    cout << "\n赋值后: " << age << endl;
55
    
56
    return 0;
57
}

前置++通常比后置++更高效 ，因为：

1. 前置++：

   • 直接修改对象

   • 返回对象引用

   • 无需创建临时对象

2. 后置++：

   • 需要创建临时对象保存原始状态

   • 修改对象

   • 返回临时对象

对于简单的内置类型（如int），性能差异很小。但对于复杂的用户定义类型，前置++的性能优势更为明显。

[]运算符重载

[] 运算符（下标运算符）是 C++ 中常用的运算符之一，它允许我们像访问数组元素一样访问自定义类型的对象。通过重载 [] 运算符，我们可以为自定义类实现类似数组的访问语法，使代码更加直观和易于理解。

[] 运算符重载的基本语法如下：

xxxxxxxxxx
1
1
返回类型 operator[](参数类型 参数名);

具体来说，有两种常见的形式：

xxxxxxxxxx
5
1
// 非 const 版本，允许修改元素
2
返回类型& operator[](参数类型 参数名);
3

4
// const 版本，不允许修改元素
5
const 返回类型& operator[](参数类型 参数名) const;

简单的数组封装类

xxxxxxxxxx
64
1
#include <iostream>
2
#include <stdexcept>
3

4
class MyArray {
5
private:
6
    int* data;
7
    int size;
8

9
public:
10
    MyArray(int sz) : size(sz) {
11
        data = new int[size]();
12
    }
13
    
14
    ~MyArray() {
15
        delete[] data;
16
    }
17
    
18
    // 非 const 版本，可读可写
19
    int& operator[](int index) {
20
        if (index < 0 || index >= size) {
21
            throw std::out_of_range("索引越界");
22
        }
23
        return data[index];
24
    }
25
    
26
    // const 版本，只读
27
    const int& operator[](int index) const {
28
        if (index < 0 || index >= size) {
29
            throw std::out_of_range("索引越界");
30
        }
31
        return data[index];
32
    }
33
    
34
    int getSize() const {
35
        return size;
36
    }
37
};
38

39
int main() {
40
    MyArray arr(5);
41
    
42
    // 使用 [] 运算符赋值
43
    for (int i = 0; i < arr.getSize(); ++i) {
44
        arr[i] = i * 10;
45
    }
46
    
47
    // 使用 [] 运算符读取
48
    for (int i = 0; i < arr.getSize(); ++i) {
49
        std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
50
    }
51
    
52
    // 使用 const 对象
53
    const MyArray constArr = arr;
54
    // constArr[0] = 100;  // 错误：不能修改 const 对象的元素
55
    std::cout << "constArr[2] = " << constArr[2] << std::endl;
56
    
57
    try {
58
        std::cout << arr[10] << std::endl;  // 越界访问
59
    } catch (const std::out_of_range& e) {
60
        std::cout << "异常：" << e.what() << std::endl;
61
    }
62
    
63
    return 0;
64
}

使用非整数类型作为索引

xxxxxxxxxx
46
1
#include <iostream>
2
#include <string>
3
#include <map>
4

5
class Dictionary {
6
private:
7
    std::map<std::string, std::string> data;
8

9
public:
10
    // 非 const 版本
11
    std::string& operator[](const std::string& key) {
12
        return data[key];  // 利用 std::map 的 [] 运算符
13
    }
14
    
15
    // const 版本
16
    const std::string& operator[](const std::string& key) const {
17
        auto it = data.find(key);
18
        if (it == data.end()) {
19
            throw std::out_of_range("键不存在");
20
        }
21
        return it->second;
22
    }
23
    
24
    bool hasKey(const std::string& key) const {
25
        return data.find(key) != data.end();
26
    }
27
};
28

29
int main() {
30
    Dictionary dict;
31
    
32
    // 使用 [] 运算符添加/修改元素
33
    dict["apple"] = "苹果";
34
    dict["banana"] = "香蕉";
35
    dict["orange"] = "橙子";
36
    
37
    // 使用 [] 运算符读取元素
38
    std::cout << "apple 的中文是：" << dict["apple"] << std::endl;
39
    std::cout << "banana 的中文是：" << dict["banana"] << std::endl;
40
    
41
    // 修改元素
42
    dict["apple"] = "红苹果";
43
    std::cout << "修改后，apple 的中文是：" << dict["apple"] << std::endl;
44
    
45
    return 0;
46
}

实现多维数组访问

xxxxxxxxxx
65
1
#include <iostream>
2
#include <vector>
3

4
class Matrix {
5
private:
6
    std::vector<std::vector<int>> data;
7
    int rows, cols;
8

9
public:
10
    Matrix(int r, int c) : rows(r), cols(c) {
11
        data.resize(rows);
12
        for (int i = 0; i < rows; ++i) {
13
            data[i].resize(cols, 0);
14
        }
15
    }
16
    
17
    // 返回行引用，以支持二维访问
18
    std::vector<int>& operator[](int row) {
19
        if (row < 0 || row >= rows) {
20
            throw std::out_of_range("行索引越界");
21
        }
22
        return data[row];
23
    }
24
    
25
    // const 版本
26
    const std::vector<int>& operator[](int row) const {
27
        if (row < 0 || row >= rows) {
28
            throw std::out_of_range("行索引越界");
29
        }
30
        return data[row];
31
    }
32
    
33
    void print() const {
34
        for (int i = 0; i < rows; ++i) {
35
            for (int j = 0; j < cols; ++j) {
36
                std::cout << data[i][j] << " ";
37
            }
38
            std::cout << std::endl;
39
        }
40
    }
41
};
42

43
int main() {
44
    Matrix mat(3, 4);
45
    
46
    // 使用 [][] 设置元素
47
    for (int i = 0; i < 3; ++i) {
48
        for (int j = 0; j < 4; ++j) {
49
            mat[i][j] = i * 10 + j;
50
        }
51
    }
52
    
53
    // 打印矩阵
54
    std::cout << "矩阵内容：" << std::endl;
55
    mat.print();
56
    
57
    // 访问单个元素
58
    std::cout << "mat[1][2] = " << mat[1][2] << std::endl;
59
    
60
    // 修改元素
61
    mat[1][2] = 100;
62
    std::cout << "修改后 mat[1][2] = " << mat[1][2] << std::endl;
63
    
64
    return 0;
65
}

代理类模式

有时我们需要在访问元素时执行特殊操作（如写时复制、延迟计算等），可以使用代理类模式：

xxxxxxxxxx
73
1
#include <iostream>
2
#include <string>
3

4
class StringArray {
5
private:
6
    std::string* data;
7
    int size;
8
    
9
    // 代理类，用于实现特殊的下标操作
10
    class Proxy {
11
    private:
12
        StringArray& array;
13
        int index;
14
    
15
    public:
16
        Proxy(StringArray& a, int i) : array(a), index(i) {}
17
        
18
        // 赋值运算符，当执行 array[i] = value 时调用
19
        Proxy& operator=(const std::string& value) {
20
            if (index < 0 || index >= array.size) {
21
                throw std::out_of_range("索引越界");
22
            }
23
            
24
            // 这里可以添加特殊处理逻辑
25
            std::cout << "写入操作：将 " << value << " 写入位置 " << index << std::endl;
26
            array.data[index] = value;
27
            return *this;
28
        }
29
        
30
        // 转换运算符，当读取 array[i] 时调用
31
        operator std::string() const {
32
            if (index < 0 || index >= array.size) {
33
                throw std::out_of_range("索引越界");
34
            }
35
            
36
            // 这里可以添加特殊处理逻辑
37
            std::cout << "读取操作：从位置 " << index << " 读取 " << array.data[index] << std::endl;
38
            return array.data[index];
39
        }
40
    };
41

42
public:
43
    StringArray(int sz) : size(sz) {
44
        data = new std::string[size];
45
    }
46
    
47
    ~StringArray() {
48
        delete[] data;
49
    }
50
    
51
    // [] 运算符返回代理对象
52
    Proxy operator[](int index) {
53
        return Proxy(*this, index);
54
    }
55
};
56

57
int main() {
58
    StringArray arr(3);
59
    
60
    // 写入操作
61
    arr[0] = "Hello";
62
    arr[1] = "World";
63
    arr[2] = "C++";
64
    
65
    // 读取操作
66
    std::string s1 = arr[0];
67
    std::string s2 = arr[1];
68
    
69
    // 组合操作
70
    std::cout << "组合：" << s1 + " " + s2 + " " + std::string(arr[2]) << std::endl;
71
    
72
    return 0;
73
}

<<输出运算符重载

在C++中，<<运算符原本是位左移运算符，但在C++标准库中被重载用于输出流操作。通过重载这个运算符，我们可以为自定义类型定义输出格式，使其能够直接与std::cout等输出流一起使用。

xxxxxxxxxx
1
1
std::ostream& operator<<(std::ostream& os, const MyClass& obj);

1. 友元函数

xxxxxxxxxx
15
1
class MyClass {
2
private:
3
    int _value;
4
    std::string _name;
5
    
6
public:
7
    // 声明为友元函数，可以访问私有成员
8
    friend std::ostream& operator<<(std::ostream& os, const MyClass& obj);
9
};
10

11
// 实现友元函数
12
std::ostream& operator<<(std::ostream& os, const MyClass& obj) {
13
    os << "名称: " << obj._name << ", 值: " << obj._value;
14
    return os;
15
}

2. 成员函数

xxxxxxxxxx
12
1
class MyClass {
2
private:
3
    int _value;
4
    std::string _name;
5
    
6
public:
7
    // 作为成员函数实现
8
    std::ostream& operator<<(std::ostream& os) const {
9
        os << "名称: " << _name << ", 值: " << _value;
10
        return os;
11
    }
12
};

成员函数方式不常用，因为它改变了运算符的使用方式（obj << cout而不是cout << obj）。

在继承体系中，派生类的<<运算符可以调用基类的<<运算符：

xxxxxxxxxx
7
1
friend std::ostream& operator<<(std::ostream& os, const Derived& obj) {
2
    // 先调用基类的<<运算符
3
    os << static_cast<const Base&>(obj);
4
    // 再输出派生类特有部分
5
    os << ", 派生类成员: " << obj._derivedMember;
6
    return os;
7
}

xxxxxxxxxx
4
1
MyClass obj("测试", 100);
2
std::cout << obj << std::endl;
3
// 输出：名称: 测试, 值: 100
4
        

>>输入运算符重载

在C++中，>>运算符原本是位右移运算符，但在C++标准库中被重载用于输入流操作。通过重载这个运算符，我们可以为自定义类型定义输入格式，使其能够直接与std::cin等输入流一起使用。

xxxxxxxxxx
1
1
std::istream& operator>>(std::istream& is, MyClass& obj);

1. 友元函数

xxxxxxxxxx
21
1
class MyClass {
2
private:
3
    int _value;
4
    std::string _name;
5
    
6
public:
7
    // 声明为友元函数，可以访问私有成员
8
    friend std::istream& operator>>(std::istream& is, MyClass& obj);
9
};
10

11
// 实现友元函数
12
std::istream& operator>>(std::istream& is, MyClass& obj) {
13
    is >> obj._name >> obj._value;
14
    
15
    // 检查输入是否成功
16
    if (!is) {
17
        // 处理输入错误
18
    }
19
    
20
    return is;
21
}

2. 成员函数

xxxxxxxxxx
12
1
class MyClass {
2
private:
3
    int _value;
4
    std::string _name;
5
    
6
public:
7
    // 作为成员函数实现
8
    std::istream& operator>>(std::istream& is) {
9
        is >> _name >> _value;
10
        return is;
11
    }
12
};

成员函数方式不常用，因为它改变了运算符的使用方式（obj >> cin而不是cin >> obj）。

xxxxxxxxxx
19
1
std::istream& operator>>(std::istream& is, MyClass& obj) {
2
    int tempValue;
3
    std::string tempName;
4
    
5
    // 先读取到临时变量
6
    is >> tempName >> tempValue;
7
    
8
    // 验证输入
9
    if (is) {
10
        // 输入有效，更新对象
11
        obj._name = tempName;
12
        obj._value = tempValue;
13
    } else {
14
        // 输入无效，将流设置为失败状态
15
        is.setstate(std::ios::failbit);
16
    }
17
    
18
    return is;
19
}

xxxxxxxxxx
10
1
MyClass obj;
2
std::cout << "请输入名称和值：";
3
std::cin >> obj;
4

5
// 检查输入是否成功
6
if (std::cin) {
7
    std::cout << "输入成功！" << std::endl;
8
} else {
9
    std::cout << "输入失败！" << std::endl;
10
}

成员访问运算符

C++中有两种主要的成员访问运算符：点运算符(.)和箭头运算符(->)。这两个运算符用于访问类或结构体的成员（包括变量和函数）。

点运算符 (.)

点运算符用于通过对象直接访问其成员。

xxxxxxxxxx
1
1
对象名.成员名

• 用于访问普通对象（非指针）的成员

• 用于访问引用类型对象的成员

• 用于访问通过值传递的对象的成员

xxxxxxxxxx
18
1
class Person {
2
public:
3
    std::string name;
4
    void sayHello() {
5
        std::cout << "你好，我是" << name << std::endl;
6
    }
7
};
8

9
int main() {
10
    Person person;
11
    person.name = "张三";  // 使用点运算符访问成员变量
12
    person.sayHello();    // 使用点运算符调用成员函数
13
    
14
    Person& personRef = person;
15
    personRef.name = "李四";  // 引用类型也使用点运算符
16
    
17
    return 0;
18
}

箭头运算符 (->)

箭头运算符用于通过指针访问对象的成员。

xxxxxxxxxx
1
1
指针名->成员名

• 用于访问指针所指向对象的成员

• 用于访问动态分配对象的成员

• 用于智能指针访问其管理对象的成员

xxxxxxxxxx
14
1
int main() {
2
    Person* personPtr = new Person();
3
    personPtr->name = "王五";    // 使用箭头运算符访问指针所指对象的成员变量
4
    personPtr->sayHello();      // 使用箭头运算符调用指针所指对象的成员函数
5
    
6
    delete personPtr;  // 不要忘记释放内存
7
    
8
    // 使用智能指针
9
    std::shared_ptr<Person> smartPtr = std::make_shared<Person>();
10
    smartPtr->name = "赵六";
11
    smartPtr->sayHello();
12
    
13
    return 0;
14
}

箭头运算符(->)可以被重载，但有特殊规则：

xxxxxxxxxx
20
1
class SmartPointer {
2
private:
3
    Person* ptr;
4
    
5
public:
6
    SmartPointer(Person* p) : ptr(p) {}
7
    ~SmartPointer() { delete ptr; }
8
    
9
    // 重载箭头运算符
10
    Person* operator->() {
11
        return ptr;  // 必须返回指针类型
12
    }
13
};
14

15
int main() {
16
    SmartPointer sp(new Person());
17
    sp->name = "智能指针测试";  // 等价于 (sp.operator->())->name
18
    sp->sayHello();
19
    return 0;
20
}

重载箭头运算符时：

• 必须是类的成员函数

• 必须返回指针类型或者另一个重载了箭头运算符的类对象

箭头运算符重载在两层和三层结构下的使用

在多层结构下，箭头运算符的重载可以实现链式调用，这在智能指针和代理类设计中非常有用。

箭头运算符重载有几个特殊规则：

1. 必须是类的成员函数

2. 不能有参数（是一个无参数的一元运算符）

3. 必须返回指针或者另一个重载了箭头运算符的对象

两层结构

两层结构是指一个类重载箭头运算符，返回一个指针。

xxxxxxxxxx
29
1
class Resource {
2
public:
3
    void doSomething() {
4
        std::cout << "资源执行操作" << std::endl;
5
    }
6
    int value = 42;
7
};
8

9
class SmartPointer {
10
private:
11
    Resource* ptr;
12

13
public:
14
    SmartPointer(Resource* p = nullptr) : ptr(p) {}
15
    ~SmartPointer() { delete ptr; }
16
    
17
    // 箭头运算符重载 - 返回指针
18
    Resource* operator->() {
19
        std::cout << "箭头运算符被调用" << std::endl;
20
        return ptr;
21
    }
22
};
23

24
int main() {
25
    SmartPointer sp(new Resource());
26
    sp->doSomething();  // 等价于 (sp.operator->())->doSomething();
27
    int x = sp->value;  // 等价于 (sp.operator->())->value;
28
    return 0;
29
}

当编译器看到sp->doSomething()时，它会：

1. 调用sp.operator->()，得到一个Resource*指针

2. 对该指针应用箭头运算符，访问doSomething()方法

三层结构（链式调用）

三层结构是指一个类重载箭头运算符，返回另一个重载了箭头运算符的对象，形成链式调用。

xxxxxxxxxx
52
1
class Level3 {
2
private:
3
    Resource* ptr;
4

5
public:
6
    Level3(Resource* p) : ptr(p) {}
7
    
8
    // 最终返回真正的指针
9
    Resource* operator->() {
10
        std::cout << "Level3::operator->被调用" << std::endl;
11
        return ptr;
12
    }
13
};
14

15
class Level2 {
16
private:
17
    Level3 level3;
18

19
public:
20
    Level2(Resource* p) : level3(p) {}
21
    
22
    // 返回另一个重载了箭头运算符的对象
23
    Level3 operator->() {
24
        std::cout << "Level2::operator->被调用" << std::endl;
25
        return level3;
26
    }
27
};
28

29
class Level1 {
30
private:
31
    Level2 level2;
32

33
public:
34
    Level1(Resource* p) : level2(p) {}
35
    
36
    // 返回另一个重载了箭头运算符的对象
37
    Level2 operator->() {
38
        std::cout << "Level1::operator->被调用" << std::endl;
39
        return level2;
40
    }
41
};
42

43
int main() {
44
    Level1 l1(new Resource());
45
    l1->doSomething();
46
    // 执行顺序：
47
    // 1. l1.operator->() 返回 Level2对象
48
    // 2. Level2对象.operator->() 返回 Level3对象
49
    // 3. Level3对象.operator->() 返回 Resource*指针
50
    // 4. 使用该指针调用 doSomething()
51
    return 0;
52
}