155

クラスに特定の署名の特定のメンバー関数があるかどうかを検出するためのテンプレート トリックを求めています。

この問題は、ここで引用されているものと似ています http://www.gotw.ca/gotw/071.htm しかし、同じではありません.Sutterの本の項目で、彼はクラスCがメンバー関数を提供しなければならないという質問に答えました.そうしないと、プログラムはコンパイルされません。私の問題では、クラスにその機能がある場合は何かをする必要があり、そうでない場合は「何か他のこと」をする必要があります。

同様の問題が boost::serialization によって直面されましたが、私は彼らが採用した解決策が好きではありません: 特定のメンバー関数を定義しない限り、特定のシグネチャを持つ無料の関数 (定義する必要がある) をデフォルトで呼び出すテンプレート関数 (その場合、特定の型の 2 つのパラメーターを受け取る「シリアル化」) を特定の署名で行うと、コンパイル エラーが発生します。つまり、侵入型と非侵入型の両方のシリアライゼーションを実装することです。

私は次の 2 つの理由から、このソリューションは好きではありません。

  1. 邪魔にならないようにするには、boost::serialization 名前空間にあるグローバルな「serialize」関数をオーバーライドする必要があります。そのため、クライアント コードで名前空間のブーストと名前空間のシリアル化を開く必要があります。
  2. その混乱を解決するためのスタックは、10 から 12 の関数呼び出しでした。

そのメンバー関数を持たないクラスのカスタム動作を定義する必要があり、私のエンティティは異なる名前空間内にあります (そして、ある名前空間で定義されたグローバル関数を別の名前空間でオーバーライドしたくありません)。

このパズルを解くヒントを教えてください。

4

17 に答える 17

101

あなたのことを正しく理解しているかどうかはわかりませんが、SFINAE を利用してコンパイル時に関数の存在を検出することができます。私のコードの例 (クラスにメンバー関数 size_t used_memory() const があるかどうかをテストします)。

template<typename T>
struct HasUsedMemoryMethod
{
    template<typename U, size_t (U::*)() const> struct SFINAE {};
    template<typename U> static char Test(SFINAE<U, &U::used_memory>*);
    template<typename U> static int Test(...);
    static const bool Has = sizeof(Test<T>(0)) == sizeof(char);
};

template<typename TMap>
void ReportMemUsage(const TMap& m, std::true_type)
{
        // We may call used_memory() on m here.
}
template<typename TMap>
void ReportMemUsage(const TMap&, std::false_type)
{
}
template<typename TMap>
void ReportMemUsage(const TMap& m)
{
    ReportMemUsage(m, 
        std::integral_constant<bool, HasUsedMemoryMethod<TMap>::Has>());
}
于 2008-09-17T21:27:29.683 に答える
40

コンパイル時のメンバー関数のイントロスペクションに関するこの質問に対する受け入れられた回答は、当然のことながら人気がありますが、次のプログラムで観察できる問題があります。

#include <type_traits>
#include <iostream>
#include <memory>

/*  Here we apply the accepted answer's technique to probe for the
    the existence of `E T::operator*() const`
*/
template<typename T, typename E>
struct has_const_reference_op
{
    template<typename U, E (U::*)() const> struct SFINAE {};
    template<typename U> static char Test(SFINAE<U, &U::operator*>*);
    template<typename U> static int Test(...);
    static const bool value = sizeof(Test<T>(0)) == sizeof(char);
};

using namespace std;

/* Here we test the `std::` smart pointer templates, including the
    deprecated `auto_ptr<T>`, to determine in each case whether
    T = (the template instantiated for `int`) provides 
    `int & T::operator*() const` - which all of them in fact do.
*/ 
int main(void)
{
    cout << has_const_reference_op<auto_ptr<int>,int &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int &>::value;
    cout << has_const_reference_op<shared_ptr<int>,int &>::value << endl;
    return 0;
}

