Pourquoi les fonctions C ne peuvent-elles pas ê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 : pourquoi cela ne peut pas être fait

En C, la surcharge d'une fonction permet plusieurs fonctions portant le même nom mais différentes listes de paramètres pour coexister au sein d’une classe. Cependant, on ne peut pas surcharger les fonctions uniquement sur la base de la constance d'un paramètre sans pointeur et sans référence.

Considérez l'exemple de code suivant :

#include <iostream>
using std::cout;

class Test {
public:
    Test() {}
    int foo(const int) const;    // const function
    int foo(int);                // non-const function
};

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;
}

Comme le montre le code, nous essayez de surcharger la méthode foo en fonction de la constance de l'argument : une version const qui accepte les arguments const et une version non const qui accepte les arguments non const. Cependant, ce code entraînera une erreur de compilation indiquant que la fonction ne peut pas être surchargée.

Cette erreur survient car C n'autorise pas la surcharge basée uniquement sur la constance d'un type sans pointeur et sans référence. La raison en est que lors du passage d'un argument de valeur, l'argument réel est copié dans une variable temporaire à l'intérieur de la fonction appelée. Cette copie est distincte de l'argument d'origine, et sa constance n'affecte pas la constance de l'argument d'origine.

Par conséquent, dans l'exemple ci-dessus, lors de l'appel de obj.foo(3), une copie temporaire du littéral 3 est créé et il est transmis à la fonction const. De même, lors de l'appel de obj.foo(variable), une copie temporaire de la variable est créée et transmise à la fonction non const. Le compilateur ne peut pas faire la différence entre ces deux cas en se basant uniquement sur la constance de l'argument.

En résumé, la surcharge de fonctions basée sur la constance d'un type sans pointeur et sans référence n'est pas autorisée en C . En effet, la constance d'un argument de valeur n'affecte pas la constance de l'argument à l'intérieur de la fonction, et le compilateur ne peut pas faire la distinction entre les deux en fonction du seul type d'argument.

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!