Question

背景

我正在编写一个使用USB设备的应用程序。这包括根据USB供应商ID和产品ID查找我的应用程序可以使用的USB设备的设备。但是，这些设备有时会具有多个可能起作用的驱动程序，即应用程序实现，具体取决于平台和月相（客户遗留的东西）。因此，我想结合使用std::shared_ptr和一系列不错的接口和东西来使用运行时多态性。

问题

我无法根据运行时给定的键弄清楚如何make_shared某个类型的对象。至少不是在丑陋的意义上。

到目前为止的解决方案

我正在考虑以某种方式将类型值存储到映射known_drivers中（在此示例中为多图，但没有太大区别），因此最终，根据数字值，我可以构造一个不同的类类型并将其填充到shared_ptr中。

示例代码

#include <iostream>
#include <algorithm>
#include <iterator>
#include <map>
#include <memory>
#include <stdexcept>

using vendor_product_usb_id_t = std::pair<uint16_t, uint16_t>;

struct usb_device {
    static std::shared_ptr<usb_device> open(vendor_product_usb_id_t);
    virtual void do_stuff() = 0;
};

struct usb_device_using_driver_a : usb_device {
    usb_device_using_driver_a() {throw std::runtime_error("Not supported on this platform");}
protected:
    void do_stuff() override {}
};

struct usb_device_using_driver_b : usb_device {
protected:
    void do_stuff() override {std::cout << "Stuff B\n";}
};


const std::multimap<vendor_product_usb_id_t, ??> known_drivers = {{{0x42,0x1337}, driver_a}, {{0x42,0x1337}, driver_b}};

std::shared_ptr<usb_device> usb_device::open(vendor_product_usb_id_t id) {
    std::shared_ptr<usb_device> value;
    for (auto [begin,end] = known_drivers.equal_range(id); begin != end; ++begin) {
        try {
            value = std::make_shared<*begin>();
        } catch (std::exception& e) {
            continue;
        }
    }
    return value;
}

int main() {
    auto device = usb_device::open(std::make_pair(0x42,0x1337));
    if (device) {
        device->do_stuff();
    }
}

Answer 1

在C ++中无法存储类型并使用它来创建实例，因为C ++还没有反射。

但是，factory pattern和virtual constructor idiom可以满足您的需求。

作为基本出发点：

using vendor_product_usb_id_t = std::pair<uint16_t, uint16_t>;

struct usb_device {
    using usb_ptr = std::shared_ptr<usb_device>;

    virtual void do_stuff() = 0;

    // virtual constructor
    virtual usb_ptr create(vendor_product_usb_id_t) = 0;
};


struct usb_device_using_driver_a : usb_device {
    usb_ptr create(vendor_product_usb_id_t) override {
        return usb_ptr(new usb_device_using_driver_a);
    }

    void do_stuff() override {
        std::cout << "usb_device_using_driver_a::do_stuff()" << std::endl;
    }
};


struct usb_device_using_driver_b : usb_device {
    usb_ptr create(vendor_product_usb_id_t) override {
        throw std::runtime_error("Not supported on this platform");
    }

    void do_stuff() override {
        std::cout << "usb_device_using_driver_b::do_stuff()\n";
    }
};


class usb_device_factory {
public:

    static usb_device::usb_ptr open(vendor_product_usb_id_t id) {
        // note this map is static
        // for simplicity changed the multimap to map
        static std::map<vendor_product_usb_id_t, usb_device::usb_ptr> known_drivers = {
            std::make_pair(std::make_pair(0x42,0x1337), usb_device::usb_ptr(new usb_device_using_driver_a())),
            std::make_pair(std::make_pair(0x43,0x1337), usb_device::usb_ptr(new usb_device_using_driver_b())),
        };

        return known_drivers[id]->create(id);
    }
};


int main() {
    try {
        auto device = usb_device_factory::open(std::make_pair(0x42,0x1337));
        device->do_stuff();

        // this will throw
        device = usb_device_factory::open(std::make_pair(0x43,0x1337));
        device->do_stuff();
    }
    catch(std::exception const& ex) {
        std::cerr << ex.what();
    }
}

Live。

在没有虚拟构造函数的情况下也可以，但是工厂模式的基本原理仍然适用：

using vendor_product_usb_id_t = std::pair<uint16_t, uint16_t>;


struct usb_device {
    virtual void do_stuff() = 0;
};

using usb_ptr = std::shared_ptr<usb_device>;



struct usb_device_using_driver_a : usb_device {
    void do_stuff() override {
        std::cout << "usb_device_using_driver_a::do_stuff()" << std::endl;
    }
};


struct usb_device_using_driver_b : usb_device {
    void do_stuff() override {
        std::cout << "usb_device_using_driver_b::do_stuff()\n";
    }
};


class usb_device_factory {
public:

    static usb_ptr open(vendor_product_usb_id_t id) {
        // note this map is static
        static std::map<vendor_product_usb_id_t, std::function<usb_ptr()>> known_drivers = {
            std::make_pair(std::make_pair(0x42,0x1337), []() { return usb_ptr(new usb_device_using_driver_a()); } ),
            std::make_pair(std::make_pair(0x43,0x1337), []() { return usb_ptr(new usb_device_using_driver_b()); } ),
        };

        return known_drivers[id]();
    }
};


int main() {
    try {
        auto device = usb_device_factory::open(std::make_pair(0x42,0x1337));
        device->do_stuff();

        device = usb_device_factory::open(std::make_pair(0x43,0x1337));
        device->do_stuff();
    }
    catch(std::exception const& ex) {
        std::cerr << ex.what();
    }
}

Live。

使用这两种变体，都可以在运行时使用附加驱动程序来扩展地图。由于它存储在“动态”映射中，因此没有开关可以限制驱动程序的数量。

编辑：

刚刚发现了一个类似的问题，答案基本上与我的相同，使用虚拟构造函数取消了工厂模式：

Can objects be created based on type_info?

基于类型映射的运行时类型选择

背景

问题

到目前为止的解决方案

示例代码

1 个答案:

编辑：