En passant membre de pointeur de fonction de membre de l'objet en c++

J'ai un problème avec l'aide d'un pointeur de fonction en C++. Voici mon exemple:

#include <iostream>

using namespace std;

class bar
{
public:
    void (*funcP)();
};

class foo
{
public:
    bar myBar;
    void hello(){cout << "hello" << endl;};
};

void byebye()
{
    cout << "bye" << endl;
}


int main()
{
    foo testFoo;

    testFoo.myBar.funcP = &byebye;         //OK
    testFoo.myBar.funcP = &testFoo.hello;  //ERROR
    return 0;
}

Compilateur renvoie une erreur à testFoo.myBar.funcP = &testFoo.hello;:

ISO C++ forbids de prendre l'adresse d'un membre lié fonction permettant de former un
pointeur de fonction membre. Dire
"&foo::hello'

impossible de convertir de 'void (foo::)()' de 'void ()()' attribution

Alors j'ai essayé comme ceci:

class bar
{
public:
    void (*foo::funcP)();
};

Mais maintenant, le compilateur ajoute un de plus:

'foo' n'a pas été déclaré

Est-il un moyen de le faire fonctionner?

Merci d'avance pour les suggestions

InformationsquelleAutor Moomin | 2010-03-03

c++function-pointers member-function-pointers

Prenant chacun suggestions ensemble, votre solution finale ressemblera à:

#include <iostream> 
using std::cout;
usind std::endl;

class foo; //tell the compiler there's a foo out there.

class bar 
{ 
public: 
    //If you want to store a pointer to each type of function you'll
    //need two different pointers here:
    void (*freeFunctionPointer)();
    void (foo::*memberFunctionPointer)();
}; 

class foo 
{ 
public: 
    bar myBar; 
    void hello(){ cout << "hello" << endl; }
}; 

void byebye() 
{ 
    cout << "bye" << endl; 
} 


int main() 
{ 
    foo testFoo; 

    testFoo.myBar.freeFunctionPointer = &byebye;
    testFoo.myBar.memberFunctionPointer = &foo::hello;

    ((testFoo).*(testFoo.myBar.memberFunctionPointer))(); //calls foo::hello()
    testFoo.myBar.freeFunctionPointer();   //calls byebye()
    return 0; 
}

La C++ FAQ Lite a quelques conseils sur la façon de simplifier la syntaxe.

La prise de Chris' idée et de l'utiliser, vous pourriez faire vous-même quelque chose comme ceci:

#include <iostream>
using std::cout; using std::endl;

class foo;
typedef void (*FreeFn)();
typedef void (foo::*MemberFn)();

class bar
{
public:
  bar() : freeFn(NULL), memberFn(NULL) {}
  void operator()(foo* other)
  {
    if (freeFn != NULL) { freeFn(); }
    else if (memberFn != NULL) { ((other)->*(memberFn))(); }
    else { cout << "No function attached!" << endl; }
  }

  void setFreeFn(FreeFn value) { freeFn = value; memberFn = NULL; }
  void setMemberFn(MemberFn value) { memberFn = value; freeFn = NULL; }
private:
  FreeFn freeFn;
  MemberFn memberFn;
};

class foo
{
public:
  bar myBar;
  void hello() { cout << "foo::hello()" << endl; }
  void operator()() { myBar(this); }
};

void bye() { cout << "bye()" << endl; }

int main()
{
  foo testFoo;

  testFoo();

  testFoo.myBar.setMemberFn(&foo::hello);
  testFoo();

  testFoo.myBar.setFreeFn(&bye);
  testFoo();

  return 0;
}

Sympa, mais comment faire pour exécuter la fonction qui memberFunctionPointer points? testFoo.myBar.*memberFuncionPointer() résultats d'erreur
J'ai ajouté un échantillon correct d'appeler les fonctions de ce temps.
Juste pour être complet, vous pouvez ajouter un constructeur par défaut pour bar pour définir à la fois des pointeurs vers 0. Vous pouvez configurer la classe afin de toujours, a un seul ensemble de membres (c'est à dire le réglage de l'un des membres 0s l'autre), puis en ajouter une operator() fonction qui appelle l'ensemble des membres. Mais ça va être plus compliqué que celui de la fin.

InformationsquelleAutor Bill

8

Que le message d'erreur indique, les méthodes appartiennent à la classe, et non pas à des instances individuelles. Pour cette raison, les pointeurs de fonctions libres et des pointeurs vers des non-méthodes statiques sont des choses complètement différentes. Vous aurez également besoin d'une instance à l'appel de la méthode sur.
```
//declaring and taking the address of a foo's method 
void (foo::*method)() = &foo::hello; //as the compiler nicely suggests

//calling a function through pointer
free_func();

//calling a method through pointer
foo instance;
(instance.*method)();
```
Vous pouvez utiliser des bibliothèques comme Coup de pouce.Lier et Coup de pouce.La fonction (aussi dans le std::tr1 je pense) de faire abstraction de la différence et aussi lier un exemple de la méthode:
```
#include <iostream>
#include <boost/bind.hpp>
#include <boost/function.hpp>

using namespace std;

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

void byebye()
{
    cout << "bye" << endl;
}


int main()
{
    foo testFoo;

    boost::function<void()> helloFunc(boost::bind(&foo::hello, testFoo));
    boost::function<void()> byeFunc(byebye);

    helloFunc();
    byeFunc();
    return 0;
}
```
- Pourrait s'il vous plaît expliquer comment faire fonctionner le "hello()" de l'testFoo.myBar? Je n'ai 'testFoo.myBar.funcP = &foo::bonjour;' mais '(testFoo.myBar.*funcP) (); "revient", funcP n'a pas été déclarée... " lors de la compilation
InformationsquelleAutor UncleBens
0

Pour faire de votre deuxième option travail, déclarer foo ainsi, le compilateur sait que c'est une classe.

Notez également que votre pointeur de fonction syntaxe est incorrecte. Le * vient juste avant le nom de la variable:
```
class foo;

class bar
{
public:
    void (foo::*funcP)();
};
```
InformationsquelleAutor R Samuel Klatchko
0

avant foo déclaration à l'avant de la barre:
```
class foo;
```
InformationsquelleAutor Andrey

Vous devez vous connecter pour publier un commentaire.