模板類型檢查C ++

Question

我有一個模板功能，它接收對象。 我需要確定對象是否派生自特定的基類。 如果它是從基類派生的，我需要調用附加函數。 無論如何我能用C ++ Linux做到嗎？

class baseA{
};

class derivedA:baseA{

};

class testB{
};

template<typename T>
void functionA(const T& value){

//if T is derived from baseA, call an additional function

//perform common operations for derivedA and testB...

}

為了澄清，附加函數是derivedA中的成員函數，但不是testB中的成員函數。

Answer 1

Boost.TypeTraits boost :: is_base_of

const bool is = boost::is_base_of<Base,Derived>::value;

`is_base_of`是如何工作的？

Answer 2

混合模板和繼承有點困難。

麻煩：

template <typename T>
void function(T const& t);

void function(A const& a);

如果您使用struct B: A {}: ,則首選模板版本，因為不需要轉換，因此它是“更好”的匹配。

如果您可以訪問模板版本的定義，則可以使用is_base_of和disable_if的組合。

template <typename T>
typename boost::disable_if< boost::is_base_of<A, T> >::type function(T const& t);

這個簡單的修改使用了SFINAE，基本上它在嘗試為從A派生的任何類實例化function時產生錯誤，並且C ++標准指定如果某個函數可能沒有被實例化，那么它將從沒有考慮的重載集中刪除觸發編譯器錯誤。

如果您無法訪問function的模板定義，那么您就不走運了。

Answer 3

您可以使用運行時類型標識（RTTI）來實現此目的。 示例如下：

class A{
public:
virtual void func(){cout << "Base" << endl;}
virtual ~A(){}
};

class B:public A{
public:
void func(){cout << "Derived" << endl;}
};

int main(){
A * d1 = new B();
B * d2;

d1 -> func() ;

d2 = dynamic_cast<B*>(d1);

if(d2 != NULL)
       cout << "Base exists" << endl;
else
       cout << "No relation" << endl;

return 0;
}

Answer 4

如果不知道您想要做的額外工作的確切性質，可能有兩種方法可以解決這個問題。

選項1：假設您要調用的函數是foo（）。 您可以在baseA和testB上實現foo（）。 baseA :: foo（）可以為你提供額外的工作，而testB：foo（）只會做什么。 但是如果foo（）不屬於這兩個類中的任何一個，那么這種風格是沒有意義的。

可選2：專門針對baseA的功能A（或者也可選擇testB）

void function_specialized(baseA* param)
{
    // Do your extra work

    // Then call the common functionA
    functionA<baseA>(*param);
}

template<typename T>
functionA(const T& value)
{
   //...
}

Answer 5

真正的模板專業化會更好:)

class A {
public:
    char c;
};

template <typename T> void foo(const T & t)
{
    std::cout << "this is generic.";
}

template <> void foo(const A & a)
{
    std::cout << "this is specialized.";
}

int main(int argc, char * argv[])
{
    foo(A());

    foo(int());
}

Answer 6

您可以進行完全靜態的模板專業化：

template <typename T>
void function(const T& value)
{
  common_task();
}

template <>
void function<A>(const A& value)
{
  common_task();
  // special A tasks
}