Thread: Trouble with SFINAE

Hey folks,

I'm currently trying to make my container wrapper only define some specific member functions if they are supported by the underlying container.

Code:

template<typename Type, template<typename...> typename Container>
class container {
public:
    using size_type=typename Container<Type>::size_type;
    
    auto at(size_type position)
        -> decltype(std::declval<Container<Type>>()[std::declval<size_type>()]);
};

Sadly it doesn't really work at the moment: my compiler throws hard errors instead of silently removing the overload...

Code:

int main()
{
    container<int, std::vector> first; // fine
    container<int, std::set> second; // hard error: no operator[] defined
}

It would be nice if someone could point out my mistake! Thanks

Yes, I tried and failed... The problem with `std::enable_if' is that it requires a boolean parameter, and I didn't manage to convert a syntax query to a boolean value. I also played around a bit with `std::result_of', but it doesn't work either:

Code:

// This gives me a bunch of compiler errors
auto at(size_type position) -> typename std::result_of<decltype(&Container<Type>::operator[])(Container<Type>, std::declval<size_type>())>::type;

I also found solutions like this one, but they seem to be a bit of overkill to me.

O_o

You aren't giving the compiler an option.

The expression `decltype(std::declval<Container<Type>>()[std::declval<size_type>()])` could be reduced to `decltype(Container<Type>()[0])` in most cases. The expression `decltype(Container<Type>()[0])` does not result in simple substitution failure because the expression is not being evaluated in the context of a template function. The SFINAE technique works for code that only attempts to look into a type in the appropriate context of expanding a template function. You simply have a method which belongs to a template class; the code fails for the same reason `decltype(std::declval<std::set<int>>()[std::declval<size_type>()])` fails.

I also found solutions like this one, but they seem to be a bit of overkill to me.

You may not like the code, but the approach of evaluating the expression in the context of a template function is correct.

Soma

The answer is typically

Code:

template<typename T>
struct foo
{
    template<typename T2 = T>
    auto bar() -> std::enable_if_t</* something something referencing T2 */, void> {}
};

By using the extra template, the function will only be instantiated when called and then SFINAE kicks in.

By using the extra template, the function will only be instantiated when called and then SFINAE kicks in.

O_o

For the sake of information, the extra template parameter does not have to be a part of the method signature.

A template method can't be virtual so you'll may occasionally need to move the extra template parameter into another class which can then be inherited.

Soma