C++ 设计模式——组合模式

最新推荐文章于 2024-08-25 23:11:21 发布
最新推荐文章于 2024-08-25 23:11:21 发布
阅读量492 收藏 15
点赞数 24
分类专栏： C++ 设计模式 文章标签： c++ 设计模式 组合模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_68194402/article/details/141533510
版权

C++ 设计模式——组合模式

C++ 设计模式——组合模式

组合模式（Composite Pattern）是一种结构性设计模式，允许将一组对象组织成树形结构以表示“部分-整体”的层次结构。使得用户对单个对象和组合对象的操作/使用/处理具有一致性。组合模式使得客户端可以以统一的方式对待单个对象和组合对象，从而简化了客户端代码的复杂性。

1. 主要组成成分

  1. 抽象组件（Component）：声明了叶子和组合对象的共同接口。
  2. 叶子组件（Leaf）：实现了组件接口，代表树中的叶子节点。
  3. 组合组件（Composite）：实现了组件接口，定义了叶子和子组件的行为，存储子组件。

2. 逐步构建透明组合模式

透明组合模式允许客户端以统一的方式处理单个对象和组合对象。通过在基类中定义 Add 和 Remove 方法，组合对象可以自由添加和删除子对象。这种模式适用于需要处理树形结构的场景，提供了良好的灵活性和可扩展性。下面是如何逐步构建透明组合模式的示例。

1. 定义抽象组件（Component）

首先，定义一个抽象基类 FileSystem，声明所有具体组件的接口。

//抽象父类FileSystem（抽象接口）
class FileSystem
{
public:
    virtual void ShowName(int level) = 0; //显示名字，参数level用于表示显示的层级，用于显示对齐
    virtual int Add(FileSystem* pfilesys) = 0; //向当前目录中增加文件或子目录
    virtual int Remove(FileSystem* pfilesys) = 0;//从当前目录中移除文件或子目录
    virtual ~FileSystem() {} //做父类时析构函数应该为虚函数
};
2. 实现叶子组件（Leaf）

接下来，创建一个表示文件的类 File，它继承自 FileSystem。

//文件相关类
class File :public FileSystem
{
public:
    //构造函数
    File(string name) :m_sname(name) {}
    //显示名字
    void ShowName(int level)
    {
        for (int i = 0; i < level; ++i) { cout << "    "; } //显示若干个空格用与对齐
        cout << "-" << m_sname << endl;
    }
    virtual int Add(FileSystem* pfilesys)
    {
        //文件中其实是不可以增加其他文件或者目录的，所以这里直接返回-1，无奈的是父类中定义了该接口，所以子类中也必须实现该接口
        return -1;
    }
    virtual int Remove(FileSystem* pfilesys)
    {
        //文件中不包含其他文件或者目录，所以这里直接返回-1
        return -1;
    }
private:
    string m_sname;  //文件名
};
3. 实现组合组件（Composite）

接着，创建一个表示目录的类 Dir，它也继承自 FileSystem。

//目录相关类
class Dir :public FileSystem
{
public:
    //构造函数
    Dir(string name) :m_sname(name) {}
    //显示名字
    void ShowName(int level)
    {
        //（1）显示若干个空格用与对齐
        for (int i = 0; i < level; ++i) { cout << "    "; }
        //（2）输出本目录名
        cout << "+" << m_sname << endl;
        //（3）显示的层级向下走一级
        level++;
        //（4）输出所包含的子内容（可能是文件，也可能是子目录）
        //遍历目录中的文件和子目录
        for (auto iter = m_child.begin(); iter != m_child.end(); ++iter)
        {
            (*iter)->ShowName(level);
        }//end for
    }
    virtual int Add(FileSystem* pfilesys)
    {
        m_child.push_back(pfilesys);
        return 0;
    }
    virtual int Remove(FileSystem* pfilesys)
    {
        m_child.remove(pfilesys);
        return 0;
    }
private:
    string m_sname;             //文件名
    list<FileSystem*> m_child;  //目录中包含的文件或其他目录列表
};
4. 主函数（Main）

在 main 函数中，创建文件和目录对象，并构建树形结构。

int main()
{
    Dir* root = new Dir("root");
    FileSystem* file1 = new File("common.mk");
    FileSystem* file2 = new File("config.mk");
    Dir* appDir = new Dir("app");
    FileSystem* file3 = new File("nginx.c");

    // 构建树形结构
    root->Add(file1);
    root->Add(file2);
    root->Add(appDir);
    appDir->Add(file3);

    // 显示整个目录结构
    root->ShowName(0);

    // 释放资源
    delete file3;
    delete appDir;
    delete file2;
    delete file1;
    delete root;

    return 0;
}

