C++学习笔记——友元、嵌套类、异常

目录

一、友元

一个使用友元的示例代码

输出结果

二、嵌套类

一个使用嵌套类的示例代码

输出结果

三、异常

一个使用异常处理的示例代码

输出结果

四、结论

五、使用它们的注意事项

---

上一篇文章链接：

C++中的继承和模板是非常强大和灵活的特性，它们可以帮助我们实现代码复用、抽象和泛化等目标。本文将着重介绍私有继承、多重继承和类模板这三个C++中比较重要的特性。

C++学习笔记——私有继承、多重继承、类模板-CSDN博客例如，我们可以使用模板参数来定义成员变量和成员函数，或者使用特化（partial specialization）和偏特化（full specialization）来针对不同的情况实现不同的行为。私有继承是一种比较特殊的继承方式，它在语法上与公有继承和保护继承没有太大区别，但是其继承关系所暴露的接口和成员变量都会被隐藏起来，只有派生类自己可以访问到基类的成员。此外，多重继承也可以用来实现接口继承和实现继承的分离，从而更好地实现面向对象的编程思想。是一个类模板，可以使用不同类型的数据来实例化。https://blog.csdn.net/m0_62338174/article/details/135573044?csdn_share_tail=%7B%22type%22%3A%22blog%22%2C%22rType%22%3A%22article%22%2C%22rId%22%3A%22135573044%22%2C%22source%22%3A%22m0_62338174%22%7D?

C++ 是一门功能强大的编程语言，它提供了很多工具来实现各种编程任务。在本文中，我们将介绍 C++ 中的三个重要概念：友元、嵌套类和异常。

一、友元

C++ 中的友元是一种机制，允许一个类或函数访问另一个类的私有成员。当一个类或者函数被声明为另一个类的友元后，它就可以在访问该类的私有成员时绕过访问权限检查，直接访问该类的私有成员。

友元可以是一个类、一个函数或者一个整个命名空间。为了使一个类成为另一个类的友元，需要在其中一个类的声明中使用 friend 关键字来声明该类是另一个类的友元。需要注意的是，友元关系是单向的，即如果 A 类是 B 类的友元，那么 B 类并不一定是 A 类的友元。

使用友元的优点在于它可以提高程序的灵活性和可读性。比如，一个类中的某些私有成员可能只是为了方便内部实现而设置的，但是这些成员对于外部用户来说并没有意义，此时可以通过把需要访问这些私有成员的类或函数声明为友元来提高程序的可用性和可读性。

然而，需要注意的是，过度使用友元会破坏封装性，并降低代码的可维护性。因此，在使用友元时，应该谨慎使用，只在必要的情况下使用友元。

一个使用友元的示例代码

#include <iostream>

class A {
private:
    int x;

public:
    A(int value) : x(value) {}

    friend class B;
};

class B {
public:
    void showMessage(A& a) {
        std::cout << "x = " << a.x << std::endl;
    }
};

int main() {
    A a(10);
    B b;
    b.showMessage(a);
    return 0;
}

在这个示例中，B 类被声明为 A 类的友元，因此 B 类可以访问 A 类的私有成员 x。 showMessage() 函数通过引用参数来接收 A 类的对象，并输出了它的私有成员 x 的值。

输出结果

x = 10

友元的使用可以提高程序的灵活性和可读性。但是，需要注意的是过度使用友元会破坏封装性，并降低代码的可维护性。

二、嵌套类

C++ 中的嵌套类是指一个类定义在另一个类的内部，它可以访问外部类的私有成员和保护成员，但外部类不能访问嵌套类的私有成员。嵌套类可以看作是一种逻辑上的组织方式，它可以将与主类相关的功能归纳在一起，提高程序的封装性和可读性。

使用嵌套类的优点在于它可以提高程序的封装性和可读性。比如，一个类中可能包含多个不同的子类，如果将这些子类定义在主类的内部，可以使程序更加整洁和易读。

然而，需要注意的是，过度使用嵌套类会增加代码的复杂度，并降低代码的可维护性。因此，在使用嵌套类时，应该谨慎使用，只在必要的情况下使用嵌套类。

一个使用嵌套类的示例代码

#include <iostream>

class A {
private:
    int x;

public:
    A(int value) : x(value) {}

