Que signifie « int & foo() » en C++ ?

Question

Lors de la lecture de cette explication sur lvalues et rvalues, ces lignes de code collé à moi:

int& foo();
foo() = 42; // OK, foo() is an lvalue

Je l'ai essayé dans g++, mais le compilateur dit "undefined reference to foo()". Si j'ajoute

int foo()
{
  return 2;
}

int main()
{
  int& foo();
  foo() = 42;
}

Il compile bien, mais l'exécution, il donne une erreur de segmentation. Juste la ligne

int& foo();

par lui-même à la fois compile et s'exécute sans problème.

Que fait ce code signifie? Comment pouvez-vous attribuer une valeur à un appel de fonction, et pourquoi n'est-il pas une rvalue?

Answer 1

L'explication est en supposant qu'il est raisonnable de mise en œuvre pour l' foo qui renvoie une lvalue référence à un valide int.

Une telle mise en œuvre pourrait être:

int a = 2; //global variable, lives until program termination

int& foo() {
    return a;
} 

Maintenant, depuis foo renvoie une lvalue de référence, nous pouvons attribuer quelque chose à la valeur de retour, comme suit:

foo() = 42;

Cela permettra de mettre à jour le global a avec la valeur 42, ce qui nous permet de vérifier en accédant à la variable directement ou en appelant foo nouveau:

int main() {
    foo() = 42;
    std::cout << a;     //prints 42
    std::cout << foo(); //also prints 42
}

Answer 2

Toutes les autres réponses déclarer une statique à l'intérieur de la fonction. Je pense que cela pourrait vous confondre, afin de prendre un coup d'oeil à ceci:

int& highest(int  & i, int  & j)
{
    if (i > j)
    {
        return i;
    }
    return j;
}

int main()
{
    int a{ 3};
    int b{ 4 };
    highest(a, b) = 11;
    return 0;
}

Parce qu' highest() renvoie une référence, vous pouvez lui affecter une valeur. Lorsque cela fonctionne, b sera changé à 11. Si vous avez changé l'initialisation de sorte qu' a a été, disons, 8, a serait changé à 11. C'est un code qui pourrait en fait servir un but, contrairement aux autres exemples.

Answer 3

int& foo();

Déclare une fonction nommée foo qui retourne une référence à un int. Ce que les exemples ne parvient pas à faire est de vous donner une définition de cette fonction que vous pouvez compiler. Si nous utilisons

int & foo()
{
    static int bar = 0;
    return bar;
}

Maintenant, nous avons une fonction qui retourne une référence à l' bar. depuis le bar est static il continuera à vivre après l'appel à la fonction afin de retourner une référence, c'est sûr. Maintenant, si nous ne

foo() = 42;

Ce qui se passe est que nous attribuer 42 bar depuis que nous assignons à la référence et la référence est juste un alias pour bar. Si nous appelons la fonction de nouveau comme

std::cout << foo();

Il serait d'imprimer 42 depuis que nous avons mis bar à celui ci-dessus.

Answer 4

int &foo(); déclare une fonction appelée foo() avec le type de retour int&. Si vous appelez cette fonction sans fournissant un corps, alors vous êtes susceptible d'obtenir une référence non définie à l'erreur.

Dans votre deuxième tentative, vous fourni une fonction int foo(). Cela a un autre type de retour de la fonction déclarée en int& foo();. Vous avez donc deux déclarations du même foo qui ne correspondent pas, ce qui viole l'Une Définition de la Règle provoquant un comportement indéterminé (pas de diagnostic requis).

Pour quelque chose qui fonctionne, prendre le local de la déclaration de la fonction. Ils peuvent conduire à silencieux comportement indéfini comme vous l'avez vu. Au lieu de cela, utilisez uniquement les déclarations de fonction en dehors de toute fonction. Votre programme pourrait ressembler à:

int &foo()
{
    static int i = 2;
    return i;
}  

int main()
{
    ++foo();  
    std::cout << foo() << '\n';
}

Answer 5

est une fonction retournant une référence à . Votre fonction fournie retourne `` sans référence.

Vous pouvez le faire