C++类（上）-优快云博客

本文链接：https://blog.youkuaiyun.com/zxtzxt12138/article/details/143778848

1、C++的OOP思路

C++中OOP（Object-Oriented Programming）思想的主要特征有以下几个方面：

封装（Encapsulation）：将对象的状态和行为封装在一起，使得对象的内部实现细节对外部世界不可见。

在C++中，可以使用私有成员变量和公有成员函数来实现封装。

继承（Inheritance）：允许一个对象继承另一个对象的属性和方法，可以扩展和修改父类的行为。

在C++中，可以使用继承关键字（class或struct）来实现继承。

多态（Polymorphism）：允许对象在不同的上下文中表现出不同的行为。

在C++中，可以使用函数重载和虚函数来实现多态。

抽象（Abstraction）：将复杂的对象或系统抽象化为简单的接口，隐藏实现细节。

在C++中，可以使用抽象类和接口来实现抽象。

Composition：允许对象组合其他对象来形成新的对象。

在C++中，可以使用容器类（如std::vector）和智能指针来实现组合。

C++ OOP思想的主要优点是：

提高了代码重用性和可维护性
提高了代码的灵活性和可扩展性
提高了代码的可读性和可理解性

以下是一些常见的OOP设计模式：

单一责任原则（Single Responsibility Principle）：每个对象应该只有一个责任。
开放-封闭原则（Open-Closed Principle）：软件 Entities（对象、模块、类）应该是开放的（可以扩展）而封闭的（不能修改）。
里氏替换原则（Liskov Substitution Principle）：子类应该能够替换父类。
接口隔离原则（Interface Segregation Principle）：客户端不应该被迫实现一个它们不需要的接口。
依赖倒置原则（Dependency Inversion Principle）：高层模块不应该依赖低层模块，而是两者都应该依赖抽象。

2、类的对象

在C++中，类是用户定义的数据类型，它可以包含数据成员和成员函数。类的定义使用关键字class，后面跟着类名和类体。

以下是一个简单的类定义：

class Person {
public:
    string name;
    int age;

    void printInfo() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

在上面的例子中，我们定义了一个名为Person的类，它有两个数据成员name和age，以及一个成员函数printInfo()。

对象（Object）定义

对象是类的实例，它具有类的所有成员变量和成员函数。对象的定义使用类名和对象名，例如：

Person person1;

在上面的例子中，我们定义了一个名为person1的对象，它是Person类的实例。

对象的初始化

对象可以使用构造函数来初始化。构造函数是类的特殊成员函数，它用于将对象初始化为特定的状态。例如：

class Person {
public:
    string name;
    int age;

    Person(string n, int a) : name(n), age(a) {}