GCC 4.6.3で構築されたプログラム出力は、を提供しないこと110を通知 します。T = std::shared_ptr<int>int & T::operator*() const

この落とし穴にまだ賢明でない場合は std::shared_ptr<T>、ヘッダーのの定義を見てください<memory>。その実装でstd::shared_ptr<T>は、は、継承元の基本クラスから派生しoperator*() constます。したがって、 SFINAE<U, &U::operator*>演算子の「検索」を構成 するテンプレートのインスタンス化U = std::shared_ptr<T>は発生しません。これstd::shared_ptr<T>は operator*()、それ自体には何もなく、テンプレートのインスタンス化は「継承を行わない」ためです。

Tこの障害は、「sizeof（）Trick」を使用して、メンバー関数があるかどうかを検出するためのよく知られたSFINAEアプローチには影響しませんmf（たとえば 、この回答とコメントを参照）。しかし、それT::mfが存在することを確立することは、多くの場合（通常は？）十分ではありません。必要な署名があることを確立する必要がある場合もあります。ここで、図解されたテクニックが得点します。&T::mf目的の署名のポインター化されたバリアントは、SFINAEプローブが成功するために満たす必要があるテンプレートタイプのパラメーターに内接します 。T::mfただし、このテンプレートのインスタンス化手法では、が継承されたときに間違った答えが返されます。

のコンパイル時イントロスペクションのための安全なSFINAE手法では、SFINAE関数テンプレートの解像度が依存する型をインスタンス化するためにテンプレート引数内でT::mfの使用を回避する必要があります。&T::mf代わりに、SFINAEテンプレート関数の解決は、オーバーロードされたSFINAEプローブ関数の引数型として使用される正確に適切な型宣言にのみ依存できます。

この制約に従う質問への回答としてE T::operator*() const、任意のTおよびのコンパイル時の検出について説明しますE。同じパターンが必要な変更を加え て、他のメンバーメソッドのシグネチャをプローブします。

#include <type_traits>

/*! The template `has_const_reference_op<T,E>` exports a
    boolean constant `value that is true iff `T` provides
    `E T::operator*() const`
*/ 
template< typename T, typename E>
struct has_const_reference_op
{
    /* SFINAE operator-has-correct-sig :) */
    template<typename A>
    static std::true_type test(E (A::*)() const) {
        return std::true_type();
    }

    /* SFINAE operator-exists :) */
    template <typename A> 
    static decltype(test(&A::operator*)) 
    test(decltype(&A::operator*),void *) {
        /* Operator exists. What about sig? */
        typedef decltype(test(&A::operator*)) return_type; 
        return return_type();
    }

    /* SFINAE game over :( */
    template<typename A>
    static std::false_type test(...) {
        return std::false_type(); 
    }

    /* This will be either `std::true_type` or `std::false_type` */
    typedef decltype(test<T>(0,0)) type;

    static const bool value = type::value; /* Which is it? */
};

このソリューションでは、オーバーロードされたSFINAEプローブ関数test()が「再帰的に呼び出されます」。（もちろん、実際にはまったく呼び出されません。コンパイラーによって解決された仮想呼び出しの戻りタイプが含まれているだけです。）

少なくとも1つ、多くても2つの情報ポイントを調査する必要があります。

  • T::operator*()存在しますか？そうでない場合は、完了です。
  • それが存在することを考えるとT::operator*()、その署名はあります E T::operator*() constか？

への単一の呼び出しの戻りタイプを評価することによって答えを取得しますtest(0,0)。それはによって行われます：

    typedef decltype(test<T>(0,0)) type;

この呼び出しは、の過負荷に解決されるか、/* SFINAE operator-exists :) */過負荷に解決される可能性があります。オーバーロードを解決することはできません。これは、引数が1つだけで、2つ渡すためです。test()/* SFINAE game over :( *//* SFINAE operator-has-correct-sig :) */

なぜ私たちは2つを渡すのですか？単に解像度を強制的に除外し /* SFINAE operator-has-correct-sig :) */ます。2番目の引数には他の意味はありません。

