Ist es möglich, ein Merkmal zu erstellen, um zu antworten, ob ein Typ von std kommt?

Question

Nach this question von ADL eine Verwendung eines Merkmals erstellen kann zu beantworten, wenn der übergebene Typ aus unserem Namespace kommt:

#include <utility> 

namespace helper 
{ 
    template <typename T, typename = void> 
    struct is_member_of_sample : std::false_type 
    { 
    }; 

    template <typename T> 
    struct is_member_of_sample< 
     T, 
     decltype(adl_is_member_of_sample(std::declval<T>()))> : std::true_type 
    { 
    }; 
} 

namespace sample 
{ 
    template <typename T> 
    auto adl_is_member_of_sample(T &&) -> void; 
} 

// -- Test it 

namespace sample 
{ 
    struct X; 
} 

struct Y; 

static_assert(helper::is_member_of_sample<sample::X>::value, ""); 
static_assert(not helper::is_member_of_sample<Y>::value, ""); 

int main(){} 

Aus ersichtlichen Grund dieser kann nicht auf den std Namespace angewendet werden - es gibt einfach keine Möglichkeit, das zu injizieren adl_is_member_of_sample entspricht dem Namespace std, ohne sich einem undefinierten Verhalten auszusetzen.

Gibt es eine Abhilfe ermöglicht das Merkmal zu schaffen?

Answer 1

Dies scheint zu funktionieren:

#include <functional> 
#include <type_traits> 
#include <utility> 
#include <string> 

namespace other { struct S{}; } 

namespace my { 
    template< class Type > 
    void ref(Type&&) {} 

    template< class Type > 
    auto ref_to(Type&& o) 
     -> Type& 
    { return o; } 

    template< class Type > 
    constexpr auto is_std_type() 
     -> bool 
    { 
     using std::is_same; 
     using std::declval; 
     return not is_same< void, decltype(ref(ref_to(declval<Type>())))>::value; 
    } 

    struct Blah {}; 

    constexpr bool int_is_std  = is_std_type<int>(); 
    constexpr bool blah_is_std  = is_std_type<Blah>(); 
    constexpr bool other_is_std  = is_std_type<other::S>(); 
    constexpr bool string_is_std = is_std_type<std::string>(); 
}; 

#include <iostream> 
using namespace std; 
auto main() 
    -> int 
{ 
    cout << boolalpha; 
    cout << "int is std = " << my::int_is_std << "\n"; 
    cout << "blah is std = " << my::blah_is_std << "\n"; 
    cout << "other is std = " << my::other_is_std << "\n"; 
    cout << "string is std = " << my::string_is_std << "\n"; 
}