Как вызвать функцию-член, только если объект имеет ее?

Возможный дубликат:
Можно ли написать шаблон C++ для проверки существования функции?

У меня есть функция f который получает значение val типа T (Шаблонный). Есть ли способ вызвать функцию-член на val только если тип имеет такую ​​функцию-член?

Пример:

struct Bar {
  void foo() const {}
};

template<class T>
void f(T const& val) {
  // Is there any way to call *only* if foo() is available on type T?                                                           
  // SFINAE technique?                                                                                                          
  val.foo();
}

int main() {
  Bar bar;
  f(bar);
  f(3.14);
}

Для меня это похоже на технику SFINAE, возможно, с использованием boost::enable_if, но я не знаю, как заставить это работать здесь. Обратите внимание, что я не могу легко изменить Bar введите пример. Я знаю, что было бы легко, если Bar содержит некоторые определенные typedef и т. д., которые указывают, что функция доступна.

Излишне говорить, что я не знаю, набор типов T тот f будет вызван с. У некоторых есть foo функция-член, некоторые нет.

Источник

2 ответа

Вы можете сделать это, как показано в тестовой программе ниже (построенной с GCC 4.7.0 или clang 3.1).

Функция статического шаблона has_void_foo_no_args_const<T>::eval(T const & t) вызовет t.foo() если метод void T::foo() const существует и является публичным. Ничего не поделаешь, если такого метода нет. (И, конечно, ошибка компиляции произойдет, если метод является закрытым.)

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

#include <iostream>

/*! The template `has_void_foo_no_args_const<T>` exports a
    boolean constant `value` that is true iff `T` provides
    `void foo() const`

    It also provides `static void eval(T const & t)`, which
    invokes void `T::foo() const` upon `t` if such a public member
    function exists and is a no-op if there is no such member.
*/ 
template< typename T>
struct has_void_foo_no_args_const
{
    /* SFINAE foo-has-correct-sig :) */
    template<typename A>
    static std::true_type test(void (A::*)() const) {
        return std::true_type();
    }

    /* SFINAE foo-exists :) */
    template <typename A> 
    static decltype(test(&A::foo)) 
    test(decltype(&A::foo),void *) {
        /* foo exists. What about sig? */
        typedef decltype(test(&A::foo)) return_type; 
        return return_type();
    }

    /* SFINAE game over :( */
    template<typename A>
    static std::false_type test(...) {
        return std::false_type(); 
    }

    /* This will be either `std::true_type` or `std::false_type` */
    typedef decltype(test<T>(0,0)) type;

    static const bool value = type::value; /* Which is it? */

    /*  `eval(T const &,std::true_type)` 
        delegates to `T::foo()` when `type` == `std::true_type`
    */
    static void eval(T const & t, std::true_type) {
        t.foo();
    }
    /* `eval(...)` is a no-op for otherwise unmatched arguments */ 
    static void eval(...){
        // This output for demo purposes. Delete
        std::cout << "T::foo() not called" << std::endl;        
    }

    /* `eval(T const & t)` delegates to :-
        - `eval(t,type()` when `type` == `std::true_type`
        - `eval(...)` otherwise
    */  
    static void eval(T const & t) {
        eval(t,type());
    }
};

// For testing
struct AA {
    void foo() const {
        std::cout << "AA::foo() called" << std::endl;
    }
};

// For testing
struct BB {
    void foo() {
        std::cout << "BB::foo() called" << std::endl;
    }
};

// For testing
struct CC {
    int foo() const {
        std::cout << "CC::foo() called" << std::endl;
        return 0;
    }
};

// This is the desired implementation of `void f(T const& val)` 
template<class T>
void f(T const& val) {
    has_void_foo_no_args_const<T>::eval(val);
}

int main() {
    AA aa;
    std::cout << (has_void_foo_no_args_const<AA>::value ? 
        "AA has void foo() const" : "AA does not have void foo() const")
        << std::endl; 
    f(aa);
    BB bb;  
    std::cout << (has_void_foo_no_args_const<BB>::value ? 
        "BB has void foo() const" : "BB does not have void foo() const")
        << std::endl;
    f(bb);
    CC cc;  
    std::cout << (has_void_foo_no_args_const<CC>::value ? 
        "CC has void foo() const" : "CC does not have void foo() const")
        << std::endl;
    f(cc);  
    std::cout << (has_void_foo_no_args_const<double>::value ? 
        "Double has void foo() const" : "Double does not have void foo() const")
        << std::endl;
    f(3.14);
            return 0;

}

Эта программа выводит:

AA has void foo() const
AA::foo() called
BB does not have void foo() const
T::foo() not called
CC does not have void foo() const
T::foo() not called
Double does not have void foo() const
T::foo() not called
Источник

Если у вас был typedef bool has_f или static (что-то, доступное во время компиляции), я думаю, вы можете выполнить ветвление (используя функцию метапрограммирования boost) или предоставить 2 шаблона, один из которых будет создан, если has_f определен, другой, если он не, Это не представляется возможным напрямую, без метаданных о T, IMHO.

Источник
Другие вопросы по тегам