公告:魔扣目录网为广大站长提供免费收录网站服务,提交前请做好本站友链:【 网站目录:https://www.morko.net 】, 免友链快审服务(50元/站),

点击这里在线咨询客服
新站提交
  • 网站:51995
  • 待审:27
  • 小程序:12
  • 文章:995072
  • 会员:740

在软件开发中,构建模块化、可扩展和易维护的应用程序是每位架构师的目标。本文将介绍如何设计和实现一个模块类来构建一个模块化编程框架,以便更好地管理和扩展应用程序功能。

引言

在软件开发中,模块化编程是一种重要的架构方法。它将应用程序分解为多个相互独立的模块,每个模块负责不同的任务。这种方法使得代码更易维护、更易扩展,也更易重用。本文将介绍一个简单而强大的模块化编程框架,它包括两个主要组件:模块类(Module)和模块工厂类(ModuleFactory)。这两者的结合为开发者提供了一种灵活的方式,可以轻松地创建和管理模块。

模块类(Module)

设计

模块类是模块化编程框架的核心。每个模块都是一个继承自 Module 的类。模块类有一个名字属性,用于唯一标识每个模块。

class Module {
public:
    Module() = default;
    virtual ~Module() = default;

    const std::string &getModuleName() const {
        return moduleName_;
    }

protected:
    void setModuleName(const std::string &name) {
        moduleName_ = name;
    }

private:
    std::string moduleName_;
    friend class ModuleFactory;
};

在上述代码中,Module 类包括了以下主要部分:

  • getModuleName(): 获取模块的名字。
  • setModuleName(const std::string &name): 设置模块的名字。

setModuleName 方法的私有访问权限确保只有 ModuleFactory 类能够修改模块的名字。

模块工厂类(ModuleFactory)

设计

模块工厂类是一个用于创建和管理模块的中心枢纽。每个模块必须在工厂中进行注册,以便能够通过工厂创建和获取模块的实例。

 class ModuleFactory {
private:
    // 内部结构体,用于标识模块
    struct moduleid {
        moduleid() = default;
        moduleid(std::string n, std::size_t h)
            : name(std::move(n)), code(h) {}
        explicit moduleid(const std::type_info &info)
            : name(info.name()), code(info.hash_code()) {}

        bool operator==(const moduleid &mid) const {
            return name == mid.name && code == mid.code;
        }

        std::string name;
        std::size_t code = 0;
    };

public:
    // 获取 ModuleFactory 的单例实例
    static ModuleFactory &getFactory() {
        static ModuleFactory factory;
        return factory;
    }

    // 获取注册在工厂中的模块名称集合
    const std::unordered_set<std::string> &getModuleNames() const {
        return *moduleNames_;
    }

    // 用于注册模块的辅助结构体
    template<typename T, typename C = T>
    struct ModuleRegisterHelper {
        // 构造函数,用于注册模块
        template<typename... Args>
        ModuleRegisterHelper(std::string n, Args &&...args) {
            auto mptr = getFactory().moduleMapTable_;
            if (mptr->find(n) != mptr->end()) {
                throw std::invalid_argument("模块 " + n + " 已经注册。");
            }
            getFactory().moduleNames_->insert(n);
            std::function<std::unique_ptr<Module>(Args...)> create_func = [](Args... args) {
                return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
            };
            const std::any const_any = std::any(create_func);
            (*mptr)[n] = std::make_pAIr(moduleid(typeid(C)), const_any);
        }
    };

    // 获取指定名称和类型的模块
    template<typename T = Module, typename... Args>
    typename std::enable_if<std::is_base_of<Module, T>::value, std::unique_ptr<T>>::type
    getModule(const std::string &n, Args &&...args) {
        auto mptr = getFactory().moduleMapTable_;
        auto miter = mptr->find(n);
        if (miter == mptr->end()) {
            throw std::runtime_error("找不到名称为 " + n + " 的模块。");
        }
        if (miter->second.first == moduleid(typeid(T))) {
            auto moduleCreator = std::any_cast<std::function<std::unique_ptr<Module>(Args...)>>(miter->second.second);
            std::unique_ptr<Module> module = moduleCreator(std::forward<Args>(args)...);
            module->setModuleName(n);
            return std::unique_ptr<T>(static_cast<T *>(module.release()));
        }
        auto moduleCreator = std::any_cast<std::function<std::unique_ptr<Module>(Args...)>>(miter->second.second);
        std::unique_ptr<Module> module = moduleCreator(std::forward<Args>(args)...);
        if (!dynamic_cast<T *>(module.get())) {
            throw std::runtime_error("无法将模块 " + n + " 产生的类型转换为 " + typeid(T).name());
        }
        module->setModuleName(n);
        return std::unique_ptr<T>(static_cast<T *>(module.release()));
    }

private:
    static std::unordered_map<std::string, std::pair<moduleid, std::any>> *moduleMapTable_;
    static std::unordered_set<std::string> *moduleNames_;

    ModuleFactory() {}
    ModuleFactory(const ModuleFactory &) = delete;
    ModuleFactory(ModuleFactory &&) = delete;
};

