如何调用成员函数只有当对象恰好有吗？ [重复](How to call member funct

可能重复：
是否有可能写一个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成员函数，有些则没有。

Answer 1:

为此，您可以通过下面的测试程序（与GCC 4.7.0或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

Answer 2:

如果你有一个typedef BOOL has_f，或静态（可在编译时的东西），我想你可以分支（使用升压元编程功能），或提供2个模板，一个会实例如果has_f定义其他如果不是。它不觉得是可行的直接，无需大约T t的元数据，恕我直言。