は、それが選択的に、私はこのようになりますクラステンプレートを持つ派生クラス

Question

で型を定義することが可能ですfoo<some_base>::some_typeは、がBase::some_typeを隠すので、intになります。私がしたいのは、Base::some_typeが定義されている場合は、some_typeをfooにローカルに定義して 'int - これは可能ですか？

私は関係を反転し、自分自身にいくつかの頭痛の種を保存し、しかし、それは実際のアプリケーションでは非常に論理的ではありません...

Answer 1

ものは、テンプレートメタプログラミングのビットで可能です:)

スタートタイプは「some_type」と呼ばれる、ネストされたタイプを持っているかどうかを決定するメタ関数を書くことで。

template <typename T> 
struct has_some_type 
{ 
    typedef char no;     // type with sizeof == 1 
    typedef struct { char x[2]; } yes; // type with sizeof == 2 

    template <typename X, typename Y = typename X::some_type> 
    struct foo {}; 

    template <typename X> 
    static yes test(foo<X>*); 

    template <typename X> 
    static no test(...); 

    static const bool value = (sizeof(test<T>(0)) == sizeof(yes)); 
}; 

今、あなたは派生クラスでこのような何かを行うことができます：

template <typename T, bool has_some_type> 
struct get_some_type; 

template <typename T> 
struct get_some_type<T, true> 
{ 
    typedef typename T::some_type type; 
}; 

template <typename T> 
struct get_some_type<T, false> 
{ 
    typedef int type; // the default type 
}; 

template <typename base> 
class derived : base 
{ 
    typedef typename get_some_type<base, has_some_type<base>::value>::type some_type; 

    ... 
}; 

Answer 2

はそのintデフォルトstruct fooに追加のテンプレート引数を与えることができる：

template <Base, Typedef = int> 
struct foo : Base 
{ 
    typedef Typedef some_type; 
}; 

その後foo<some_base, some_base::some_type>::some_typeはsome_base::some_typeです。

Answer 3

これは動作するはずです：

struct sfinae_types 
{ 
    struct yes { char x; }; 
    struct no { char x[2]; }; 
}; 

template<class T> 
class has_some_type : sfinae_types 
{ 
    private: 
    template<class U> 
    static yes test(typename U::some_type *); 
    template<class U> 
    static no test(...); 
    public: 
    enum { value = (sizeof(yes) == sizeof(test<T>(0))) }; 
}; 

template<bool, class T, typename DT> 
struct get_some_type 
{ 
    typedef DT type; 
}; 

template<class T, typename DT> 
struct get_some_type<true, T, DT> 
{ 
    typedef typename T::some_type type; 
}; 

struct B1 
{ 
}; 

struct B2 
{ 
    typedef float some_type; 
}; 

template<typename T> 
struct D : T 
{ 
    typedef typename get_some_type<has_some_type<T>::value, T, int>::type some_type; 
}; 

#include<iostream> 
#include<typeinfo> 

int main() 
{ 
    std::cout << has_some_type<B1>::value << std::endl; 
    std::cout << typeid(D<B1>::some_type).name() << std::endl; 
    std::cout << has_some_type<B2>::value << std::endl; 
    std::cout << typeid(D<B2>::some_type).name() << std::endl; 
    return(0); 
} 

そしてHighCommander4を提示するもののわずかな変化である。このような何か数秒上に...

私はboost :: mplがここに便利だと思います私が手作業で作った有用なTMP表現。