Référence de retour en C++

C++ offre la possibilité de renvoyer une valeur ou une adresse par sa référence plutôt que par des pointeurs. L’utilisation de références au lieu de pointeurs peut simplifier la lecture et la gestion d’un programme C++. En C++, les références et les pointeurs sont étroitement liés les uns aux autres. La principale distinction est que, bien que les références soient simplement un nom alternatif, un « alias » pour une autre variable, les pointeurs peuvent être utilisés dans des opérations telles que l'ajout de valeurs. Une référence est un nom alternatif ou une copie de la valeur d'origine et est indiquée par le symbole & .

Exemple 1:

Nous importons le fichier d'en-tête « iostream », puis utilisons l'espace de noms « std ». Les fichiers d'en-tête sont importés dans les codes C++ car de nombreuses fonctions sont définies. Ensuite, nous créons une fonction de référence de retour en plaçant le symbole « & » avec le nom de la fonction, « returnTheValue ».

Ici, la référence « valeur » est maintenant insérée. En dessous, nous imprimons la valeur et l'adresse avec la référence « &value ». Ensuite, nous plaçons la référence de retour et plaçons la « valeur ». Maintenant, le « main() » est invoqué ici, et nous initialisons « n1 » avec la valeur « 44 ». En dessous, « int& n2 » est initialisé avec « returnTheValue(n1) ». Maintenant, nous imprimons la valeur de « n1 » ainsi que son adresse. Ensuite, nous imprimons la valeur de « n2 » ainsi que l'adresse de « n2 » en utilisant le « cout ».

Codage 1 :

Sortir:

Ici, nous pouvons noter qu'une référence n'est qu'un nom alternatif d'une autre variable, comme indiqué dans ce qui suit. En tant qu'adresse de valeur, « n1 » et « n2 » ne changent jamais.

Exemple 2 :

Nous utilisons l'espace de noms « std » après avoir importé le fichier d'en-tête « iostream ». Ensuite, nous utilisons le nom de la fonction « MyReturnValueFunc » et le symbole « & » pour créer une fonction de référence de retour. La référence à la variable « v1 » est placée ici. Nous imprimons la valeur et l'adresse avec la référence « &v1 » en dessous. Ensuite, nous insérons la « référence de retour » en utilisant « return » et « v1 » à cet emplacement. Ici, « main() » est appelé et « num_1 » est initialisé avec la valeur « 19 ». L'initialisation de « int& num_2 » se fait avec « MyReturnValueFunc(num_1) ».

Actuellement, nous imprimons la valeur et l'adresse de « num_1 » et, en utilisant « cout », nous imprimons la valeur et l'adresse de « num_2 ». Nous modifions maintenant la valeur de « num_1 » en utilisant l'adresse renvoyée ici par « MyReturnValueFunc ». Cette fonction renvoie le nom alternatif de « v1 » qui est également le nom alternatif de « num_1 ». Nous modifions donc sa valeur et la définissons sur « 91 ». Nous attribuons « 91 » à « MyReturnValueFunc(num_1) » qui fait ici office d'alias. Ensuite, nous imprimons à nouveau la valeur et l'adresse de « num_1 ».

Code 2 :

Sortir:

Comme démontré dans ce qui suit, nous pouvons voir qu'une référence est simplement un nom alternatif pour une autre variable puisque l'adresse des valeurs « v1 », « num_1 » et « num_2 » est restée constante :

Exemple 3 :

Le fichier d'en-tête « iostream » est importé et l'espace de noms « std » est utilisé. Puisque de nombreuses fonctions sont spécifiées dans les fichiers d’en-tête, nous les importons dans les codes C++. Ici, on crée une fonction « ReturnRefFun() » dans laquelle on place « int& my_ref » qui renvoie la référence. Le « int& ReturnRefFun » est déclaré ici comme fonction de référence. Après cela, nous incrémentons la valeur de la variable « my_ref ». En dessous, on met « return » qui renvoie la référence de « my_ref ».

Après cela, la méthode « main() » est invoquée ici. Ensuite, nous initialisons la variable « first_value » avec « 21 ». En dessous, nous renvoyons la copie de la référence en plaçant « first_value » dans la fonction « ReturnRefFun » et la sauvegardons dans la variable « copied_value ». Ensuite, nous imprimons à la fois la « first_value » ainsi que la « copied_value » en utilisant le « cout ». En dessous, nous incrémentons la variable « copied_value » en plaçant le « copied_value++ ». Ensuite, nous imprimons la « copied_value » après l'avoir incrémentée et la « first_value » en utilisant « cout ». Après cela, nous renvoyons la référence en initialisant la variable « int& ref_value » avec « ReturnRefFun(first_value) ».

Après cela, nous imprimons la valeur de la variable « my_ref » que nous avons copiée. Ensuite, nous imprimons la valeur de la variable « first_value ». En dessous, nous incrémentons la valeur de « ref_value » en mettant « ref_value++ ». En dessous, nous imprimons la valeur incrémentée de « ref_value » ainsi que la variable « first_value » à l'aide de « cout ». Lorsque la « ref_value » est modifiée, la « first_value » changera également.

Code 3 :

Sortir:

Voici le résultat du code précédent où nous avons utilisé la technique du « retour de référence ». L'exemple montre la distinction entre renvoyer un double de la variable de référence et renvoyer la variable de référence elle-même.

Exemple 4 :

Ici, « int& rByRef » est déclaré comme fonction de référence qui renvoie la variable de référence. Nous passons les « int& data » à cette fonction « int& rByref() ». Ici, nous imprimons l'adresse de la variable « data », puis utilisons la référence de retour en dessous. Maintenant, nous initialisons la variable « x_var » après avoir invoqué la méthode « main() ». Ensuite, nous imprimons ici l'adresse de « x_var » en mettant le « &x_var » dans le « cout ».

En dessous, nous utilisons la variable de référence en attribuant « rByref(x_var) » au « int& y_var ». Ensuite, nous imprimons également l'adresse de cette variable de référence « &y_var ». En dessous, nous copions la variable « x_var » dans la variable « z_var » et imprimons également l'adresse de cette variable copiée qui est « &z_var ». Après cela, nous appelons la fonction « rByref() », passons la variable « x_var » comme paramètre à l'intérieur et attribuons « 93 » à cette variable. Nous restituons également l'adresse du « x_var » en mettant le « &x_var » dans le « cout ».

Code 4 :

Sortir:

Le résultat montre clairement que l’adresse de la variable clonée, « z_var », diffère de tous les autres emplacements auxquels la variable d’origine, « x_var », fait référence.

Conclusion

Le concept de « référence de retour » est exploré en détail dans ce didacticiel. Nous avons appris que la « référence de retour » est similaire aux « pointeurs » de la programmation C++. Nous avons expliqué que pour indiquer quelle fonction renvoie une référence, le symbole « & » doit être utilisé avec le type de retour de la fonction. Nous avons illustré quelques exemples et leurs résultats et compris ce concept dans ce tutoriel.