特定のメンバー関数がクラスで定義されているかどうかに応じて動作を変更するテンプレートを作成することは可能ですか?
これが私が書きたいことの簡単な例です：
template<class T>
std::string optionalToString(T* obj)
{
if (FUNCTION_EXISTS(T->toString))
return obj->toString();
else
return "toString not defined";
}
したがって、class TがtoString()定義されている場合は、それを使用します。それ以外の場合は、そうではありません。やり方がわからない魔法の部分は「FUNCTION_EXISTS」の部分です。
はい、SFINAE を使用すると、特定のクラスが特定のメソッドを提供しているかどうかを確認できます。作業コードは次のとおりです。
#include <iostream>
struct Hello
{
int helloworld() { return 0; }
};
struct Generic {};
// SFINAE test
template <typename T>
class has_helloworld
{
typedef char one;
struct two { char x[2]; };
template <typename C> static one test( decltype(&C::helloworld) ) ;
template <typename C> static two test(...);
public:
enum { value = sizeof(test<T>(0)) == sizeof(char) };
};
int main(int argc, char *argv[])
{
std::cout << has_helloworld<Hello>::value << std::endl;
std::cout << has_helloworld<Generic>::value << std::endl;
return 0;
}
Linux と gcc 4.1/4.3 でテストしました。異なるコンパイラを実行している他のプラットフォームに移植できるかどうかはわかりません。
この質問は古いですが、C++11 では、関数の存在 (または実際には型以外のメンバーの存在) をチェックする新しい方法があり、再び SFINAE に依存しています。
template<class T>
auto serialize_imp(std::ostream& os, T const& obj, int)
-> decltype(os << obj, void())
{
os << obj;
}
template<class T>
auto serialize_imp(std::ostream& os, T const& obj, long)
-> decltype(obj.stream(os), void())
{
obj.stream(os);
}
template<class T>
auto serialize(std::ostream& os, T const& obj)
-> decltype(serialize_imp(os, obj, 0), void())
{
serialize_imp(os, obj, 0);
}
それでは、いくつかの説明に進みます。最初に、式 SFINAEを使用して、内部の最初の式が有効でない場合 (つまり、関数が存在しない場合)、serialize(_imp)オーバーロードの解決から関数を除外します。decltype
はvoid()、これらすべての関数の戻り値の型を作成するために使用されますvoid。
0引数は、両方が使用可能な場合にオーバーロードを優先するために使用されますos << obj(リテラル0は型intであり、最初のオーバーロードがより適切に一致します)。
ここで、関数が存在するかどうかをチェックするトレイトが必要になるでしょう。幸いなことに、それを書くのは簡単です。ただし、必要な関数名ごとにトレイトを自分で作成する必要があることに注意してください。
#include <type_traits>
template<class>
struct sfinae_true : std::true_type{};
namespace detail{
template<class T, class A0>
static auto test_stream(int)
-> sfinae_true<decltype(std::declval<T>().stream(std::declval<A0>()))>;
template<class, class A0>
static auto test_stream(long) -> std::false_type;
} // detail::
template<class T, class Arg>
struct has_stream : decltype(detail::test_stream<T, Arg>(0)){};
そして解説へ。まず、sfinae_trueヘルパー型で、基本的には書き込みと同じdecltype(void(std::declval<T>().stream(a0)), std::true_type{})です。メリットはとにかく短いこと。
次に、チェックインが失敗したかどうかに応じて、または最後にstruct has_stream : decltype(...)いずれかから継承します。
最後に、どのように構築できるかを知らなくても、渡した型の「値」を提供します。これは、などの未評価のコンテキスト内でのみ可能であることに注意してください。std::true_typestd::false_typedecltypetest_streamstd::declvaldecltypesizeof
(およびすべての未評価のコンテキスト) が強化decltypeされているため、必ずしも必要ではないことに注意してください。sizeofすでにタイプを提供しているだけdecltypeなので、よりクリーンです。sizeofオーバーロードの 1 つのバージョンを次に示します。
template<class T>
void serialize_imp(std::ostream& os, T const& obj, int,
int(*)[sizeof((os << obj),0)] = 0)
{
os << obj;
}
およびパラメータは、同じ理由でまだ存在していますint。long配列ポインターは、使用sizeofできるコンテキストを提供するために使用されます。
C++ では、これにSFINAEを使用できます (C++11 の機能では、ほぼ任意の式で拡張 SFINAE をサポートしているため、これはより単純であることに注意してください。以下は、一般的な C++03 コンパイラで動作するように作成されています)。
#define HAS_MEM_FUNC(func, name) \
template<typename T, typename Sign> \
struct name { \
typedef char yes[1]; \
typedef char no [2]; \
template <typename U, U> struct type_check; \
template <typename _1> static yes &chk(type_check<Sign, &_1::func > *); \
template <typename > static no &chk(...); \
static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \
}
上記のテンプレートとマクロは、メンバー関数ポインター型と実際のメンバー関数ポインターを指定して、テンプレートのインスタンス化を試みます。型が適合しない場合、SFINAE はテンプレートを無視します。このような使い方：
HAS_MEM_FUNC(toString, has_to_string);
template<typename T> void
doSomething() {
if(has_to_string<T, std::string(T::*)()>::value) {
...
} else {
...
}
}
ただし、そのブランチでそのtoString関数を呼び出すことはできないことに注意してください。ifコンパイラは両方の分岐で有効性をチェックするため、関数が存在しない場合は失敗します。1 つの方法は、もう一度 SFINAE を使用することです ( enable_ifboost からも取得できます)。
template<bool C, typename T = void>
struct enable_if {
typedef T type;
};
template<typename T>
struct enable_if<false, T> { };
HAS_MEM_FUNC(toString, has_to_string);
template<typename T>
typename enable_if<has_to_string<T,
std::string(T::*)()>::value, std::string>::type
doSomething(T * t) {
/* something when T has toString ... */
return t->toString();
}
template<typename T>
typename enable_if<!has_to_string<T,
std::string(T::*)()>::value, std::string>::type
doSomething(T * t) {
/* something when T doesnt have toString ... */
return "T::toString() does not exist.";
}
楽しんで使ってください。その利点は、オーバーロードされたメンバー関数、およびメンバー関数に対しても機能することです (メンバー関数のポインター型としてconst使用することを思い出して ください!)。std::string(T::*)() const
requires式C++20には、関数の存在をチェックするための組み込みの方法であるrequires式などの概念とさまざまなツールが付属しています。optionalToStringそれらを使用すると、関数を次のように書き換えることができます。
template<class T>
std::string optionalToString(T* obj)
{
constexpr bool has_toString = requires(const T& t) {
t.toString();
};
if constexpr (has_toString)
return obj->toString();
else
return "toString not defined";
}
N4502は、C++17 標準ライブラリに含めるための検出ツールキットを提案し、最終的にライブラリの基礎 TS v2 に組み込まれました。それ以来、式に取り込まれているため、おそらく標準に含まれることはありませんrequiresが、それでもややエレガントな方法で問題を解決します. std::is_detectedツールキットは、その上にタイプまたは関数検出メタ関数を簡単に記述するために使用できるものを含む、いくつかのメタ関数を導入します。使用方法は次のとおりです。
template<typename T>
using toString_t = decltype( std::declval<T&>().toString() );
template<typename T>
constexpr bool has_toString = std::is_detected_v<toString_t, T>;
上記の例はテストされていないことに注意してください。検出ツールキットは標準ライブラリではまだ利用できませんが、提案には完全な実装が含まれており、本当に必要な場合は簡単にコピーできます。C++17 の機能とうまく連携しますif constexpr:
template<class T>
std::string optionalToString(T* obj)
{
if constexpr (has_toString<T>)
return obj->toString();
else
return "toString not defined";
}
Boost.Hana は明らかにこの特定の例に基づいて構築されており、そのドキュメントで C++14 のソリューションを提供しているため、直接引用します。
[...] Hana は、
is_validC++14 のジェネリック ラムダと組み合わせて、同じことをよりクリーンに実装できる関数を提供します。auto has_toString = hana::is_valid([](auto&& obj) -> decltype(obj.toString()) { });
has_toStringこれにより、指定された式が渡された引数で有効かどうかを返す関数オブジェクトが残ります。結果は として返されるIntegralConstantため、関数の結果はとにかく型として表されるため、constexpr-ness はここでは問題になりません。これで、冗長性が減っただけでなく (ワンライナーです!)、意図がより明確になりました。その他の利点は、has_toString高次アルゴリズムに渡すことができ、関数スコープでも定義できるため、名前空間スコープを実装の詳細で汚染する必要がないという事実です。
このようなチェックを実行するためのもう 1 つのやや慣用的なツールキットは、エレガントではありませんが、Boost 1.54.0で導入された Boost.TTI です。あなたの例では、マクロを使用する必要がありますBOOST_TTI_HAS_MEMBER_FUNCTION。使用方法は次のとおりです。
#include <boost/tti/has_member_function.hpp>
// Generate the metafunction
BOOST_TTI_HAS_MEMBER_FUNCTION(toString)
// Check whether T has a member function toString
// which takes no parameter and returns a std::string
constexpr bool foo = has_member_function_toString<T, std::string>::value;
次に、 を使用しboolて SFINAE チェックを作成できます。
説明
マクロは、チェックされた型を最初のテンプレート パラメータとしてBOOST_TTI_HAS_MEMBER_FUNCTION受け取るメタ関数を生成します。has_member_function_toString2 番目のテンプレート パラメーターはメンバー関数の戻り値の型に対応し、次のパラメーターは関数のパラメーターの型に対応します。クラスにメンバー関数がある場合、メンバーvalueには含まれます。trueTstd::string toString()
または、has_member_function_toStringメンバー関数ポインターをテンプレート パラメーターとして使用できます。そのため、 に置き換えることが可能has_member_function_toString<T, std::string>::valueですhas_member_function_toString<std::string T::* ()>::value。
この質問は 2 年前のものですが、あえて回答を追加します。うまくいけば、以前の、議論の余地のない優れたソリューションが明確になります。typeof私は Nicola Bonelli と Johannes Schaub の非常に役立つ回答を取得し、それらを IMHO であり、より読みやすく、明確で、拡張機能を必要としないソリューションにマージしました。
template <class Type>
class TypeHasToString
{
// This type won't compile if the second template parameter isn't of type T,
// so I can put a function pointer type in the first parameter and the function
// itself in the second thus checking that the function has a specific signature.
template <typename T, T> struct TypeCheck;
typedef char Yes;
typedef long No;
// A helper struct to hold the declaration of the function pointer.
// Change it if the function signature changes.
template <typename T> struct ToString
{
typedef void (T::*fptr)();
};
template <typename T> static Yes HasToString(TypeCheck< typename ToString<T>::fptr, &T::toString >*);
template <typename T> static No HasToString(...);
public:
static bool const value = (sizeof(HasToString<Type>(0)) == sizeof(Yes));
};
gcc 4.1.2で確認しました。クレジットは主に Nicola Bonelli と Johannes Schaub に送られます。
C++11 の簡単な解決策:
template<class T>
auto optionalToString(T* obj)
-> decltype( obj->toString() )
{
return obj->toString();
}
auto optionalToString(...) -> string
{
return "toString not defined";
}
更新、3 年後: (これはテストされていません)。存在をテストするには、これでうまくいくと思います：
template<class T>
constexpr auto test_has_toString_method(T* obj)
-> decltype( obj->toString() , std::true_type{} )
{
return obj->toString();
}
constexpr auto test_has_toString_method(...) -> std::false_type
{
return "toString not defined";
}
さて、この質問にはすでに多くの回答がありますが、Morwenn からのコメントを強調したいと思います。C++17 の提案があり、これにより非常に簡単になります。詳細についてはN4502を参照してください。自己完結型の例として、以下を検討してください。
この部分は定数部分なのでヘッダーに入れます。
// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/n4502.pdf.
template <typename...>
using void_t = void;
// Primary template handles all types not supporting the operation.
template <typename, template <typename> class, typename = void_t<>>
struct detect : std::false_type {};
// Specialization recognizes/validates only types supporting the archetype.
template <typename T, template <typename> class Op>
struct detect<T, Op, void_t<Op<T>>> : std::true_type {};
次に、探しているもの (型、メンバー型、関数、メンバー関数など) を指定する変数部分があります。OPの場合：
template <typename T>
using toString_t = decltype(std::declval<T>().toString());
template <typename T>
using has_toString = detect<T, toString_t>;
N4502から取った次の例は、より精巧なプローブを示しています。
// Archetypal expression for assignment operation.
template <typename T>
using assign_t = decltype(std::declval<T&>() = std::declval<T const &>())
// Trait corresponding to that archetype.
template <typename T>
using is_assignable = detect<T, assign_t>;
上記の他の実装と比較すると、これは非常に単純です。ツール (void_tおよびdetect) のセットを減らすだけで十分であり、毛むくじゃらのマクロは必要ありません。さらに、以前のアプローチよりもかなり効率的 (コンパイル時間とコンパイラのメモリ消費量) であることが報告されています ( N4502を参照)。
これが実際の例です。Clang では正常に動作しますが、残念ながら 5.1 より前の GCC バージョンは、C++11 標準の異なる解釈に従っていたvoid_tため、期待どおりに動作しませんでした。Yakk はすでに回避策を提供しています: 次の定義を使用しますvoid_t(パラメーター リストの void_t は機能しますが、戻り値の型としては機能しません)。
#if __GNUC__ < 5 && ! defined __clang__
// https://stackoverflow.com/a/28967049/1353549
template <typename...>
struct voider
{
using type = void;
};
template <typename...Ts>
using void_t = typename voider<Ts...>::type;
#else
template <typename...>
using void_t = void;
#endif
これが型特性の目的です。残念ながら、手動で定義する必要があります。あなたの場合、次のことを想像してください。
template <typename T>
struct response_trait {
static bool const has_tostring = false;
};
template <>
struct response_trait<your_type_with_tostring> {
static bool const has_tostring = true;
}
これは、「X を実行した場合、コンパイルできますか?」という一般的な問題に対する C++11 のソリューションです。
template<class> struct type_sink { typedef void type; }; // consumes a type, and makes it `void`
template<class T> using type_sink_t = typename type_sink<T>::type;
template<class T, class=void> struct has_to_string : std::false_type {}; \
template<class T> struct has_to_string<
T,
type_sink_t< decltype( std::declval<T>().toString() ) >
>: std::true_type {};
このコンテキストで 0 の引数で呼び出すことができるメソッドがある場合にのみ、has_to_stringそのようなトレイトです。has_to_string<T>::valuetrueT.toString
次に、タグ ディスパッチを使用します。
namespace details {
template<class T>
std::string optionalToString_helper(T* obj, std::true_type /*has_to_string*/) {
return obj->toString();
}
template<class T>
std::string optionalToString_helper(T* obj, std::false_type /*has_to_string*/) {
return "toString not defined";
}
}
template<class T>
std::string optionalToString(T* obj) {
return details::optionalToString_helper( obj, has_to_string<T>{} );
}
これは、複雑な SFINAE 式よりも保守しやすい傾向があります。
これらのトレイトを頻繁に実行していることに気付いた場合は、マクロを使用してこれらのトレイトを記述できますが、それらは比較的単純 (それぞれ数行) であるため、価値がない可能性があります。
#define MAKE_CODE_TRAIT( TRAIT_NAME, ... ) \
template<class T, class=void> struct TRAIT_NAME : std::false_type {}; \
template<class T> struct TRAIT_NAME< T, type_sink_t< decltype( __VA_ARGS__ ) > >: std::true_type {};
上記が行うことは、マクロを作成することMAKE_CODE_TRAITです。必要な特性の名前と、型をテストできるコードを渡しますT。したがって：
MAKE_CODE_TRAIT( has_to_string, std::declval<T>().toString() )
上記の特性クラスを作成します。
余談ですが、上記の手法は MS が「式 SFINAE」と呼んでいるものの一部であり、2013 年のコンパイラはかなり失敗します。
C++1y では、次の構文が可能であることに注意してください。
template<class T>
std::string optionalToString(T* obj) {
return compiled_if< has_to_string >(*obj, [&](auto&& obj) {
return obj.toString();
}) *compiled_else ([&]{
return "toString not defined";
});
}
これは、多くの C++ 機能を悪用するインライン コンパイルの条件分岐です。(コードがインラインであることの) 利点は (それがどのように機能するかをほとんど誰も理解していないことの) コストの価値がないため、そうすることはおそらく価値がありませんが、上記のソリューションの存在は興味深いかもしれません。
使用法の抜粋は次のとおりです。*このすべての根性はさらに下にあります
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)
（上記のソリューションとは異なり）継承されたメンバー関数もチェックする別のスレッドでこれに対する回答を書きました：
そのソリューションの例を次に示します。
次の署名を持つメンバーを確認しています:
T::const_iterator begin() const
template<class T> struct has_const_begin
{
typedef char (&Yes)[1];
typedef char (&No)[2];
template<class U>
static Yes test(U const * data,
typename std::enable_if<std::is_same<
typename U::const_iterator,
decltype(data->begin())
>::value>::type * = 0);
static No test(...);
static const bool value = sizeof(Yes) == sizeof(has_const_begin::test((typename std::remove_reference<T>::type*)0));
};
メソッドの constness もチェックし、プリミティブ型でも機能することに注意してください。(has_const_begin<int>::valueつまり、 false であり、コンパイル時エラーは発生しません。)
今、私たちは署名を探しています:void foo(MyClass&, unsigned)
template<class T> struct has_foo
{
typedef char (&Yes)[1];
typedef char (&No)[2];
template<class U>
static Yes test(U * data, MyClass* arg1 = 0,
typename std::enable_if<std::is_void<
decltype(data->foo(*arg1, 1u))
>::value>::type * = 0);
static No test(...);
static const bool value = sizeof(Yes) == sizeof(has_foo::test((typename std::remove_reference<T>::type*)0));
};
MyClass は、デフォルトで構築可能である必要も、特別な概念を満たす必要もないことに注意してください。この手法は、テンプレート メンバーでも機能します。
これに関する意見をお待ちしております。
ここで litb によって提示された標準 C++ ソリューションは、メソッドがたまたま基底クラスで定義されている場合、期待どおりに機能しません。
この状況を処理するソリューションについては、次を参照してください。
ロシア語 : http://www.rsdn.ru/forum/message/2759773.1.aspx
Roman.Perepelitsa による英訳 : http://groups.google.com/group/comp.lang.c++.moderated/tree/browse_frm/thread/4f7c7a96f9afbe44/c95a7b4c645e449f?pli=1
めちゃくちゃ賢いです。ただし、このソリューションの 1 つの問題は、テスト対象の型が基本クラスとして使用できない型 (プリミティブ型など) である場合にコンパイラ エラーが発生することです。
Visual Studio で、引数のないメソッドを操作する場合、sizeof 式の deduce( ) の引数の周りに余分な ( ) のペアを挿入する必要があることに気付きました。
さて、これは素敵な小さなパズルでした - 素晴らしい質問です!
これは、非標準演算子に依存しないNicola Bonelli のソリューションの代替です。typeof
残念ながら、GCC (MinGW) 3.4.5 または Digital Mars 8.42n では動作しませんが、MSVC (VC6 を含む) のすべてのバージョンと Comeau C++ では動作します。
長いコメント ブロックには、それがどのように機能するか (または機能することになっているか) の詳細が含まれています。それが言うように、どの動作が標準に準拠しているかはわかりません-それについてのコメントを歓迎します.
更新 - 2008 年 11 月 7 日:
このコードは構文的には正しいものの、MSVC と Comeau C++ が示す動作は標準に従っていないようです (正しい方向に向けてくれたLeon Timmermansとlitbに感謝します)。C++03 標準では次のように規定されています。
14.6.2 依存名 [temp.dep]
パラグラフ 3
クラス テンプレートまたはクラス テンプレートのメンバーの定義で、クラス テンプレートの基本クラスがテンプレート パラメーターに依存している場合、基本クラスのスコープは、クラスの定義の時点でも、非修飾名の検索中に調べられません。テンプレートまたはメンバー、またはクラス テンプレートまたはメンバーのインスタンス化中。
したがって、テンプレートがインスタンス化されたときに呼び出しサイトで名前検索を実行するtoString()メンバー関数をMSVC または Comeau が考慮すると、それは正しくないように見えます (この場合、実際に私が探していた動作であっても)。TdoToString()
GCC と Digital Mars の動作は正しいようです。どちらの場合も、非メンバーtoString()関数が呼び出しにバインドされています。
Rats - 巧妙な解決策を見つけたかもしれないと思ったのですが、代わりにいくつかのコンパイラのバグを発見しました...
#include <iostream>
#include <string>
struct Hello
{
std::string toString() {
return "Hello";
}
};
struct Generic {};
// the following namespace keeps the toString() method out of
// most everything - except the other stuff in this
// compilation unit
namespace {
std::string toString()
{
return "toString not defined";
}
template <typename T>
class optionalToStringImpl : public T
{
public:
std::string doToString() {
// in theory, the name lookup for this call to
// toString() should find the toString() in
// the base class T if one exists, but if one
// doesn't exist in the base class, it'll
// find the free toString() function in
// the private namespace.
//
// This theory works for MSVC (all versions
// from VC6 to VC9) and Comeau C++, but
// does not work with MinGW 3.4.5 or
// Digital Mars 8.42n
//
// I'm honestly not sure what the standard says
// is the correct behavior here - it's sort
// of like ADL (Argument Dependent Lookup -
// also known as Koenig Lookup) but without
// arguments (except the implied "this" pointer)
return toString();
}
};
}
template <typename T>
std::string optionalToString(T & obj)
{
// ugly, hacky cast...
optionalToStringImpl<T>* temp = reinterpret_cast<optionalToStringImpl<T>*>( &obj);
return temp->doToString();
}
int
main(int argc, char *argv[])
{
Hello helloObj;
Generic genericObj;
std::cout << optionalToString( helloObj) << std::endl;
std::cout << optionalToString( genericObj) << std::endl;
return 0;
}
https://stackoverflow.com/a/264088/2712152で提供されているソリューションを変更して、もう少し一般的なものにしました。また、新しい C++11 機能を使用しないため、古いコンパイラで使用でき、msvc でも動作するはずです。ただし、可変長マクロを使用するため、コンパイラは C99 でこれを使用できるようにする必要があります。
次のマクロを使用して、特定のクラスに特定の typedef があるかどうかを確認できます。
/**
* @class : HAS_TYPEDEF
* @brief : This macro will be used to check if a class has a particular
* typedef or not.
* @param typedef_name : Name of Typedef
* @param name : Name of struct which is going to be run the test for
* the given particular typedef specified in typedef_name
*/
#define HAS_TYPEDEF(typedef_name, name) \
template <typename T> \
struct name { \
typedef char yes[1]; \
typedef char no[2]; \
template <typename U> \
struct type_check; \
template <typename _1> \
static yes& chk(type_check<typename _1::typedef_name>*); \
template <typename> \
static no& chk(...); \
static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \
}
次のマクロを使用して、特定のクラスに特定のメンバー関数があるかどうか、または指定された数の引数がないかどうかを確認できます。
/**
* @class : HAS_MEM_FUNC
* @brief : This macro will be used to check if a class has a particular
* member function implemented in the public section or not.
* @param func : Name of Member Function
* @param name : Name of struct which is going to be run the test for
* the given particular member function name specified in func
* @param return_type: Return type of the member function
* @param ellipsis(...) : Since this is macro should provide test case for every
* possible member function we use variadic macros to cover all possibilities
*/
#define HAS_MEM_FUNC(func, name, return_type, ...) \
template <typename T> \
struct name { \
typedef return_type (T::*Sign)(__VA_ARGS__); \
typedef char yes[1]; \
typedef char no[2]; \
template <typename U, U> \
struct type_check; \
template <typename _1> \
static yes& chk(type_check<Sign, &_1::func>*); \
template <typename> \
static no& chk(...); \
static bool const value = sizeof(chk<T>(0)) == sizeof(yes); \
}
上記の 2 つのマクロを使用して、次のように has_typedef と has_mem_func のチェックを実行できます。
class A {
public:
typedef int check;
void check_function() {}
};
class B {
public:
void hello(int a, double b) {}
void hello() {}
};
HAS_MEM_FUNC(check_function, has_check_function, void, void);
HAS_MEM_FUNC(hello, hello_check, void, int, double);
HAS_MEM_FUNC(hello, hello_void_check, void, void);
HAS_TYPEDEF(check, has_typedef_check);
int main() {
std::cout << "Check Function A:" << has_check_function<A>::value << std::endl;
std::cout << "Check Function B:" << has_check_function<B>::value << std::endl;
std::cout << "Hello Function A:" << hello_check<A>::value << std::endl;
std::cout << "Hello Function B:" << hello_check<B>::value << std::endl;
std::cout << "Hello void Function A:" << hello_void_check<A>::value << std::endl;
std::cout << "Hello void Function B:" << hello_void_check<B>::value << std::endl;
std::cout << "Check Typedef A:" << has_typedef_check<A>::value << std::endl;
std::cout << "Check Typedef B:" << has_typedef_check<B>::value << std::endl;
}
奇妙なことに、このサイトで一度見た次の素晴らしいトリックを誰も提案しませんでした。
template <class T>
struct has_foo
{
struct S { void foo(...); };
struct derived : S, T {};
template <typename V, V> struct W {};
template <typename X>
char (&test(W<void (X::*)(), &X::foo> *))[1];
template <typename>
char (&test(...))[2];
static const bool value = sizeof(test<derived>(0)) == 1;
};
T がクラスであることを確認する必要があります。foo のルックアップのあいまいさが置換失敗のようです。標準かどうかはわかりませんが、gccで動作するようにしました。
タイプで「機能」がサポートされているかどうかを確認するために使用できる汎用テンプレート:
#include <type_traits>
template <template <typename> class TypeChecker, typename Type>
struct is_supported
{
// these structs are used to recognize which version
// of the two functions was chosen during overload resolution
struct supported {};
struct not_supported {};
// this overload of chk will be ignored by SFINAE principle
// if TypeChecker<Type_> is invalid type
template <typename Type_>
static supported chk(typename std::decay<TypeChecker<Type_>>::type *);
// ellipsis has the lowest conversion rank, so this overload will be
// chosen during overload resolution only if the template overload above is ignored
template <typename Type_>
static not_supported chk(...);
// if the template overload of chk is chosen during
// overload resolution then the feature is supported
// if the ellipses overload is chosen the the feature is not supported
static constexpr bool value = std::is_same<decltype(chk<Type>(nullptr)),supported>::value;
};
foo署名に対応したメソッドがないかチェックするテンプレートdouble(const char*)
// if T doesn't have foo method with the signature that allows to compile the bellow
// expression then instantiating this template is Substitution Failure (SF)
// which Is Not An Error (INAE) if this happens during overload resolution
template <typename T>
using has_foo = decltype(double(std::declval<T>().foo(std::declval<const char*>())));
例
// types that support has_foo
struct struct1 { double foo(const char*); }; // exact signature match
struct struct2 { int foo(const std::string &str); }; // compatible signature
struct struct3 { float foo(...); }; // compatible ellipsis signature
struct struct4 { template <typename T>
int foo(T t); }; // compatible template signature
// types that do not support has_foo
struct struct5 { void foo(const char*); }; // returns void
struct struct6 { std::string foo(const char*); }; // std::string can't be converted to double
struct struct7 { double foo( int *); }; // const char* can't be converted to int*
struct struct8 { double bar(const char*); }; // there is no foo method
int main()
{
std::cout << std::boolalpha;
std::cout << is_supported<has_foo, int >::value << std::endl; // false
std::cout << is_supported<has_foo, double >::value << std::endl; // false
std::cout << is_supported<has_foo, struct1>::value << std::endl; // true
std::cout << is_supported<has_foo, struct2>::value << std::endl; // true
std::cout << is_supported<has_foo, struct3>::value << std::endl; // true
std::cout << is_supported<has_foo, struct4>::value << std::endl; // true
std::cout << is_supported<has_foo, struct5>::value << std::endl; // false
std::cout << is_supported<has_foo, struct6>::value << std::endl; // false
std::cout << is_supported<has_foo, struct7>::value << std::endl; // false
std::cout << is_supported<has_foo, struct8>::value << std::endl; // false
return 0;
}
この解決策はどうですか？
#include <type_traits>
template <typename U, typename = void> struct hasToString : std::false_type { };
template <typename U>
struct hasToString<U,
typename std::enable_if<bool(sizeof(&U::toString))>::type
> : std::true_type { };
ここには多くの回答がありますが、新しい c++ 機能を使用せずに (c++98 機能のみを使用して)、実際のメソッド解決順序を実行するバージョンを見つけることができませんでした。
注: このバージョンは、vc++2013、g++ 5.2.0、およびオンライン コンパイラでテストされ、動作します。
そこで、sizeof() のみを使用するバージョンを思いつきました。
template<typename T> T declval(void);
struct fake_void { };
template<typename T> T &operator,(T &,fake_void);
template<typename T> T const &operator,(T const &,fake_void);
template<typename T> T volatile &operator,(T volatile &,fake_void);
template<typename T> T const volatile &operator,(T const volatile &,fake_void);
struct yes { char v[1]; };
struct no { char v[2]; };
template<bool> struct yes_no:yes{};
template<> struct yes_no<false>:no{};
template<typename T>
struct has_awesome_member {
template<typename U> static yes_no<(sizeof((
declval<U>().awesome_member(),fake_void()
))!=0)> check(int);
template<typename> static no check(...);
enum{value=sizeof(check<T>(0)) == sizeof(yes)};
};
struct foo { int awesome_member(void); };
struct bar { };
struct foo_void { void awesome_member(void); };
struct wrong_params { void awesome_member(int); };
static_assert(has_awesome_member<foo>::value,"");
static_assert(!has_awesome_member<bar>::value,"");
static_assert(has_awesome_member<foo_void>::value,"");
static_assert(!has_awesome_member<wrong_params>::value,"");
ライブ デモ (拡張された戻り値の型チェックと vc++2010 の回避策): http://cpp.sh/5b2vs
自分で考えたのでソースはありません。
g++ コンパイラでライブ デモを実行する場合、0 の配列サイズが許可されていることに注意してください。つまり、使用された static_assert は、失敗した場合でもコンパイラ エラーをトリガーしません。
一般的に使用される回避策は、マクロの「typedef」を「extern」に置き換えることです。
これは、テンプレート メンバー関数を含む、任意のアリティを持つすべての可能なメンバー関数のオーバーロードを、おそらくデフォルトの引数で処理する私のバージョンです。指定された引数の型を使用して、クラス型へのメンバー関数呼び出しを行う場合、相互に排他的な 3 つのシナリオ ((1) 有効、(2) あいまい、または (3) 実行不可能) を区別します。使用例:
#include <string>
#include <vector>
HAS_MEM(bar)
HAS_MEM_FUN_CALL(bar)
struct test
{
void bar(int);
void bar(double);
void bar(int,double);
template < typename T >
typename std::enable_if< not std::is_integral<T>::value >::type
bar(const T&, int=0){}
template < typename T >
typename std::enable_if< std::is_integral<T>::value >::type
bar(const std::vector<T>&, T*){}
template < typename T >
int bar(const std::string&, int){}
};
これで、次のように使用できます。
int main(int argc, const char * argv[])
{
static_assert( has_mem_bar<test>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(char const*,long)>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(std::string&,long)>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(std::vector<int>, int*)>::value , "");
static_assert( has_no_viable_mem_fun_call_bar<test(std::vector<double>, double*)>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(int)>::value , "");
static_assert( std::is_same<void,result_of_mem_fun_call_bar<test(int)>::type>::value , "");
static_assert( has_valid_mem_fun_call_bar<test(int,double)>::value , "");
static_assert( not has_valid_mem_fun_call_bar<test(int,double,int)>::value , "");
static_assert( not has_ambiguous_mem_fun_call_bar<test(double)>::value , "");
static_assert( has_ambiguous_mem_fun_call_bar<test(unsigned)>::value , "");
static_assert( has_viable_mem_fun_call_bar<test(unsigned)>::value , "");
static_assert( has_viable_mem_fun_call_bar<test(int)>::value , "");
static_assert( has_no_viable_mem_fun_call_bar<test(void)>::value , "");
return 0;
}
これは c++11 で書かれたコードですが、typeof 拡張 (gcc など) を持つ非 c++11 に簡単に移植できます (マイナーな調整で)。HAS_MEM マクロを独自のものに置き換えることができます。
#pragma once
#if __cplusplus >= 201103
#include <utility>
#include <type_traits>
#define HAS_MEM(mem) \
\
template < typename T > \
struct has_mem_##mem \
{ \
struct yes {}; \
struct no {}; \
\
struct ambiguate_seed { char mem; }; \
template < typename U > struct ambiguate : U, ambiguate_seed {}; \
\
template < typename U, typename = decltype(&U::mem) > static constexpr no test(int); \
template < typename > static constexpr yes test(...); \
\
static bool constexpr value = std::is_same<decltype(test< ambiguate<T> >(0)),yes>::value ; \
typedef std::integral_constant<bool,value> type; \
};
#define HAS_MEM_FUN_CALL(memfun) \
\
template < typename Signature > \
struct has_valid_mem_fun_call_##memfun; \
\
template < typename T, typename... Args > \
struct has_valid_mem_fun_call_##memfun< T(Args...) > \
{ \
struct yes {}; \
struct no {}; \
\
template < typename U, bool = has_mem_##memfun<U>::value > \
struct impl \
{ \
template < typename V, typename = decltype(std::declval<V>().memfun(std::declval<Args>()...)) > \
struct test_result { using type = yes; }; \
\
template < typename V > static constexpr typename test_result<V>::type test(int); \
template < typename > static constexpr no test(...); \
\
static constexpr bool value = std::is_same<decltype(test<U>(0)),yes>::value; \
using type = std::integral_constant<bool, value>; \
}; \
\
template < typename U > \
struct impl<U,false> : std::false_type {}; \
\
static constexpr bool value = impl<T>::value; \
using type = std::integral_constant<bool, value>; \
}; \
\
template < typename Signature > \
struct has_ambiguous_mem_fun_call_##memfun; \
\
template < typename T, typename... Args > \
struct has_ambiguous_mem_fun_call_##memfun< T(Args...) > \
{ \
struct ambiguate_seed { void memfun(...); }; \
\
template < class U, bool = has_mem_##memfun<U>::value > \
struct ambiguate : U, ambiguate_seed \
{ \
using ambiguate_seed::memfun; \
using U::memfun; \
}; \
\
template < class U > \
struct ambiguate<U,false> : ambiguate_seed {}; \
\
static constexpr bool value = not has_valid_mem_fun_call_##memfun< ambiguate<T>(Args...) >::value; \
using type = std::integral_constant<bool, value>; \
}; \
\
template < typename Signature > \
struct has_viable_mem_fun_call_##memfun; \
\
template < typename T, typename... Args > \
struct has_viable_mem_fun_call_##memfun< T(Args...) > \
{ \
static constexpr bool value = has_valid_mem_fun_call_##memfun<T(Args...)>::value \
or has_ambiguous_mem_fun_call_##memfun<T(Args...)>::value; \
using type = std::integral_constant<bool, value>; \
}; \
\
template < typename Signature > \
struct has_no_viable_mem_fun_call_##memfun; \
\
template < typename T, typename... Args > \
struct has_no_viable_mem_fun_call_##memfun < T(Args...) > \
{ \
static constexpr bool value = not has_viable_mem_fun_call_##memfun<T(Args...)>::value; \
using type = std::integral_constant<bool, value>; \
}; \
\
template < typename Signature > \
struct result_of_mem_fun_call_##memfun; \
\
template < typename T, typename... Args > \
struct result_of_mem_fun_call_##memfun< T(Args...) > \
{ \
using type = decltype(std::declval<T>().memfun(std::declval<Args>()...)); \
};
#endif
C++14 でのすべてのメタプログラミングをスキップして、 Fitライブラリを使用fit::conditionalしてこれを記述するだけです。
template<class T>
std::string optionalToString(T* x)
{
return fit::conditional(
[](auto* obj) -> decltype(obj->toString()) { return obj->toString(); },
[](auto*) { return "toString not defined"; }
)(x);
}
ラムダから直接関数を作成することもできます。
FIT_STATIC_LAMBDA_FUNCTION(optionalToString) = fit::conditional(
[](auto* obj) -> decltype(obj->toString(), std::string()) { return obj->toString(); },
[](auto*) -> std::string { return "toString not defined"; }
);
ただし、ジェネリック ラムダをサポートしないコンパイラを使用している場合は、別の関数オブジェクトを記述する必要があります。
struct withToString
{
template<class T>
auto operator()(T* obj) const -> decltype(obj->toString(), std::string())
{
return obj->toString();
}
};
struct withoutToString
{
template<class T>
std::string operator()(T*) const
{
return "toString not defined";
}
};
FIT_STATIC_FUNCTION(optionalToString) = fit::conditional(
withToString(),
withoutToString()
);
おそらく他の例ほど良くはありませんが、これは私が C++11 で思いついたものです。これは、オーバーロードされたメソッドを選択するために機能します。
template <typename... Args>
struct Pack {};
#define Proxy(T) ((T &)(*(int *)(nullptr)))
template <typename Class, typename ArgPack, typename = nullptr_t>
struct HasFoo
{
enum { value = false };
};
template <typename Class, typename... Args>
struct HasFoo<
Class,
Pack<Args...>,
decltype((void)(Proxy(Class).foo(Proxy(Args)...)), nullptr)>
{
enum { value = true };
};
使用例
struct Object
{
int foo(int n) { return n; }
#if SOME_CONDITION
int foo(int n, char c) { return n + c; }
#endif
};
template <bool has_foo_int_char>
struct Dispatcher;
template <>
struct Dispatcher<false>
{
template <typename Object>
static int exec(Object &object, int n, char c)
{
return object.foo(n) + c;
}
};
template <>
struct Dispatcher<true>
{
template <typename Object>
static int exec(Object &object, int n, char c)
{
return object.foo(n, c);
}
};
int runExample()
{
using Args = Pack<int, char>;
enum { has_overload = HasFoo<Object, Args>::value };
Object object;
return Dispatcher<has_overload>::exec(object, 100, 'a');
}
作業コードの例を次に示します。
template<typename T>
using toStringFn = decltype(std::declval<const T>().toString());
template <class T, toStringFn<T>* = nullptr>
std::string optionalToString(const T* obj, int)
{
return obj->toString();
}
template <class T>
std::string optionalToString(const T* obj, long)
{
return "toString not defined";
}
int main()
{
A* a;
B* b;
std::cout << optionalToString(a, 0) << std::endl; // This is A
std::cout << optionalToString(b, 0) << std::endl; // toString not defined
}
toStringFn<T>* = nullptrで呼び出されたときintに取る関数よりも優先される追加の引数を取る関数を有効にします。long0
true関数が実装されている場合に返す関数にも同じ原則を使用できます。
template <typename T>
constexpr bool toStringExists(long)
{
return false;
}
template <typename T, toStringFn<T>* = nullptr>
constexpr bool toStringExists(int)
{
return true;
}
int main()
{
A* a;
B* b;
std::cout << toStringExists<A>(0) << std::endl; // true
std::cout << toStringExists<B>(0) << std::endl; // false
}
同様の問題がありました：
いくつかの基本クラスから派生する可能性のあるテンプレート クラス。特定のメンバーを持つものと持たないものがあります。
「typeof」（Nicola Bonelli's）の回答と同様に解決しましたが、decltypeを使用して、MSVSで正しくコンパイルおよび実行します。
#include <iostream>
#include <string>
struct Generic {};
struct HasMember
{
HasMember() : _a(1) {};
int _a;
};
// SFINAE test
template <typename T>
class S : public T
{
public:
std::string foo (std::string b)
{
return foo2<T>(b,0);
}
protected:
template <typename T> std::string foo2 (std::string b, decltype (T::_a))
{
return b + std::to_string(T::_a);
}
template <typename T> std::string foo2 (std::string b, ...)
{
return b + "No";
}
};
int main(int argc, char *argv[])
{
S<HasMember> d1;
S<Generic> d2;
std::cout << d1.foo("HasMember: ") << std::endl;
std::cout << d2.foo("Generic: ") << std::endl;
return 0;
}