Question

我想知道是否可以将模板用作地图的关键字。例如：

std::map< <T> , Node> nodes;

从本质上讲，我想要做的是能够拥有一堆包含任意类型数据的节点，并且由该数据键入。我想我可以通过将所述数据转换为二进制并按键进行键控来实现，但这很麻烦，我想避免它。

为了澄清，我希望能够使用任何类型的变量作为密钥。例如，如果我有2个节点，一个包含int作为其数据，另一个包含Foo作为其数据，我希望能够使用它们的数据作为键将它们放在同一个映射中。也许地图不是我想要的，我不确定......

思考？谢谢！

Answer 1

我认为为此目的，使用std::type_info类型更容易：

std::map<std::type_info, std::string> m;
m[typeid(int)] = "integer";

但这实际上取决于你想要达到的目标，我现在还不清楚。希望有所帮助

Answer 2

我通常做的是：

template<typename T>
void type_id(){}

using type_id_t = void(*)();

然后，我这样使用它：

std::map<type_id_t, Node> nodes;

nodes[type_id<AType>] = Node{...};
nodes[type_id<BType>] = Node{...};

当然，这可以通过C ++ 14中的变量模板来增强。

对不起，我刚刚重新阅读了这个问题，我理解得更好。

你想要的是std::any，但它只是C ++ 17。您可以改为使用boost::any。

看起来像这样：

std::map<std::any, Node> nodes;

nodes.emplace("string as key", Node{});
nodes.emplace(23, Node{});

只要地图可以某种方式订购std::any的实例，它就应该有效。如果没有，您可以改为使用哈希映射：

std::unordered_map<std::any, Node> nodes;

然后只要地图可以散列任何一个，它就会起作用。

Answer 3

至少如果我理解你想要什么，简短的回答是否定的。

必须对地图中的键进行排序 - 也就是说，您必须为任何一对键A和B定义，您必须定义一个有序关系，其中A小于B，或者B小于A，或者这两个键是等价的。

鉴于完全任意类型的两个键，它们不会成为比较它们的定义方式。因此，您无法将它们用作地图的键。

为了得到某种结果，您需要定义一些您想要支持的特定类型。然后，您可以定义一些（大致）您想要支持的所有类型的联合。仅凭这一点就足够了 - 你还必须定义排序。根据您尝试完成的任务，您可能（例如）在每个对象中都有一个ID，并按ID排序。或者，您可以定义对象之间的顺序，因此（例如）每Person个Dog在每个Dream之前排序，在每个$cmd = 'psql -U postgres -c "SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'portal';"'; exec($cmd);之前进行排序，依此类推。然后，你必须像往常一样在每种类型中定义一个排序。

但是，我警告说，这通常涉及相当多的额外工作，并且提供的回报非常小。我说90％以上的时间我见过人（尝试）做到这一点，这是一个错误最好的错误。如果可能的话，我会尝试找到其他方法来解决您尝试解决的任何问题。

Answer 4

您可以创建一个类似于poly_key的类，它将接受任何类型，只要它是：

可复制或可移动（可演示此版本）
相等的平等（如果在无序地图中使用）
小于可比较（如果在地图中使用）
hashable（如果在有序地图中使用）
ostreamable（本演示）

像这样：

#include <iostream>
#include <string>
#include <memory>
#include <unordered_map>
#include <map>
#include <typeinfo>

/// a non-polymorphic container for a polymorphic key type
struct poly_key
{
    /// concept defines the key's capabilities
    struct concept {

        virtual bool equal(const void* other) = 0;
        virtual bool less(const void* other) = 0;
        virtual const void* address() const = 0;
        virtual const std::type_info& type() const = 0;
        virtual std::size_t hash() const = 0;
        virtual std::ostream& emit(std::ostream&) const = 0;
        virtual std::unique_ptr<concept> clone() const = 0;
        virtual ~concept() = default;
    };

    using ptr_type = std::unique_ptr<concept>;

    /// model<> models the concept for any key which supports the required operations
    template<class T>
    struct model : concept {
        model(T&& t) : _t(std::move(t)) {}

        bool equal(const void* other) override {
            return _t == (*reinterpret_cast<const T*>(other));
        }

        bool less(const void* other) override {
            return _t < (*reinterpret_cast<const T*>(other));
        }

        const void* address() const override {
            return std::addressof(_t);
        }
        const std::type_info& type() const override {
            return typeid(_t);
        }

        std::size_t hash() const override {
            return std::hash<T>()(_t);
        }

        std::ostream& emit(std::ostream& os) const override
        {
            return os << _t;
        }

        virtual std::unique_ptr<concept> clone() const override
        {
            return std::make_unique<model>(*this);
        }


        T _t;
    };

    template<class T>
    poly_key(T t) : _impl(std::make_unique<model<T>>(std::move(t))) {}

    std::size_t hash() const {
        return _impl->hash();
    }

    bool operator==(const poly_key& r) const {
        return _impl->type() == r._impl->type()
        && _impl->equal(r._impl->address());
    }

    bool operator<(const poly_key& r) const {
        auto& lt = _impl->type();
        auto& rt = r._impl->type();

        if (lt.before(rt)) {
            return true;
        }
        else if (rt.before(lt)) {
            return false;
        }
        else {
            return _impl->less(r._impl->address());
        }
    }

    poly_key(const poly_key& r)
    : _impl(r._impl->clone())
    {

    }

    poly_key(poly_key&& r)
    : _impl(std::move(r._impl))
    {

    }

    friend std::ostream& operator<<(std::ostream& os, const poly_key& k)
    {
        return k._impl->emit(os);
    }

    ptr_type _impl;
};

/// make it hashable
namespace std {
    template<> struct hash<::poly_key> {
        bool operator()(const ::poly_key& r) const {
            return r.hash();
        }
    };
}

//
// test
//
int main()
{
    std::unordered_map<poly_key, std::string> m;

    m.emplace(poly_key(std::string("key 1")), "Hello");
    m.emplace(poly_key(2), "World");

    std::cout << "unordered:\n";
    for (auto& e : m) {
        std::cout << e.first << " : " << e.second << std::endl;
    }

    std::cout << "\nordered:\n";
    std::map<poly_key, std::string> m2 (m.begin(), m.end());
    for (auto& e : m2) {
        std::cout << e.first << " : " << e.second << std::endl;
    }   
}

示例输出（顺序可能因工具集而异）：

unordered:
2 : World
key 1 : Hello

ordered:
key 1 : Hello
2 : World

Answer 5

为您的类型提供名称，并将其与地图一起使用：

#include<map>
#include<cassert>

struct B { static int cnt; };
int B::cnt = 0;

template<typename T>
struct D: B { static const int type; };

template<typename T>
const int D<T>::type = B::cnt++;

std::map<int, int> values;

template<typename T>
void set(int value) { values[D<T>::type] = value; }

template<typename T>
int get() { return values[D<T>::type]; }

struct T1 { };
struct T2 { };

int main() {
    set<T1>(42);
    set<T2>(0);
    assert(get<T1>() == 42);
    assert(get<T2>() == 0);
    set<T2>(3);
    assert(get<T2>() == 3);
}

使用模板作为std :: map中的键

5 个答案: