C++模块化之内部类_c++ 内部类-CSDN博客

本文链接：https://blog.csdn.net/haokan123456789/article/details/140217981

1.引言

在C++中，内部类（Nested Class）是一种相对不太常用但却非常强大的编程工具。就是在一个类内部定义另外一个类，注意此时这个内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

注意：内部类就是外部类的友元类。注意友元类的定义，内部类可以通过外部类的对象参数来访问外部类中的所有成员，不管是public、protected、private。但是外部类不是内部类的友元。

下面是一个简单的内部类的例子：

#include <iostream>  
#include <string>  
  
class OuterClass {  
private:  
    std::string outerData;  
  
public:  
    OuterClass(const std::string& data) : outerData(data) {}  
  
    class InnerClass {  
    private:  
        std::string innerData;  
  
    public:  
        InnerClass(const std::string& data) : innerData(data) {}  
  
        void display() {  
            std::cout << "Outer Class Data: " << outer->outerData << std::endl;  
            std::cout << "Inner Class Data: " << innerData << std::endl;  
        }  
  
        // 必须有一个指向外部类实例的指针或引用  
        OuterClass* outer;  
    };  
  
    InnerClass* createInnerClass(const std::string& innerData) {  
        InnerClass* inner = new InnerClass(innerData);  
        inner->outer = this; // 设置外部类实例的指针  
        return inner;  
    }  
};  
  
int main() {  
    OuterClass outer("Outer Data");  
    OuterClass::InnerClass* inner = outer.createInnerClass("Inner Data");  
    inner->display();  
  
    delete inner; // 不要忘记释放内存  
    return 0;  
}

在这个例子中，InnerClass 是一个非静态内部类，它依赖于 OuterClass 的实例。我们通过 outer 指针来访问外部类的私有成员。

2.内部类的访问控制

内部类与外部类之间的访问控制是C++中的一个重要特性。内部类可以访问外部类的私有和保护成员，反之亦然。这使得内部类可以更方便地操作外部类的内部状态。以下是一个例子：

class OuterClass {
private:
    int outerValue;

public:
    OuterClass(int value) : outerValue(value) {}

    class InnerClass {
    public:
        void display(const OuterClass& outer) {
            std::cout << "Outer class value: " << outer.outerValue << std::endl;
        }
    };
};

int main() {
    OuterClass outer(42);
    OuterClass::InnerClass inner;
    inner.display(outer);

    return 0;
}

在这个例子中，InnerClass通过传递一个OuterClass对象的引用来访问其私有成员outerValue。这种设计使得内部类可以直接与外部类进行交互，而不需要暴露外部类的私有成员。

注意内部类可以直接访问外部类中的static、枚举成员，不需要外部类的对象/类名。

class A
{
public: 
    class B{
        void foo(){
             cout << k <<endl;//OK
             //cout << h <<endl;// ERROR
        }
     };

private: 
    static int k;
    int h;
};
int A::k=3;

内部类可以现在外部类中声明，然后在外部类外定义：

class A
{
public: 
    class B;

private: 
    static int i;
};

class A::B
{
public:
    void foo(){
        cout << i <<endl;
    }//!!!这里也不需要加A::i.
};

int A::i=3;

3.优缺点分析

优点

封装性增强：

内部类可以帮助将一个类的实现细节封装起来，避免外部直接访问这些细节。通过内部类，可以更方便地访问外部类的私有成员，而无需将这些成员暴露给外部世界，从而增强了类的封装性。

内部类可以声明为private或protected，进一步限制其访问范围，实现更好的信息隐藏。

模块化：

内部类使得相关的功能可以集中在一个地方，提高了代码的可读性和维护性。尤其是在实现复杂的数据结构（如树、图）时，内部类可以用来表示节点或边，使得数据结构的实现更加清晰和紧凑。

作用域控制：