このtoの呼び出しは、最初の引数0がそのオーバーロードの最初のパラメータータイプである、をで満たす場合にのみtest(0,0)解決されます。0は、存在する場合に備えてそのタイプを満たします。/* SFINAE operator-exists :) */decltype(&A::operator*)A = TT::operator*

コンパイラが「はい」と言ったとしましょう。次に、それは進行中で /* SFINAE operator-exists :) */あり、関数呼び出しの戻りタイプを決定する必要があります。その場合はdecltype(test(&A::operator*))、-へのさらに別の呼び出しの戻りタイプですtest()。

今回は、&A::operator*存在することがわかっている引数を1つだけ渡します。そうしないと、ここには存在しません。toの呼び出しは、にtest(&A::operator*)解決されるか、/* SFINAE operator-has-correct-sig :) */またはに再度解決される可能性があります/* SFINAE game over :( */。呼び出しは 、そのオーバーロードの単一のパラメータータイプである、を、で満たす場合/* SFINAE operator-has-correct-sig :) */に備えて一致します。&A::operator*E (A::*)() constA = T

コンパイラT::operator*は、必要なシグニチャがある場合、ここで「はい」と表示し、オーバーロードの戻りタイプを再度評価する必要があります。これ以上の「再帰」はありません。それはstd::true_typeです。

コンパイラーが呼び出しを選択しない場合、/* SFINAE operator-exists :) */または呼び出しをtest(0,0)選択しない/* SFINAE operator-has-correct-sig :) */ 場合test(&A::operator*)は、どちらの場合も /* SFINAE game over :( */、最終的な戻りタイプはstd::false_typeです。

これは、さまざまなケースのサンプル（GCC 4.6.3）で期待される回答を生成するテンプレートを示すテストプログラムです。

// To test
struct empty{};

// To test 
struct int_ref
{
    int & operator*() const {
        return *_pint;
    }
    int & foo() const {
        return *_pint;
    }
    int * _pint;
};

// To test 
struct sub_int_ref : int_ref{};

// To test 
template<typename E>
struct ee_ref
{
    E & operator*() {
        return *_pe;
    }
    E & foo() const {
        return *_pe;
    }
    E * _pe;
};

// To test 
struct sub_ee_ref : ee_ref<char>{};

using namespace std;

#include <iostream>
#include <memory>
#include <vector>

int main(void)
{
    cout << "Expect Yes" << endl;
    cout << has_const_reference_op<auto_ptr<int>,int &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int &>::value;
    cout << has_const_reference_op<shared_ptr<int>,int &>::value;
    cout << has_const_reference_op<std::vector<int>::iterator,int &>::value;
    cout << has_const_reference_op<std::vector<int>::const_iterator,
            int const &>::value;
    cout << has_const_reference_op<int_ref,int &>::value;
    cout << has_const_reference_op<sub_int_ref,int &>::value  << endl;
    cout << "Expect No" << endl;
    cout << has_const_reference_op<int *,int &>::value;
    cout << has_const_reference_op<unique_ptr<int>,char &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int const &>::value;
    cout << has_const_reference_op<unique_ptr<int>,int>::value;
    cout << has_const_reference_op<unique_ptr<long>,int &>::value;
    cout << has_const_reference_op<int,int>::value;
    cout << has_const_reference_op<std::vector<int>,int &>::value;
    cout << has_const_reference_op<ee_ref<int>,int &>::value;
    cout << has_const_reference_op<sub_ee_ref,int &>::value;
    cout << has_const_reference_op<empty,int &>::value  << endl;
    return 0;
}

このアイデアに新しい欠陥はありますか？回避する障害に再び陥ることなく、より一般的にすることができますか？

于 2012-05-22T18:23:03.580 に答える
20

ここにいくつかの使用法のスニペットがあります:

x特定のクラスのメンバーを確認します。var、func、class、union、または enum の可能性があります。

