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

Question

背景

我正在编写一个使用 USB 设备的应用程序。这包括我的应用程序可以使用的 USB 设备的设备发现，基于 USB 供应商 ID 和产品 ID。然而，这些设备有时有多个可能工作的驱动程序，即应用程序实现，具体取决于平台和月相（客户遗留的东西）。所以我想通过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.

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

编辑：

刚刚发现了一个类似的问题，答案和我的基本一样，unsing factory pattern with virtual constructors：

Can objects be created based on type_info?