Pointeur de fonction C++ (membre de la classe) à la non-fonction membre statique

class Foo {
public:
    Foo() { do_something = &Foo::func_x; }

    int (Foo::*do_something)(int);   //function pointer to class member function

    void setFunc(bool e) { do_something = e ? &Foo::func_x : &Foo::func_y; }

private:
    int func_x(int m) { return m *= 5; }
    int func_y(int n) { return n *= 6; }
};

int
main()
{
    Foo f;
    f.setFunc(false);
    return (f.*do_something)(5);  //<- Not ok. Compile error.
}

Comment puis-je obtenir que cela fonctionne?

Ne sont pas func_x et func_y fonctions statiques, même si elles ne sont pas marqués comme tels?

InformationsquelleAutor Girish | 2009-06-13

c++function-pointers

32

La ligne que vous voulez est
```
   return (f.*f.do_something)(5);
```
(Qui compile -- je l'ai essayé)

"*f.do_something" désigne le pointeur lui-même --- "f", raconte-nous d'où pour obtenir le faire_quelque_chose valeur de. Mais nous avons encore besoin de lui donner un objet qui sera la ce pointeur lorsque nous appelons la fonction. C'est pourquoi nous avons besoin de la "f." préfixe.
- Techniquement, "f.faire_quelque_chose" retourne le pointeur, et le ".*" l'opérateur appelle le pointeur vers une fonction membre d'une classe.
- Donc je suppose return (f.*Foo::do_something)(5) devrait également fonctionner.
- Il ne le fait pas.
- Ah, mais cela signifie que si vous avez Foo g, alors ce serait également compiler et exécuter: return (g.*f.do_something)(5); Droit? (même si il n'y a pas de bonne raison de le faire)
InformationsquelleAutor James Curran
36
```
 class A{
    public:
        typedef int (A::*method)();

        method p;
        A(){
            p = &A::foo;
            (this->*p)(); //<- trick 1, inner call
        }

        int foo(){
            printf("foo\n");
            return 0;
        }
    };

    void main()
    {
        A a;
        (a.*a.p)(); //<- trick 2, outer call
    }
```
- Tudok, après être passé par votre post un deuxième temps, j'ai réalisé que vous avez donné la bonne réponse trop (astuce 2). Merci.
- Votre code ne fonctionne pas. J'ai copier/coller et essayer de compiler. test_function_pointer_2.C: Dans le constructeur 'A::A()': test_function_pointer_2.C:7: erreur: argument de type 'int (A::)()' ne correspond pas 'int (A::*)()'
- Je me souviens qu'il a fait un travail. De toute façon, vous avez raison. Je l'ai testé avec gcc et obtenu la même erreur. Je l'ai corrigé.
InformationsquelleAutor Nick Dandoulakis

class A {
    int var;
    int var2;
public:
    void setVar(int v);
    int getVar();
    void setVar2(int v);
    int getVar2();
    typedef int (A::*_fVar)();
    _fVar fvar;
    void setFvar(_fVar afvar) { fvar = afvar; }
    void insideCall() { (this->*fvar)(); }
};

void A::setVar(int v)
{
    var = v;
}

int A::getVar()
{
    std::cout << "A::getVar() is called. var = " << var << std::endl;
    return var;
}

void A::setVar2(int v2)
{
    var2 = v2;
}

int A::getVar2()
{
    std::cout << "A::getVar2() is called. var2 = " << var2 << std::endl;
    return var2;
}

int main()
{
    A a;
    a.setVar(3);
    a.setVar2(5);

//   a.fvar = &A::getVar;
    a.setFvar(&A::getVar);
    (a.*a.fvar)();

    a.setFvar(&A::getVar2);
    (a.*a.fvar)();

    a.setFvar(&A::getVar);
    a.insideCall();

    a.setFvar(&A::getVar2);
    a.insideCall();

    return 0;
}

J'ai étendu Nick Dandoulakis de réponse. Je vous remercie.

J'ai ajouté une fonction qui définie la fonction de membre du pointeur en dehors de la classe. J'ai ajouté une autre fonction qui peut être appelée de l'extérieur pour montrer intérieure appel de fonction membre pointeur.

Plutôt que de poster un bloc de code, merci de expliquer pourquoi ce code résout le problème posé. Sans une explication, ce n'est pas une réponse.
J'ai écrit qu'il est étendu à partir de Nick Dandoulakis réponse. Il a été expliqué là. Je suis nouveau dans stackoverflow peut-être que j'ai besoin de le faire d'une manière différente.
Eh bien, vous pourriez nous expliquer ce que vous avez changé, par exemple, et pourquoi.

InformationsquelleAutor Volkan Ozyilmaz

0

Essayer (f.*faire_quelque_chose)(5);

InformationsquelleAutor Suvesh Pratapa

#include<iostream>
using namespace std;

class A {

public:
    void hello()
    {
        cout << "hello" << endl;
    };

    int x = 0;

};


void main(void)
{

    //pointer
    A * a = new A;
    void(A::*pfun)() = &A::hello;
    int  A::*v1 = &A::x;

    (a->*pfun)();
    a->*v1 = 100;
    cout << a->*v1 << endl << endl;

    //----------------------------- 
    A  b;
    void(A::*fun)() = &A::hello;
    int  A::*v2 = &A::x;

    (b.*fun)();
    b.*v2 = 200;
    cout << b.*v2 << endl;

}

InformationsquelleAutor SaeidMo7

-4

Je pense que l'appel d'une non membre statique de la classe peut aussi être fait en utilisant une fonction membre statique.
- Ce n'est pas possible. "Lors de la modification d'un membre de données dans une déclaration de classe, le mot-clé static indique qu'une copie du membre est partagée par toutes les instances de la classe. Lors de la modification d'une fonction membre dans une déclaration de classe, le mot-clé static indique que la fonction n'accède qu'aux membres statiques." Voir référence MSDN
- ainsi, vous pouvez garder une liste de toutes les instances de l'auge, le constructeur et ensuite l'appeler, pour toutes les instances, mais je suppose que c'est un peu une claque idée :p
InformationsquelleAutor Pradip Bhojania

Vous devez vous connecter pour publier un commentaire.