Comment résoudre l'ambiguïté lors du passage de pointeurs de fonction surchargés en C ?

Pointeurs de fonction surchargés en C

En C , une fonction surchargée est une fonction avec plusieurs implémentations avec des signatures différentes. Lorsqu'une fonction surchargée est transmise à un algorithme générique, il peut être difficile de spécifier quelle implémentation doit être utilisée.

Considérons l'exemple suivant :

class A {
    void f(char c);
    void f(int i);

    void scan(const std::string& s) {
        std::for_each(s.begin(), s.end(), f); // Overloaded function passed to 'for_each'
    }
};

Ici, nous avons une classe A avec deux fonctions membres surchargées nommées f qui prennent respectivement un char et un int comme paramètres. La fonction membre scan de A tente d'utiliser l'algorithme for_each pour parcourir une chaîne, en appelant la fonction f pour chaque caractère.

Problème :

Cependant, le compilateur ne peut pas déterminer automatiquement quelle implémentation de f doit être utilisée lorsqu'elle est transmise à std::for_each. En effet, l'algorithme attend un pointeur de fonction avec une signature spécifique et les signatures de fonction surchargées ne peuvent pas être distinguées les unes des autres en fonction du type de pointeur de fonction générique.

Solution :

Pour spécifier quelle surcharge de f utiliser, nous pouvons utiliser l'une des techniques suivantes :

1. Casting statique avec signature de fonction :

Nous pouvons utiliser static_cast<>() pour convertir le pointeur de fonction vers la signature spécifique requise par std::for_each:

// Uses the void f(char c); overload
std::for_each(s.begin(), s.end(), static_cast<void (*)(char)>(f));

// Uses the void f(int i); overload
std::for_each(s.begin(), s.end(), static_cast<void (*)(int)>(f));

2. Déclaration de pointeur de fonction :

Alternativement, nous pouvons déclarer des pointeurs de fonction avec la signature souhaitée et les attribuer à la fonction surchargée :

void (*fpc)(char) = &A::f; // Function pointer for void f(char c)
std::for_each(s.begin(), s.end(), fpc); // Uses the void f(char c); overload

void (*fpi)(int) = &A::f; // Function pointer for void f(int i)
std::for_each(s.begin(), s.end(), fpi); // Uses the void f(int i); overload

Pour les fonctions membres (facultatif) :

Si la fonction surchargée est une fonction membre, l'utilitaire mem_fun peut être utilisé, ou la solution fournie dans le L'article lié du Dr Dobb peut être utilisé pour spécifier la surcharge souhaitée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!