运行上述代码，输出结果如下：

+root
    -common.mk
    -config.mk
    +app
        -nginx.c
透明组合模式 UML 图

透明组合模式 UML 图

透明组合模式 UML 图解析
  • Component (抽象组件): 为树枝和树叶定义接口（例如，增加、删除、获取子节点等），可以是抽象类，包含所有子类公共行为的声明或默认实现体。这里指 FileSystem 类。
  • Leaf (叶子组件): 用于表示树叶节点对象，这种对象没有子节点，因此抽象组件中定义的一些接口（例如 Add、Remove）在这里没有实现的意义。这里指 File 类。
  • Composite (树枝组件): 用于表示一个容器（树枝）节点对象，可以包含子节点，子节点可以是树叶，也可以是树枝，其中提供了一个集合用于存储子节点（以此形成一个树形结构，可以通过递归来访问所有节点）。实现了抽象组件中定义的接口。这里指 Dir 类。
透明组合模式的优点
  • 一致的接口：客户端可以使用相同的方式处理单个对象和组合对象。
  • 简化代码：减少了客户端代码的复杂性，便于管理和扩展。
  • 灵活性：可以轻松地添加新的叶子或组合类。
透明组合模式的缺点
  • 设计复杂性：需要设计一个抽象组件接口，可能导致过多的类。
  • 性能开销：在某些实现中，可能会有额外的性能开销，特别是在树结构较深时。
透明组合模式的适用场景
  • 需要表示“部分-整体”层次结构的场景，例如文件系统、组织结构等。
  • 客户端需要统一处理单个对象和组合对象的场景。

3. 逐步构建安全组合模式

安全组合模式通过类型安全的方式管理树形结构中的对象，确保只有组合对象可以添加子对象。通过实现 ifCompositeObj 方法，能够明确区分叶子和组合对象，从而避免不当操作。此模式适用于需要严格管理树形结构的场景。以下是逐步构建安全组合模式的示例。

1. 定义抽象组件（Component）

首先，定义一个抽象基类 FileSystem，它声明了所有具体组件的接口。

#include <iostream>
#include <list>
#include <string>

class Dir; // 前向声明

//抽象父类FileSystem（抽象接口）
class FileSystem
{
public:
    virtual void ShowName(int level) = 0; //显示名字，参数level用于表示显示的层级，用于显示对齐
    virtual ~FileSystem() {}//做父类时析构函数应该为虚函数
    virtual Dir* ifCompositeObj() { return nullptr; }
    virtual int countNumOfFiles() = 0;  //统计目录下包含的文件个数

};
2. 实现叶子组件（Leaf）

接下来，创建一个表示文件的类 File，它继承自 FileSystem。

//文件相关类
class File :public FileSystem
{
public:
    //构造函数
    File(string name) :m_sname(name) {}

    //显示名字
    void ShowName(int level)
    {
        for (int i = 0; i < level; ++i) { cout << "    "; } //显示若干个空格用与对齐
        cout << "-" << m_sname << endl;
    }
    
    virtual int countNumOfFiles()
    {
        return 1; //文件节点，做数量统计时按1计算
    }

private:
    string m_sname;  //文件名
};
3. 实现组合组件（Composite）

接着，创建一个表示目录的类 Dir，它也继承自 FileSystem。

// 目录类
class Dir :public FileSystem
{
    //该类内容基本没变，把Add和Remove成员函数前面的virtual修饰符去掉即可。
public:
    //构造函数
    Dir(string name) :m_sname(name) {}
    //显示名字
    void ShowName(int level)
    {
        //（1）显示若干个空格用与对齐
        for (int i = 0; i < level; ++i) { cout << "    "; }
        //（2）输出本目录名
        cout << "+" << m_sname << endl;
        //（3）显示的层级向下走一级
        level++;
        //（4）输出所包含的子内容（可能是文件，也可能是子目录）
        //遍历目录中的文件和子目录
        for (auto iter = m_child.begin(); iter != m_child.end(); ++iter)
        {
            (*iter)->ShowName(level);
        }//end for
    }
    /*virtual*/ int Add(FileSystem* pfilesys)
    {
        m_child.push_back(pfilesys);
        return 0;
    }
    /*virtual*/ int Remove(FileSystem* pfilesys)
    {
        m_child.remove(pfilesys);
        return 0;
    }

