SFINAE: some failures more equal than others?

Question

I'm trying to use SFINAE to distinguish a class that has a member called 'name'. I set things up in what seems to be the standard pattern but it's not working -- instead of silently ignoring the 'failed' substitution, the compiler produces an error.

I'm sure I've run up against some template substitution rule, I'd be grateful if someone could explain which one.

This is a stripped down example. I'm using gcc:

 template <typename U> string test( char(*)[sizeof(U::name)] = 0 ) { return "has name!"; }
 template <typename U> string test(...) { return "no name"; }

 struct HasName { string name; }
 struct NoName  {}

 cout << "HasName: " << test<HasName>(0) << endl;  //fine
 cout << "NoName: " << test<NoName>(0) << endl;    //compiler errors:

 //error: size of array has non-integral type `<type error>'
 //error: `name' is not a member of `NoName'

Answer 1

The following appears valid (although as Michael says, it doesn't necessarily give the result you want on other compilers):

#include <string>
#include <iostream>
using namespace std;

template <typename U> string test( char(*)[sizeof(U::name)] = 0 ) { return "has name!"; }
template <typename U> string test(...) { return "no name"; }

struct HasName { static string name; };
struct NoName  { };

 int main() {
    cout << "HasName: " << test<HasName>(0) << endl;
    cout << "NoName: " << test<NoName>(0) << endl;
}

Output:

HasName: has name!
NoName: no name

gcc (GCC) 4.3.4 20090804 (release) 1

Comeau also accepts the code.

Answer 2

Here's an attempt at this:

// Tested on Microsoft (R) C/C++ Optimizing Compiler Version 15.00.30729.01
template<typename T>
class TypeHasName
{
private:
    typedef char (&YesType)[2];
    typedef char (&NoType)[1];

    struct Base { int name; };
    struct Derived : T, Base { Derived(); };

    template<typename U, U> struct Dummy;

    template<typename U>
    static YesType Test(...);

    template<typename U>
    static NoType Test(Dummy<int Base::*, &U::name>*);

public:
    enum { Value = (sizeof(Test<Derived>(0)) == sizeof(YesType)) };
};

#include <string>  
#include <iostream>  

struct HasName { std::string name; };  
struct NoName {};

int main()
{  
    std::cout << "HasName: " << TypeHasName<HasName>::Value << std::endl;  
    std::cout << "NoName: " << TypeHasName<NoName>::Value << std::endl;  
    return 0;
}

The idea is that if T has a variable named name, then Derived will have two name variables (one from T and one from Base). If T does not declare a name variable, then Derived will only have one from Base.

If Derived has two name variables, then the expression &U::name in the second Test() overload will be ambiguous and SFINAE should remove that function from the overload set.