7

我有一个带有虚函数的基类：

class Base
{
public:
  virtual void Function();
};

void Base::Function()
{
  cout << "default version" << endl;
}

和一个派生的模板类：

template <class T> class Derived : public Base
{
public:
  virtual void Function();
};

有没有办法Function()从所有类型的基类中获取，除了一些选择的类型？所以我想要的是能够定义一个覆盖Function()，比如说，int和long：

void Derived<int>::Function()
{
  cout << "overriden version 1" << endl;
}

void Derived<long>::Function()
{
  cout << "overriden version 2" << endl;
}

并拥有Function()所有其他类型的默认版本，没有明确定义Function()它们，所以输出

int main ()
{
  Derived<int> derivedInt;
  derivedInt.Function();

  Derived<long> derivedLong;
  derivedLong.Function();

  Derived<double> derivedDouble;
  derivedDouble.Function();
}

将会

overriden version 1
overriden version 2
default version

可能吗？

4

3 回答 3

8

类模板的成员函数实际上是函数模板，因此您可以对它们进行专门化：

template <typename T> class Foo
{
    void Function();
};

template <typename T> void Foo::Function() { /* ... */ }

template <> void Foo<int>::Function() { /* ... */ }
于 2012-06-02T15:29:58.180 回答
4

第一个解决方案（使用typeid运算符）： 

#include <iostream>
#include <typeinfo>

using namespace std;

class Base
{
public:
    virtual void Function();
};

void Base::Function()
{
    cout << "default version\n";
}

template<typename T>
class Derived : Base
{
public:
    virtual void Function();
};

template<typename T>
void Derived<T>::Function()
{
    if(typeid(T) == typeid(int)) // check if T is an int
    {
        cout << "overriden version 1\n";
    }
    else if(typeid(T) == typeid(long)) // check if T is a long int
    {
        cout << "overriden version 2\n";
    }
    else // if T is neither an int nor a long
    {
        Base::Function(); // call default version
    }
}

int main()
{
    Derived<int> di;
    Derived<long> dl;
    Derived<float> df;

    di.Function();
    dl.Function();
    df.Function();

    return 0;
}

我使用typeid运算符检查 T 是 anint还是 a long int，如果是，我打印“覆盖版本 [number]”。如果不是，我调用Base::Function()，它将打印“默认版本”

注意：要使用typeid运算符，您需要包含头文件typeinfo

第二种解决方案（使用模板专业化）：

// class declarations as before

template<typename T>
void Derived<T>::Function()
{
    Base::Function(); // call default version
}

template<>
void Derived<int>::Function()
{
    cout << "overriden version 1\n";
}

template<>
void Derived<long>::Function()
{
    cout << "overriden version 2\n";
}

int main()
{
    Derived<int> di;
    Derived<long> dl;
    Derived<float> df;

    di.Function();
    dl.Function();
    df.Function();

    return 0;
}

在这里，我用模板专业化解决了你的问题。如果 T 是 anint或 a long int，我称其为专用版本。否则，我称之为通用版本，相当于Base::Function().

于 2012-06-02T18:11:01.393 回答
3

是的，通过专业化Derived。

  • 编写没有它的通用版本（它将继承它Base）
  • 专门Derived覆盖

简单的方案，但它的工作原理。

于 2012-06-02T15:14:50.517 回答