std :: tr1 :: mem_fn typ zwracany

Question

chcę umieścić wynik to:

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

Wewnątrz zmiennej, jaki jest typ tej zmiennej?

To będzie wyglądać następująco:

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

Ponadto, co jest wynikiem std::tr1::bind typ?

Dziękujemy!

Answer 1

Typy zwrotów obu std::tr1::mem_fn i std::tr1::bind są nieokreślone.

można zapisać wynik std::tr1::bind w std::tr1::function:

struct ClassA { 
    void Func() { } 
}; 

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

Można również zapisać wynik std::tr1::mem_fn w std::tr1::function:

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

Answer 2

Rodzaj powrót mem_fn i bind jest nieokreślony. Oznacza to, że w zależności od argumentów zwracany jest inny rodzaj obiektu, a standard nie określa szczegółów, jak ta funkcja musi zostać zaimplementowana.

Jeśli chcesz dowiedzieć się, jaki typ jest w konkretnym przypadku z konkretną implementacją biblioteki (teoretycznie, mam nadzieję), zawsze możesz spowodować błąd i uzyskać typ z komunikatu o błędzie. Np .:

#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 

W tym przypadku należy pamiętać, że nazwa typu jest zarezerwowana do użytku wewnętrznego. W twoim kodzie nie powinieneś używać niczego z wiodącym podkreśleniem (i wielką literą).

w C++ 0x, przypuszczam typ zwracany byłby auto :)

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

Answer 3

Funkcja może być realizowana w następujący sposób (trzeba więc również zobaczyć typ zwracany): Można spróbować fragment kodu tutaj http://webcompiler.cloudapp.net/. Niestety korzysta z szablonów variadic https://en.wikipedia.org/wiki/Variadic_template, które są tylko częścią standardu 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; 
}