std :: enable_ifでメンバー関数を条件付きでコンパイル

簡単な例を使って、使い方を理解しようとしていますstd::enable_if。この回答を読んだ後、簡単な例を考え出すのはそれほど難しくないと思いました。std::enable_if2つのメンバー関数から選択して、そのうちの1つだけを使用できるようにしたい。

残念ながら、以下はgcc 4.7でコンパイルできません。何時間も試行した後、私の間違いは何ですかと皆さんに尋ねています。

#include <utility>
#include <iostream>

template< class T >
class Y {

    public:
        template < typename = typename std::enable_if< true >::type >
        T foo() {
            return 10;
        }
        template < typename = typename std::enable_if< false >::type >
        T foo() {
            return 10;
        }

};


int main() {
    Y< double > y;

    std::cout << y.foo() << std::endl;
}

gccは次の問題を報告します。

% LANG=C make CXXFLAGS="-std=c++0x" enable_if
g++ -std=c++0x    enable_if.cpp   -o enable_if
enable_if.cpp:12:65: error: `type' in `struct std::enable_if<false>' does not name a type
enable_if.cpp:13:15: error: `template<class T> template<class> T Y::foo()' cannot be overloaded
enable_if.cpp:9:15: error: with `template<class T> template<class> T Y::foo()'

g ++が2番目のメンバー関数の間違ったインスタンス化を削除しないのはなぜですか？規格によると、std::enable_if< bool, T = void >::typeブールテンプレートパラメータがtrueの場合にのみ存在します。しかし、なぜg ++はこれをSFINAEと見なさないのですか？オーバーロードのエラーメッセージは、g ++が2番目のメンバー関数を削除しないという問題から発生し、これがオーバーロードであると考えていると思います。

SFINAEが機能するのは、テンプレート引数の引数演繹での置換により、構成の形式が不適切な場合のみです。そのような代用はありません。

私もそのことを考えて、使用しようとしたstd::is_same< T, int >::valueと! std::is_same< T, int >::valueされ、同じ結果が得られます。

これは、クラステンプレートがインスタンス化されるとき（特に、タイプのオブジェクトを作成するときに発生しますY<int>）、すべてのメンバー宣言（必ずしもその定義/ボディではない！）がインスタンス化されるためです。その中には、そのメンバーテンプレートもあります。Tは既知であり!std::is_same< T, int >::value、falseを返すことに注意してください。だからそれはY<int>含むクラスを作成します

class Y<int> {
    public:
        /* instantiated from
        template < typename = typename std::enable_if< 
          std::is_same< T, int >::value >::type >
        T foo() {
            return 10;
        }
        */

        template < typename = typename std::enable_if< true >::type >
        int foo();

        /* instantiated from

        template < typename = typename std::enable_if< 
          ! std::is_same< T, int >::value >::type >
        T foo() {
            return 10;
        }
        */

        template < typename = typename std::enable_if< false >::type >
        int foo();
};

はstd::enable_if<false>::type存在しない型にアクセスするため、宣言の形式が正しくありません。したがって、プログラムは無効です。

メンバーテンプレートenable_ifを、メンバーテンプレート自体のパラメーターに依存させる必要があります。その後、型全体が依然として依存しているため、宣言は有効です。それらの1つを呼び出そうとすると、テンプレート引数の引数の控除が行われ、SFINAEが期待どおりに行われます。これを行う方法については、この質問と対応する回答を参照してください。

私はこの短い例も作成しましたが、うまくいきます。

#include <iostream>
#include <type_traits>

class foo;
class bar;

template<class T>
struct is_bar
{
    template<class Q = T>
    typename std::enable_if<std::is_same<Q, bar>::value, bool>::type check()
    {
        return true;
    }

    template<class Q = T>
    typename std::enable_if<!std::is_same<Q, bar>::value, bool>::type check()
    {
        return false;
    }
};

int main()
{
    is_bar<foo> foo_is_bar;
    is_bar<bar> bar_is_bar;
    if (!foo_is_bar.check() && bar_is_bar.check())
        std::cout << "It works!" << std::endl;

    return 0;
}

詳しく説明してほしい場合はコメントしてください。私はコードが多かれ少なかれ自明だと思いますが、それからもう一度私はそれを作ったので間違っているかもしれません:)

あなたはここでそれを実際に見ることができます。

「うまくいく」ソリューションを探している後発者のために：

#include <utility>
#include <iostream>

template< typename T >
class Y {

    template< bool cond, typename U >
    using resolvedType  = typename std::enable_if< cond, U >::type; 

    public:
        template< typename U = T > 
        resolvedType< true, U > foo() {
            return 11;
        }
        template< typename U = T >
        resolvedType< false, U > foo() {
            return 12;
        }

};


int main() {
    Y< double > y;

    std::cout << y.foo() << std::endl;
}

コンパイル：

g++ -std=gnu++14 test.cpp 

実行すると：

./a.out 
11

この投稿から：

デフォルトのテンプレート引数はテンプレートの署名の一部ではありません

しかし、次のようなことができます：

#include <iostream>

struct Foo {
    template < class T,
               class std::enable_if < !std::is_integral<T>::value, int >::type = 0 >
    void f(const T& value)
    {
        std::cout << "Not int" << std::endl;
    }

    template<class T,
             class std::enable_if<std::is_integral<T>::value, int>::type = 0>
    void f(const T& value)
    {
        std::cout << "Int" << std::endl;
    }
};

int main()
{
    Foo foo;
    foo.f(1);
    foo.f(1.1);

    // Output:
    // Int
    // Not int
}

この問題を解決する1つの方法として、メンバー関数の特殊化は、特殊化を別のクラスに入れ、そのクラスから継承することです。他のすべての基礎データにアクセスするには、継承の順序を変更する必要がある場合がありますが、この手法は機能します。

template< class T, bool condition> struct FooImpl;
template<class T> struct FooImpl<T, true> {
T foo() { return 10; }
};

template<class T> struct FoolImpl<T,false> {
T foo() { return 5; }
};

template< class T >
class Y : public FooImpl<T, boost::is_integer<T> > // whatever your test is goes here.
{
public:
    typedef FooImpl<T, boost::is_integer<T> > inherited;

    // you will need to use "inherited::" if you want to name any of the 
    // members of those inherited classes.
};

この手法の欠点は、メンバー関数ごとにさまざまなことをテストする必要がある場合、それぞれのクラスを作成し、それを継承ツリーにチェーンする必要があることです。これは、一般的なデータメンバーにアクセスする場合にも当てはまります。

例：

template<class T, bool condition> class Goo;
// repeat pattern above.

template<class T, bool condition>
class Foo<T, true> : public Goo<T, boost::test<T> > {
public:
    typedef Goo<T, boost::test<T> > inherited:
    // etc. etc.
};

ブール値は、推定されるテンプレートパラメータに依存する必要があります。したがって、修正する簡単な方法は、デフォルトのブールパラメータを使用することです。

template< class T >
class Y {

    public:
        template < bool EnableBool = true, typename = typename std::enable_if<( std::is_same<T, double>::value && EnableBool )>::type >
        T foo() {
            return 10;
        }

};

ただし、メンバー関数をオーバーロードする場合は機能しません。代わりに、TickライブラリTICK_MEMBER_REQUIRESから使用するのが最善です。

template< class T >
class Y {

    public:
        TICK_MEMBER_REQUIRES(std::is_same<T, double>::value)
        T foo() {
            return 10;
        }

        TICK_MEMBER_REQUIRES(!std::is_same<T, double>::value)
        T foo() {
            return 10;
        }

};

次のようなマクロが必要な独自のメンバーを実装することもできます（別のライブラリを使用したくない場合に備えて）。

template<long N>
struct requires_enum
{
    enum class type
    {
        none,
        all       
    };
};


#define MEMBER_REQUIRES(...) \
typename requires_enum<__LINE__>::type PrivateRequiresEnum ## __LINE__ = requires_enum<__LINE__>::type::none, \
class=typename std::enable_if<((PrivateRequiresEnum ## __LINE__ == requires_enum<__LINE__>::type::none) && (__VA_ARGS__))>::type

これが、マクロを使用した私のミニマリストの例です。enable_if((...))より複雑な式を使用する場合は、二重括弧を使用します。

template<bool b, std::enable_if_t<b, int> = 0>
using helper_enable_if = int;

#define enable_if(value) typename = helper_enable_if<value>

struct Test
{
     template<enable_if(false)>
     void run();
}