CREATE_MEMBER_CHECK(x);
bool has_x = has_member_x<class_to_check_for_x>::value;

メンバー関数を確認しますvoid x()。

//Func signature MUST have T as template variable here... simpler this way :\
CREATE_MEMBER_FUNC_SIG_CHECK(x, void (T::*)(), void__x);
bool has_func_sig_void__x = has_member_func_void__x<class_to_check_for_x>::value;

メンバー変数を確認しますx。

CREATE_MEMBER_VAR_CHECK(x);
bool has_var_x = has_member_var_x<class_to_check_for_x>::value;

メンバー クラスを確認しxます。

CREATE_MEMBER_CLASS_CHECK(x);
bool has_class_x = has_member_class_x<class_to_check_for_x>::value;

メンバー ユニオンを確認しxます。

CREATE_MEMBER_UNION_CHECK(x);
bool has_union_x = has_member_union_x<class_to_check_for_x>::value;

メンバーの列挙型を確認しxます。

CREATE_MEMBER_ENUM_CHECK(x);
bool has_enum_x = has_member_enum_x<class_to_check_for_x>::value;

x署名に関係なく、メンバー関数を確認します。

CREATE_MEMBER_CHECK(x);
CREATE_MEMBER_VAR_CHECK(x);
CREATE_MEMBER_CLASS_CHECK(x);
CREATE_MEMBER_UNION_CHECK(x);
CREATE_MEMBER_ENUM_CHECK(x);
CREATE_MEMBER_FUNC_CHECK(x);
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

また

CREATE_MEMBER_CHECKS(x);  //Just stamps out the same macro calls as above.
bool has_any_func_x = has_member_func_x<class_to_check_for_x>::value;

詳細とコア:

/*
    - Multiple inheritance forces ambiguity of member names.
    - SFINAE is used to make aliases to member names.
    - Expression SFINAE is used in just one generic has_member that can accept
      any alias we pass it.
*/

//Variadic to force ambiguity of class members.  C++11 and up.
template <typename... Args> struct ambiguate : public Args... {};

//Non-variadic version of the line above.
//template <typename A, typename B> struct ambiguate : public A, public B {};

template<typename A, typename = void>
struct got_type : std::false_type {};

template<typename A>
struct got_type<A> : std::true_type {
    typedef A type;
};

template<typename T, T>
struct sig_check : std::true_type {};

template<typename Alias, typename AmbiguitySeed>
struct has_member {
    template<typename C> static char ((&f(decltype(&C::value))))[1];
    template<typename C> static char ((&f(...)))[2];

    //Make sure the member name is consistently spelled the same.
    static_assert(
        (sizeof(f<AmbiguitySeed>(0)) == 1)
        , "Member name specified in AmbiguitySeed is different from member name specified in Alias, or wrong Alias/AmbiguitySeed has been specified."
    );

    static bool const value = sizeof(f<Alias>(0)) == 2;
};

マクロ (El Diablo!):

CREATE_MEMBER_CHECK:

//Check for any member with given name, whether var, func, class, union, enum.
#define CREATE_MEMBER_CHECK(member)                                         \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct Alias_##member;                                                      \
                                                                            \
template<typename T>                                                        \
struct Alias_##member <                                                     \
    T, std::integral_constant<bool, got_type<decltype(&T::member)>::value>  \
> { static const decltype(&T::member) value; };                             \
                                                                            \
struct AmbiguitySeed_##member { char member; };                             \
                                                                            \
template<typename T>                                                        \
struct has_member_##member {                                                \
    static const bool value                                                 \
        = has_member<                                                       \
            Alias_##member<ambiguate<T, AmbiguitySeed_##member>>            \
            , Alias_##member<AmbiguitySeed_##member>                        \
        >::value                                                            \
    ;                                                                       \
}

CREATE_MEMBER_VAR_CHECK:

//Check for member variable with given name.
#define CREATE_MEMBER_VAR_CHECK(var_name)                                   \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct has_member_var_##var_name : std::false_type {};                      \
                                                                            \
