sfinae

Synopsis Given a type with a variadic template constructor that forwards the arguments to an implementation class, is it possible to restrict the types being forwarded with SFINAE? Details First, consider the non-variadic case with a constructor taking a universal reference. Here one can disable forwarding of a non-const lvalue reference via SFINAE to use the copy constructor instead. struct foo { foo() = default; foo(foo const&) { std::cout << "copy" << std::endl; } template < typename T, typename Dummy = typename std::enable_if< !std::is_same< T, typename std::add_lvalue_reference<foo>::type

So I want to write an automatic != : template<typename U, typename T> bool operator!=(U&& u, T&& t) { return !( std::forward<U>(u) == std::forward<T>(t) ); } but that is impolite 1 . So I write // T() == U() is valid? template<typename T, typename U, typename=void> struct can_equal:std::false_type {}; template<typename T, typename U> struct can_equal< T, U, typename std::enable_if< std::is_convertible< decltype( std::declval<T>() == std::declval<U>() ), bool >::value >::type >: std::true_type {}; which is a type traits class that says "is t == u valid code that returns a type convertible to

Edit, in order to avoid confusion: decltype does not accept two arguments. See answers. The following two structs can be used to check for the existance of a member function on a type T during compile-time: // Non-templated helper struct: struct _test_has_foo { template<class T> static auto test(T* p) -> decltype(p->foo(), std::true_type()); template<class> static auto test(...) -> std::false_type; }; // Templated actual struct: template<class T> struct has_foo : decltype(_test_has_foo::test<T>(0)) {}; I think the idea is to use SFINAE when checking for the existance of a member function, so

I'm not sure if this has anything to do with sfinae, or just something thats relevant for any templated function. I am attempting to use sfinae to enable/disable a member function based on existence of corresponding free function, which in turn is enabled/disabled based on existance of member function in another type, all using method described here : struct S; template <typename T> inline auto f(S& s, T const& t) -> decltype(t.f(s), void()) { t.f(s); } struct S { template <typename T> auto f(T const& t) -> decltype(f(*this, t), void()) { f(*this, t); // <--------------------------------------

I want to check if two types are of the same template. As an example I want the following snippet of code to return true because both objects are vectors despite the inner elements being of different types. It's important that the check is made at compile time (that's why the function is constexpr). #include <iostream> #include <type_traits> #include <vector> template <typename Container1, typename Container2> constexpr bool CheckTypes(Container1 c1, Container2 c2) { return std::is_same<Container1,Container2>::value; } int main() { std::vector<int> v1(100,0); std::vector<double> v2(100,0); std

Is it possible to write c++ template/macros to check whether two functions have the same signatures (return type and arguments list) ? Here's a simple example of how I want to use it: int foo(const std::string& s) {...} int bar(const std::string& s) {...} if (SAME_SIGNATURES(foo, bar)) { // do something useful... make Qt signal-slot connection for example... } else { // signatures mismatch.. report a problem or something... } So is it possible somehow or is it just a pipe dream ? P.S. Actually I'm interesting in c++ 2003 standard. C++11 Solution No need to write any template yourself. You can