【发布时间】：2014-12-15 17:38:14
【问题描述】：
参考下面的代码，有人能弄清楚如何适应
template <typename RET, typename... ARGS1, typename... ARGS2>
RET Mediator::change (Object* o, RET (Object::*f)(ARGS1...), ARGS2&&... args) {
const std::tuple<ARGS2...> t(args...);
for (Object* x : objects)
(x->*f)(std::get<0>(t), o->rating, std::get<1>(t), o->str);
}
这样我就不必每次更改 ARGS2... 时都重写不同的版本。我不介意在参数仅包含 4 个参数的情况下这样做，但是您可以想象，如果它远大于 4，则需要进行泛化。 ARGS1... 中的类型应由不同的类型组成，所以应该有办法让 std::get(t), std::get(t), ... 正确放置，这样就不需要像上面那样手动操作（即使有是重复类型，那么它们可以简单地放置在重复类型的第一个插槽中）。下面是完整的代码（上下文是，当每个 Mediator 的 Object 订阅者发生变化时，Mediator 的其他 Object 订阅者也会相应地发生变化）：
#include <iostream>
#include <string>
#include <vector>
#include <tuple>
struct Mediator {
std::vector<struct Object*> objects;
void registerObject (Object* o) {objects.emplace_back(o);}
template <typename RET, typename... ARGS1, typename... ARGS2>
RET change (Object*, RET (Object::*)(ARGS1...), ARGS2&&...);
};
struct Object {
int value;
double rating;
char letter;
std::string str;
Mediator& mediator;
Object (int v, double r, char l, const std::string& s, Mediator& m) :
value(v), rating(r), letter(l), str(s), mediator(m) {mediator.registerObject(this);}
virtual void adjust (int, double, char, const std::string&) = 0;
template <typename RET, typename... ARGS1, typename... ARGS2>
RET change (RET (Object::*f)(ARGS1...), ARGS2&&... args) {
return mediator.change(this, f, std::forward<ARGS2>(args)...);
}
};
struct A : Object {
using Object::Object;
virtual void adjust (int a, double b, char c, const std::string& s) override {
std::cout << "Type A adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
}
};
struct B : Object {
using Object::Object;
virtual void adjust (int a, double b, char c, const std::string& s) override {
std::cout << "Type B adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
}
};
struct C : Object {
using Object::Object;
virtual void adjust (int a, double b, char c, const std::string& s) override {
std::cout << "Type C adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
}
};
template <typename RET, typename... ARGS1, typename... ARGS2>
RET Mediator::change (Object* o, RET (Object::*f)(ARGS1...), ARGS2&&... args) {
const std::tuple<ARGS2...> t(args...);
for (Object* x : objects)
(x->*f)(std::get<0>(t), o->rating, std::get<1>(t), o->str);
}
int main() {
Mediator mediator;
Object *a = new A(6, 1.2, 'a', "alan", mediator);
Object *b = new B(2, 6.5, 'b', "bob", mediator);
Object *c = new C(4, 0.8, 'c', "craig", mediator);
c->change (&Object::adjust, 8, 'k');
}
输出：
Type A adjusted using values 8, 0.8, k, and craig.
Type B adjusted using values 8, 0.8, k, and craig.
Type C adjusted using values 8, 0.8, k, and craig.
这是我的解决方案。它给出了相同的输出，但标记为// Here! 的行是我需要自动生成的。
#include <iostream>
#include <string>
#include <vector>
#include <tuple>
template <std::size_t...> struct index_sequence {};
template <std::size_t N, std::size_t... Is>
struct make_index_sequence_helper : make_index_sequence_helper<N-1, N-1, Is...> {};
template <std::size_t... Is>
struct make_index_sequence_helper<0, Is...> {
using type = index_sequence<Is...>;
};
template <std::size_t N>
using make_index_sequence = typename make_index_sequence_helper<N>::type;
struct Mediator {
std::vector<struct Object*> objects;
void registerObject (Object* o) {objects.emplace_back(o);}
template <typename RET, typename... ARGS1, typename... ARGS2>
RET change (Object*, RET (Object::*)(ARGS1...), ARGS2&&...);
template <typename RET, typename... ARGS, std::size_t... Is>
RET changeHelper (RET (Object::*)(ARGS...), const std::tuple<ARGS...>&, index_sequence<Is...>);
};
struct Object {
int value;
double rating;
char letter;
std::string str;
Mediator& mediator;
Object (int v, double r, char l, const std::string& s, Mediator& m) :
value(v), rating(r), letter(l), str(s), mediator(m) {mediator.registerObject(this);}
virtual void adjust (int, double, char, const std::string&) = 0;
template <typename RET, typename... ARGS1, typename... ARGS2>
RET change (RET (Object::*f)(ARGS1...), ARGS2&&... args) {
return mediator.change(this, f, std::forward<ARGS2>(args)...);
}
};
struct A : Object {
using Object::Object;
virtual void adjust (int a, double b, char c, const std::string& s) override {
std::cout << "Type A adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
}
};
struct B : Object {
using Object::Object;
virtual void adjust (int a, double b, char c, const std::string& s) override {
std::cout << "Type B adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
}
};
struct C : Object {
using Object::Object;
virtual void adjust (int a, double b, char c, const std::string& s) override {
std::cout << "Type C adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
}
};
template <typename RET, typename... ARGS1, typename... ARGS2>
RET Mediator::change (Object* o, RET (Object::*f)(ARGS1...), ARGS2&&... args) {
const std::tuple<ARGS2...> t(args...);
// Here!
const std::tuple<ARGS1...> tuple(std::get<0>(t), o->rating, std::get<1>(t), o->str);
changeHelper (f, tuple, make_index_sequence<sizeof...(ARGS1)>());
}
template <typename RET, typename... ARGS, std::size_t... Is>
RET Mediator::changeHelper (RET (Object::*f)(ARGS...),
const std::tuple<ARGS...>& tuple, index_sequence<Is...>) {
for (Object* x : objects)
(x->*f) (std::get<Is>(tuple)...);
}
int main() {
Mediator mediator;
Object *a = new A(6, 1.2, 'a', "alan", mediator);
Object *b = new B(2, 6.5, 'b', "bob", mediator);
Object *c = new C(4, 0.8, 'c', "craig", mediator);
c->change (&Object::adjust, 8, 'k');
}
如何自动生成元组
const std::tuple<ARGS1...> tuple(std::get<0>(t), o->rating, std::get<1>(t), o->str);
使用类似的东西
template <typename... ARGS1, typename... ARGS2>
std::tuple<ARGS1...> extractTuple (Object* o, ARGS2&&... args);
这样对于不同的（可能很多，如果 ARGS1... 很大）选择 ARGS2... 就不需要新版本的 Mediator::change？我目前的想法是使用递归辅助方法，std::is_same、std::tuple_cat 等...但我遇到了问题（我认为我们正在解压 ARGS2... 在解压 ARGS1... 在检查期间类型）。
【问题讨论】：
-
注意：使用全部大写的模板参数名称可能会导致宏替换。对于单字母名称，这不是什么大问题，因为很少有人会疯狂到用单字母名称定义宏。但是例如
RET很有可能成为宏的名称。 -
你怎么知道哪个参数去了哪里？这个界面对我来说似乎很糟糕，因为参数的位置是你“调整”的关键。您可能想要构建一个带有命名成员（而不是元组）的结构并用它调用函数指针。它更容易理解和理解，至少不再依赖于参数数量和位置。
-
@xryl669。如果 ARGS1... 中的所有类型都是不同的类型，那么程序应该有一种方法可以确定参数的去向。我现在正在尝试使用递归帮助器、std::is_same 等来解决一个解决方案……但即使 ARGS1 中有重复的类型……，我的问题表明那些来自 ARGS2 的……可以简单地首先放置在重复的插槽中，因此不同类型的情况仍然有效。
-
我理解你的问题，但同样，我认为像这段代码的用户一样，几乎不可能理解什么参数应该放在哪里。即使您在“参数类型推论”中很聪明，但通过阅读此类代码，我仍不清楚在函数调用中放入什么（以什么顺序等......）。我认为您将花费更少的时间来设计可能的“struct ArgumentForFuncX”、“struct ArgumentForFuncY”版本，并且这是有文档的并且可以理解的。
-
@xryl669，我在我的问题中添加了更多代码，包括我对所需
std::tuple<ARGS1...> extractTuple (Object* o, ARGS2&&... args)的最新尝试。它越来越接近解决它，我的直觉告诉我它应该是可能的（我正在考虑定义 struct concatenate> {using value = typename std::tuple ; 来帮忙）。如果我的尝试不起作用，我明天会提出这个问题。一旦获得 extractTuple，我们就完成了。
标签： c++ templates c++11 variadic