C++: la fonction passe en tant que paramètre à une autre fonction

Question

je suis exécute actuellement un arbre binaire en C++ et je veux traverser avec une fonction appelée in_order().

est-il possible de passer une fonction comme argument, afin que je puisse faire des choses comme ci-dessous (sans avoir à écrire le code pour parcourir la liste plus d'une fois)?

struct tree_node; // and so on 
class tree;  // and so on 

void print_node() { 
    // some stuff here 
} 

// some other functions 

tree mytree(); 

// insert some nodes 

mytree.in_order(print_node); 
mytree.in_order(push_node_to_stack); 
mytree.in_order(something_else); 

Answer 1

Oui, vous pouvez le faire de plusieurs façons. Voici deux possibilités communes.

pointeurs de fonction de style ancien

class mytree 
{ 
    // typedef for a function pointer to act 
    typedef void (*node_fn_ptr)(tree_node&); 

    void in_order(node_fn_ptr) 
    { 
     tree_node* pNode; 

     while (/* ... */) 
     { 
     // traverse... 
     // ... lots of code 

     // found node! 
      (*fnptr)(*pNode); 
      // equivalently: fnptr(*pNode) 
     } 
    } 
}; 

void MyFunc(tree_node& tn) 
{ 
    // ... 
} 

void sample(mytree& tree) 
{ 
    // called with a default constructed function: 
    tree.inorder(&MyFunc); 
    // equivalently: tree.inorder(MyFunc); 
} 

En utilisant foncteurs

Avec un membre de modèle, fonctionne avec des pointeurs de fonction

class mytree 
{ 
    // typedef for a function pointer to act 
    typedef void (*node_fn_ptr)(tree_node&); 

    template<class F> 
    void in_order(F f) 
    { 
     tree_node* pNode; 

     while (/* ... */) 
     { 
     // traverse... 
     // ... lots of code 

     // found node! 
      f(*pNode); 
     } 
    } 
}; 

struct ExampleFunctor 
{ 
    void operator()(tree_node& node) 
    { 
     // do something with node 
    } 
} 

void sample(mytree& tree) 
{ 
    // called with a default constructed function: 
    tree.inorder(ExampleFunctor()); 
} 

Answer 2

Oui, vous pouvez utiliser un pointeur de fonction en tant que paramètre à in_order. Vous pouvez également avoir besoin de le surcharger, au cas où les signatures des fonctions passées ne correspondent pas. Pour les fonctions comme print_node, déclarent in_order comme celui-ci (à condition que son type de retour est void aussi bien):

void tree::in_order(void (*)()) 
{ 
    //implementation 
} 

Answer 3

Je pense que vous devriez utiliser le modèle des visiteurs à la place.

http://en.wikipedia.org/wiki/Visitor_pattern

La classe des visiteurs de base devrait avoir une méthode virtuelle pour fonctionner sur un nœud. Passez le visiteur en argument à votre méthode in_order. Puis dérivez votre visiteur autant de fois que vous le souhaitez pour toute opération que vous voulez faire.