Question

我可以使用C ++模板类来区分对象类型吗？或者我应该使用什么？

EG。我有一个班级Synonym，例如，它可以是Statement, Procedure, etc类型。我有接受这些同义词的函数，并根据其类型对它们进行评估。所以我觉得如果我可以这样做会很好：

enum Types { Statement, Procedure, Variable, ... };

template <typename Types>
class Synonym { ... }

void evaluate(Synonym<Statement> s, Synonym<Variable> v) { do something }
              ^ so that I can do this ... instead of checking the type in function like: 

void evaluate(Synonym s, Synonym v) {
    assert(s.type == Statement);
    assert(v.type == Variable);

    // also would like to eliminate things like: (if possible)
    switch(s.type) {
        case XXX: doSomething ... 
        case YYY: doAnotherThing ...
    }
}

Answer 1

您可以创建一个功能模板，然后专注于该模板

template<typename Type>
void evaluate (Type t) {}

template<>
void evaluate<Statement>( Statement s)
{}

这样，当你传递Statement时，它会选择那个重载，你可以根据类型做不同的行为。

Answer 2

我认为使用变体和访客模式是合适的。在这里查看Boost.Variant：http://www.boost.org/doc/libs/1_51_0/doc/html/variant.html，最后一个示例（也在下面但展开）显示了一个访问者实现。还有其他变种和访客实施。 std :: any和loki也是选项。我个人喜欢loki但这可能只是因为我是Alexandrescu的忠实粉丝。

#include "boost/variant.hpp"
#include <iostream>

class ToLengthVisitor : public boost::static_visitor<int>
{
public:
    int operator()(int i) const
    {
        return i;
    }

    int operator()(const std::string & str) const
    {
        return str.length();
    }

    int operator()(const char * str) const
    {
        const char * temp = str;
        while(*temp != '\0') temp++;
        return temp-str;
    }
};

int main()
{
    typedef boost::variant< int, std::string, const char * > MyVariant;
    MyVariant u(std::string("hello world"));
    std::cout << u; // output: hello world

    MyVariant cu(boost::get<std::string>(u).c_str());

    int result = boost::apply_visitor( ToLengthVisitor(), u );
    std::cout << result; // output: 11 (i.e., length of "hello world")
    result = boost::apply_visitor( ToLengthVisitor(), cu );
    std::cout << result; // output: 11 (i.e., length of "hello world")
}

模板类来区分对象类型？

2 个答案: