具有可变参数模板参数的函数指针

Function pointer with variadic template arguments

本文关键字：参数 函数 指针 变参      更新时间：2023-10-16

参考下面的代码，有人能想出如何适应

吗 
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<0>(t(，std：：get<1>(t(，...正确放置，因此无需像上面那样手动执行此操作(即使存在重复类型，也可以简单地将它们放置在重复类型的第一个插槽中(。 下面是完整的代码(上下文是，当中介程序的每个对象订阅者更改时，中介程序的其他对象订阅者也将相应更改(：

#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... ？ 我目前的想法是使用递归辅助方法，std：：is_same，std：：tuple_cat等......但我遇到了问题(我认为我们正在解压缩 ARGS2...在解包 ARGS1...在检查类型期间(。

首先，我们需要一个标签和一系列函数来根据对象的类型从对象中获取值。 足够简单。

template<class T> struct typetag {};
const int& get_type_from_class(const Object* o, typetag<int>) {return o->value;}
const double& get_type_from_class(const Object* o, typetag<double>) {return o->rating;}
const char& get_type_from_class(const Object* o, typetag<char>) {return o->letter;}
const long& get_type_from_class(const Object* o, typetag<long>) {return o->tag;}

下一部分是我们需要根据类型从参数列表中获取类型，如果没有参数匹配，则默认返回第一个参数。 也不是太难了。 有递归不匹配情况、递归匹配情况和最后匹配情况。 尽管这似乎具有相当数量的递归，但即使是最简单的优化器也应该能够将其内联到最佳程序集中。 出于我不明白的原因，这些必须按这个确切的顺序排列。

template<class T> 
const T& get_T_by_type(const T& def) 
{return def;}
template<class T, class...pRest> 
const T& get_T_by_type(const T& def, const T& returnme, const pRest&...rest) 
{return returnme;}
template<class T, class p0, class...pRest> 
const T& get_T_by_type(const T& def, const p0& discard, const pRest&...rest) 
{return get_T_by_type(def, rest...);}

最后，我们调用函数。 对于每个ARGS1，我们调用 get_T_by_type 来获取相同类型的ARGS2，并且作为默认值，我们使用 get_type_from_class 来传递类中的现有值。 

template <typename RET, typename... ARGS1, typename... ARGS2>
void Mediator::change (Object* o, RET (Object::*f)(ARGS1...), const ARGS2&... args) {
    for (Object* x : objects) {
        (x->*f)(
            get_T_by_type(get_type_from_class(o, typetag<ARGS1>{}),args...) //pass all args2
            ... //pass one of that for each args1
            );
    }
}

请注意，我已将返回类型更改为 void ，因为您委托调用多个函数。 或者，您可以返回返回结果的vector。

http://coliru.stacked-crooked.com/a/36afa072711b0655

好的，我有一个初稿。 它仍然需要通过解压缩 ARGS1 来进一步推广......而不是我在下面所做的方式。 但至少，这第一个解决方案表明，这个问题可能完全可以解决。

#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;
    long tag;
    Mediator& mediator;
    Object (int v, double r, char l, long s, Mediator& m) :
        value(v), rating(r), letter(l), tag(s), mediator(m) {mediator.registerObject(this);}
    virtual void adjust (int, double, char, long) = 0;
    virtual void transform (char, double, int) = 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, long s) override {
        std::cout << "Type A adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type A transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
struct B : Object {
    using Object::Object;
    virtual void adjust (int a, double b, char c, long s) override {
        std::cout << "Type B adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type B transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
struct C : Object {
    using Object::Object;
    virtual void adjust (int a, double b, char c, long s) override {
        std::cout << "Type C adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type C transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
template <typename T, typename TUPLE> struct Concatenate;
template <typename FIRST, typename ...REST>
struct Concatenate<FIRST, std::tuple<REST...>> {
    using type = typename std::tuple<FIRST, REST...>;
};
template <typename HEAD, typename TUPLE>
typename Concatenate<HEAD, TUPLE>::type nextTuple (Object* o, const TUPLE& tuple) {
    if (std::is_same<HEAD, int>::value)
        return std::tuple_cat (tuple, std::tuple<int>(o->value));
    else if (std::is_same<HEAD, double>::value)
        return std::tuple_cat (tuple, std::tuple<double>(o->rating));
    else if (std::is_same<HEAD, char>::value)
        return std::tuple_cat (tuple, std::tuple<char>(o->letter));
    else if (std::is_same<HEAD, long>::value)
        return std::tuple_cat (tuple, std::tuple<long>(o->tag));
}
template <typename HEAD, typename TUPLE, typename FIRST, typename... REST>
typename Concatenate<HEAD, TUPLE>::type nextTuple (Object* o, const TUPLE& tuple, FIRST first, REST... rest) {
    if (std::is_same<HEAD, FIRST>::value)
        return std::tuple_cat (tuple, std::tuple<FIRST>(first));
    return nextTuple<HEAD, TUPLE, REST...> (o, tuple, rest...);
}
template <typename RET, typename... ARGS1, typename... ARGS2>
std::tuple<ARGS1...> extractTuple (Object* o, RET (Object::*)(ARGS1...), ARGS2&&... args) {
// Function pointer parameter needed to maintain ARGS1..., else it will become an empty pack.
    std::tuple<> t0;
    const auto t1 = nextTuple<int> (o, t0, args...);
        // In general, unpack ARGS1...
    const auto t2 = nextTuple<double> (o, t1, args...);
    const auto t3 = nextTuple<char> (o, t2, args...);
    return nextTuple<long> (o, t3, args...);
}
template <typename RET, typename... ARGS1, typename... ARGS2>
RET Mediator::change (Object* o, RET (Object::*f)(ARGS1...), ARGS2&&... args) {
    const std::tuple<ARGS1...> tuple = extractTuple (o, f, args...);  // The key function.
    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', 1111, mediator);
    Object *b = new B(2, 6.5, 'b', 2222, mediator);
    Object *c = new C(4, 0.8, 'c', 3333, mediator);
    c->change (&Object::adjust, 8, 'k');
//  c->change (&Object::transform, 'z', 4);  // This does not work though.
}

输出：

Type A adjusted using values 8, 0, k, and 3333.
Type B adjusted using values 8, 0, k, and 3333.
Type C adjusted using values 8, 0, k, and 3333.

出于某种原因，std：：string 存在问题，所以我将第 4 个参数替换为 long。 所以这个解决方案仍然需要改进。 我还引入了一个新的 Object 成员函数transform来表明 main(( 中的行c->change (&Object::transform, 'z', 4);不起作用(在 Mooing Duck 的解决方案中也不起作用(，因此这个解决方案需要更多的泛化，通过某种递归与 ARGS1...可能，要完整。 我上面的解决方案仅处理特定的 ARGS1...形式(整数、双精度、字符、长整型(。

我怀疑Mooing Duck的解决方案也可以推广到处理传递给Mediator：：change的对象的任何新成员函数。

更新：好的，我已经extractTuple替换为

template <typename TUPLE, typename... ARGS2>
TUPLE extractTuple (Object*, const TUPLE& tuple, ARGS2&&...) {return tuple;}
template <typename TUPLE, typename FIRST, typename... REST, typename... ARGS2>
auto extractTuple (Object* o, const TUPLE& current, ARGS2&&... args)
-> decltype (extractTuple<typename Concatenate<FIRST, TUPLE>::type, REST...>
(o, nextTuple<FIRST> (o, current, args...), args...)) {
    const typename Concatenate<FIRST, TUPLE>::type next = nextTuple<FIRST> (o, current, args...);
    return extractTuple<typename Concatenate<FIRST, TUPLE>::type, REST...> (o, next, args...);
}

我认为这通过解压缩 ARGS1 来概括上述解决方案...... 这是我现在的新代码：

#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;
    long tag;
    Mediator& mediator;
    Object (int v, double r, char l, long s, Mediator& m) :
        value(v), rating(r), letter(l), tag(s), mediator(m) {mediator.registerObject(this);}
    virtual void adjust (int, double, char, long) = 0;
    virtual void transform (char, double, int) = 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, long s) override {
        std::cout << "Type A adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type A transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
struct B : Object {
    using Object::Object;
    virtual void adjust (int a, double b, char c, long s) override {
        std::cout << "Type B adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type B transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
struct C : Object {
    using Object::Object;
    virtual void adjust (int a, double b, char c, long s) override {
        std::cout << "Type C adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type C transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
template <typename T, typename TUPLE> struct Concatenate;
template <typename FIRST, typename ...REST>
struct Concatenate<FIRST, std::tuple<REST...>> {
    using type = typename std::tuple<FIRST, REST...>;
};
template <typename HEAD, typename TUPLE>
typename Concatenate<HEAD, TUPLE>::type nextTuple (Object* o, const TUPLE& tuple) {
    if (std::is_same<HEAD, int>::value)  // Using overload from some new class can probably handle all these cases better.
        return std::tuple_cat (tuple, std::tuple<int>(o->value));
    else if (std::is_same<HEAD, double>::value)
        return std::tuple_cat (tuple, std::tuple<double>(o->rating));
    else if (std::is_same<HEAD, char>::value)
        return std::tuple_cat (tuple, std::tuple<char>(o->letter));
    else if (std::is_same<HEAD, long>::value)
        return std::tuple_cat (tuple, std::tuple<long>(o->tag));
}
template <typename HEAD, typename TUPLE, typename FIRST, typename... REST>
typename Concatenate<HEAD, TUPLE>::type nextTuple (Object* o, const TUPLE& tuple, FIRST first, REST... rest) {
    if (std::is_same<HEAD, FIRST>::value)
        return std::tuple_cat (tuple, std::tuple<FIRST>(first));
    return nextTuple<HEAD, TUPLE, REST...> (o, tuple, rest...);
}
template <typename TUPLE, typename... ARGS2>
TUPLE extractTuple (Object*, const TUPLE& tuple, ARGS2&&...) {return tuple;}
// *** The change
template <typename TUPLE, typename FIRST, typename... REST, typename... ARGS2>
auto extractTuple (Object* o, const TUPLE& current, ARGS2&&... args)
-> decltype (extractTuple<typename Concatenate<FIRST, TUPLE>::type, REST...>
(o, nextTuple<FIRST> (o, current, args...), args...)) {
    const typename Concatenate<FIRST, TUPLE>::type next = nextTuple<FIRST> (o, current, args...);
    return extractTuple<typename Concatenate<FIRST, TUPLE>::type, REST...> (o, next, args...);
}
template <typename RET, typename... ARGS1, typename... ARGS2>
RET Mediator::change (Object* o, RET (Object::*f)(ARGS1...), ARGS2&&... args) {
    const std::tuple<ARGS1...> tuple = extractTuple<std::tuple<>, ARGS1...> (o, std::tuple<>(), args...);  // The key function.
    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', 1111, mediator);
    Object *b = new B(2, 6.5, 'b', 2222, mediator);
    Object *c = new C(4, 0.8, 'c', 3333, mediator);
    c->change (&Object::adjust, 8, 'k');
    c->change (&Object::transform, 'z', 4);
}

请注意，c->change (&Object::transform, 'z', 4);现在在main((中。 但是我的GCC 4.8.1似乎有错误，无法处理声明

template <typename TUPLE, typename FIRST, typename... REST, typename... ARGS2>
auto extractTuple (Object* o, const TUPLE& current, ARGS2&&... args)
-> decltype (extractTuple<typename Concatenate<FIRST, TUPLE>::type, REST...>
(o, nextTuple<FIRST> (o, current, args...), args...)) {

导致"内部编译器错误"。 也许拥有 C++14 的最新编译器的人可以检查这是否是法律声明？ 我没有C++14。

这个答案是基于Mooing Duck的原始答案，它只处理了一个特殊情况。 我添加了大约两倍的代码量，以使用元组概括他的答案。 不过，他上面的新通用解决方案显然更胜一筹。

#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;
    long tag;
    Mediator& mediator;
    Object (int v, double r, char l, long s, Mediator& m) : value(v), rating(r), letter(l), tag(s), mediator(m) {mediator.registerObject(this);}
    virtual void adjust (int, double, char, long) = 0;
    virtual void transform (char, double, int) = 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, long s) override {
        std::cout << "Type A adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type A transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
struct B : Object {
    using Object::Object;
    virtual void adjust (int a, double b, char c, long s) override {
        std::cout << "Type B adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type B transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
struct C : Object {
    using Object::Object;
    virtual void adjust (int a, double b, char c, long s) override {
        std::cout << "Type C adjusted using values " << a << ", " << b << ", " << c << ", and " << s << "." << std::endl;
    }
    virtual void transform (char a, double b, int c) override {
        std::cout << "Type C transformed using values " << a << ", " << b << ", and " << c << "." << std::endl;
    }
};
template <typename T, typename TUPLE> struct Concatenate;
template <typename FIRST, typename ...REST>
struct Concatenate<FIRST, std::tuple<REST...>> {
    using type = typename std::tuple<REST..., FIRST>;  // This time, we must concatenate at the back else 'extractTuple<std::tuple<>, ARGS1...>(t, std::tuple<>())' below will be in reverse!
};
struct NamedObjectChangeParameters {
    int value;
    double rating;
    char letter;
    long tag;
    explicit NamedObjectChangeParameters (const Object& o) : value(o.value), rating(o.rating), letter(o.letter), tag(o.tag) {}
    // change overloads for Mediator::change.
    void change (int a) {value = a;}
    void change (double b) {rating = b;}
    void change (char c) {letter = c;}
    void change (long d) {tag = d;}
    template <typename FIRST, typename... REST>
    void change (const FIRST& first, const REST&... rest) {
        change (first);
        change (rest...);
    }
    // nextTuple overloads for the important extractTuple function.
    template <typename TUPLE> typename Concatenate<int, TUPLE>::type
    nextTuple (int, const TUPLE& tuple) {return std::tuple_cat (tuple, std::tuple<int>(value));}
    template <typename TUPLE> typename Concatenate<double, TUPLE>::type
    nextTuple (double, const TUPLE& tuple) {return std::tuple_cat (tuple, std::tuple<int>(rating));}
    template <typename TUPLE> typename Concatenate<char, TUPLE>::type   
    nextTuple (char, const TUPLE& tuple) {return std::tuple_cat (tuple, std::tuple<int>(letter));}
    template <typename TUPLE> typename Concatenate<long, TUPLE>::type   
    nextTuple (long, const TUPLE& tuple) {return std::tuple_cat (tuple, std::tuple<int>(tag));}
};
template <typename TUPLE>
TUPLE extractTuple (NamedObjectChangeParameters&, const TUPLE& tuple) {return tuple;}
template <typename TUPLE, typename FIRST, typename... REST>
auto extractTuple (NamedObjectChangeParameters& t, const TUPLE& current)
-> decltype (extractTuple<typename Concatenate<FIRST, TUPLE>::type, REST...> (t, t.nextTuple<TUPLE> (FIRST(), current))) {
    const typename Concatenate<FIRST, TUPLE>::type next = t.nextTuple<TUPLE> (FIRST(), current);  // nextTuple<TUPLE> is an overloaded function of NamedObjectChangeParameters that creates the correct type based on what type FIRST is.
    return extractTuple<typename Concatenate<FIRST, TUPLE>::type, REST...> (t, next);
}
template <typename RET, typename... ARGS1, typename... ARGS2>
RET Mediator::change (Object* o, RET (Object::*f)(ARGS1...), ARGS2&&... args) {
    NamedObjectChangeParameters t(*o);
    t.change(args...);
    changeHelper (f, extractTuple<std::tuple<>, ARGS1...>(t, std::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', 1111, mediator);
    Object *b = new B(2, 6.5, 'b', 2222, mediator);
    Object *c = new C(4, 0.8, 'c', 3333, mediator);
    c->change (&Object::adjust, 8, 'k');
    c->change (&Object::transform, 'z', 4);
}

输出：

Type A adjusted using values 8, 0, k, and 3333.
Type B adjusted using values 8, 0, k, and 3333.
Type C adjusted using values 8, 0, k, and 3333.
Type A transformed using values z, 0, and 4.
Type B transformed using values z, 0, and 4.
Type C transformed using values z, 0, and 4.
相关文章：