Pasando alrededor de un funtor anidado (C ++)

Question

¿Hay alguna forma de pasar foo_ por fuera de main? Vi algo sobre Boost en otra pregunta sobre los funtores. Eso parece que puede funcionar. Aquí está la respuesta mencionando Boost en esa pregunta. Si puedo, me gustaría evitar Boost.

#include <iostream>

int main()
{
    class foo {
        public:
        void operator()() {
            std::cout << "Hello" << std::endl;
        }
    };

    foo foo_;
    foo_();
    return 0;
}

Answer 1

No, actualmente los tipos locales no tienen permitido ingresar a las plantillas (de lo contrario, podrías haber usado boost o std :: tr1 :: function). Sin embargo, tal vez podría hacerlo OOP, donde Foo hereda algo (que tiene una función virtual opeator () que su aplicación implementa) y le pasa un ptr a Foo.

Answer 2

Las clases locales de la función

no se pueden usar como argumentos de plantilla si eso es lo que quieres decir. Esto solo será compatible con C ++ 0x.

Answer 3

Parece posible usar la dirección de una función estática de una clase local. Sin embargo, operator () debe ser una función miembro no estática, por lo tanto, deberá darle un nombre:

#include <iostream>

template <class T>
void bar(T f)
{
    f();
}

int main()
{
    class foo {
        public:
        static void do_it() {
            std::cout << "Hello" << std::endl;
        }
    };
    bar(&foo::do_it);
    return 0;
}

Answer 4

No creo que sea posible invocar a un miembro de una clase que no esté definido en el alcance actual. En este caso, el functor no retiene ningún estado y se comporta como una función que no toma parámetros y no devuelve ningún valor, por lo que podría asignar una instancia de este a un puntero de función sin formato. Sin embargo, ya no es un foo : es solo un puntero de función.

Una solución es derivar foo a partir de una clase base virtual pura definida a nivel global, como:

class base
{
public:
    void operator()() { doit(); }
protected:
    virtual void doit() = 0;
};

int main()
{
    class foo
    {
    public:
        void operator()() { doit(); }
    protected:
        virtual void doit()
        {
            std::cout << "Hello" << std::endl;
        }
    };
 }

Ahora puede pasar una instancia de foo como base , y el método virtual doit () se invocará como se esperaba.

Answer 5

EDIT: esto no parece ser un C ++ válido, aunque algunos copilers lo toman sin queja.

bueno, si tiene algo que acepta functores como un parámetro de plantilla, podría pasarle algo que se comporte como un funtor, aunque no estoy completamente seguro de que es lo que está buscando.

template< class tFunctor >
void UseFunctor( const tFunctor& func )
{
  func();
}

int main()
{
  foo foo_;
  UseFunctor( foo_ );
}