std :: tr1 :: mem_fn trở lại loại

Question

tôi muốn đưa kết quả của việc này:

std::tr1::mem_fn(&ClassA::method); 

Bên trong một biến, kiểu của biến này là gì?

Điều đó sẽ giống như thế này:

MagicalType fun = std::tr1::mem_fn(&ClassA::method); 

Ngoài ra, các loại quả của std::tr1::bind là gì?

Cảm ơn bạn!

Answer 1

Loại trả lại của cả hai std::tr1::mem_fn và std::tr1::bind không được chỉ định.

Bạn có thể lưu trữ các kết quả của std::tr1::bind trong một std::tr1::function:

struct ClassA { 
    void Func() { } 
}; 

ClassA obj; 
std::tr1::function<void()> bound_memfun(std::tr1::bind(&ClassA::Func, obj)); 

Bạn cũng có thể lưu trữ các kết quả của std::tr1::mem_fn trong một std::tr1::function:

std::tr1::function<void(ClassA&)> memfun_wrap(std::tr1::mem_fn(&ClassA::Func)); 

Answer 2

Kiểu trả về của mem_fn và bind là không được chỉ định. Điều đó có nghĩa, tùy thuộc vào các đối số một loại đối tượng khác được trả về và tiêu chuẩn không quy định chi tiết cách chức năng này phải được triển khai.

Nếu bạn muốn tìm hiểu loại trong một trường hợp cụ thể với một triển khai thư viện cụ thể (vì lý thuyết, tôi hy vọng), bạn luôn có thể gây ra lỗi và nhận loại từ thông báo lỗi. Ví dụ:

#include <functional> 

struct X 
{ 
    double method(float); 
}; 

int x = std::mem_fn(&X::method); 

9 Untitled.cpp cannot convert 'std::_Mem_fn<double (X::*)(float)>' to 'int' in initialization 

Trong trường hợp này, lưu ý rằng tên của loại được dành để sử dụng nội bộ. Trong mã của bạn, bạn không nên sử dụng bất kỳ thứ gì có dấu gạch dưới hàng đầu (và một chữ cái viết hoa).

Trong C++ 0x, Tôi cho rằng kiểu trả về sẽ là auto :)

auto fun = std::mem_fn(&ClassA::method); 

Answer 3

Chức năng có thể được thực hiện theo cách sau (bạn vì thế cũng thấy kiểu trả về): Bạn có thể thử này đoạn mã ở đây http://webcompiler.cloudapp.net/. Thật không may, nó làm cho việc sử dụng các mẫu variadic https://en.wikipedia.org/wiki/Variadic_template chỉ là một phần của tiêu chuẩn C++ 11.

#include <iostream> 
#include <string> 

template <class R, class T, class... Args > class MemFunFunctor 
{ 
    private: 
    R (T::*mfp)(Args...); //Pointer to a member function of T which returns something of type R and taking an arbitrary number of arguments of any type 

public: 
    explicit MemFunFunctor(R (T::*fp)(Args...)):mfp(fp) {} 

    R operator()(T* t, Args... parameters) 
    { 
     (t->*mfp)(parameters...); 
    } 

}; 

template <class R,class T, class... Args> MemFunFunctor<R,T,Args... > my_mem_fn(R (T::*fp)(Args...)) 
{ 
    return MemFunFunctor<R,T,Args... >(fp); 
} 


class Foo //Test class 
{ 
    public: 
     void someFunction(int i, double d, const std::string& s) 
     { 
      std::cout << i << " " << d << " " << s << std::endl; 
     } 
}; 


int main() //Testing the above code 
{ 

    Foo foo; 
    auto f = my_mem_fn(&Foo::someFunction); 

    f(&foo, 4, 6.7, "Hello World!"); //same as foo.someFunction(4, 6.7, "Hello World!"); 

    return 0; 
}