Passstreng som referanse i C ++

C ++ -referansen er et navn for en variabel som allerede eksisterer. En referanse til en variabel kan ikke endres for å referere til den andre variabelen når den er initialisert. Pekere eller referanser kan sendes som parametere til funksjoner i C++. Dermed er utfallet identisk under begge omstendigheter. Passering med referanse gjør det mulig for en funksjon å oppdatere en variabel uten å opprette en kopi. Vi må erklære referansevariabler slik at parameteren og variabelen sendes for å dele samme minneplassering. Eventuelle endringer som skjer i parameteren påvirker også variabelen.

Ved hjelp av eksempler vil vi forstå C ++ som passerer med referansetilnærming og hvordan vi kan gi pekere som argumenter til funksjoner i denne artikkelen. Parametrene som er gitt for å fungere som pekere er de samme som enhver annen verdi når du passerer en verdi som referanse. Som et resultat må du oppgi pekertyper for funksjonsargumentene, som i SWAP () -funksjonen, som bytter verdiene til forskjellige heltallvariabler adressert av deres argumenter.

Eksempel 1: PROGRAM FOR PASSING PÅ REFERANSE Uten pekere i C++

Her passerer vi en verdi som referanse uten å bruke pekerdeklarasjonen. Nedenfor er illustrasjonsprogrammet for å sende en variabel som referanse.

Til å begynne med har vi inkludert overskriftsfilene for programgjennomføringen i overskriftsdelen. I neste trinn har vi en funksjonsdefinisjon for å bytte verdier. Funksjonen får et navnbytte, og funksjonen tar to strengvariable referanser som en parameter. Strengvariablene Byttefunksjonen vil gjelde er definert som “Str1” og “Str2” referansestrenger.

Deretter, i funksjonen, opprettet vi en variabel "temp", som vi passerte variabelen "Str1". Etter det blir “Str2” tilordnet “Str1”, og deretter “STR2” har “STR2”. På denne måten brukes byttealgoritmen på referansestrengen.

Vi har vår hovedfunksjon der to strenger er erklært som "str_a" og "str_b" og initialisert med noen strengverdier. Strengverdiene vil bli skrevet ut før byttefunksjonen blir brukt. Deretter har vi påkalt byttefunksjonen i hovedfunksjonen og passert strengen som er definert i hovedfunksjonen. Etter det vil den byttede strengen bli skrevet ut.

#inkludere
ved hjelp av navneområdet STD;
void Swap (String & Str1, String & Str2)
streng temp;
temp = str1;
str1 = str2;
str2 = temp;

int main ()

String str_a = "c ++", str_b = "programmering";
cout<< "Strings Before swapping" <cout<< "string 1 : " <cout<< "String 2 : " <Swap (str_a, str_b);
cout<< "\nStrings After swapping" <cout<< "string 1 : " <cout<< "string 2 : " <retur 0;

Utfallet viser strengen før bytting og etter å ha byttet gjennom referansestrengen som er passert i funksjonen.

Eksempel 2: PROGRAM FOR PASSING PÅ REFERANSE MED POKTERER I C++

Som i det foregående eksemplet har vi bare sett den forbipasserende strengen med referanse. Derfor bruker vi pekere som referanse i C ++ i dette eksemplet.

Programmet begynner med å lage en funksjon som er representert med navnet "SwapString" og passerer to-pekerstrenger som et argument. Deretter har vi kalt programmets hovedfunksjon. I hovedfunksjonen heter de to strengene henholdsvis “Str1” og “Str2”. Disse strengvariablene initialiseres med ordens streng.

Deretter har vi kalt funksjonen "SwapString", som strengvariabler “Str1” og “Str2” -adresser blir bestått. Strengene vil bli byttet i denne funksjonsdefinisjonen i hovedfunksjonen og trykt. Etter det har vi kalt funksjonen "SwapString" utenfor hovedfunksjonen for å bytte de spesifiserte strengene.

#inkludere
ved hjelp av navneområdet STD;
void swapString (streng*, streng*);
int main ()

