Question

我正在尝试实现一个可以使用多种类型元素的向量，并且可以对所有这些元素应用函数。这可以通过基类，虚函数和继承轻松完成，但我明确表示不想使用它。到目前为止我到目前为止：

#include <iostream>
#include <vector>
#include <tuple>

// this will be my new polymorphic vector;
template<typename... Ts>
class myvector {
    std::tuple<std::vector<Ts>...> vectors;

    template <template<typename> class funtype>
    void for_each() {
    }

    template <template<typename> class funtype, typename X, typename... Xs>
    void for_each() {
        std::vector<X>& vector = std::get<std::vector<X>>(vectors);
        for ( X& x : vector ) {
            funtype<X> fun;
            fun(x);
        }
        for_each<funtype, Xs...>();
    }

public:
    template <typename T>
    void push_back(const T& t) {
        std::vector<T>& vector = std::get<std::vector<T>>(vectors);
        vector.push_back(t);
    }

    template <typename T>
    void pop_back() {
        std::vector<T>& vector = std::get<std::vector<T>>(vectors);
        vector.pop_back();
    }

    /* here I would like to pass a function, or function object that 
     * can be expanded to all underlying types. I would prefer to just 
     * give a function name, that has an implementation to all types in Ts
     */
    template <template<typename> class funtype>
    void ForEach() {
        for_each<funtype,Ts...>();
    }
};


struct foo {
};

struct bar {
};

template <typename T>
void method(T& t);

template<>
void method(foo& b) {
    std::cout << "foo" << std::endl;
}

template<>
void method(bar& b) {
    std::cout << "bar" << std::endl;
}

int main()
{
    myvector<foo,bar> mv;
    mv.push_back( foo{} );
    mv.push_back( bar{} );
    mv.ForEach<method>();
}

目前我有点陷入困境，我希望你能就如何走得更远给我一些建议。

Answer 1

常见的解决方案是使用具有一组operator()：

的函数对象

struct my_fun_type
{
    void operator()(foo&) const
    { std::cout << "foo\n"; }

    void operator()(bar&) const
    { std::cout << "bar\n"; }
};

这允许传递＆＃34; set＆＃34;重载函数到算法，状态，并且使用起来相当方便：

my_algorithm(my_fun_type{});

如果我们想要添加对此类函数对象的支持，我们可以按如下方式定义ForEach：

template <typename Elem, typename Fun>
void for_each(Fun&& fun) {
    std::vector<Elem>& vector = std::get<std::vector<Elem>>(vectors);
    for ( Elem& e : vector ) {
        fun(x);
    }
}

template <typename Fun>
void ForEach(Fun&& fun) {
    int dummy[] = { 0, (for_each<Ts>(fun), 0)... };
    (void)dummy;
}

dummy可以为for_each中的所有类型调用Ts。 (void)dummy旨在禁止编译器警告（永远不会读取dummy）。

您可以在其他Q＆amp; As中了解有关此技术的更多信息，例如that one。

Fun&&不是左值参考，而是universal reference。

请注意，上面的示例与许多标准库算法不同，后者通过值获取函数对象：

template <typename Elem, typename Fun>
void for_each(Fun fun) {
    std::vector<Elem>& vector = std::get<std::vector<Elem>>(vectors);
    std::for_each(vector.begin(), vector.end(), std::move(fun));
}

template <typename Fun>
void ForEach(Fun fun) {
    int dummy[] = { 0, (for_each<Ts>(fun), 0)... };
    (void)dummy;
}

要传递一组重载的自由函数，我们可以将它们包装在一个函数对象中（感谢@Yakk的建议）：

struct method_t
{
    template<class... Ts>
    void operator()(Ts&&... ts) const
    { method( std::forward<Ts>(ts)... ); }
};

在C ++ 1y中，使用多态lambda可以使用较少的样板文件创建这样的函数对象类型：

[](auto&&... pp)
{ method( std::forward<decltype(pp)>(pp)... ); }

没有虚拟或继承的多态向量

1 个答案: