将任何对象成对写入文件的功能

Question

我尝试编写一个模板函数，该函数应该将成对的对象（不同类型）写入文件。 就像这样：

template<class A, class B>
void write_parameters(const std::string &file_name, std::initializer_list<std::pair<A, B>> parameters) {

    std::ofstream file;

    if (!file_exists(file_name)) {
        file.open(file_name, std::ios_base::app);
    } else {
        file.open(file_name);
    }

    if (!file) {
        throw std::runtime_error("file failed to be created");
    }

    for (std::pair<A, B> p : parameters) {
        file << std::string(p.first) << " = " << std::string(p.second) << "\n";
    }

    file << "---------------------------------------------\n";
    file.close();
}

我刚刚意识到的问题是，调用此函数时需要传递A和B的类型，所以我不能在多个不同的映射中调用此函数，还是可以吗？

这是我试图打电话给的：

write_parameters<std::string, std::string>(std::string("parameters/") + s.instance_name, {
        {"starting_node", std::string(starting_node},
        {"max_iter",      max_iter},
        {"nice_gain",     nice_gain},
        {"lazy",          lazy},
        {"random_start",  random_start}
});

但这不起作用，因为例如max_iter不是字符串。 如何解决此问题而无需为每个映射调用write_parameters ？

Answer 1

传递并捕获一包与您要编写的参数相对应的对。 然后，您可以使用这个很酷的技巧来调用包中每个参数的callable：

namespace detail{
template<class F,class...Ps>
void invoke( F&& f, Ps&&... ps ) {
    using pack=int[];
    (void)pack{((f(move(ps)),0))...};
}
}

现在变成：

template<class...Ps>
void write_parameters( std::string const& file_name, Ps&&... ps) {
  std::ofstream file(file_name,ios_base::app|ios_base::out);

  if (!file) {
    throw std::runtime_error("file failed to be created");
  }

  detail::invoke(
    [&](auto&& p) { file << p.first << " " << p.second << '\n'; },
    forward<Ps>(ps)...
  );
}

int main() {
  write_parameters(
    "parameters/" + s.instance_name,
    make_pair("starting_node", starting_node),
    make_pair("max_iter",      max_iter),
    make_pair("nice_gain",     nice_gai),
    make_pair("lazy",          lazy),
    make_pair("random_start",  random_start)
  );
}