類型特徵與靜態成員的優點？

Question

我有一個類（Voxel）與子類可能或可能不具有許多不同的屬性（材料，密度等）與get和set方法。現在，我想要寫一些代碼如下：

template <typename VoxelType> 
void process(VoxelType voxel) 
{ 
    if(VOXEL_HAS_MATERIAL) 
    { 
    //Do some work which involves calling get/setMaterial() 
    } 
    if(VOXEL_HAS_DENSITY) 
    { 
    //Do some work which involves calling get/setDensity() 
    } 
} 

因此，我要像落實VOXEL_HAS_MATERIAL和VOXEL_HAS_DENSITY部分。兩個簡單的選項是：

1. 靜態hasMaterial()和hasDensity()方法添加到Voxel類，在派生類中重寫。
2. 創建一個類型特徵類hasMaterial()和hasDensity()，並專門爲每個Voxel子類。

使用方法（2）允許爲原始類型（int等）定義特徵，但在我的情況下這沒有用。在這裏使用類型特徵是否還有其他優點，還是應該採用更簡單的靜態方法？

注意：我也知道基於SFINAE的方法，我將分別考慮。

編輯1：我已更改示例代碼以顯示使用模板。我正在尋找這個問題的靜態而非運行時解決方案。理想情況下，如果編譯器確定它們不能針對給定類型執行，編譯器將能夠去除if語句中的代碼。

Answer 1

類型特徵很有用，因爲它們可以很容易地添加到類型中，即使您無法更改類型本身。此外，使用類型特徵，你可以簡單地提供一個合理的默認值（例如，你可以將hasMaterial和hasDensity委託給類的合適的靜態成員），然後你只需要對不適用於這個類的類進行特化默認。

Answer 2

爲什麼這些方法應該是靜態的？只需在Voxel類中聲明方法virtual bool hasMaterial();和virtual bool hasDensity();，並在任何子類中覆蓋它們。在子類中返回true，否則返回false。

你可以再做：

void process(Voxel* voxel) 
{ 
    if(voxel->hasMaterial()) 
    { 
     //Do some work which involves calling get/setMaterial() 
    } 
    if(voxel->hasDensity()) 
    { 
     //Do some work which involves calling get/setDensity() 
    } 
} 

然後，您可以創建一個類似與材料和密度的getter和setter類的接口，也讓他們繼承。

Answer 3

靜態成員不能被覆蓋。你應該讓它們變成虛擬的。我想你的設計有問題，如果可能的話粘貼一些uml圖或你的源代碼。

Answer 4

不使用運行時，而是使用靜態檢查。

首先，定義該宏：

#define HAS_MEMBER_VARIABLE(NEW_STRUCT, VAR)         \ 
template<typename T> struct NEW_STRUCT {          \ 
    struct Fallback { int VAR; }; /* introduce member name "VAR" */    \ 
    struct Derived : T, Fallback { };           \ 
                       \ 
    template<typename C, C> struct ChT;           \ 
                       \ 
    template<typename C> static char (&f(ChT<int Fallback::*, &C::VAR>*))[1]; \ 
    template<typename C> static char (&f(...))[2];        \ 
                       \ 
    static bool const value = sizeof(f<Derived>(0)) == 2;      \ 
}; 

，其檢查在一個類是否存在一個成員變量。

然後使用SFINAE做一些事情，如果變量存在，像下面的例子：

#include <iostream> 

#define HAS_MEMBER_VARIABLE(NEW_STRUCT, VAR)         \ 
template<typename T> struct NEW_STRUCT {          \ 
    struct Fallback { int VAR; }; /* introduce member name "VAR" */    \ 
    struct Derived : T, Fallback { };           \ 
                       \ 
    template<typename C, C> struct ChT;           \ 
                       \ 
    template<typename C> static char (&f(ChT<int Fallback::*, &C::VAR>*))[1]; \ 
    template<typename C> static char (&f(...))[2];        \ 
                       \ 
    static bool const value = sizeof(f<Derived>(0)) == 2;      \ 
}; 

HAS_MEMBER_VARIABLE(x_check, x) 

struct A 
{ 
    int x; 
}; 
struct B 
{ 
    float notX; 
}; 

template< typename T, bool hasX = x_check<T>::value > 
struct doX 
{ 
    static void foo(const T & t) 
    { 
     std::cout<<"type has x variable, and it's value is "<<t.x<<std::endl; 
    } 
}; 
template< typename T > 
struct doX< T, false > 
{ 
    static void foo(const T &) 
    { 
     std::cout<<"type has no x variable"<<std::endl; 
    } 
}; 

template< typename T > 
void doFoo(const T& t) 
{ 
    doX< T, x_check<T>::value >::foo(t); 
}; 

int main() 
{ 
    A a; a.x = 6; 
    B b; b.notX = 3.6; 

    std::cout<<"Calling foo() on A : "; 
    doFoo(a); 
    std::cout<<"Calling foo() on B : "; 
    doFoo(b); 
}