fork download

#include <iostream>
#include <type_traits>
#include <sstream>
 
namespace has_insertion_operator_impl {
  typedef char no;
  typedef char yes[2];
 
  struct any_t {
    template<typename T> any_t( T const& );
  };
 
  no const any_t any_t::operator+(const any_t &other) const;
 
  yes& test( any_t&, any_t );
  no test( no );
 
  template<typename T>
  struct has_insertion_operator {
    static any_t& a;
    static any_t& b;
    static T const &t;
    static bool const value = sizeof( test(a + b) ) == sizeof( yes );
  };
}
 
template<typename T>
struct has_insertion_operator :
  has_insertion_operator_impl::has_insertion_operator<T> {
};
 
template <typename T,
    typename std::enable_if<
        has_insertion_operator<T>::value, T>::type* = nullptr>
void print(T lhs, T rhs) {
    std::cout << lhs + rhs << std::endl;
}
 
template <typename T,
    typename std::enable_if<
        !has_insertion_operator<T>::value, T>::type* = nullptr>
void print(T lhs, T rhs) {
    std::cout << 42 << std::endl;
}
 
struct Foo
{
public:
    Foo() : val(0) { }
    Foo(int v) : val(v) { }
    ~Foo() { }
 
    int value() const { return val; }
 
    Foo & operator+=(const Foo &rhs);
    const Foo operator+(const Foo &other) const;
private:
    int val;
};
 
Foo & Foo::operator+=(const Foo &rhs) {
    this->val += rhs.value();
 
    return *this;
}
 
const Foo Foo::operator+(const Foo &other) const {
    Foo result = *this;     // Make a copy of myself.  Same as MyClass result(*this);
    result += other;            // Use += to add other to the copy.
    return result;              // All done!
}
 
int main()
{
    print(42, 42);
    print(Foo(42), Foo(42));
    return 0;
}

prog.cpp:13:18: error: expected initializer before ‘any_t’
prog.cpp:23:48: error: no match for ‘operator+’ in ‘has_insertion_operator_impl::has_insertion_operator<T>::a + has_insertion_operator_impl::has_insertion_operator<T>::b’
prog.cpp: In function ‘int main()’:
prog.cpp:75:17: error: no matching function for call to ‘print(int, int)’
prog.cpp:75:17: note: candidates are:
prog.cpp:35:6: note: template<class T, typename std::enable_if<has_insertion_operator<T>::value, T>::type* <anonymous> > void print(T, T)
prog.cpp:35:6: note:   template argument deduction/substitution failed:
prog.cpp:34:55: note: invalid template non-type parameter
prog.cpp:42:6: note: template<class T, typename std::enable_if<(! has_insertion_operator<T>::value), T>::type* <anonymous> > void print(T, T)
prog.cpp:42:6: note:   template argument deduction/substitution failed:
prog.cpp:41:56: error: in argument to unary !
prog.cpp:41:56: note: invalid template non-type parameter
prog.cpp:76:27: error: no matching function for call to ‘print(Foo, Foo)’
prog.cpp:76:27: note: candidates are:
prog.cpp:35:6: note: template<class T, typename std::enable_if<has_insertion_operator<T>::value, T>::type* <anonymous> > void print(T, T)
prog.cpp:35:6: note:   template argument deduction/substitution failed:
prog.cpp:34:55: note: invalid template non-type parameter
prog.cpp:42:6: note: template<class T, typename std::enable_if<(! has_insertion_operator<T>::value), T>::type* <anonymous> > void print(T, T)
prog.cpp:42:6: note:   template argument deduction/substitution failed:
prog.cpp:41:56: error: in argument to unary !
prog.cpp:41:56: note: invalid template non-type parameter

Standard output is empty