template<typename T>                                                        \
struct has_member_var_##var_name<                                           \
    T                                                                       \
    , std::integral_constant<                                               \
        bool                                                                \
        , !std::is_member_function_pointer<decltype(&T::var_name)>::value   \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_SIG_CHECK:

//Check for member function with given name AND signature.
#define CREATE_MEMBER_FUNC_SIG_CHECK(func_name, func_sig, templ_postfix)    \
                                                                            \
template<typename T, typename = std::true_type>                             \
struct has_member_func_##templ_postfix : std::false_type {};                \
                                                                            \
template<typename T>                                                        \
struct has_member_func_##templ_postfix<                                     \
    T, std::integral_constant<                                              \
        bool                                                                \
        , sig_check<func_sig, &T::func_name>::value                         \
    >                                                                       \
> : std::true_type {}

CREATE_MEMBER_CLASS_CHECK:

//Check for member class with given name.
#define CREATE_MEMBER_CLASS_CHECK(class_name)               \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_class_##class_name : std::false_type {};  \
                                                            \
template<typename T>                                        \
struct has_member_class_##class_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_class<                                    \
            typename got_type<typename T::class_name>::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_UNION_CHECK:

//Check for member union with given name.
#define CREATE_MEMBER_UNION_CHECK(union_name)               \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_union_##union_name : std::false_type {};  \
                                                            \
template<typename T>                                        \
struct has_member_union_##union_name<                       \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_union<                                    \
            typename got_type<typename T::union_name>::type \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_ENUM_CHECK:

//Check for member enum with given name.
#define CREATE_MEMBER_ENUM_CHECK(enum_name)                 \
                                                            \
template<typename T, typename = std::true_type>             \
struct has_member_enum_##enum_name : std::false_type {};    \
                                                            \
template<typename T>                                        \
struct has_member_enum_##enum_name<                         \
    T                                                       \
    , std::integral_constant<                               \
        bool                                                \
        , std::is_enum<                                     \
            typename got_type<typename T::enum_name>::type  \
        >::value                                            \
    >                                                       \
> : std::true_type {}

CREATE_MEMBER_FUNC_CHECK:

//Check for function with given name, any signature.
#define CREATE_MEMBER_FUNC_CHECK(func)          \
template<typename T>                            \
struct has_member_func_##func {                 \
    static const bool value                     \
        = has_member_##func<T>::value           \
        && !has_member_var_##func<T>::value     \
        && !has_member_class_##func<T>::value   \
        && !has_member_union_##func<T>::value   \
        && !has_member_enum_##func<T>::value    \
    ;                                           \
}

CREATE_MEMBER_CHECKS:

//Create all the checks for one member.  Does NOT include func sig checks.
#define CREATE_MEMBER_CHECKS(member)    \
CREATE_MEMBER_CHECK(member);            \
CREATE_MEMBER_VAR_CHECK(member);        \
CREATE_MEMBER_CLASS_CHECK(member);      \
CREATE_MEMBER_UNION_CHECK(member);      \
CREATE_MEMBER_ENUM_CHECK(member);       \
CREATE_MEMBER_FUNC_CHECK(member)
于 2013-05-31T23:30:24.413 に答える
13