内部类的作用域被限制在外部类的范围内，这有助于避免命名冲突和不必要的依赖。同时，这种设计也使得内部类的使用更加局部化，减少了全局作用域中的类数量。

访问控制灵活性：

内部类可以访问外部类的所有成员（包括私有成员），这为类之间的数据共享和交互提供了便利。同时，通过调整内部类的访问修饰符（如public、protected、private），可以对内部类的访问进行灵活控制。

实现隐藏：

在一些需要隐藏实现细节的场景中，内部类可以有效地将这些细节封装起来。例如，在数据库连接池的实现中，可以使用内部类来封装连接的管理逻辑。

缺点

复杂性增加：

虽然内部类可以提高封装性和模块化，但它们也可能增加代码的复杂性。当嵌套层次较多时，理解和维护代码可能会变得更加困难。

可读性问题：

对于不熟悉内部类设计模式的开发者来说，内部类可能会降低代码的可读性。因此，在使用内部类时，需要提供充分的注释和文档来解释其设计目的和使用方式。

访问限制：

尽管内部类可以访问外部类的私有成员，但外部类不能直接访问内部类的私有成员（除非通过内部类的对象）。这可能会在某些情况下限制设计的灵活性。

编译器支持：

尽管大多数现代C++编译器都支持内部类，但在一些特殊情况下，可能会遇到编译器特有的问题或限制。因此，在跨平台开发时需要注意编译器之间的差异。

4.实际运用

内部类在实际编程中有着广泛的应用，以下是几个常见的场景：

4.1.实现复杂数据结构

在实现如树、图等复杂数据结构时，内部类可以用来表示节点或边，从而使得数据结构的实现更加清晰和紧凑。例如，在实现二叉树时，可以将节点定义为内部类：

class BinaryTree {  
private:  
    struct Node {  
        int value;  
        Node* left;  
        Node* right;  
        Node(int val) : value(val), left(nullptr), right(nullptr) {}  
    };  
    Node* root;  
public:  
    BinaryTree() : root(nullptr) {}  
    // 添加节点、删除节点等函数  
};

4.2.封装细节实现

在一些需要隐藏实现细节的场景中，内部类可以有效地将这些细节封装起来。例如，在实现一个加密算法，在某种特殊的情况下，我想隐藏这个加密算法实现，那么就可以把这个加密算法封装在类的内部，通过接口提供出来，代码如下：

#include <iostream>
#include <string>

//加密接口
class IDecrypt
{
public:
    virtual std::string  encryptDecrypt(const std::string& input, char key) = 0;
};

//一种加密实现
class CBasicDecrypt : public IDecrypt
{
public:
    std::string encryptDecrypt(const std::string& input, char key) override {
        std::string output = input;
 
        for (size_t i = 0; i < input.length(); ++i) {
            output[i] = input[i] ^ key;
        }
 
        return output;
    }
};


class CMyBusiness
{
    ...

protected:
    //我的加密实现
    class CMyDecrypt : public IDecrypt
    {
     public:
        std::string encryptDecrypt(const std::string& input, char key) override {
            std::string output = input;
 
            for (size_t i = 0; i < input.length(); ++i) {
                output[i] = input[i] | key;
            }
 
            return output;
        }       
    };

public:
    //通过接口给外界使用，隐藏它的实现
    IDecrypt* getDecrypt() {
        return &m_myDecrypt;
    }

private:
    CMyDecrypt  m_myDecrypt;
};

4.3.事件处理和回调

在GUI编程或需要事件处理机制的应用中，内部类常用于实现事件处理和回调函数。例如，在一个按钮点击事件处理中，可以使用内部类来封装事件处理逻辑：

class Button {  
public:  
    class ClickListener {  
    public:  
        virtual void onClick() = 0;  
    };  
private:  
    ClickListener* listener;  
public:  
    void setClickListener(ClickListener* listener) {  
        this->listener = listener;  
    }  
    void click() {  
        if (listener) {  
            listener->onClick();  
        }  
    }  
};