Как определить, содержит ли класс определенную функцию-член во время компиляции

Кража из здесь, и если вы исправите свой код так, чтобы GetInt было константой, мы получим:

HAS_MEM_FUNC(GetInt, has_GetInt);

template <bool B>
struct bool_type
{
    static const bool value = B;
};

typedef bool_type<true> true_type;
typedef bool_type<false> false_type;

namespace detail
{
    template <typename T>
    int get_int(const T& pX, true_type)
    {
        return pX.GetInt();
    }

    template <typename T>
    int get_int(const T& pX, false_type)
    {
        return pX.m;
    }
}

template <typename T>
int get_int(const T& pX)
{
    return detail::get_int(pX,
                            has_GetInt<T, int (T::*)() const>::value);
}

Однако это довольно ужасный дизайн. Вам следует исправить проблему, а не применять исправление.

Ошибка замены не является ошибкой или, более компактно, SFINAE

Но в вашем конкретном случае вам не нужны SFINAE, виртуальные участники или что-то подобное.

Вам просто нужна обычная перегруженная функция.

int GetInt(A& t) { return t.GetInt(); }
int GetInt(const B& t) { return t.m; }

Если есть код, который необходимо совместно использовать в разных версиях, реорганизуйте его так, чтобы был шаблон, который вызывает перегруженную встроенную функцию, все поведение, зависящее от типа, находится во встроенной функции, а все общее поведение - в шаблоне.

Для вашей потребности "У меня много, много классов" SFINAE будет выглядеть примерно так:

template<typename T>
int GetInt(const T& t, int (T::*extra)() const = &T::GetInt)
{
    return t.GetInt();
}

template<typename T>
auto GetInt(const T& t) -> decltype(t.m)
{
    return t.m;
}

РЕДАКТИРОВАТЬ: Реальность SFINAE намного уродливее, по крайней мере, до тех пор, пока не появится C ++ 0x. Фактически, он начинает выглядеть так же плохо, как и ответ GMan.

struct A{ int GetInt() const { return 10; } };
struct B{ int m; };

template<typename T, int (T::*extra)() const>
struct has_mfunc
{
    typedef int type;
};

template<typename T>
typename has_mfunc<T, &T::GetInt>::type GetInt(const T& t)
{
    return t.GetInt();
}

template<typename T, typename U, U (T::*extra)>
struct has_field
{
    typedef U type;
};

template<typename T>
typename has_field<T, int, &T::m>::type GetInt(const T& t)
{
    return t.m;
}

int main(void)
{
   A a;
   B b;
   b.m = 5;
   return GetInt(a) + GetInt(b);
}

Технически это просто включает в себя несколько шаблонных арканов, которые вы можете найти в Google, например. has_member или тому подобное. Вне манжеты, в коде обнаружения, если бы я мог написать такое, я бы просто сделал своего рода фальшивый производный от рассматриваемого класса и проверил размер члена производного класса.

Однако не делайте этого.

Что еще делать - зависит. Но кажется, что ваши классы соответствуют двум разным «схемам», так сказать, без того, чтобы эти схемы были доступны через систему типов (например, кажется, что классы не являются производными от двух базовых классов A и B). Затем один из вариантов - ввести шаблон признаков, который сообщает оберткам, является ли параметр шаблона T схемой A или B. Специализируйте признаки для каждого соответствующего класса, который отличается от значения по умолчанию. Выберите значение по умолчанию, чтобы минимизировать объем работы.

Ура & hth.,

Именно для этого и существует наследование. Вы можете легко использовать использование dynamic_cast для вопросов типа во время выполнения. Например, вы можете определить абстрактный базовый класс с именем HasGetInt и унаследовать от него классы, которым нужна эта функция, а не изобретать колесо.