Passer la chaîne par référence en C ++

La référence C ++ est un nom pour une variable qui existe déjà. Une référence à une variable ne peut pas être modifiée pour faire référence à l'autre variable une fois initialisé. Les pointeurs ou références peuvent être transmis comme paramètres aux fonctions en C++. Ainsi, le résultat est identique dans les deux circonstances. Le passage par référence permet à une fonction de mettre à jour une variable sans créer de copie. Nous devons déclarer des variables de référence afin que le paramètre et la variable soient passés pour partager le même emplacement de mémoire. Toutes les modifications qui se produisent dans le paramètre affectent également la variable.

Avec l'aide d'exemples, nous comprendrons que C ++ passant par une approche de référence et comment fournir des pointeurs comme arguments aux fonctions dans cet article. Les paramètres transmis pour fonctionner comme des pointeurs sont les mêmes que toute autre valeur lors de la réussite d'une valeur par référence. En conséquence, vous devez fournir des types de pointeurs pour les arguments de fonction, comme dans la fonction swap (), qui échange les valeurs de diverses variables entières abordées par leurs arguments.

Exemple 1: Programme de passage par référence sans pointeurs en C++

Ici, nous passons une valeur par référence sans utiliser la déclaration du pointeur. Vous trouverez ci-dessous le programme d'illustration pour passer une variable par référence.

Initialement, nous avons inclus les fichiers d'en-tête de l'implémentation du programme dans la section d'en-tête. À l'étape suivante, nous avons une définition de fonction pour l'échange de valeurs. La fonction reçoit un échange de nom, et la fonction prend deux références de variable de chaîne en tant que paramètre. Les variables de chaîne que la fonction d'échange s'appliquera sont définies comme des chaînes de référence «STR1» et «STR2».

Ensuite, dans la fonction, nous avons créé une «température» variable, que nous avons passé la variable «STR1». Après cela, le «STR2» est affecté à «STR1», puis «STR2» a le «STR2». De cette façon, l'algorithme de swap est appliqué à la chaîne de référence.

Nous avons notre fonction principale où deux chaînes sont déclarées «str_a» et «str_b» et initialisées avec certaines valeurs de chaîne. Les valeurs de chaîne seront imprimées avant l'application de la fonction d'échange. Ensuite, nous avons invoqué la fonction d'échange dans la fonction principale et passé la chaîne définie dans la fonction principale. Après cela, la chaîne échangée sera imprimée.

#inclure
Utilisation de Namespace Std;
void swap (String & str1, string & str2)
chaîne temporaire;
temp = str1;
str1 = str2;
str2 = temp;

int main()

String str_a = "c ++", str_b = "programmation";
couter<< "Strings Before swapping" <couter<< "string 1 : " <couter<< "String 2 : " <swap (str_a, str_b);
couter<< "\nStrings After swapping" <couter<< "string 1 : " <couter<< "string 2 : " <retour 0;

Le résultat montre la chaîne avant d'échanger et après l'échange à travers la chaîne de référence passée dans la fonction.

Exemple 2: Programme de passage par référence avec des pointeurs en C++

Comme dans l'exemple précédent, nous n'avons vu la chaîne de passage que par référence. Par conséquent, nous utiliserons des pointeurs par référence en C ++ dans cet exemple.

Le programme commence par créer une fonction qui est représentée avec le nom «swapstring» et passe les chaînes à deux points comme argument. Ensuite, nous avons appelé la fonction principale du programme. Dans la fonction principale, les deux chaînes sont nommées respectivement «STR1» et «STR2»,. Ces variables de chaîne sont initialisées avec la chaîne de mots.

Ensuite, nous avons appelé la fonction «swapstring», auxquelles les variables de chaîne «STR1» et «STR2» sont passées. Les chaînes seront échangées dans cette définition de fonction dans la fonction principale et imprimée. Après cela, nous avons appelé la fonction «swapstring» en dehors de la fonction principale pour échanger les chaînes spécifiées.

#inclure
Utilisation de Namespace Std;
void swapstring (String *, String *);
int main()

