C ++ appelle une fonction d'un vecteur de pointeurs de fonction dans une classe où la définition de la fonction est dans le principal

Bien, dans mon main j'ai:

void somefunction();
int main()
{
    //bla bla bla
    SomeClass myclass = SomeClass();
    void(*pointerfunc)() = somefunction;
    myclass.addThingy(pointerfunc);

    //then later i do
    myclass.actionWithDiffrentOutcomes();
}

void somefunction()
{
    //some code
}

et dans la classe:

class SomeClass()
{
    public:
        void addThingy(void (*function)());
        void actionWithDiffrentOutcomes();
    private:
        std::vector<void (**)()> vectoroffunctions;
}
SomeClass::addThingy(void (*function)())
{
    vectoroffunctions.push_back(&function);
}
SomeClass::actionWithDiffrentOutcomes()
{
    (*vectoroffunctions[0])();;
}

Je suis une sorte de nouvelle-ish pour les pointeurs, mais j'ai lu sur mon c++ livres, googlé, ext. et cela semble correct, compile, lance mais quand je l'appelle "actionWithDiffrentOutcomes()" je reçois une violation d'accès. Je ne suis pas sûr de quoi faire. il semble correct, mais quelque chose qui est évidemment faux. Alors, comment puis-je appeler une fonction dans une classe lors de la définition est dans un autre?

Je suis en train de faire de cette façon parce que je ne peux pas coder en dur chaque option dans une instruction switch.

source d'informationauteur Steven Venham

  1. 12

    Votre code est presque correct. Votre vecteur est à tort la tenue des pointeurs de pointeurs de fonctions plutôt que de simplement les pointeurs de fonctions. addThingy est l'ajout de l'adresse de l' function pointeur dans la vectormais le pointeur est hors de portée dans la ligne suivante.

    Modifier votre code comme suit:

    //Store pointers to functions, rather than
//pointers to pointers to functions
std::vector<void (*)()> vectoroffunctions;

SomeClass::addThingy(void (*function)())
{
    //Don't take the address of the address:
    vectoroffunctions.push_back(function);
}

    Aussi, vous avez beaucoup d'erreurs de syntaxe dans le reste du code qui doit arrêter le code de la même compilation.

  2. 5

    Le problème est ici:

    vectoroffunctions.push_back(&function);

    Vous êtes en train d'ajouter l'adresse de l' local variable. La variable locale est détruite une fois que vous êtes de retour de la fonction. L'adresse à laquelle le vecteur des magasins de points d'un objet détruit c'est pourquoi vous obtenez "violation d'accès" erreur lors de l'exécution.

    Pour résoudre ce problème, faites ceci:

    Premier changement de cette 

    std::vector<void (**)()> vectoroffunctions;

    :

    std::vector<void (*)()> _functions; //vector of function-pointer-type
                                    //I changed the name also!

    qui est pratiquement la même chose que:

    std::vector<void()> _functions; //vector of function-type

    Maintenant le faire:

    _functions.push_back(function); //add copy!

    De la rendre plus souple, vous pouvez utiliser un modèle avec std::function:

    class A
{
    public:
        template<typename Function>
        void add(Function && fn) 
        {  
            _functions.push_back(std::forward<Function>(fn)); 
        }
        void invoke_all()
        {
           for(auto && fn : _functions)
                fn();
        }
    private:
        std::vector<std::function<void()>> _functions;
};

    Maintenant, vous pouvez l'utiliser pour stocker des fonctions ainsi que les foncteurs:

    void myfunction() { std::cout << "myfunction" << std::endl ; }

struct myfunctor
{
       void operator()() { std::cout << "myfunctor" << std::endl ; }
};

A a;
a.add(myfunction);   //add function
a.add(myfunctor());  //add functor!
a.invoke_all();

    De sortie (Démo En Ligne):

    myfunction
myfunctor

    Espère que ça aide.

  3. 1

    Pointeurs de fonction sont beaucoup plus lisible avec typedefs:

    typedef void (*RequiredFunction)();

    Vous pouvez déclarer addThingy() comme ceci:

        void addThingy(RequiredFunction function);

    Et vectoroffunctions comme suit:

        std::vector<RequiredFunction> vectoroffunctions;

    La définition de addThingy sera:

    void SomeClass::addThingy(RequiredFunction function)
{
    vectoroffunctions.push_back(function);
}

    Et votre main() ressemblerait plus à: 

    int main()
{
    SomeClass sc;
    RequiredFunction pointerfunc = somefunction;
    sc.addThingy(pointerfunc);
    sc.actionWithDiffrentOutcomes();
}

    Beaucoup moins de *s et &s avec qui faire des erreurs!