c++ - ¿Cuál es el tipo de retorno de boost:: bind?

std::bind

Question

Quiero guardar el "archivador" de una función en una variable, usarla repetitivamente en el siguiente código explotando sus instalaciones de sobrecarga de operadores. Aquí está el código que realmente hace lo que quiero:

#include <boost/bind.hpp>
#include <vector>
#include <algorithm>
#include <iostream>

class X 
{       
    int n; 
public: 
    X(int i):n(i){}
    int GetN(){return n;}  
};

int main()
{
    using namespace std;
    using namespace boost;

    X arr[] = {X(13),X(-13),X(42),X(13),X(-42)};
    vector<X> vec(arr,arr+sizeof(arr)/sizeof(X));

    _bi::bind_t<int, _mfi::mf0<int, X>, _bi::list1<arg<1> > > bindGetN = bind(&X::GetN,_1);

    cout << "With  n =13 : " 
         << count_if(vec.begin(),vec.end(),bindGetN == 13)
         << "/nWith |n|=13 : " 
         << count_if(vec.begin(),vec.end(),bindGetN == 13 || bindGetN == -13)
         << "/nWith |n|=42 : " 
         << count_if(vec.begin(),vec.end(),bindGetN == 42 || bindGetN == -42) 
         << "/n";

    return 0;                                                                    
} 

Lo que me molesta es, por supuesto, la línea:

bi::bind_t<int, _mfi::mf0<int, X>, _bi::list1<arg<1> > > bindGetN = bind(&X::GetN,_1);

Obtuve el tipo simplemente cometiendo un error de tipo y analizando el mensaje de error. Eso ciertamente no es una buena manera de ir. ¿Hay una manera de obtener el tipo para el "bindGetN"? O, tal vez hay diferentes maneras de producir una funcionalidad similar?

Edición: olvidé mencionar que la sugerencia "estándar" de usar la function , por así decirlo, no funciona en este caso, porque me gustaría sobrecargar a mi operador.

Answer 1

La respuesta corta es: no necesita saber (implementación definida). Es una expresión de enlace ( std::tr1::is_bind_expression<T>::value true para el tipo real).

Mirar

1. std::tr1::function<>
2. BOOST_AUTO()
3. Palabras clave ''auto'' c ++ 0x (Inferencia de tipos)
   • Está cerca de usar decltype() puede ayudarte a avanzar.

1.

std::tr1::function<int> f; // can be assigned from a function pointer, a bind_expression, a function object etc

int realfunc();
int realfunc2(int a);

f = &realfunc;
int dummy;
f = tr1::bind(&realfunc2, dummy);

2.

BOOST_AUTO () apunta a soportar la semántica de c ++ 0x auto sin el compilador c ++ 0x support:

BOOST_AUTO(f,boost::bind(&T::some_complicated_method, _3, _2, "woah", _2));

3.

Esencialmente lo mismo pero con soporte de compilador:

template <class T> struct DoWork { /* ... */ };

auto f = boost::bind(&T::some_complicated_method, _3, _2, "woah", _2));

DoWork<decltype(T)> work_on_it(f); // of course, using a factory would be _fine_

Tenga en cuenta que el auto probablemente se ha inventado para este tipo de situación: el tipo real es un ''que no quiere saber'' y puede variar entre compiladores / plataformas / bibliotecas