从命令行创建通用对象

Question

我有两个 C++ 抽象类 Abs1 和 Abs2。然后我有：

`A : public Abs1`
`B : public Abs1` 
`C : public Abs2`
`D : public Abs2`

现在，我正在尝试create objects from command line arguments，我必须重写链接问题中的公共工厂函数make_abstract，例如：

std::unique_ptr<Abs1> makeAbs1 (int argc, const char*argv[])
{

    if (argc == 1) {
        return nullptr;
    }
    const std::string name = argv[1];
    if (name == "A") {
        return detail::make_abstract<A, std::tuple<int, std::string, int>>(argc, argv);
    } else if (name == "B") {
        return detail::make_abstract<B, std::tuple<int, int>>(argc, argv);
    }
}



std::unique_ptr<Abs2> makeAbs2 (int argc, const char*argv[])
{

    if (argc == 1) {
        return nullptr;
    }
    const std::string name = argv[1];
    if (name == "C") {
        return detail::make_abstract<C, std::tuple<int>>(argc, argv);
    } else if (name == "D") {
        return detail::make_abstract<D, std::tuple<int, float>>(argc, argv);
    }
}

如您所见，这是非常多余的。我该如何做这个的通用版本？在这个版本中，我们可以传递任意数量的实现类，因此if 级联不是解决方案。请注意，我们不能修改任何这些类。

我在想也许可变参数模板会有所帮助，但我想不出很多问题：

template <typename T, typename ...Ts>
std::unique_ptr<T> make (int argc, const char*argv[]){
  const std::string name = argv[1];
  for(Ti : Ts) //this is obviously wrong
    if(typeid(Ti).name == name)
      return detail::make_abstract<T, std::tuple</*Here shoudl be different for every Ti*/>>(argc, argv);

}

Answer 1

哦，这很有趣:)

[TL;DR：底部有一个活生生的例子]

我在您的detail::make_abstract 函数之上实现了两层映射。让我们从调用代码开始：

int main(int argc, char **argv) {
    std::unique_ptr<Abs1> p1;
    std::unique_ptr<Abs2> p2;

    makeEverything(argc, argv, p1, p2);
}

在这里，我们用argc、argv 和std::unique_ptrs 的列表调用makeEverything。函数结束后，其中一个指针将持有正确类型的对象。

让我们更深入。

inline void makeEverything(int, char**) { }

template <class Abs, class... Abses>
void makeEverything(int argc, char **argv,
    std::unique_ptr<Abs> &abs, std::unique_ptr<Abses> &... abses) {

    abs = makeAbs<Abs>(argc, argv);

    if(!abs)
        makeEverything(argc, argv, abses...);
}

这是你常用的递归可变参数函数模板：获取第一个指针，尝试为它构造一个对象。如果失败，请将其丢弃并重试下一个。您可以在顶部的基本情况重载中放置一些错误处理：当根本无法构造任何对象时将调用它。

所以现在我们知道Abs1、Abs2 中的哪一个是所需的基类。
让我们更深入。

template <class Abs>
using Factory = std::unique_ptr<Abs>(int, char **);

template <class Abs>
using FactoryMap = std::map<std::string, Factory<Abs>*>;

template <class Abs>
struct Factories {
    static const FactoryMap<Abs> map;
};

template <class Abs>
std::unique_ptr<Abs> makeAbs(int argc, char **argv) {

    if (argc < 2)
        return nullptr;

    return Factories<Abs>::map.at(argv[1])(argc, argv);
}

makeAbs 检查并检索argv[1]。然后它将它用作工厂函数映射的键，以检索与该名称对应的工厂，然后调用它并返回结果对象。

如果不知道该名称的对象，std::map::at() 将抛出 std::out_of_bounds。当然，您可以更改错误处理方式

现在让我们看看如何填充工厂地图，其实很简单：

template <>
FactoryMap<Abs1> const Factories<Abs1>::map {
    {"A", detail::make_abstract_erased<Abs1, A, std::tuple<int, std::string, int>>},
    {"B", detail::make_abstract_erased<Abs1, B, std::tuple<int, int>>}
};

您只需为要使用的每个Abs 提供FactoryMap<Abs>::map 的定义。由于这是一个对象定义，因此应将其放在 .cpp 文件中。请注意，作为奖励，您可以添加新类及其映射而无需重新编译任何其他内容！

拼图的最后一块：detail::make_abstract_erased。您尚未提供 detail::make_abstract 的声明，但它看起来返回 std::unique_ptr<T>，T 是它的第一个模板参数。

鉴于 C++ 不允许在返回类型不同的函数指针之间进行转换（并且有充分的理由），我们需要额外的层来包装 detail::make_abstract 并执行转换：

namespace detail {
    template <class Abs, class T, class Params>
    std::unique_ptr<Abs> make_abstract_erased(int argc, char **argv) {
        return make_abstract<T, Params>(argc, argv);
    }
}

就是这样！

See it live on Coliru