0

此方法尝试std::vector<?>根据键 ( ) 选择 ( std::string)，其中?是int或float：

template<typename L>
inline void EnsembleClustering::Graph::forNodesWithAttribute(std::string attrKey, L handle) {
    // get nodemap for attrKey

    auto nodeMap; // ?

    auto findIdPair = this->attrKey2IdPair.find(attrKey);
    if (findIdPair != this->attrKey2IdPair.end()) {
        std::pair<index, index> idPair = findIdPair->second;
        index typeId = idPair.first;
        index mapId = idPair.second;

        // nodemaps are in a vector, one for each node attribute type int, float, NodeAttribute
        switch (typeId) {
        case 0:
            nodeMap = this->nodeMapsInt[mapId];
            break;
        case 1:
            nodeMap = this->nodeMapsFloat[mapId];
            break;
        }

        // iterate over nodes and call handler with attribute
        this->forNodes([&](node u) {
            auto attr = nodeMap[u];
            handle(u, attr);
        });
    } else {
        throw std::runtime_error("node attribute not found");
    }

}

该类的相关成员是：

std::map<std::string, std::pair<index, index>> attrKey2IdPair;  // attribute key -> (attribute type index, attribute map index)

// storage
std::vector<std::vector<int> > nodeMapsInt;         // has type id 0
std::vector<std::vector<float> > nodeMapsFloat;     // has type id 1

这将无法编译，因为auto nodeMap(= std::vector<?>) 未初始化。但是为了初始化它，我必须在编译时知道它的类型。

也许我正在尝试的事情不能用静态类型来完成。有没有 C++ 方法来完成这个？

4

2 回答 2

2

如果您的变体数量有限（即只有 float 的向量和 int 的向量），您可以使用boost::variant它来存储它。

定义变体类型，并定义访问者结构：

#include "boost/variant.hpp"

//Define type
typedef boost::variant<std::vector<int>, std::vector<float>> VectorType;

struct VectorTypeVisitor : public boost::static_visitor<void>
    {
        node& m_u;

        VectorTypeVisitor(node& u) : m_u(u) { } //Pass node to visitor in constructor

        void operator()(const std::vector<int>& nodeMap) const
        {
            auto attr = nodeMap[m_u];
            handle(m_u, attr);
        }

        void operator()(const std::vector<float>& nodeMap) const
        {
            auto attr = nodeMap[m_u];
            handle(m_u, attr); //What to do if visitor applied to float
        }
    }

您的代码可能如下所示：

template<typename L>
inline void EnsembleClustering::Graph::forNodesWithAttribute(std::string attrKey, L handle) {
    // get nodemap for attrKey

    VectorType nodeMap;

    auto findIdPair = this->attrKey2IdPair.find(attrKey);
    if (findIdPair != this->attrKey2IdPair.end()) {
        std::pair<index, index> idPair = findIdPair->second;
        index typeId = idPair.first;
        index mapId = idPair.second;

        // nodemaps are in a vector, one for each node attribute type int, float, NodeAttribute
        switch (typeId) {
        case 0:
            nodeMap = this->nodeMapsInt[mapId];
            break;
        case 1:
            nodeMap = this->nodeMapsFloat[mapId];
            break;
        }

        // iterate over nodes and call handler with attribute
        this->forNodes([&](node u) {
            boost::apply_visitor(VectorTypeVisitor(u), nodeMap);
        });
    } else {
        throw std::runtime_error("node attribute not found");
    }
}

但是，传递 typeId 之类的变量来识别变量类型仍然不好。

于 2013-02-07T19:43:45.843 回答
2

这些是模板的事实与它无关。 std::vector<std::vector<int> >并且 std::vector<std::vector<float> >是两个完全不相关的类，并且行为如此。如果你真的需要这样的东西，你必须定义一个抽象基类和两个派生类，每个派生类都包装相应的 std::vector. 但我看不出你将如何使用它，甚至无法定义适当的抽象基类，因为向量中包含的类型渗透到了接口中。您几乎在每次通话中使用的类型也必须不同。

于 2013-02-07T19:12:05.930 回答