テンプレートパラメータに応じて共用体メンバを選択してください

Question

私はC++で共用体を扱っていますが、テンプレートパラメータに応じてアクティブな共用体メンバにアクセスする関数テンプレートが必要です。私は専門、またはアクセスして割り当てることが均質でない方法のような悪いハックを発見し、これを達成するために

union Union { 
    int16_t i16; 
    int32_t i32; 
}; 

enum class ActiveMember { 
    I16 
    , I32 
} 

template <ActiveMember M> 
void doSomething(Union a, const Union b) { 
    selectMemeber(a, M) = selectMember(b, M); 
    // this would be exactly (not equivalent) the same 
    // that a.X = b.X depending on T. 
} 

：

コード（doSomethingのは一例です）のようなものです。

私は何かが不足しています、そしてそのようなものは他のアプローチでそれをするべきですか？

Answer 1

可能性1

の代わりに、列挙型を使用して、あなたはメンバーを選ぶために、単純な構造体を使用することができます。

typedef short int16_t; 
typedef long int32_t; 

union Union { 
    int16_t i16; 
    int32_t i32; 
}; 

struct ActiveMemberI16 {}; 
struct ActiveMemberI32 {}; 

template <typename M> 
void doSomething(Union& a, Union b) { 
    selectMember(a, M()) = selectMember(b, M()); 

    // this would be exactly (not equivalent) the same 
    // that a.X = b.X depending on T. 
} 

int16_t& selectMember(Union& u, ActiveMemberI16) 
{ 
    return u.i16; 
} 

int32_t& selectMember(Union& u, ActiveMemberI32) 
{ 
    return u.i32; 
} 

int main(int argc, char* argv[]) 
{ 
    Union a,b; 
    a.i16 = 0; 
    b.i16 = 1; 
    doSomething<ActiveMemberI16>(a,b); 
    std::cout << a.i16 << std::endl; 

    b.i32 = 3; 
    doSomething<ActiveMemberI32>(a,b); 
    std::cout << a.i32 << std::endl; 
    return 0; 
} 

これはすべてのための構造体とselectMemberメソッドを定義する必要がありしかし、少なくともselectMemberは他の多くの関数で使用できます。

私は引数を参照に変えましたが、適切でない場合はこれを調整することができます。

希望型のポインタへの組合のポインタをキャストすることによって可能性2

、あなたは、単一のselectMember機能に行くことができます。

typedef short int16_t; 
typedef long int32_t; 

union Union { 
    int16_t i16; 
    int32_t i32; 
}; 
template <typename T> 
T& selectMember(Union& u) 
{ 
    return *((T*)&u); 
} 

template <typename M> 
void doSomething(Union& a, Union b) { 
    selectMember<M>(a) = selectMember<M>(b); 

    // this would be exactly (not equivalent) the same 
    // that a.X = b.X depending on T. 
} 



int _tmain(int argc, _TCHAR* argv[]) 
{ 
    Union a,b; 
    a.i16 = 0; 
    b.i16 = 1; 

    doSomething<int16_t>(a,b); 
    std::cout << a.i16 << std::endl; 

    b.i32 = 100000; 
    doSomething<int32_t>(a,b); 
    std::cout << a.i32 << std::endl; 
    return 0; 
} 

Answer 2

テンプレートの特殊化を「悪いハック」と考える理由はわかりませんが、C++では「静的if」というようなことはありません。そのため、結果に基づいて生成されたコードをコンパイラで区別したい場合コンパイル時にと評価された式の場合、異なる特殊バージョンのテンプレートを定義する必要があります。

#include <iostream> 

using namespace std; 

union Union { 
    int16_t int16; 
    int32_t int32; 
}; 

enum class ActiveMember { 
    INT16 
    , INT32 
}; 

// Declare primary template 
template <ActiveMember M> 
void doSomething(Union a, const Union b); 

// First specialization 
template <> 
void doSomething<ActiveMember::INT16>(Union a, const Union b) 
{ 
    a.int16 = b.int16; 

    // Do what you want here... 
    cout << "int16" << endl; 
} 

// Second specialization 
template <> 
void doSomething<ActiveMember::INT32>(Union a, const Union b) 
{ 
    a.int32 = b.int32; 

    // Do what you want here... 
    cout << "int32" << endl; 
} 

そして、これはあなたがそれを使用する方法である：ここでは

はあなたがそれをどのように定義するかです。

int main() 
{ 
    Union u1, u2; 
    u1.int32 = 0; 
    u2.int32 = 0; 

    doSomething<ActiveMember::INT16>(u1, u2); 
    doSomething<ActiveMember::INT32>(u1, u2); 

    return 0; 
} 

Answer 3

私は考えることができる唯一の解決策は、労働組合に演算子を追加することです：

union Union 
{ 
    char c; 
    short s; 
    int i; 
    float f; 
    double d; 

    operator char() const { return c; } 
    operator short() const { return s; } 
    operator int() const { return i; } 
    operator float() const { return f; } 
    operator double() const { return d; } 
    template <typename T> operator T() const { /* invalid conversion */ T t; return t; } 

    Union &operator =(char ac) { c = ac; return *this; } 
    Union &operator =(short as) { s = as; return *this; } 
    Union &operator =(int ai) { i = ai; return *this; } 
    Union &operator =(float af) { f = af; return *this; } 
    Union &operator =(double ad) { d = ad; return *this; } 
    template <typename T> Union &operator =(T at) { /* invalid asignement */ return *this; } 
}; 

それはそれはsome typeとして動作するときに、労働組合の動作を制御することができます：

​​

オペレータのテンプレートバージョンが無効なコンバージョンと一致しています。