Norme et surcharge

Les fonctions doivent varier d'au - un des éléments :
=> le type d'un des paramètres (const/volatile font partis du type - enfin, les plus 'enfouis' pour reprendre le terme de la norme, c'est à dire que celui le plus à droite est ignoré)
=> le nombre de paramètres
=> const/volatile (pour lequel on pourrait par analogie dire qu'il s'agit d'une variation du type du paramètre implicite this)
=> le namespace (pour les fonctions libres)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct s
{
void f(int);
void f(int &);
void f(int const &);
void f(int) const;
void f(int &) const;
void f(int const &) const;
void f(int)volatile;
void f(int &)volatile;
void f(int const &)volatile;
void f(int) volatile const;
void f(int &) volatile const;
void f(int const &) volatile const;
// et il doit m'en manquer
};

typedef n'est pas un type différent.

Code:

1
2
3
typedef int MyInt;
void f(int);
void f(MyInt); // pas une surcharge

Ceci dit d'autres phénomènes peuvent venir perturber : masquage, fonction virtuelle, fonction statique, template, arguments par défaut

Code:

1
2
3
4
5
6
7
8
struct s
{
static void f();
void f(); //erreur à cause de static
void f() const; // erreur à cause de static
 
void f(int ); // OK un paramètre différent 
};

Code:

1
2
3
4
void f(); // 1
void f(int =0); // 2 Ceci est bien une surcharge mais :
f(1); // OK => appel 2
f(); // => KO appel ambigüe

Code:

1
2
3
4
5
void f(int ); // 
void f(int const);// Ceci n'est pas une surcharge
void f(int volatile);// Ceci n'est pas une surcharge
void f(int const &); // Ceci est bien une surcharge mais :
f(1); // KO appel ambigue

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
void f(int ); // 1
namespace
{
    void f(int); //2
    void dummy ()
    {
        f(2); // Appel de 2
        ::f(1); // Appel de 1
    }
}
 
namespace d
{
    void f(int); // 3
    void dummy ()
    {
        f(3); // appel de 3
        ::f(1);// appel de 1
    }
}
 
 
int main()
{
    ::f(1); // appel de 1
    f(0); // Erreur => appel ambigue
    dummy();
    d::f(3);
    d::dummy();
   return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
void f( ); // 1
namespace
{
    void f(int); //2
    void dummy()
    {
        f(2);
        f(); // erreur //1 est masquée
        ::f(); // ok
    }
}
int main()
{
    f(); // ok 1
    f(2); // ok 2
 
return 0;
}

Je pense qu'il y a matière à un tuto au - aussi long que celui sur les fonctions virtuelles :aie: