Member Detection for private const member function - c++

Question

I'm trying to build a trait for member detector when the member is const and private. I can use the idiom DetectX from wikibook
template<typename T>
class DetectX
{
struct Fallback { int X; }; // add member name "X"
struct Derived : T, Fallback { };
template<typename U, U> struct Check;
typedef char ArrayOfOne[1]; // typedef for an array of size one.
typedef char ArrayOfTwo[2]; // typedef for an array of size two.
template<typename U>
static ArrayOfOne & func(Check<int Fallback::*, &U::X> *);
template<typename U>
static ArrayOfTwo & func(...);
public:
typedef DetectX type;
enum { value = sizeof(func<Derived>(0)) == 2 };
};
But the idiom doesn't differentiate between private const member function and private non-const member function.It just happens to detect both non-const and const private member function.
I think the const information is lost when you take address of (&U::X) .
How do i detect a private member function and differentiate between const and non-const private member function of the same class ?
After looking at Tyker's code i could get a C++03 implementation using friend . I'm still waiting to see a solution without friend.
/* Start - decltype simulation in c++03 */
template <size_t>
struct TypeId;
#define REGISTER_TYPE(T, id) \
template <> \
struct TypeId<id> { \
char value[id]; \
typedef T type; \
static char const* const name; \
}; \
char const* const TypeId<id>::name = #T; \
TypeId<id> type_to_id(T);
#define TYPEID_(value) TypeId<sizeof(type_to_id(value))>
#define TYPEOF(value) typename TYPEID_(value)::type
#define TYPENAME(value) TYPEID_(value)::name
REGISTER_TYPE(int, 1)
REGISTER_TYPE(unsigned int, 2)
/* End - decltype simulation - c++03 */
template <typename T>
class DetectX {
template <typename V>
struct Check;
template <typename U>
static char& func(
Check<TYPEOF((*(const U*)0).mem())>*); // use const U* or U*
template <typename U>
static short& func(...);
public:
typedef DetectX type;
enum { value = sizeof(func<T>(0)) }; // returns 1 or 2
};
class bar {
private:
int mem() const;
template <typename T>
friend class DetectX;
};
/* Register class and function signatures */
#define REGISTER_CLASS(X) \
typedef int (X::*pf)(); \
typedef int (X::*pfc)() const;
REGISTER_CLASS(bar)
REGISTER_TYPE(pf, 3)
REGISTER_TYPE(pfc, 4)
int main() { std::cout << DetectX<bar>::value << std::endl; }

Answer 1

Generate an object from std::declval<T>(), then cast it to const, then invoke the member function. Do this in a SFINAE function. The function should have two overloading versions with different return types. Use decltype and std::is_same to check the return type in order to know if the member function is const-qualified.

Answer 2

it is possible with to detect const private members with the following code.
the only drawback is a friend declaration, but i don't think it can be done without.
template<typename T, typename...>
using first_type = T;
class private_const_test {
template<typename = void>
static constexpr std::false_type has_const_test_impl(...) {
return std::false_type();
}
template<typename T>
static constexpr first_type<std::true_type, decltype(std::declval<const T>().test())> has_const_test_impl(T) {
return std::true_type();
}
public:
template<typename T>
static constexpr bool has_const_test = decltype(has_const_test_impl(std::declval<T>()))::value;
};
class public_const_test {
template<typename = void>
static constexpr std::false_type has_const_test_impl(...) {
return std::false_type();
}
template<typename T>
static constexpr first_type<std::true_type, decltype(std::declval<const T>().test())> has_const_test_impl(T) {
return std::true_type();
}
public:
template<typename T>
static constexpr bool has_const_test = decltype(has_const_test_impl(std::declval<T>()))::value;
};
template<typename T>
constexpr bool has_private_const_test = private_const_test::has_const_test<T> && !public_const_test::has_const_test<T>;
struct A {
friend class private_const_test;
private:
void test() const {}
};
struct B {
friend class private_const_test;
void test() const {}
};
int main()
{
std::cout << has_private_const_test<A> << std::endl; // true
std::cout << has_private_const_test<B> << std::endl; // false
std::cout << has_private_const_test<int> << std::endl; // false
}