C++ 如何使用指向泛型模板类的指针访问依赖于模板参数类型的成员函数

有没有办法让指针指向泛型模板类并调用其返回值取决于模板参数的函数？以下是我想做的：

class Node{...}

template < typename Type > class NumberNode : public Node
{
    public:
        NumberNode( Type value ) : _value( value ) { }

        Type getValue() { return _value; }

    private:
        Type _value;
}

void foo( int x )    { /* do something */ }
void foo( float x )  { /* do something else */ }

void main(...)
{
    std::vector< Node* > nodes;

    nodes.push_back( new NumberNode< int >( 1 ) );
    nodes.push_back( new NumberNode< float >( 1.f ) );

    for( Node* ptr_node : nodes )
    {
        foo( static_cast< NumberNode* >( ptr_node )->getValue() );
    }
}

class Node 
{
 public:
  virtual void foo() = 0;
};

类节点{…}
模板类编号节点：公共节点
{
公众：
NumberNode（类型值）：\u值（值）{}
键入getValue（）{return\u value；}
私人：
类型_值；
}
void foo（int x）{/*做点什么*/}
void foo（float x）{/*执行其他操作*/}
空总管（…）
{
std：：向量节点；
nodes.push_back（新的NumberNode（1））；
nodes.push_back（newnumbernode（1.f））；
用于（节点*ptr_节点：节点）
{
foo（static_cast（ptr_节点）->getValue（））；
}
}

---

我不能这样做，因为

static_cast（派生*）

应该知道完整的模板类型，这会有所不同。我也不能让

Base

成为模板类型，因为其他类也从中派生。有人知道解决方法吗？

这是正确的做法：

class Node{...}

template < typename Type > class NumberNode : public Node
{
    public:
        NumberNode( Type value ) : _value( value ) { }

        Type getValue() { return _value; }

    private:
        Type _value;
}

void foo( int x )    { /* do something */ }
void foo( float x )  { /* do something else */ }

void main(...)
{
    std::vector< Node* > nodes;

    nodes.push_back( new NumberNode< int >( 1 ) );
    nodes.push_back( new NumberNode< float >( 1.f ) );

    for( Node* ptr_node : nodes )
    {
        foo( static_cast< NumberNode* >( ptr_node )->getValue() );
    }
}

class Node 
{
 public:
  virtual void foo() = 0;
};

你的循环变为

for( Node* ptr_node : nodes )
{
    ptr_node->foo();
}

foo

可以在

NumberNode

中实现，如下所示：

template <typename Type> 
void NumberNode::foo() 
{
  ::foo(_value);
}

模板
void NumberNode:：foo（）
{
：：foo（_值）；
}

这种设计可能不再需要

getValue（）

，您可以将其删除。这是件好事。吸气剂是弱设计的表现。对象应该做东西，而不是有东西

---

如果出于某种原因，您不想在

节点

中使用

foo

（可能您有太多类似

foo

的函数，并且不想污染接口），另一种方法是实现for

节点

。然而，Visitor也有它自己的缺点，所以我只建议在这种情况下使用它作为最后的手段。

你能把函数模板化，这样你就可以专门处理你想要的类型吗？@Ben我不这么认为。函数应该根据类型做完全不同的事情，因此它需要根据模板参数进行分支，我认为这是不可能的。我认为我不理解你想要达到什么，所以它可能对你有帮助，或者在你看来没有帮助。在C++中，我们有类模板，而不是“模板类”。类模板不是类

NumberNode

是一个类模板

NumberNode

是一个类

NumberNode

是一个完全不同的类。没有

NumberNode*

这样的东西，因为

NumberNode

不是一个类。而且，

main

的标准原型是

int main（）

或

int main（int，char**）

。