模板类的 std::map 类型签名（声明）

Question

我已经定义了很多这样的模板类变量：

someTemplate<int, int, char> variable1;
someTemplate<char, int, char> variable2;
someTemplate<double, double, int> variable3;
someTemplate<int, int, char> variable4;
someTemplate<int, int, float> variable15;
...

现在，我想定义关联 std::map，但我不知道如何编写类型签名（声明）……如果可能的话。例如：

std::map<int,_____> assocArr;

我需要它，因为我想使用循环对 std::map 的所有项目调用函数：

for(auto item : assocArr)
{
    if(item.first == integerVar)
        item.second->myFunction();
}

我知道，这个简单的解决方案是制作类，它封装了所有模板类，但我的问题是如果没有这个类可以做到吗？ 由于模板类有很多变体，所以 boost::variant 的使用存在问题。

Answer 1

您可以使用Boost Type Erasure 或制作您自己的自定义类型擦除包装器。

是的，这意味着存储一个包装器，但这正是您所需要的。因为地图不能包含“任何随机类型”，并且使用例如如果有“模板类的许多变体”，boost::any 将无法正常工作。

粗略的草图：WIP https://www.livecoding.tv/sehe/

Live On Coliru

#include <map>
#include <iostream>
#include <memory>

template <typename T, typename U, typename V>
struct someTemplate {
    void myFunction() const {
        std::cout << __PRETTY_FUNCTION__ << "\n";
    }
};

struct someErasure {
    template <typename... Ts> /*explicit*/ someErasure(someTemplate<Ts...> const& v) 
        : _holder(new holder<someTemplate<Ts...> >(&v))
    { }

    someErasure(someErasure const& rhs) : _holder(rhs._holder->clone()) { }

    void myFunction() const {
        _holder->myFunction();
    }

  private:
    struct itf {
        virtual void myFunction() const = 0;
        virtual itf* clone() const = 0;
    };

    template <typename T> struct holder : itf {
        holder(T const* v) : _v(v) { }
        T const* _v;

        virtual void myFunction() const {
            _v->myFunction();
        }

        virtual holder* clone() const { return new holder(_v); }
    };

    std::unique_ptr<itf> _holder;
};

int main() {
    someTemplate<int,    int,    char>  variable1;
    someTemplate<char,   int,    char>  variable2;
    someTemplate<double, double, int>   variable3;
    someTemplate<int,    int,    char>  variable4;
    someTemplate<int,    int,    float> variable5;

    std::map<int, someErasure> assocArr {
        { 1,  variable1 },
        { 2,  variable2 },
        { 3, variable3 },
        { 4,  variable4 },
        { 5,  variable5 },
    };

    for(auto& item : assocArr)
        //if(item.first == integerVar)
    {
        std::cout << "id: " << item.first << " ";
        item.second.myFunction();
    }
}

打印

id: 1 void someTemplate<T, U, V>::myFunction() const [with T = int; U = int; V = char]
id: 2 void someTemplate<T, U, V>::myFunction() const [with T = char; U = int; V = char]
id: 3 void someTemplate<T, U, V>::myFunction() const [with T = double; U = double; V = int]
id: 4 void someTemplate<T, U, V>::myFunction() const [with T = int; U = int; V = char]
id: 5 void someTemplate<T, U, V>::myFunction() const [with T = int; U = int; V = float]

Answer 2

也添加了 Boost Type Erasure 路由。

BOOST_TYPE_ERASURE_MEMBER((has_myFunction), myFunction, 0)

namespace bte = boost::type_erasure;
using Erased = bte::any<
    boost::mpl::vector<
        bte::copy_constructible<>,
        has_myFunction<void(), bte::_self const>, 
        bte::relaxed 
    > >;

这有更多的学习曲线¹，但如果您有更多的概念需要满足，这可能是一个很好的权衡。

该示例还展示了如何实现映射值的值语义（假设 someTemplate<> 是可复制构造的）。

演示

Live On Coliru

#include <map>
#include <iostream>
#include <boost/type_erasure/any.hpp>
#include <boost/type_erasure/member.hpp>
#include <boost/type_erasure/constructible.hpp>

BOOST_TYPE_ERASURE_MEMBER((has_myFunction), myFunction, 0)

namespace bte = boost::type_erasure;
using Erased = bte::any<
    boost::mpl::vector<
        bte::copy_constructible<>,
        has_myFunction<void(), bte::_self const>, 
        bte::relaxed 
    > >;

template <typename T, typename U, typename V>
struct someTemplate {
    void myFunction() const {
        std::cout << __PRETTY_FUNCTION__ << "\n";
    }
};

int main() {
    std::map<int, Erased> assocArr {
        { 1,  someTemplate<int,    int,    char>  {} },
        { 2,  someTemplate<char,   int,    char>  {} },
        { 3,  someTemplate<double, double, int>   {} },
        { 4,  someTemplate<int,    int,    char>  {} },
        { 5,  someTemplate<int,    int,    float> {} },
    };

    for(auto& item : assocArr)
        //if(item.first == integerVar)
    {
        std::cout << "id: " << item.first << " ";
        item.second.myFunction();
    }
}

印刷：

id: 1 void someTemplate<T, U, V>::myFunction() const [with T = int; U = int; V = char]
id: 2 void someTemplate<T, U, V>::myFunction() const [with T = char; U = int; V = char]
id: 3 void someTemplate<T, U, V>::myFunction() const [with T = double; U = double; V = int]
id: 4 void someTemplate<T, U, V>::myFunction() const [with T = int; U = int; V = char]
id: 5 void someTemplate<T, U, V>::myFunction() const [with T = int; U = int; V = float]

¹正如现场直播所证明的那样：)