String str1 = "hallo", str2 = "venner";
cout<< "Strings Before swapping" <cout<< "Str1 = " << str1 <cout<< "Str2 = " << str2<SwapString (& str1, & str2);
cout<< "\nStrings After swapping" <cout<< "str1 = " << str1 <cout<< "str2 = " << str2 <retur 0;

void swapString (streng* s1, streng* s2)
streng temp;
temp = *s1;
*S1 = *S2;
*s2 = temp;

Derfor vises resultatene av passerende strengreferanser med pekere i følgende grafikk.

Eksempel 3: Program for å passere strengobjekt som referanse i C++

Selv om en funksjon ikke får endre kildestrengobjektet i anropsprogrammet, er det ganske vanlig å passere C ++ strengobjekter via referanse. Objekter er vanligvis ganske store, og det kan derfor være kostbart sammenlignet med mengden lagring de bruker og tiden som er nødvendig for å konstruere en klone av dem når de passerer dem etter verdi. Så generelt lagrer passeringsobjekter ved referanse både minne og tid.

Den eneste ulempen med å gi et objekt via referanse er at det kan endre kildeobjektet som ble gitt til funksjonen. Som ikke er ønsket. Hvis vi ikke vil oppdatere et objekt i funksjonen, vil vi foretrekke å gjøre det vanskelig.

Vi har en funksjonsdefinisjon i følgende program som "InputString", som vi passerte strengreferanse. Deretter har vi erklært et strengobjekt “Mystr” i hovedfunksjonen, og objektstrengen “Mystr” inneholder en streng av et ord.

Etter det kalte vi en "inputstring" og ga dette strengobjektet inn i det. Vi har en funksjonsdefinisjon "InputString" utenfor hovedfunksjonen, som oppretter en ny strengobjektreferanse fra “Mystr”. Den nye strengen er definert som "NewsTR" og deretter initialisert i funksjonens kropp. Vi har endret objektstrengen “NewsTr” og skrevet ut det nye strengobjektet.

#inkludere
#inkludere
bruker std :: cout;
bruker std :: endl;
bruker std :: streng;
void inputString (String &);
int main ()

String mystr = "wel";
cout<< "String value: " <InputString (Mystr);
cout<< "String value now :" <retur 0;

void inputString (String & NewsTR)

cout<< "String value in function :" <NewsTr = NewsTr + "Come";
cout<< "String value now in function :" <

Grafikken nedenfor representerer de resulterende strengverdiene til kildestrengen og endret streng.

Eksempel 4: Program for å passere et konstant strengobjekt som referanse i C++

Kompilatoren vil kaste en feil hvis en referanse sendes til det konstante objektet. Vi kan takle dette problemet ved å bruke en konstant variabel referanse. Dette forhindrer at variabelen som referansepunktene blir endret.

Først har vi funksjonsdefinisjonen "DisplayString", der en konstant strengreferanse sendes. De konstante strengene er definert og initialisert i hovedfunksjonen som “STR1” og “STR2”. Etter det, pass disse konstante strengene til funksjonen “InputString”. Påkalte funksjonen utenfor hovedfunksjonen der vi har erklært en konstant strengvariabel “Mystr”.

#inkludere
#inkludere
bruker std :: cout;
bruker std :: endl;
bruker std :: streng;
tomrom displayString (const string &);
int main ()

const string str1 = "Infinix";
String str2 = "iPhone";
cout<< "str1 :" << str1 <DisplayString (STR1);
cout<< "str2 : " << str2 <DisplayString (STR2);
retur 0;

Void DisplaysString (Const String & Mystr)

cout<< "MyStr : " <

Et ikke-konstant objekt sendes til en funksjon gjennom en konstant objektreferanse. Så vi får ingen kompilasjonsfeil i koden.

Konklusjon

Referanser gjør det mulig for en funksjon å påvirke verdien av et argument, som kan være fordelaktig i noen situasjoner. Const referanser derimot, sørg for at funksjonen ikke endrer argumentet. Dermed har vi konkludert med artikkelen her med eksemplets demonstrasjon i C ++ og håper det kan være nyttig.