    virtual Dir* ifCompositeObj() { return this; }

    virtual int countNumOfFiles()
    {
        int iNumOfFiles = 0;
        for (auto iter = m_child.begin(); iter != m_child.end(); ++iter)
        {
            iNumOfFiles += (*iter)->countNumOfFiles();//递归调用
        }
        return iNumOfFiles;
    }


private:
    string m_sname;             //文件名
    list<FileSystem*> m_child;  //目录中包含的文件或其他目录列表
};
4. 主函数（Main）

在 main 函数中，创建文件和目录对象，并构建树形结构。

int main() {
    Dir* root = new Dir("root");
    FileSystem* file1 = new File("common.mk");
    FileSystem* file2 = new File("config.mk");
    Dir* appDir = new Dir("app");
    FileSystem* file3 = new File("nginx.c");

    // 构建树形结构
    root->Add(file1);
    root->Add(file2);
    root->Add(appDir);
    appDir->Add(file3);

    // 显示整个目录结构
    root->ShowName(0);
    std::cout << "文件的数量为：" << root->countNumOfFiles() << std::endl;

    // 释放资源
    delete file3;
    delete appDir;
    delete file2;
    delete file1;
    delete root;

    return 0;
}

运行上述代码，输出结果如下：

+root
    -common.mk
    -config.mk
    +app
        -nginx.c
文件的数量为：3
安全组合模式 UML 图

安全组合模式 UML 图

安全组合模式 UML 图解析
  • Component (抽象组件): 定义树枝和树叶的接口，包含公共行为的声明。
  • Leaf (叶子组件): 表示没有子节点的对象，通常不实现 Add 和 Remove 方法。
  • Composite (树枝组件): 包含子节点，能够递归地调用子节点的方法。
安全组合模式的优点
  • 类型安全：通过类型检查，确保只有组合对象可以添加子对象。
  • 清晰的责任分配：各类的功能分离更加明确，便于维护。
安全组合模式的缺点
  • 复杂性增加：实现安全组合模式可能需要更多的代码和逻辑。
  • 不够灵活：如果需要动态改变对象的行为，可能会受到限制。
安全组合模式的适用场景
  • 需要确保组合对象的类型安全，避免非法操作的场景。
  • 需要明确区分叶子和组合对象的场景。

总结

组合模式是一种强大的设计模式，适用于处理树形结构的场景。通过透明组合模式和安全组合模式，两者各有优缺点，开发者应根据具体需求选择合适的实现方式。组合模式不仅简化了客户端的代码，还提高了代码的可扩展性和可维护性。

透明组合模式完整代码

#include <iostream>
#include <list>
using namespace std;

//抽象父类FileSystem（抽象接口）
class FileSystem
{
public:
    virtual void ShowName(int level) = 0; //显示名字，参数level用于表示显示的层级，用于显示对齐
    virtual int Add(FileSystem* pfilesys) = 0; //向当前目录中增加文件或子目录
    virtual int Remove(FileSystem* pfilesys) = 0;//从当前目录中移除文件或子目录
    virtual ~FileSystem() {} //做父类时析构函数应该为虚函数
};

//文件相关类
class File :public FileSystem
{
public:
    //构造函数
    File(string name) :m_sname(name) {}
    //显示名字
    void ShowName(int level)
    {
        for (int i = 0; i < level; ++i) { cout << "    "; } //显示若干个空格用与对齐
        cout << "-" << m_sname << endl;
    }
    virtual int Add(FileSystem* pfilesys)
    {
        //文件中其实是不可以增加其他文件或者目录的，所以这里直接返回-1，无奈的是父类中定义了该接口，所以子类中也必须实现该接口
        return -1;
    }
    virtual int Remove(FileSystem* pfilesys)
    {
        //文件中不包含其他文件或者目录，所以这里直接返回-1
        return -1;
    }
private:
    string m_sname;  //文件名
};

