Norme : Fonctions libres et méthodes

**jblecanard** · 08/04/2010, 15h29

Bonjour à tous

comme vous le savez, on peut posséder des méthodes qui possèdent le même nom que des fonctions libres. Et dans ce cas, l'opérateur unaire "::" permet de lever l'ambiguité.

Je me demandais juste ce que disait la norme à ce sujet : lorsque ni this ni :: ne sont utilisés lors de l'appel, est ce qu'il s'agit de la méthode par défaut, ou s'agit-il d'un comportement indéterminé ?

J'avoue, j'ai essayé de chercher tout seul dans la norme et je n'ai pas trouvé.

**koala01** · 08/04/2010, 16h42

Salut,

Au sein d'une fonction membre, l'utilisation de this est implicite.

Si une fonction libre a exactement le même nom qu'une fonction membre et qu'elle prend exactement les mêmes paramètres, ce sera donc la fonction membre qui sera appelée, exactement comme si on avait invoqué this->laFonction.

Dans une fonction non membre, le problème ne se pose pas vraiment, car tu appellera généralement la fonction membre... depuis un objet, à moins que ce ne soit une fonction statique, auquel cas, tu l'invoquera depuis... le type lui-même:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
int main()
{
     T1 truc;
     foo(truc); // appel de la fonction libre
     Type machin;
     machin.foo(truc); // appel de Type::foo (fonction membre classique)
     Type::foo(truc); // appel de Type::foo (fonction statique)
}

**white_tentacle** · 08/04/2010, 17h05

Envoyé par koala01

Si une fonction libre a exactement le même nom qu'une fonction membre et qu'elle prend exactement les mêmes paramètres, ce sera donc la fonction membre qui sera appelée, exactement comme si on avait invoqué this->laFonction.

Il me semble que c'est plutôt :
- s'il existe une fonction membre dont la signature est compatible avec l'appel, c'est elle qui sera appelée, sinon, on cherche une fonction libre compatible.

Ce qui est assez cohérent : supposons le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
void f(double d)
{
        std::cout << "::f" << std::endl;
}
 
class A
{
    public:
        A() {};
        void f(int a) { std::cout << "A::f" << std::endl; }
        void g() { return f(1.2); }
};

On imagine mal que, suivant si ::f(double) est déclarée (ce qui est dépendant des fichiers d'en-tête inclus), g appelle tantôt A::f, tantôt ::f -> on aurait une grosse incohérence dans la définition de la fonction, qui ne serait pas partout la même (théoriquement possible puisqu'inlinée). C'est donc bien toujours A::f qui est appelée, puisque 1.2 est implicitement convertible en int.