Les fonctions C peuvent-elles être surchargées uniquement sur la base de la constance d'un argument sans pointeur et sans référence ?

Surcharge de fonctions avec des arguments Const

En C , la surcharge de fonctions nous permet de définir plusieurs fonctions portant le même nom mais avec des types d'arguments différents ou Nombres. Cependant, il existe des limites à la surcharge basées sur la constance des arguments.

Considérez le code donné :

#include <iostream>
using std::cout;

class Test {
public:
    Test() {}
    int foo(const int) const;
    int foo(int);
};

int main() {
    Test obj;
    Test const obj1;
    int variable = 0;
    do {
        obj.foo(3);                           // Call the const function
        obj.foo(variable);                 // Attempt to call the non-const function
        variable++;
        usleep(2000000);
    } while (1);
}

int Test::foo(int a) {
    cout << "NON CONST" << std::endl;
    a++;
    return a;
}

int Test::foo(const int a) const {
    cout << "CONST" << std::endl;
    return a;
}

Ce code tente de surcharger la fonction foo en fonction de la constance de l'argument. Cependant, le compilateur génère une erreur indiquant que la fonction ne peut pas être surchargée.

Explication

En C , surcharge de fonctions basée uniquement sur la constance d'un non-pointeur, Les arguments de type non-référence ne sont pas autorisés. En effet, le compilateur ne peut pas faire la différence entre les deux fonctions en fonction de la constance de la valeur transmise par valeur.

Dans le code donné, les deux versions de foo reçoivent un entier par valeur. Lorsque l'argument est passé par valeur, une copie de la variable est créée et la constance du paramètre formel n'affecte pas la valeur de la copie.

Par conséquent, le compilateur n'a aucun moyen de déterminer quelle version de foo à appeler si un entier non const est transmis par valeur. Cette ambiguïté viole l'interdiction de surcharge des fonctions avec la même signature.

Approche alternative

Pour obtenir le comportement souhaité, une approche alternative peut être utilisée. Une option consiste à utiliser le passage par référence avec une constance explicite, comme indiqué ci-dessous :

int foo(const int& a);
int foo(int& a);

Avec cette approche, le compilateur peut faire la distinction entre les deux fonctions en fonction de la constance de la référence, permettant une bonne surcharge.

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!