    void printInfo() {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

Person person1("John", 25);

在上面的例子中，我们定义了一个名为Person的类，它有一个构造函数Person(string, int)，用于将对象初始化为特定的状态。然后，我们定义了一个名为person1的对象，它使用构造函数来初始化为名为John，年龄为25。

对象的访问

对象的成员变量和成员函数可以使用点运算符（.`）或箭头运算符（->）来访问。例如：

person1.name = "Jane";
person1.age = 30;

person1.printInfo(); // Output: Name: Jane, Age: 30

在上面的例子中，我们使用点运算符来访问对象person1的成员变量name和age，然后使用箭头运算符来调用对象的成员函数printInfo()。

2.1、构造函数

C++中的构造函数是一种特殊的函数，它在对象被创建时被调用，以便初始化对象的成员变量。

构造函数的主要用途是初始化对象的成员变量，以便在对象被使用时，它们已经被正确地初始化。

2.1.1、默认构造

默认构造函数的定义

默认构造函数是编译器在以下情况下自动生成的构造函数：

类中没有定义任何构造函数。
类中的所有成员变量都有默认值或者可以被默认构造。

默认构造函数的名称与类名相同，且没有参数。

默认构造函数的行为

默认构造函数的行为取决于类的成员变量：

内置类型（如int、double等）：不会被初始化，其值是未定义的。
类类型：如果成员变量是另一个类的对象，且该类有默认构造函数，则会调用该默认构造函数进行初始化。
指针类型：不会被初始化，其值是未定义的。

示例代码

以下是一个简单的示例，展示了默认构造函数的行为：

#include <iostream>
#include <string>

class MyClass {
public:
    int x;
    std::string str;
};

int main() {
    MyClass obj; // 调用默认构造函数
    std::cout << "x: " << obj.x << std::endl; // x的值是未定义的
    std::cout << "str: " << obj.str << std::endl; // str的值是空字符串
    return 0;
}

在这个示例中，MyClass类没有定义任何构造函数，编译器会自动生成一个默认构造函数。x的值是未定义的，str的值是空字符串。

自定义默认构造函数

有时候，默认构造函数的行为可能不符合我们的需求，我们可以手动定义一个默认构造函数来初始化成员变量。

#include <iostream>
#include <string>

class MyClass {
public:
    int x;
    std::string str;

    // 自定义默认构造函数
    MyClass() : x(0), str("default") {}
};

int main() {
    MyClass obj; // 调用自定义的默认构造函数
    std::cout << "x: " << obj.x << std::endl; // x的值是0
    std::cout << "str: " << obj.str << std::endl; // str的值是"default"
    return 0;
}

在这个示例中，我们手动定义了一个默认构造函数，并在构造函数中初始化了成员变量x和str。

总结

默认构造函数是编译器在类中没有定义任何构造函数时自动生成的构造函数。它的行为取决于类的成员变量。如果默认行为不符合需求，可以手动定义一个默认构造函数来初始化成员变量。

2.1.2、转换构造

C++的转换构造函数是指只有一个参数的构造函数，它允许将其他类型的值隐式或显式地转换为该类的对象。这是一种隐式类型转换机制，方便了不同类型数据之间的转换，但也可能带来一些潜在的风险。

定义:

一个转换构造函数的签名只有一个参数，且不是复制构造函数或移动构造函数。例如：

class MyClass {
public:
  MyClass(int x) : value(x) {} // 转换构造函数，将int转换为MyClass
  int value;
};

int main() {
  MyClass obj(10); // 使用转换构造函数创建MyClass对象
  return 0;
}

在这个例子中，MyClass(int x) 就是一个转换构造函数。它允许将一个 int 类型的值直接转换为 MyClass 对象。

隐式转换:

转换构造函数最主要的特性是它允许隐式转换。这意味着，如果你的代码中需要一个 MyClass 对象，而你提供了一个 int，编译器会自动调用转换构造函数来创建 MyClass 对象。

void myFunction(MyClass obj) {
  // ...
}

int main() {
  myFunction(5); // 隐式转换：int 5 被转换为 MyClass 对象
  return 0;
}

在上面的例子中，myFunction 期待一个 MyClass 对象作为参数，但我们传递了一个 int 值 5。编译器会自动调用 MyClass(int x) 转换构造函数，将 5 转换为 MyClass 对象，然后传递给 myFunction。

显式转换:

你也可以显式地使用转换构造函数进行类型转换，使用函数调用语法：

int main() {
  MyClass obj = MyClass(5); // 显式转换
  return 0;
}

潜在风险和避免:

虽然转换构造函数很方便，但它也可能导致代码难以理解和维护，甚至出现难以追踪的错误。主要风险在于：

意外的隐式转换: 编译器自动进行的隐式转换可能并非你预期的行为，导致程序逻辑错误。
歧义: 如果有多个转换构造函数，或者存在其他可以进行隐式转换的途径，可能会导致编译器歧义错误。

为了避免这些风险，可以采取以下措施：

避免使用隐式转换: 尽量避免编写只有一个参数的构造函数，除非你明确需要这种隐式转换的功能。
使用 explicit 关键字: 在转换构造函数声明前添加 explicit 关键字可以禁止隐式转换，只允许显式转换。

class MyClass {
public:
  explicit MyClass(int x) : value(x) {} // 显式转换构造函数
  int value;
};

现在，myFunction(5); 将会产生编译错误，因为隐式转换被禁止了。你必须显式地进行转换：myFunction(MyClass(5));

总结:

转换构造函数是一个强大的工具，但需要谨慎使用。 explicit 关键字是避免潜在问题的重要手段。在设计类时，仔细权衡隐式转换的便利性和潜在风险，选择最适合你项目的方式。通常情况下，除非有非常明确的需求，否则建议避免使用隐式转换，并使用 explicit 关键字来增强代码的清晰性和可维护性。

2.1.3、拷贝构造

拷贝构造函数（Copy Constructor）是C++中用于创建一个对象的副本的特殊构造函数。它通常在对象被通过值传递或返回时、以及在对象被复制时被调用。拷贝构造函数的定义形式如下：

class MyClass {
public:
    // 拷贝构造函数
    MyClass(const MyClass& other) {
        // 初始化 this 对象的成员变量，使其与 other 对象的成员变量相同
    }

    // 其他成员函数和成员变量
};

拷贝构造函数的特点

参数：拷贝构造函数的参数是一个对同类对象的引用，通常是 const 引用，以避免对源对象进行修改。
返回类型：拷贝构造函数没有返回类型，即使用 void 也不行。
调用时机：
- 当对象通过值传递给函数时。
- 当对象从函数中通过值返回时。
- 当对象被显式地复制时，例如使用赋值运算符 =。

示例代码

以下是一个简单的示例，展示了如何定义和使用拷贝构造函数：

#include <iostream>

class MyClass {
public:
    int value;

    // 默认构造函数
    MyClass(int val) : value(val) {}

    // 拷贝构造函数
    MyClass(const MyClass& other) : value(other.value) {
        std::cout << "拷贝构造函数被调用" << std::endl;
    }

    // 显示对象的值
    void display() const {
        std::cout << "Value: " << value << std::endl;
    }
};

int main() {
    MyClass obj1(10); // 使用默认构造函数创建对象
    MyClass obj2 = obj1; // 使用拷贝构造函数创建对象的副本

    obj1.display(); // 输出 obj1 的值
    obj2.display(); // 输出 obj2 的值

    return 0;
}

在这个示例中，MyClass obj2 = obj1; 会调用拷贝构造函数，将 obj1 的内容复制到 obj2 中。

2.1.3.1、浅拷贝

浅拷贝是指在创建一个对象的副本时，新对象的成员变量直接从原对象的成员变量中复制。对于基本数据类型（如 int、float 等），浅拷贝没有问题。但对于指针类型的成员变量，浅拷贝只是复制指针的值，而不是复制指针指向的内存数据。这意味着新对象和原对象将共享同一块内存。

示例代码

#include <iostream>

class MyClass {
public:
    int* data;

    // 默认构造函数
    MyClass(int val) {
        data = new int(val);
    }

    // 浅拷贝构造函数
    MyClass(const MyClass& other) {
        data = other.data; // 浅拷贝，只复制指针
    }

    // 析构函数
    ~MyClass() {
        delete data;
    }

    // 显示对象的值
    void display() const {
        std::cout << "Value: " << *data << std::endl;
    }
};

int main() {
    MyClass obj1(10); // 使用默认构造函数创建对象
    MyClass obj2 = obj1; // 使用浅拷贝构造函数创建对象的副本

    obj1.display(); // 输出 obj1 的值
    obj2.display(); // 输出 obj2 的值

    obj2.data = new int(20); // 修改 obj2 的 data
    *obj2.data = 20;

    obj1.display(); // 输出 obj1 的值
    obj2.display(); // 输出 obj2 的值

    return 0;
}

在这个示例中，obj1 和 obj2 共享同一块内存。当 obj2 修改 data 的值时，obj1 也会受到影响。

2.1.3.2、深拷贝

深拷贝是指在创建一个对象的副本时，新对象的成员变量不仅从原对象的成员变量中复制，还会创建新的内存空间来存储数据。对于指针类型的成员变量，深拷贝会创建新的内存并复制指针指向的数据，而不是只复制指针的值。

示例代码

#include <iostream>

class MyClass {
public:
    int* data;

    // 默认构造函数
    MyClass(int val) {
        data = new int(val);
    }

    // 深拷贝构造函数
    MyClass(const MyClass& other) {
        data = new int(*other.data); // 深拷贝，创建新的内存并复制数据
    }

    // 析构函数
    ~MyClass() {
        delete data;
    }

    // 显示对象的值
    void display() const {
        std::cout << "Value: " << *data << std::endl;
    }
};

int main() {
    MyClass obj1(10); // 使用默认构造函数创建对象
    MyClass obj2 = obj1; // 使用深拷贝构造函数创建对象的副本

    obj1.display(); // 输出 obj1 的值
    obj2.display(); // 输出 obj2 的值

    obj2.data = new int(20); // 修改 obj2 的 data
    *obj2.data = 20;

    obj1.display(); // 输出 obj1 的值
    obj2.display(); // 输出 obj2 的值

    return 0;
}

在这个示例中，obj1 和 obj2 各自拥有独立的内存空间。当 obj2 修改 data 的值时，obj1 不会受到影响。

总结

浅拷贝：直接复制对象的成员变量，对于指针类型，只复制指针的值，新旧对象共享同一块内存。
深拷贝：复制对象的成员变量，并为指针类型创建新的内存空间，新旧对象拥有独立的内存。

在实际开发中，选择浅拷贝还是深拷贝取决于具体需求。对于包含动态分配内存的类，通常需要实现深拷贝以避免内存管理问题。

2.1.4、移动构造

移动构造函数是一种特殊的构造函数，它允许你将一个对象的资源“移动”到另一个新创建的对象中，而不是复制它们。这对于包含动态分配内存或其他昂贵资源的对象尤其有用，因为它可以避免不必要的内存分配和复制操作，从而提高效率。

核心思想: 移动构造函数接收一个右值引用 (&&) 作为参数。右值引用表示一个将要被销毁或不再被使用的临时对象。移动构造函数可以从这个临时对象中“窃取”资源，而无需进行复制。这使得资源的转移非常高效，避免了复制的开销。

与复制构造函数的区别:

复制构造函数: 创建一个对象的完整副本，包括所有资源的复制。
移动构造函数: 将资源从一个对象转移到另一个对象，而不是复制它们。原对象通常会在移动后进入一个有效的但未定义的状态（通常被置于一个"已移动"状态，以防止后续意外使用）。

示例 (C++)

#include <iostream>
#include <string>
#include <vector>

class MyResource {
public:
  std::string data;
  std::vector<int> numbers;

  MyResource(const std::string& str, const std::vector<int>& nums) : data(str), numbers(nums) {
    std::cout << "Constructor called
";
  }

  // 复制构造函数
  MyResource(const MyResource& other) : data(other.data), numbers(other.numbers) {
    std::cout << "Copy constructor called
";
  }

  // 移动构造函数
  MyResource(MyResource&& other) noexcept : data(std::move(other.data)), numbers(std::move(other.numbers)) {
    // 将other置于有效但未定义的状态，防止后续使用
    other.data = ""; // 清空数据，防止意外访问已移动的资源
    other.numbers.clear();
    std::cout << "Move constructor called
";
  }

  ~MyResource() {
    std::cout << "Destructor called
";
  }
};


int main() {
  MyResource obj1("Hello", {1, 2, 3});

  // 复制构造函数被调用
  MyResource obj2 = obj1;  

  // 移动构造函数被调用。  obj3 接管 obj1 的资源。
  MyResource obj3 = std::move(obj1);

  return 0;
}

在这个例子中，std::move 将 obj1 转换为右值引用，允许移动构造函数被调用。注意，obj1 在移动后不再拥有资源，再次访问它的成员变量会产生未定义行为。因此，other.data = ""; other.numbers.clear(); 非常重要，它保证了资源的正确转移和避免潜在的错误。

什么时候使用移动构造函数？

当对象包含动态分配的内存时。
当对象包含其他昂贵的资源（例如文件句柄、网络连接等）时。
当需要避免不必要的复制操作以提高性能时。

noexcept 说明符:

在移动构造函数声明中通常使用 noexcept 说明符。这表示移动构造函数不会抛出异常。这对于异常安全至关重要，因为如果移动构造函数抛出异常，则资源可能无法正确释放，导致内存泄漏等问题。

总而言之，移动构造函数是 C++11 及更高版本中一个强大的特性，它可以显著提高程序的效率，尤其是在处理包含大量资源的对象时。理解其工作原理和使用场景对于编写高效的 C++ 代码至关重要。

2.2、析构

析构函数是C++中的一个特殊成员函数，用于在对象生命周期结束时自动执行清理工作。它的主要作用是释放对象在生命周期内分配的资源，如动态内存、文件句柄、网络连接等。析构函数的名称与类名相同，前面加一个波浪号（~），没有返回值，也不接受任何参数。

析构函数的特点

自动调用：析构函数在对象销毁时自动调用。当对象超出作用域、显式删除对象指针或程序结束时，析构函数会被自动调用。
无返回值：析构函数没有返回值，甚至不能返回void。
无参数：析构函数不接受任何参数。
唯一性：一个类只能有一个析构函数，不能重载。

析构函数的作用

释放资源：在对象生命周期内分配的资源（如动态内存）需要在对象销毁时释放，以避免资源泄漏。
清理工作：执行其他必要的清理工作，如关闭文件、释放网络连接等。

示例

#include <iostream>

class MyClass {
public:
    int* data;

    // 构造函数
    MyClass() {
        data = new int[100]; // 动态分配内存
        std::cout << "Constructor called
";
    }

    // 析构函数
    ~MyClass() {
        delete[] data; // 释放动态分配的内存
        std::cout << "Destructor called
";
    }
};

int main() {
    MyClass obj; // 创建对象，调用构造函数
    // 对象超出作用域，调用析构函数
    return 0;
}

在这个例子中，MyClass 类的构造函数动态分配了内存，析构函数负责释放这些内存。当 main 函数结束时，obj 对象超出作用域，析构函数自动被调用，释放内存。

析构函数的重要性

资源管理：确保对象在销毁时释放所有资源，避免内存泄漏和其他资源泄漏。
异常安全：在异常发生时，析构函数可以确保资源正确释放，避免资源泄漏。
自动化：析构函数的自动调用简化了资源管理，开发者不需要手动释放资源。

注意事项

避免在析构函数中抛出异常：析构函数应尽量避免抛出异常，因为在析构函数中抛出异常可能导致程序终止。
虚析构函数：如果类被设计为基类，并且有虚函数，那么析构函数也应该是虚函数。这样可以确保通过基类指针删除派生类对象时，正确调用派生类的析构函数。

class Base {
public:
    virtual ~Base() {
        std::cout << "Base destructor called
";
    }
};

class Derived : public Base {
public:
    ~Derived() {
        std::cout << "Derived destructor called
";
    }
};

int main() {
    Base* ptr = new Derived();
    delete ptr; // 调用Derived的析构函数，然后调用Base的析构函数
    return 0;
}

在这个例子中，Base 类的析构函数被声明为虚函数，确保在通过基类指针删除派生类对象时，正确调用派生类的析构函数。

总结来说，析构函数是C++中非常重要的特性，它确保对象在销毁时释放所有资源，避免资源泄漏。理解和正确使用析构函数对于编写高效和可靠的C++代码至关重要。

2.3、关键字

C++拥有许多C语言没有的关键字，这些关键字扩展了语言的功能，支持面向对象编程、泛型编程以及其他高级特性。以下是一些C++特有（或者属性C++特有）的关键字

2.3.1、static

2.3.1.1、修饰成员变量

存储方式: static 成员变量只存在一份，所有类的对象共享同一个static成员变量。它不属于任何特定对象，而是属于类本身。
初始化: static 成员变量必须在类定义体外进行初始化，通常在类的定义之外使用 类名::静态成员变量名 = 值; 的形式进行初始化。不能在类内初始化。
作用域: static 成员变量的作用域与类的作用域相同，可以在类的任何成员函数中访问。
生命周期: static 成员变量的生命周期与程序的生命周期相同，从程序启动到程序结束都存在。

示例:

class MyClass {
public:
  static int count; // 静态成员变量声明
  MyClass() { count++; } // 构造函数增加计数
  ~MyClass() { count--; } // 析构函数减少计数
};

// 静态成员变量的定义和初始化
int MyClass::count = 0;

int main() {
  MyClass obj1;
  MyClass obj2;
  std::cout << MyClass::count << std::endl; // 输出 2
  return 0;
}

2.3.1.2、修饰成员函数

存储方式: static 成员函数不与任何特定对象绑定，它属于类本身。
调用方式: static 成员函数可以通过类名直接调用 (类名::静态成员函数名();)，也可以通过对象名调用 (对象名.静态成员函数名();)，但通常推荐使用类名调用以强调其不依赖于对象的特性。
访问限制: static 成员函数只能访问类的static成员变量和static成员函数，不能访问类的非static成员变量和成员函数（因为非静态成员与特定对象关联，而静态函数不与任何对象关联）。
this指针: static 成员函数没有this指针，因为它不属于任何特定对象。

示例:

class MyClass {
public:
  static int count;
  static void incrementCount() { count++; } // 静态成员函数
  void nonStaticFunction() { count++; } // 非静态成员函数
};

int MyClass::count = 0;

int main() {
  MyClass::incrementCount(); // 通过类名调用静态成员函数
  MyClass obj;
  obj.incrementCount();     // 通过对象名调用静态成员函数 (虽然可以，但通常不推荐)
  std::cout << MyClass::count << std::endl; // 输出 2
  return 0;
}

总结:

简单来说，static 成员变量提供了一种在类中共享数据的机制，而static 成员函数提供了一种与特定对象无关的类级别操作的机制。它们都代表了类级别的属性或行为，而不是对象级别的。

2.3.2、const

C++的const关键字是一种重要的关键字，它用来修饰变量、函数参数、函数返回值或数据成员，以确保它们的值不被修改。

概念:

const 关键字可以应用于变量、函数参数、函数返回值或数据成员。
const 关键字的作用是确保修饰的变量或成员的值不被修改。
const 关键字可以与其他关键字结合使用，例如 const int 表示一个常整数。

应用场景:

1.变量：使用 const 关键字修饰变量可以确保变量的值不被修改。例如：

const int x = 10;

2.函数参数: 使用 const 关键字修饰函数参数可以确保函数参数的值不被修改。例如：

void print(const int x) {
  std::cout << x << std::endl;
}

3.函数返回值: 使用 const 关键字修饰函数返回值可以确保函数返回值的值不被修改。例如：

const int getConstValue() {
  return 10;
}

4.数据成员: 使用 const 关键字修饰数据成员可以确保数据成员的值不被修改。例如：

class MyClass {
public:
  const int x;
  MyClass(int y) : x(y) {}
};

注意事项:

const 对象: 如果一个对象是 const 的话，它的成员变量也将被认为是 const 的。
const 传递: 如果一个 const 对象作为函数参数传递给一个函数，那么函数将无法修改该对象的值。
const 返回值: 如果一个函数返回一个 const 对象，那么调用该函数的代码将无法修改该对象的值。
const_cast: 如果需要在编译时强制将一个 const 对象转换为非 const 对象，可以使用 const_cast 操作符。

例如：

const MyClass obj;
MyClass* ptr = const_cast<MyClass*>(&obj);

总结:

const 关键字是 C++ 中非常重要的关键字，它用来确保变量、函数参数、函数返回值或数据成员的值不被修改。通过使用 const 关键字，可以提高代码的可读性、可维护性和可靠性。

2.3.3、friend

友元机制允许一个类将另一个类或函数声明为它的“朋友”，从而允许朋友类或函数访问该类的私有成员（private）和保护成员（protected）。这打破了类的封装性，但有时为了提高效率或实现某些特殊功能是必要的。需要注意的是，友元关系是非对称的、非传递的和非继承的。

2.3.3.1、友元函数

友元函数是定义在类外部的普通函数，但它可以访问该类的私有成员和保护成员。它不是类的成员函数，没有 this 指针。

声明:

在类的定义内部，使用 friend 关键字声明友元函数。

示例:

class MyClass {
private:
  int privateData;
public:
  MyClass(int data) : privateData(data) {}
  friend void printPrivateData(MyClass obj); // 声明友元函数
};

void printPrivateData(MyClass obj) { // 友元函数的定义
  std::cout << obj.privateData << std::endl; // 可以访问私有成员
}

int main() {
  MyClass obj(10);
  printPrivateData(obj); // 调用友元函数
  return 0;
}

2.3.3.2、友元类

友元类是指一个类被声明为另一个类的友元，从而可以访问另一个类的私有成员和保护成员。

声明:

在类的定义内部，使用 friend 关键字声明友元类。

示例:

class MyClass {
private:
  int privateData;
public:
  MyClass(int data) : privateData(data) {}
  friend class MyFriendClass; // 声明友元类
};

class MyFriendClass {
public:
  void printPrivateData(MyClass obj) {
    std::cout << obj.privateData << std::endl; // 可以访问 MyClass 的私有成员
  }
};

int main() {
  MyClass obj(10);
  MyFriendClass friendObj;
  friendObj.printPrivateData(obj);
  return 0;
}

2.3.3.3、友元成员函数

友元成员函数是指一个类的成员函数被声明为另一个类的友元，从而可以访问另一个类的私有成员和保护成员。

声明:

在类的定义内部，使用 friend 关键字声明友元成员函数。

示例:

class MyClass {
private:
  int privateData;
public:
  MyClass(int data) : privateData(data) {}
  friend void MyFriendClass::printPrivateData(MyClass obj); // 声明友元成员函数
};

class MyFriendClass {
public:
  void printPrivateData(MyClass obj) {
    std::cout << obj.privateData << std::endl; // 可以访问 MyClass 的私有成员
  }
};

int main() {
  MyClass obj(10);
  MyFriendClass friendObj;
  friendObj.printPrivateData(obj);
  return 0;
}

总结

友元机制的优缺点:

优点:

可以提高代码效率，避免不必要的公共接口。
可以实现某些特殊的功能，例如在不同的类之间共享数据。

缺点:

破坏了类的封装性，降低了代码的可维护性和可重用性。
滥用友元会使代码难以理解和调试。

最佳实践:

谨慎使用友元，尽量减少友元的使用。
只有在必要的情况下才使用友元。
优先考虑使用公共接口或其他设计模式来实现相同的功能。

总而言之，友元机制提供了一种灵活的方式来访问类的私有成员，但在使用时需要权衡其优缺点，并遵循最佳实践，避免滥用。过度使用友元会削弱面向对象编程的封装性原则。

2.4、运算符重载

C++ 运算符重载（Operator Overloading）是指将用户定义的类中的运算符与类中的操作符函数相绑定，以便在使用该类对象时可以使用运算符来进行操作。例如，可以将 + 运算符与自定义的 add 函数相绑定，以便在使用该类对象时可以使用 + 运算符来实现加法操作。

运算符重载的基本概念:

运算符重载是将用户定义的类中的运算符与类中的操作符函数相绑定的过程。
运算符重载可以用于实现自定义的运算符函数，以便在使用该类对象时可以使用运算符来进行操作。
运算符重载可以用于实现自定义的类型转换，以便在使用该类对象时可以将其转换为其他类型。

运算符重载的语法:

运算符重载的语法主要有两种：

1.使用 operator 关键字来定义运算符函数：

class MyClass {
public:
    MyClass(int x) : x_(x) {}
    int operator+(const MyClass& other) {
        return x_ + other.x_;
    }
private:
    int x_;
};

2.使用 operator 关键字来重载运算符：

class MyClass {
public:
    MyClass(int x) : x_(x) {}
    MyClass operator+(const MyClass& other) {
        return MyClass(x_ + other.x_);
    }
private:
    int x_;
};

运算符重载的注意事项:

运算符重载只能用于用户定义的类。
运算符重载不能用于内置类型的运算符。
运算符重载可以用于实现自定义的类型转换。
运算符重载可以用于实现自定义的运算符函数。

运算符重载的返回值问题

运算符重载函数的返回值类型至关重要，它决定了重载后的运算符的行为以及如何使用运算符重载的结果。选择不当的返回值类型可能导致编译错误、运行时错误或意想不到的行为。以下详细分析不同情况下的返回值类型选择：

1. 返回值类型与运算符的语义一致:

这是最重要的原则。返回值类型应该与运算符的预期行为相符。例如：

+, -, *, / 等算术运算符: 通常返回与操作数相同类型的对象，或者能够隐式转换为相同类型的对象。如果操作数是自定义类，通常返回该自定义类的对象。这保证了运算符的链式调用（例如 a + b + c）。
=, +=, -=, *=, /= 等赋值运算符: 通常返回一个指向该对象的引用 (*this)，允许链式赋值（例如 a = b = c）。这使得赋值操作更加简洁高效。
==, !=, <, >, <=, >= 等比较运算符: 通常返回 bool 类型，表示比较结果的真假。
[] 下标运算符: 通常返回对元素的引用，允许修改元素的值。如果返回的是值，则无法修改元素。
() 函数调用运算符: 返回值类型取决于函数的定义。