String str1 = "Bonjour", str2 = "amis";
couter<< "Strings Before swapping" <couter<< "Str1 = " << str1 <couter<< "Str2 = " << str2<Swapstring (& str1, & str2);
couter<< "\nStrings After swapping" <couter<< "str1 = " << str1 <couter<< "str2 = " << str2 <retour 0;

void swapstring (String * s1, string * s2)
chaîne temporaire;
temp = * s1;
* S1 = * S2;
* s2 = temp;

Par conséquent, les résultats des références de chaîne de passage avec des pointeurs sont présentés dans le graphique suivant.

Exemple 3: Programme d'objet de chaîne passant par référence en C++

Même si une fonction ne peut pas modifier l'objet de chaîne source dans le programme d'appel, passer les objets de chaîne C ++ via la référence est assez courant. Les objets sont généralement assez importants, et donc il peut être coûteux par rapport à la quantité de stockage qu'ils utilisent et le temps nécessaire pour construire un clone d'entre eux lorsqu'ils les passent par valeur. Donc, généralement, passer des objets par référence économise à la fois la mémoire et le temps.

Le seul inconvénient de passer un objet par référence est qu'il peut modifier l'objet source qui a été transmis à la fonction. Ce n'est pas souhaité. Si nous ne voulons pas mettre à jour un objet dans la fonction, nous préférerions le rendre difficile.

Nous avons une définition de fonction dans le programme suivant comme «InputString», à laquelle nous avons passé la référence de chaîne. Ensuite, nous avons déclaré un objet de chaîne «mystr» dans la fonction principale et la chaîne d'objet «mystr» contient une chaîne d'un mot.

Après cela, nous avons appelé un «entrée» et passé cet objet de chaîne dedans. Nous avons une définition de fonction «InputString» en dehors de la fonction principale, ce qui crée une nouvelle référence d'objet de chaîne à partir du «mystr». La nouvelle chaîne est définie comme «newtr» puis initialisé dans le corps de la fonction. Nous avons modifié la chaîne d'objet «newstr» et imprimé le nouvel objet String.

#inclure
#inclure
Utilisation de std :: cout;
Utilisation de std :: endl;
Utilisation de Std :: String;
void inputString (String &);
int main()

String mystr = "wel";
couter<< "String value: " <InputString (MYSTR);
couter<< "String value now :" <retour 0;

void InputString (String & Newstr)

couter<< "String value in function :" <Newstr = newstr + "Come";
couter<< "String value now in function :" <

Le graphique ci-dessous représente les valeurs de chaîne résultantes de la chaîne source et de la chaîne modifiée.

Exemple 4: Programme de passage d'un objet de chaîne constant par référence en C++

Le compilateur lancera un défaut si une référence est transmise à l'objet constant. Nous pouvons aborder ce problème en utilisant une référence variable constante. Cela empêche la variable à laquelle les points de référence sont modifiés.

Tout d'abord, nous avons la définition de la fonction «DisplayString», où une référence de chaîne constante est transmise. Les chaînes constantes sont définies et initialisées dans la fonction principale comme «STR1» et «STR2». Après cela, passez ces chaînes constantes à la fonction «InputString». A invoqué la fonction en dehors de la fonction principale où nous avons déclaré une variable de chaîne constante «mystr».

#inclure
#inclure
Utilisation de std :: cout;
Utilisation de std :: endl;
Utilisation de Std :: String;
void displayString (const string &);
int main()

const string str1 = "infinix";
String str2 = "iPhone";
couter<< "str1 :" << str1 <DisplayString (STR1);
couter<< "str2 : " << str2 <DisplayString (STR2);
retour 0;

void displaystring (const string & mystr)

couter<< "MyStr : " <

Un objet non constant est transmis à une fonction par une référence d'objet constante. Nous n'obtenons donc aucune erreur de compilation dans le code.

Conclusion

Les références permettent à une fonction d'affecter la valeur d'un argument, qui peut être bénéfique dans certaines situations. Const références, en revanche, s'assurer que la fonction ne change pas l'argument. Ainsi, nous avons conclu l'article ici avec l'exemple de démonstration en C ++ et espérons que cela pourrait être utile.