Problem

Lets suppose, we want to create some function size(), which should take one argument and return some size.

It's easy, isn't it?

template <typename T>
size_t size(const T &val) { return val.size(); }

But now we want this function to work with objects that have getSize() function members.

template <typename T>
auto size(const T &val) -> decltype(val.size()) { return val.size(); }

template <typename T>
auto size(const T &val) -> decltype(val.getSize()) { return val.getSize(); }

Do we want more? Of course!!!

• GetSize()
• get_size()
• Size()
• more?

And what if...

class ... {
public:
    size_t size() const { ... };
    size_t get_size() const { return size(); }
};

Oops... Now we really need the std::enable_if<...>.

template <typename T, typename FDef>
constexpr auto has_func_size() -> decltype(std::declval<const T&>().size(), true) { 
    return std::is_same<FDef, &T::size>::value;
}
template <typename T, typename FDef>
constexpr auto has_func_get_size() -> decltype(std::declval<const T&>().get_size(), true) { 
    return std::is_same<FDef, &T::get_size>::value;
}

template <typename T, typename = enable_if_t<has_func_size<T, size_t (T::*)()const>(), int>>
auto size(const T &val) -> decltype(val.size()) { return val.size(); }

template <typename T, typename = enable_if_t<has_func_get_size<T, size_t (T::*)()const>() &&
    !has_func_size<T, size_t (T::*)()const>(), int>>
auto size(const T &val) -> decltype(val.getSize()) { return val.getSize(); }

And the same with the others...

I know, many of c++ programmers don't like macros. I don't like them too. But they're so helpfull sometimes.

Example compile and output

$ g++ -std=c++11 -O2 -g0 size_getter_test.cpp && ./a.out
test string size:   14
sss size:           1
string{} is empty?: true
sss{} is empty?:    false