    class B {
    public:
        void showMessage(A& a) {
            std::cout << "x = " << a.x << std::endl;
        }
    };
};

int main() {
    A a(10);
    A::B b;
    b.showMessage(a);
    return 0;
}

在这个示例中，B 类被嵌套在 A 类的内部，因此 B 类可以访问 A 类的私有成员 x。 showMessage() 函数通过引用参数来接收 A 类的对象，并输出了它的私有成员 x 的值。

输出结果

x = 10

嵌套类的使用可以提高程序的封装性和可读性。但是，需要注意的是过度使用嵌套类会增加代码的复杂度，并降低代码的可维护性。

三、异常

C++ 中的异常是指程序运行过程中遇到的错误或异常情况。当程序出现异常时，程序会跳转到异常处理器，并执行一些特定的代码，以处理异常并恢复程序的正常运行。C++ 中的异常处理机制允许程序员在程序出现错误时选择不同的处理方式，从而提高程序的可靠性和鲁棒性。

异常可以分为两类：标准异常和自定义异常。标准异常是 C++ 内置的异常类型，它们定义在 <stdexcept> 头文件中，包括 std::invalid_argument、std::range_error、std::logic_error 等。自定义异常是程序员自己定义的异常类型，可以通过继承 std::exception 类来实现。

使用异常处理的优点在于它可以提高程序的健壮性和可读性。当程序出现异常时，程序会跳转到异常处理器，并执行一些特定的代码，以处理异常并恢复程序的正常运行。

然而，需要注意的是，过度使用异常处理会影响程序的性能，并增加代码的复杂度。因此，在使用异常处理时，应该谨慎使用，只在必要的情况下使用异常处理。

一个使用异常处理的示例代码

#include <iostream>
#include <stdexcept>

int divide(int x, int y) {
    if (y == 0) {
        throw std::invalid_argument("Divide by zero.");
    }
    return x / y;
}

int main() {
    int x = 10, y = 0;
    try {
        int z = divide(x, y);
        std::cout << "z = " << z << std::endl;
    } catch (std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}

在这个示例中，divide() 函数用于计算两个整数的商，如果除数为零，则抛出一个 std::invalid_argument 异常。在 main() 函数中，我们使用 try-catch 块来捕获可能抛出的异常，当程序运行到抛出异常的地方时，程序会跳转到 catch 块并执行其中的代码。

输出结果

Error: Divide by zero.

异常处理的使用可以提高程序的健壮性和可读性。但是，需要注意的是过度使用异常处理会影响程序的性能，并增加代码的复杂度。

四、结论

友元、嵌套类和异常是 C++ 中三个重要的概念，它们可以提高程序的灵活性、封装性和健壮性。但是，需要注意的是过度使用它们会破坏程序的封装性、增加代码的复杂度和影响程序的性能。因此，在编写程序时，应根据实际情况选择适当的编程技术来提高程序的可读性、可维护性和可靠性。

五、使用它们的注意事项

在使用友元、嵌套类和异常时，需要注意以下事项：

1. 友元关系是单向的，如果将一个类 A 定义为另一个类 B 的友元，则 B 不一定是 A 的友元。
2. 友元可以提高程序的灵活性和可读性，但过度使用会破坏封装性，降低代码的可维护性。
3. 嵌套类可以将与主类相关的功能归纳在一起，提高程序的封装性和可读性，但过度使用会增加代码的复杂度，降低代码的可维护性。
4. 异常处理机制可以提高程序的健壮性和可读性，但过度使用会影响程序的性能，增加代码的复杂度。在编写程序时，应该根据实际情况选择适当的处理方式。
5. 在使用异常处理时，应该明确什么情况下应该抛出异常，什么情况下应该返回错误码或者其他特定值。抛出异常应该是一种非常规的处理方式，只在必要的情况下使用。
6. 在使用嵌套类时，应该考虑将哪些功能归纳在一起，以及哪些功能应该作为一个独立的类来实现。嵌套类的使用应该有助于提高程序的结构性和可读性。
7. 在使用友元时，应该仔细考虑哪些类或者函数需要访问另一个类的私有成员，只在必要的情况下使用。同时，应该尽量避免破坏封装性，保证程序的可维护性和可靠性。