//目录相关类
class Dir :public FileSystem
{
public:
    //构造函数
    Dir(string name) :m_sname(name) {}
    //显示名字
    void ShowName(int level)
    {
        //（1）显示若干个空格用与对齐
        for (int i = 0; i < level; ++i) { cout << "    "; }
        //（2）输出本目录名
        cout << "+" << m_sname << endl;
        //（3）显示的层级向下走一级
        level++;
        //（4）输出所包含的子内容（可能是文件，也可能是子目录）
        //遍历目录中的文件和子目录
        for (auto iter = m_child.begin(); iter != m_child.end(); ++iter)
        {
            (*iter)->ShowName(level);
        }//end for
    }
    virtual int Add(FileSystem* pfilesys)
    {
        m_child.push_back(pfilesys);
        return 0;
    }
    virtual int Remove(FileSystem* pfilesys)
    {
        m_child.remove(pfilesys);
        return 0;
    }
private:
    string m_sname;             //文件名
    list<FileSystem*> m_child;  //目录中包含的文件或其他目录列表
};

int main()
{
    //（1）创建各种目录，文件对象
    FileSystem* pdir1 = new Dir("root");
    //-------
    FileSystem* pfile1 = new File("common.mk");
    FileSystem* pfile2 = new File("config.mk");
    FileSystem* pfile3 = new File("makefile");
    //-------
    FileSystem* pdir2 = new Dir("app");
    FileSystem* pfile4 = new File("nginx.c");
    FileSystem* pfile5 = new File("ngx_conf.c");
    //-------
    FileSystem* pdir3 = new Dir("signal");
    FileSystem* pfile6 = new File("ngx_signal.c");
    //-------
    FileSystem* pdir4 = new Dir("_include");
    FileSystem* pfile7 = new File("ngx_func.h");
    FileSystem* pfile8 = new File("ngx_signal.h");

    //（2）构造树形目录结构
    pdir1->Add(pfile1);
    pdir1->Add(pfile2);
    pdir1->Add(pfile3);
    //-------
    pdir1->Add(pdir2);
    pdir2->Add(pfile4);
    pdir2->Add(pfile5);
    //-------
    pdir1->Add(pdir3);
    pdir3->Add(pfile6);
    //-------
    pdir1->Add(pdir4);
    pdir4->Add(pfile7);
    pdir4->Add(pfile8);

    //（3）输出整个目录结构，只要调用根目录的ShowName方法即可，每个子目录都有自己的ShowName方法负责自己旗下的文件和目录的显示
    pdir1->ShowName(0);

    //（4）释放资源
    delete pfile8;
    delete pfile7;
    delete pdir4;
    //-------
    delete pfile6;
    delete pdir3;
    //-------
    delete pfile5;
    delete pfile4;
    delete pdir2;
    //-------
    delete pfile3;
    delete pfile2;
    delete pfile1;
    delete pdir1;
    return 0;
}

安全组合模式完整代码

#include <iostream>
#include <list>
using namespace std;

class Dir;
//抽象父类FileSystem（抽象接口）
class FileSystem
{
public:
    virtual void ShowName(int level) = 0; //显示名字，参数level用于表示显示的层级，用于显示对齐
    virtual ~FileSystem() {}//做父类时析构函数应该为虚函数

public:
    virtual Dir* ifCompositeObj() { return nullptr; }

public:
    virtual int countNumOfFiles() = 0;  //统计目录下包含的文件个数

};

//文件相关类
class File :public FileSystem
{
public:
    //构造函数
    File(string name) :m_sname(name) {}

    //显示名字
    void ShowName(int level)
    {
        for (int i = 0; i < level; ++i) { cout << "    "; } //显示若干个空格用与对齐
        cout << "-" << m_sname << endl;
    }

public:
    virtual int countNumOfFiles()
    {
        return 1; //文件节点，做数量统计时按1计算
    }

private:
    string m_sname;  //文件名
};

class Dir :public FileSystem
{
    //该类内容基本没变，把Add和Remove成员函数前面的virtual修饰符去掉即可。
public:
    //构造函数
    Dir(string name) :m_sname(name) {}
    //显示名字
    void ShowName(int level)
    {
        //（1）显示若干个空格用与对齐
        for (int i = 0; i < level; ++i) { cout << "    "; }
        //（2）输出本目录名
        cout << "+" << m_sname << endl;
        //（3）显示的层级向下走一级
        level++;
        //（4）输出所包含的子内容（可能是文件，也可能是子目录）
        //遍历目录中的文件和子目录
        for (auto iter = m_child.begin(); iter != m_child.end(); ++iter)
        {
            (*iter)->ShowName(level);
        }//end for
    }
    /*virtual*/ int Add(FileSystem* pfilesys)
    {
        m_child.push_back(pfilesys);
        return 0;
    }
    /*virtual*/ int Remove(FileSystem* pfilesys)
    {
        m_child.remove(pfilesys);
        return 0;
    }

public:
    virtual Dir* ifCompositeObj() { return this; }

public:
    virtual int countNumOfFiles()
    {
        int iNumOfFiles = 0;
        for (auto iter = m_child.begin(); iter != m_child.end(); ++iter)
        {
            iNumOfFiles += (*iter)->countNumOfFiles();//递归调用
        }
        return iNumOfFiles;
    }


private:
    string m_sname;             //文件名
    list<FileSystem*> m_child;  //目录中包含的文件或其他目录列表
};

