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);
}

我们使用makeEverything，argc和argv列表来std::unique_ptr。函数结束后，其中一个指针将保存一个正确类型的对象。

让我们深入一点。

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>>}
};

您只需为要使用的每个FactoryMap<Abs>::map提供Abs的定义。由于这是一个对象定义，因此应将其放在.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

从命令行创建通用对象

1 个答案: