做网站那个好海口免费自助建站模板

三、运算符重载

1、友元（熟悉）

1.1 概念

类通过私有成员实现数据封装，但某些场景下频繁访问私有成员会导致效率问题。友元机制允许特定函数/类访问私有成员，但会破坏封装性，需谨慎使用。

​​友元实现方式​​：

• 友元函数
• 友元类
• 友元成员函数

---

1.2 友元函数

友元函数是类外定义的普通函数，需在类内用friend声明。
​​特点​​：

• 无this指针
• 声明位置不受访问权限限制
• 可访问多个类的私有成员（需在各自类中声明）

示例代码

#include <iostream>
using namespace std;class Test {
private:int a;
public:Test(int i) : a(i) {}void show() { cout<< a << " " << &a << endl; }// 友元函数声明friend void and_test(Test &t);
};// 友元函数定义
void and_test(Test &t) {cout << t.a << " " << &t.a << endl;
}int main() {Test t1(1);and_test(t1); // 输出与成员函数相同t1.show();return 0;
}

---

1.3 友元类

若类B是类A的友元类，则B可访问A的所有成员。
​​特性​​：

• 友元关系不可继承
• 不具有交换性（需双向声明）

互为友元示例

class Cat; // 前向声明class Test {
private:int a;
public:Test(int i) : a(i) {}void test(Cat &c);friend class Cat; // 声明Cat为友元类
};class Cat {
private:int b;
public:Cat(int i) : b(i) {}void test1(Test &t) {cout << t.a++ << endl; // 访问Test私有成员}friend class Test; // 双向友元
};void Test::test(Cat &c) {cout << c.b << endl; // 访问Cat私有成员
}int main() {Test t(44);Cat c(12);c.test1(t); // 输出45（Test的a自增）return 0;
}

1.4 友元成员函数

使类B的特定成员函数成为类A的友元，可访问A的私有成员。
​​实现步骤​​：

1. 前向声明目标类
2. 在目标类中声明友元成员函数
3. 定义成员函数时需指定类作用域

示例代码

class Test; // 前向声明class B {
public:void and_test(Test &t); // 声明友元成员函数
};class Test {
private:int a;
public:Test(int i) : a(i) {}friend void B::and_test(Test &t); // 声明友元成员函数
};void B::and_test(Test &t) {cout << t.a << endl; // 访问Test私有成员
}int main() {Test t1(2);B b;b.and_test(t1); // 输出2return 0;
}

---

2、运算符重载（掌握）

2.1 概念

允许为自定义类型重载运算符，使其支持类似内置类型的操作。
​​实现方式​​：

• 友元函数重载
• 成员函数重载

---

2.2 友元函数运算符重载

适用于需要对称性的操作（如二元运算符）。

示例：+运算符

class MyInt {
private:int a;
public:MyInt(int a) : a(a) {}friend MyInt operator+(MyInt &i, MyInt &i2); // 友元声明
};MyInt operator+(MyInt &i, MyInt &i2) {return MyInt(i.a + i2.a); // 隐式调用构造函数
}

示例：++运算符

class MyInt {// ...friend MyInt operator++(MyInt &i);      // 前置++friend MyInt operator++(MyInt &i, int); // 后置++
};MyInt operator++(MyInt &i) { return ++i.a; }         // 前置
MyInt operator++(MyInt &i, int) { return i.a++; }    // 后置

---

2.3 成员函数运算符重载

隐含this作为左操作数，适用于非对称操作。

示例：+运算符

class MyInt {
public:MyInt operator+(MyInt &i2) {return MyInt(this->a + i2.a);}
};

---

2.4 特殊运算符重载

2.4.1 赋值运算符重载

默认生成浅拷贝，需手动实现深拷贝。

class MyInt {
public:MyInt& operator=(MyInt &i) {if (this != &i) this->a = i.a;return *this;}
};

2.4.2 类型转换运算符重载

必须为成员函数，返回目标类型。

class MyInt {
public:operator int() { return a; }       // 转intoperator string() { return "hello"; } // 转string
};

---

2.5 注意事项

1. 不可创建新运算符
2. 不支持默认参数
3. 不改变优先级和结合性
4. 建议：双目用友元，单目用成员

---

3、std::string 字符串类

核心操作示例

string s1 = "hello";
string s2("world");// 拼接与追加
s1 += s2;          // s1 = "helloworld"
s1.append("!!!");    // s1 = "helloworld!!!"// 插入与删除
s1.insert(5, " ");   // s1 = "hello world"
s1.erase(5, 6);      // s1 = "hello"// 替换与清空
s1.replace(0, 5, "Hi"); // s1 = "Hi"
s1.clear();// C风格转换
char arr[10];
strcpy(arr, s1.c_str()); // C字符串转换