int main()
{
    //（1）创建各种目录，文件对象
    Dir* pdir1 = new Dir("root");
    //-------
    FileSystem* pfile1 = new File("common.mk");
    FileSystem* pfile2 = new File("config.mk");
    FileSystem* pfile3 = new File("makefile");
    //-------
    Dir* pdir2 = new Dir("app");
    if (pdir2->ifCompositeObj() != nullptr)
    {
        //是个组合对象，可以向其中增加单个对象和其它组合对象
    }
    if (dynamic_cast<Dir*>(pdir2) != nullptr)
    {
        //是个组合对象，可以向其中增加单个对象和其它组合对象
    }

    FileSystem* pfile4 = new File("nginx.c");
    FileSystem* pfile5 = new File("ngx_conf.c");
    //-------
    Dir* pdir3 = new Dir("signal");
    FileSystem* pfile6 = new File("ngx_signal.c");
    //-------
    Dir* pdir4 = new Dir("_include");
    FileSystem* pfile7 = new File("ngx_func.h");
    FileSystem* pfile8 = new File("ngx_signal.h");

    //（2）构造树形目录结构
    //这部分内容基本没变，
    pdir1->Add(pfile1);
    pdir1->Add(pfile2);
    pdir1->Add(pfile3);
    //-------
    pdir1->Add(pdir2);
    pdir2->Add(pfile4);
    pdir2->Add(pfile5);
    //-------
    pdir1->Add(pdir3);
    pdir3->Add(pfile6);
    //-------
    pdir1->Add(pdir4);
    pdir4->Add(pfile7);
    pdir4->Add(pfile8);

    //（3）输出整个目录结构，只要调用根目录的ShowName方法即可，每个子目录都有自己的ShowName方法负责自己旗下的文件和目录的显示
    pdir1->ShowName(0);

    cout << "文件的数量为：" << pdir1->countNumOfFiles() << endl;

    //（4）释放资源
    //这部分内容基本没变，
    delete pfile8;
    delete pfile7;
    delete pdir4;
    //-------
    delete pfile6;
    delete pdir3;
    //-------
    delete pfile5;
    delete pfile4;
    delete pdir2;
    //-------
    delete pfile3;
    delete pfile2;
    delete pfile1;
    delete pdir1;

    return 0;
}
不是仙人的闲人
关注
  • 24
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式——组合模式（composite pattern）
净无邪博客
10-21 859
# 一、原理讲解 ## 1.1意图 将对象组合成树形结构以表示“部分 — 整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。 ## 1.2应用场景 - 你想表示对象的部分 — 整体层次结构； - 你
C++ 设计模式 —— 组合模式
莫寒技术人生
10-13 1193
组合模式的定义组合模式的作用组合模式是一种行为型设计模式，它将对象组合成树形结构以表示部分 - 整体的层次结构。这种模式使得用户对单个对象和组合对象的使用具有一致性。组合模式主要应用于需要表示复杂对象结构或者需要将对象组合成树形结构的场景。组合模式的定义和作用：定义：组合模式通过一种巧妙的设计方案，可以一致性地处理整个树形结构或者树形结构的一部分，也可以一致性地处理树形结构中的叶子节点（不包含子节点的节点）和容器节点。
C++设计模式——组合模式
伊壬同学的博客
08-14 653
C++设计模式——组合模式概念 组合模式，将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。掌握组合模式的重点是要理解清楚 “部分/整体” 还有 ”单个对象“ 与 “组合对象” 的含义。 组合模式可以让客户端像修改配置文件一样简单的完成本来需要流程控制语句来完成的功能。 场景描述    现有一个公司需要实现一个广播的功能，用来通知
C++设计模式——组合模式(Composite Pattern)
leonardohaig的博客
06-07 1254
C++设计模式——组合模式 微信公众号：幼儿园的学霸 目录 文章目录C++设计模式——组合模式目录定义定义结构代码示例总结使用场景及注意事项优缺点参考资料 定义 定义 Compose objects into tree structures to represent part-whole hierarchies.Composite lets clients treat individual objects and compositions of objects uniformly. 将对象组合成树形结
C++设计模式——适配器模式
Abieai的博客
10-14 556
设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。主要实现了适配器模式。
【Composite模式】C++设计模式——组合模式
不负AC不负卿的博客
08-07 896
C++组合模式，Composite设计模式，本文以趣味例子引入对组合模式的认知，并加以对模式总结，同时给出了例子代码，帮助读者对该模式通俗易懂
C++设计模式——Composite组合模式
CoderZZ_2024的博客
06-19 1242
设计模式学习
C++设计模式之——组合模式
qqrrjj2011的博客
02-29 858
在组合模式中，组合对象与单个对象（也称为叶子对象或简单对象）有着相同的接口，所以客户端可以一致地对待它们，无需知道处理的是单个对象还是整个组合结构。尽管以上代码已经实现了组合模式的核心思想，但在实际应用中，我们可能还需要考虑其他因素，例如访问子组件的方式可能不仅仅是按索引获取，还可以支持更灵活的方式来遍历所有子组件。声明了所有用来管理子组件的方法，比如添加、删除和获取子组件等，但在组合对象中实现这些方法，而在叶子对象中则可能提供默认或空实现。：是组合结构中的基本元素，没有子节点，实现了。
C++ 设计模式——命令模式
qq_68194402的博客
08-23 1497
命令(Command)模式是一种行为型模式，它将请求封装为对象，从而使您能够使用不同的请求、排队请求或记录请求，以及支持可撤销的操作。
C++设计模式——Bridge桥接模式
CoderZZ_2024的博客
06-14 1303
设计模式入门
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
c++设计模式GoF23
10-28
### c++设计模式GoF23 #### 0. 引言 - **设计模式的重要性**：“Next to My Life, Software Is My Passion”——Robert C. Martin 的名言揭示了软件设计的重要地位。掌握设计模式意味着理解面向对象分析与设计...
C++设计模式之建造者模式
01-20
建造者模式 在GOF的《设计模式 可复用面向对象软件的基础》中是这样说的：将一个复杂对象的构建与它的表示分离，使得同样的...在《大话设计模式》一书中，例举了一个很好的例子————建造小人。建造一个小人，要分为
设计模式C++版
06-13
设计模式C++版文档主要聚焦于面向对象设计与分析的核心——设计模式，并以C++语言实现为示范。这份文档详尽阐述了23种GoF（Gang of Four）设计模式，并结合具体的C++源码示例，旨在帮助读者深入理解并掌握这些设计...
C++设计模式课件20_Composite_组合模式.pdf
12-13
本篇主要探讨的是结构型模式之一——组合模式。 #### 二、组合模式定义 组合模式（Composite Pattern）是一种树形结构的设计模式，它将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户可以对...
C语言：文件（写入，读取）
2301_80311224的博客
08-21 696
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
【C++】链表
qq_38801607的博客
08-22 555
链表是一种常见的动态数据结构，与数组相比，它在插入和删除操作中具有更高的效率。链表的每个元素称为节点（Node），节点包含两个部分：数据域（存储数据）和指针域（指向下一个节点的指针）。链表的最大特点是节点的内存位置不需要连续，可以通过指针来链接在一起。
C++ 重载运算符和重载函数
lly202406的博客
08-25 362
在C++编程语言中，运算符重载和函数重载是两个非常核心的概念，它们允许开发者扩展或重新定义运算符和函数的行为，以适应特定的数据类型或对象。本文将详细探讨C++中的运算符重载和函数重载，包括它们的基本概念、使用场景、实现方式以及注意事项。
【C语言篇】
最新发布
2301_81072404的博客
08-25 45
条件编译（#ifdef、#ifndef、#else、#elif、#endif）指针与动态内存分配（malloc、calloc、realloc、free）文件的读写操作（fread、fwrite、fprintf、fscanf等）控制语句（if、for、while、do-while、switch等）字符串处理函数（strlen、strcpy、strcat等）运算符（算术运算符、关系运算符、逻辑运算符等）文件的打开与关闭（fopen、fclose）数据类型（整型、浮点型、字符型等）函数参数传递（传值、传址）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值