期待するメンバー関数の名前がわかっている場合は、これで十分です。(この場合、メンバー関数がない場合、関数 bla はインスタンス化に失敗します (関数の部分的な特殊化がないため、機能する関数を作成するのは困難です。クラス テンプレートを使用する必要がある場合があります)。また、enable 構造体 (これはenable_if に似ています) は、メンバーとして持つ関数のタイプでテンプレート化することもできます。

template <typename T, int (T::*) ()> struct enable { typedef T type; };
template <typename T> typename enable<T, &T::i>::type bla (T&);
struct A { void i(); };
struct B { int i(); };
int main()
{
  A a;
  B b;
  bla(b);
  bla(a);
}
于 2008-09-17T21:33:41.400 に答える
9

これは、マイク・キンハンの答えをより簡単に解釈したものです。これにより、継承されたメソッドが検出されます。また、正確な署名をチェックします (引数の変換を可能にする jrok のアプローチとは異なります)。

template <class C>
class HasGreetMethod
{
    template <class T>
    static std::true_type testSignature(void (T::*)(const char*) const);

    template <class T>
    static decltype(testSignature(&T::greet)) test(std::nullptr_t);

    template <class T>
    static std::false_type test(...);

public:
    using type = decltype(test<C>(nullptr));
    static const bool value = type::value;
};

struct A { void greet(const char* name) const; };
struct Derived : A { };
static_assert(HasGreetMethod<Derived>::value, "");

実行可能な例

于 2015-07-21T12:42:51.427 に答える
7

C++ 20 では、これははるかに簡単になります。クラスTにメンバー関数があるかどうかをテストしたいとしますvoid T::resize(typename T::size_type)。たとえば、std::vector<U>このようなメンバー関数があります。それで、

template<typename T>
concept has_resize_member_func = requires {
    typename T::size_type;
    { std::declval<T>().resize(std::declval<typename T::size_type>()) } -> std::same_as<void>;
};

そして使い方は

static_assert(has_resize_member_func<std::string>, "");
static_assert(has_resize_member_func<int> == false, "");
于 2020-10-11T19:09:58.730 に答える
5

私自身も同じ種類の問題を抱えていて、ここで提案された解決策が非常に興味深いことがわかりました...しかし、次のような解決策が必要でした:

  1. 継承された関数も検出します。
  2. 非 C++11 対応コンパイラと互換性があります (したがって decltype はありません)

BOOST ディスカッションに基づいて、このようなものを提案する別のスレッドを見つけました。これは、 boost::has_*クラスのモデルに従って、特性クラスの 2 つのマクロ宣言として提案されたソリューションの一般化です。

#include <boost/type_traits/is_class.hpp>
#include <boost/mpl/vector.hpp>

/// Has constant function
/** \param func_ret_type Function return type
    \param func_name Function name
    \param ... Variadic arguments are for the function parameters
*/
#define DECLARE_TRAITS_HAS_FUNC_C(func_ret_type, func_name, ...) \
    __DECLARE_TRAITS_HAS_FUNC(1, func_ret_type, func_name, ##__VA_ARGS__)

/// Has non-const function
/** \param func_ret_type Function return type
    \param func_name Function name
    \param ... Variadic arguments are for the function parameters
*/
#define DECLARE_TRAITS_HAS_FUNC(func_ret_type, func_name, ...) \
    __DECLARE_TRAITS_HAS_FUNC(0, func_ret_type, func_name, ##__VA_ARGS__)

// Traits content
#define __DECLARE_TRAITS_HAS_FUNC(func_const, func_ret_type, func_name, ...)  \
    template                                                                  \
    <   typename Type,                                                        \
        bool is_class = boost::is_class<Type>::value                          \
    >                                                                         \
    class has_func_ ## func_name;                                             \
    template<typename Type>                                                   \
    class has_func_ ## func_name<Type,false>                                  \
    {public:                                                                  \
        BOOST_STATIC_CONSTANT( bool, value = false );                         \
        typedef boost::false_type type;                                       \
    };                                                                        \
    template<typename Type>                                                   \
    class has_func_ ## func_name<Type,true>                                   \
    {   struct yes { char _foo; };                                            \
        struct no { yes _foo[2]; };                                           \
        struct Fallback                                                       \
        {   func_ret_type func_name( __VA_ARGS__ )                            \
                UTILITY_OPTIONAL(func_const,const) {}                         \
        };                                                                    \
        struct Derived : public Type, public Fallback {};                     \
        template <typename T, T t>  class Helper{};                           \
        template <typename U>                                                 \
        static no deduce(U*, Helper                                           \
            <   func_ret_type (Fallback::*)( __VA_ARGS__ )                    \
                    UTILITY_OPTIONAL(func_const,const),                       \
                &U::func_name                                                 \
            >* = 0                                                            \
        );                                                                    \
        static yes deduce(...);                                               \
    public:                                                                   \
        BOOST_STATIC_CONSTANT(                                                \
            bool,                                                             \
            value = sizeof(yes)                                               \
                == sizeof( deduce( static_cast<Derived*>(0) ) )               \
        );                                                                    \
        typedef ::boost::integral_constant<bool,value> type;                  \
        BOOST_STATIC_CONSTANT(bool, is_const = func_const);                   \
        typedef func_ret_type return_type;                                    \
        typedef ::boost::mpl::vector< __VA_ARGS__ > args_type;                \
    }

// Utility functions
#define UTILITY_OPTIONAL(condition, ...) UTILITY_INDIRECT_CALL( __UTILITY_OPTIONAL_ ## condition , ##__VA_ARGS__ )
#define UTILITY_INDIRECT_CALL(macro, ...) macro ( __VA_ARGS__ )
#define __UTILITY_OPTIONAL_0(...)
#define __UTILITY_OPTIONAL_1(...) __VA_ARGS__

これらのマクロは、次のプロトタイプを持つ特性クラスに展開されます。

template<class T>
class has_func_[func_name]
{
public:
    /// Function definition result value
    /** Tells if the tested function is defined for type T or not.
    */
    static const bool value = true | false;

    /// Function definition result type
    /** Type representing the value attribute usable in
        http://www.boost.org/doc/libs/1_53_0/libs/utility/enable_if.html
    */
    typedef boost::integral_constant<bool,value> type;

    /// Tested function constness indicator
    /** Indicates if the tested function is const or not.
        This value is not deduced, it is forced depending
        on the user call to one of the traits generators.
    */
    static const bool is_const = true | false;

    /// Tested function return type
    /** Indicates the return type of the tested function.
        This value is not deduced, it is forced depending
        on the user's arguments to the traits generators.
    */
    typedef func_ret_type return_type;

    /// Tested function arguments types
    /** Indicates the arguments types of the tested function.
        This value is not deduced, it is forced depending
        on the user's arguments to the traits generators.
    */
    typedef ::boost::mpl::vector< __VA_ARGS__ > args_type;
};

では、これからできる典型的な使い方は何ですか?

// We enclose the traits class into
// a namespace to avoid collisions
namespace ns_0 {
    // Next line will declare the traits class
    // to detect the member function void foo(int,int) const
    DECLARE_TRAITS_HAS_FUNC_C(void, foo, int, int);
}

// we can use BOOST to help in using the traits
#include <boost/utility/enable_if.hpp>

// Here is a function that is active for types
// declaring the good member function
template<typename T> inline
typename boost::enable_if< ns_0::has_func_foo<T> >::type
foo_bar(const T &_this_, int a=0, int b=1)
{   _this_.foo(a,b);
}

// Here is a function that is active for types
// NOT declaring the good member function
template<typename T> inline
typename boost::disable_if< ns_0::has_func_foo<T> >::type
foo_bar(const T &_this_, int a=0, int b=1)
{   default_foo(_this_,a,b);
}

// Let us declare test types
struct empty
{
};
struct direct_foo
{
    void foo(int,int);
};
struct direct_const_foo
{
    void foo(int,int) const;
};
struct inherited_const_foo :
    public direct_const_foo
{
};

// Now anywhere in your code you can seamlessly use
// the foo_bar function on any object:
void test()
{
    int a;
    foo_bar(a); // calls default_foo

    empty b;
    foo_bar(b); // calls default_foo

    direct_foo c;
    foo_bar(c); // calls default_foo (member function is not const)

    direct_const_foo d;
    foo_bar(d); // calls d.foo (member function is const)

    inherited_const_foo e;
    foo_bar(e); // calls e.foo (inherited member function)
}
于 2013-03-28T15:16:17.837 に答える
4

std::is_member_function_pointerを使用できます

class A {
   public:
     void foo() {};
}

 bool test = std::is_member_function_pointer<decltype(&A::foo)>::value;
于 2012-11-07T08:58:12.313 に答える
3

邪魔にならないようにするために、 Koenig lookupserializeのおかげで、シリアル化されているクラスまたはアーカイブ クラスの名前空間に入れることもできます。詳細については、無料の関数オーバーライドの名前空間を参照してください。:-)

無料の関数を実装するために特定の名前空間を開くことは、単に間違っています。std(たとえば、独自の型を実装するために名前空間を開くことは想定されていませんがswap、代わりに Koenig ルックアップを使用する必要があります。)

于 2008-09-17T20:44:20.613 に答える
2

わかった。2 回目の試行。これが気に入らなくても大丈夫です。もっとアイデアを探しています。

Herb Sutter の記事では、特性について説明しています。したがって、デフォルトのインスタンス化がフォールバック動作を持つ特性クラスを持つことができ、メンバー関数が存在する各クラスに対して、特性クラスはメンバー関数を呼び出すように特化されます。Herb の記事では、コピーと貼り付けを何度も行わなくても済むように、これを行うための手法について言及していると思います。

しかし、私が言ったように、おそらく、そのメンバーを実装するクラスの「タグ付け」に関連する余分な作業を望まないでしょう。その場合、私は3番目の解決策を検討しています....

于 2008-09-17T21:16:46.713 に答える
1

C++11 サポート ( decltype) がなければ、これでうまくいくかもしれません:

SSCCE

#include <iostream>
using namespace std;

struct A { void foo(void); };
struct Aa: public A { };
struct B { };

struct retA { int foo(void); };
struct argA { void foo(double); };
struct constA { void foo(void) const; };
struct varA { int foo; };

template<typename T>
struct FooFinder {
    typedef char true_type[1];
    typedef char false_type[2];

    template<int>
    struct TypeSink;

    template<class U>
    static true_type &match(U);

    template<class U>
    static true_type &test(TypeSink<sizeof( matchType<void (U::*)(void)>( &U::foo ) )> *);

    template<class U>
    static false_type &test(...);

    enum { value = (sizeof(test<T>(0, 0)) == sizeof(true_type)) };
};

int main() {
    cout << FooFinder<A>::value << endl;
    cout << FooFinder<Aa>::value << endl;
    cout << FooFinder<B>::value << endl;

    cout << FooFinder<retA>::value << endl;
    cout << FooFinder<argA>::value << endl;
    cout << FooFinder<constA>::value << endl;
    cout << FooFinder<varA>::value << endl;
}

うまくいけばそれがどのように機能するか

A、AaおよびBは問題のクラスであり、Aa探しているメンバーを継承する特別なクラスです。

およびFooFinderは、対応する C++11 クラスの置換です。また、テンプレート メタ プログラミングを理解するために、SFINAE-sizeof-trick の基礎を明らかにします。true_typefalse_type

これは、演算子TypeSinkの積分結果をテンプレートのインスタンス化にシンクして型を形成するために後で使用されるテンプレート構造体です。sizeof

関数は別のmatchSFINAE の種類のテンプレートであり、対応する一般的なものはありません。したがって、引数の型が特殊化された型と一致する場合にのみインスタンス化できます。

両方のtest関数と enum 宣言が最終的に中心的な SFINAE パターンを形成します。を返す省略記号を使用する一般的なものfalse_typeと、優先されるより具体的な引数を持つ対応するものがあります。

testのテンプレート引数を使用して関数をインスタンス化できるようにするには、T関数をインスタンス化する必要があります。これは、引数matchをインスタンス化するために戻り値の型が必要なためです。TypeSink注意点は&U::foo、関数の引数にラップされている は、テンプレート引数の特殊化内から参照されないため、継承されたメンバーの検索が引き続き行われることです。

于 2017-07-09T17:21:06.617 に答える