Passer autour d'un foncteur imbriqué (C ++)

Question

Y at-il un moyen de passer foo_ autour de main? J'ai vu quelque chose à propos de Boost dans une autre question concernant les foncteurs. Cela semble fonctionner. Voici la réponse mentionnant Boost dans cette question. Si possible, j'aimerais éviter Boost.

#include <iostream>

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

    foo foo_;
    foo_();
    return 0;
}

Answer 1

Non, les types locaux ne sont pas autorisés à entrer dans les modèles (sinon, vous auriez pu utiliser boost ou std :: tr1 :: function). Cependant, vous pourriez peut-être le faire en POO, où Foo hérite de quelque chose (qui a une fonction opeator (virtuelle) que votre foo implémente) et que vous transmettez un ptr à Foo à la place.

Answer 2

Les classes locales de fonction

ne peuvent pas être utilisées comme arguments de modèle si c'est ce que vous voulez dire. Cela ne sera supporté que par C ++ 0x.

Answer 3

Il semble possible d'utiliser l'adresse d'une fonction statique d'une classe locale. Cependant, operator () doit être une fonction membre non statique, vous devrez donc lui attribuer un nom:

#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

Je ne pense pas qu'il soit possible d'appeler un membre d'une classe qui n'est pas définie dans la portée actuelle. Dans ce cas, le foncteur ne conserve aucun état et se comporte comme une fonction qui ne prend aucun paramètre et ne renvoie aucune valeur. Vous pouvez donc en affecter une instance à un pointeur de fonction brut. Cependant, ce n’est plus un truc : c’est juste un pointeur de fonction.

Une solution consiste à dériver toto d'une classe de base virtuelle pure définie au niveau global, telle que:

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;
        }
    };
 }

Vous pouvez maintenant passer une instance de toto en tant que base , et la méthode virtuelle doit () sera invoquée comme prévu.

Answer 5

EDIT: cela ne semble pas être valide en C ++ bien que certains copilateurs le prennent sans plainte.

Eh bien, si vous avez quelque chose qui accepte les foncteurs en tant que paramètre de modèle, vous pouvez lui transmettre n'importe quoi se comportant comme un foncteur, bien que je ne sois pas tout à fait sûr que ce soit ce que vous cherchez.

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

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