在 ModuleFactory 类中,可以创建、获取和管理已注册的模块。

注册模块

要使用模块工厂创建模块,需要首先注册模块。这里是通过
ModuleFactory::ModuleRegisterHelper 模板类来实现的。在注册模块时,需要提供模块的类型和名字。

可以使用又爱又恨的宏,避免了手动编写大量的注册代码:

#define MODULE_VARIABLE_NAME(module_name, module_type) Module_##module_name##_##module_type##_
#define REGISTER_MODULE(module_name, module_type, ...) 
    static module::ModuleFactory::ModuleRegisterHelper<module_type> MODULE_VARIABLE_NAME(module_name, module_type)(#module_name, ##__VA_ARGS__)
#define DECLARE_MODULE(module_type, ...) REGISTER_MODULE(module_type, module_type, ##__VA_ARGS__)

解释如下:

  1. MODULE_VARIABLE_NAME(module_name, module_type) 宏:
  2. 该宏用于生成一个唯一的变量名称,通常用于防止冲突。它的作用是在模块名称和模块类型之间创建一个唯一的标识符。
  3. module_name:模块名称,通常是一个字符串。
  4. module_type:模块类型,通常是一个C++类的类型。
  5. 例如,如果你有一个模块名称为 "MyModule",模块类型为 "MyModuleType",则调用 MODULE_VARIABLE_NAME 宏后将生成 Module_MyModule_MyModuleType_ 作为标识符。
  6. REGISTER_MODULE(module_name, module_type, ...) 宏:
  7. 该宏用于注册模块并将其添加到工厂中,以便后续可以根据名称获取该模块。
  8. module_name:模块的名称,通常是一个字符串。
  9. module_type:模块的类型,通常是一个C++类的类型。
  10. ...:可选的额外参数,用于创建模块对象。
  11. 该宏的作用是创建一个静态变量,并使用 MODULE_VARIABLE_NAME 宏生成唯一的变量名称,然后通过 ModuleFactory::ModuleRegisterHelper 类将模块注册到工厂中。这样,你可以在工厂中使用模块名称和类型来创建模块对象。
  12. 例如,如果你调用 REGISTER_MODULE("MyModule", MyModuleType, arg1, arg2),宏将创建一个静态变量 Module_MyModule_MyModuleType_ 并使用 ModuleFactory::ModuleRegisterHelper 来注册一个名为 "MyModule" 类型为 "MyModuleType" 的模块,同时传递额外的参数 arg1 和 arg2 用于创建该模块对象。
  13. 可以很方便的注册模块:
REGISTER_MODULE( "MyModule",MyModule);

不喜欢使用宏则可以:

template<typename T, typename... Args>
void registerModule(const std::string &moduleName, Args &&...args) {
    static ModuleFactory::ModuleRegisterHelper<T> helper(moduleName, std::forward<Args>(args)...);
}

注册模块:

registerModule<MyModuleType>("MyModule", arg1, arg2);

使用模块

下面是一个示例,展示如何使用模块类和模块工厂类来创建和管理模块。

// 定义一个模块类
class MyModule : public Module {
public:
    // 自定义模块的行为
};

// 注册模块
REGISTER_MODULE( "MyModule",MyModule);

int main() {
    // 使用模块工厂创建模块
    ModuleFactory &factory = ModuleFactory::getFactory();
    MyModule *module = factory.getMultiModule<MyModule>("MyModule");

    // 使用模块
    if (module) {
        std::cout << "Created module: " << module->getModuleName() << std::endl;
    }

    return 0;
}

项目使用案例:

下面以虚拟商城系统为例,演示如何使用模块类和模块工厂类来创建虚拟商城系统,包括购物车管理、用户注册和商品管理等多个模块。

首先,创建购物车管理模块:

#include "Module.h"

class ShoppingCartModule : public module::Module {
public:
    ShoppingCartModule() {
        setModuleName("ShoppingCartModule");
    }

    void execute() override {
        std::cout << "Shopping Cart Management Module executed." << std::endl;
        // 添加购物车操作
        addToCart("Product1", 10.0);
        addToCart("Product2", 15.0);
        displayCartContents();
        calculateTotal();
    }

    void addToCart(const std::string& item, double price) {
        cart.push_back(std::make_pair(item, price));
        std::cout << "Added " << item << " to the cart. Price: " << price << " USD" << std::endl;
    }

    void displayCartContents() {
        std::cout << "Cart Contents:" << std::endl;
        for (const auto& item : cart) {
            std::cout << item.first << " - " << item.second << " USD" << std::endl;
        }
    }

    void calculateTotal() {
        double total = 0.0;
        for (const auto& item : cart) {
            total += item.second;
        }
        std::cout << "Total Cart Value: " << total << " USD" << std::endl;
    }

private:
    std::vector<std::pair<std::string, double>> cart;
};

DECLARE_MODULE(ShoppingCartModule);

然后,创建用户注册模块:

#include "Module.h"

class UserRegistrationModule : public module::Module {
public:
    UserRegistrationModule() {
        setModuleName("UserRegistrationModule");
    }

    void execute() override {
        std::cout << "User Registration Module executed." << std::endl;
        // 用户注册操作
        registerUser("User1");
        registerUser("User2");
        displayRegisteredUsers();
        loginUser("User1");
    }

    void registerUser(const std::string& username) {
        users.push_back(username);
        std::cout << "Registered new user: " << username << std::endl;
    }

    void displayRegisteredUsers() {
        std::cout << "Registered Users:" << std::endl;
        for (const std::string& user : users) {
            std::cout << user << std::endl;
        }
    }

    void loginUser(const std::string& username) {
        std::cout << "User " << username << " logged in." << std::endl;
    }

private:
    std::vector<std::string> users;
};

DECLARE_MODULE(UserRegistrationModule);

最后,创建商品管理模块:

#include "Module.h"

class ProductManagementModule : public module::Module {
public:
    ProductManagementModule() {
        setModuleName("ProductManagementModule");
    }

    void execute() override {
        std::cout << "Product Management Module executed." << std::endl;
        // 商品管理操作
        addProduct("Product1", 10.0, 20);
        addProduct("Product2", 15.0, 15);
        displayProducts();
        showProductDetails("Product1");
    }

    void addProduct(const std::string& product, double price, int quantity) {
        products.push_back(std::make_pair(product, std::make_pair(price, quantity));
        std::cout << "Added new product: " << product << " Price: " << price << " USD Quantity: " << quantity << std::endl;
    }

    void displayProducts() {
        std::cout << "Available Products:" << std::endl;
        for (const auto& product : products) {
            std::cout << product.first << " - Price: " << product.second.first << " USD Quantity: " << product.second.second << std::endl;
        }
    }

    void showProductDetails(const std::string& product) {
        for (const auto& p : products) {
            if (p.first == product) {
                std::cout << "Product Details - " << product << ":" << std::endl;
                std::cout << "Price: " << p.second.first << " USD" << std::endl;
                std::cout << "Available Quantity: " << p.second.second << std::endl;
                return;
            }
        }
        std::cout << "Product not found: " << product << std::endl;
    }

private:
    std::vector<std::pair<std::string, std::pair<double, int>> products;
};

DECLARE_MODULE(ProductManagementModule);

最终的main函数会非常简洁:

#include "Module.h"

int main() {
    // 获取模块工厂实例
    module::ModuleFactory& factory = module::ModuleFactory::getFactory();

    // 获取购物车管理模块并执行
   auto shoppingCartModule = factory.getMultiModule<ShoppingCartModule>("ShoppingCartModule");
    shoppingCartModule->execute();

    // 获取用户注册模块并执行
    auto  userRegistrationModule = factory.getMultiModule<UserRegistrationModule>("UserRegistrationModule");
    userRegistrationModule->execute();

    // 获取商品管理模块并执行
   auto  productManagementModule = factory.getMultiModule<ProductManagementModule>("ProductManagementModule");
    productManagementModule->execute();
    return 0;
}

结论

模块化编程是一种强大的架构方法,它使得应用程序更容易维护、扩展和重用。通过使用模块类和模块工厂类,能够更好地管理和扩展应用程序的功能。模块化编程框架不仅可以帮助架构师构建可扩展的应用程序,还可以帮助开发者编写更具模块性的代码,提高代码质量和可维护性。

本文虽然简单,但一个大型框架同样也是由一招一式构成,大道至简,藏拙于巧。

参考

参考文献: [1] Gamma, E., Helm, R., Johnson, R., & Vlissides, J. (1994). Design patterns: elements of reusable object-oriented software. Pearson Education.

[2] Martin, R. C. (2003). Agile software development, principles, patterns, and practices. Pearson Education.

[3] Fowler, M. (2018). Refactoring: improving the design of existing code. Addison-Wesley Professional.

分享到:
用户无头像

网友整理

注册时间:

网站:5 个   小程序:0 个  文章:12 篇

  • 51995

    网站

  • 12

    小程序

  • 995072

    文章

  • 740

    会员

赶快注册账号,推广您的网站吧!
热门网站
最新入驻小程序

数独大挑战2018-06-03

数独一种数学游戏,玩家需要根据9

答题星2018-06-03

您可以通过答题星轻松地创建试卷

全阶人生考试2018-06-03

各种考试题,题库,初中,高中,大学四六

运动步数有氧达人2018-06-03

记录运动步数,积累氧气值。还可偷

每日养生app2018-06-03

每日养生,天天健康

体育训练成绩评定2018-06-03

通用课目体育训练成绩评定