C++ Oproep op adres en oproep op referentie

C++ is een flexibele programmeertaal voor algemene doeleinden. Het is oorspronkelijk gemaakt door Bjarne Stroustrup, een Deense computerwetenschapper, in 1985. C++ ondersteunt drie-parameter passeermethoden, i.e., bel op waarde, bel op adres en bel op referentie. In dit artikel gaan we het hebben over het mechanisme voor bellen op adres en bellen op basis van referentie.

Wat is een functie??

Voordat we ingaan op het eigenlijke onderwerp, moeten we begrijpen wat de functie is in C++. Velen van jullie zijn misschien al bekend met functies.

Een functie is in feite een stukje code dat kan worden gebruikt om een bepaalde taak uit te voeren. Een functie wordt voornamelijk gebruikt om de repetitieve code in een C++-programma te verminderen. Het neemt invoer als parameters en retourneert de uitvoer als een retourwaarde. Als we de functie één keer definiëren, kunnen we deze in het latere deel van ons programma meerdere keren aanroepen/gebruiken. Op die manier besparen we veel repetitieve code in het programma.

Elk C++-programma heeft de functie "main()". De functie "main()" is het startpunt voor een C++-programma. Afgezien van de functie "main()", kan de programmeur zoveel functies definiëren als hij wil.

Hier is de syntaxis van het definiëren van een functie:

Return_type Function_Name (Invoerparameterlijst)

Functie in C++ kan 0 of meer invoerparameters accepteren, terwijl het slechts één retourwaarde kan retourneren.

Wat is adres??

Er zijn twee soorten variabelen in C++ (vergelijkbaar met C-taal) - Gegevensvariabele en Adresvariabele. De adresvariabele wordt gebruikt om het adres van een andere gegevensvariabele op te slaan. Laten we bijvoorbeeld het volgende codefragment bekijken:

int i = 100;
int *ptr = &i;

Hier vertelt de eerste instructie ons dat de variabele "i" een gegevensvariabele is en de waarde 100 opslaat. In de tweede verklaring declareren we een pointervariabele, i.e. "ptr" en initialiseren met het adres van de variabele "i".

Wat is referentie??

De referentie is een ander krachtig kenmerk van de C++-taal. Laten we eens kijken naar het volgende codefragment:

int a = 200;
int &r = een;

In dit voorbeeld hebben we een geheel getal gedeclareerd, i.e. "a" en vervolgens een referentievariabele "r" gedeclareerd, die wordt geïnitialiseerd met de waarde van "a". De referentievariabele is dus niets anders dan een alias van een andere variabele.

Methoden voor het doorgeven van parameters:

Er zijn drie soorten methodes voor het doorgeven van parameters in de C++-taal:

Bel op waarde / Geef op waarde door
Bel op adres / Passeer op adres
Bel op referentie / Geef door op referentie

In dit artikel hebben we het over de - Bellen op adres en Bellen op referentie.

Wat is Call By Address / Pass by-adres??

In het geval van de methode Call by address / Pass by address, worden de functieargumenten doorgegeven als adres. De aanroepfunctie geeft het adres van de parameters door. Aanwijzervariabelen worden gebruikt in de functiedefinitie. Met behulp van de methode Call by address kan de functie toegang krijgen tot de daadwerkelijke parameters en deze wijzigen. We zullen later in dit artikel een voorbeeld zien van de methode Bellen op adres.

Wat is Call By Reference / Pass by reference??

In de methode Call by reference / Pass by reference worden de functieparameters als referentie doorgegeven. Binnen de functiedefinitie zijn de werkelijke parameters toegankelijk met behulp van de referentievariabele.

Voorbeelden:

Nu we het concept van methodes voor het doorgeven van parameters begrijpen, zullen we verschillende voorbeeldprogramma's zien om het mechanisme voor het doorgeven van parameters in C++ te begrijpen:

Voorbeeld-1 - Bellen op adres (1)
Voorbeeld-2 - Bellen op adres (2)
Voorbeeld-3 - Bellen op referentie (1)
Voorbeeld-4 - Bellen op referentie (2)

De eerste twee voorbeelden worden gegeven om uit te leggen hoe de methode Call by address werkt in C++. De laatste twee voorbeelden zijn om het concept Call by reference uit te leggen.

Voorbeeld-1 - Bellen op adres (1)

In dit voorbeeld gaan we het call by address-mechanisme demonstreren. Vanuit de functie "main()" roepen we de functie "hello()" aan en geven het adres van "var" door. In de functiedefinitie ontvangen we het adres van "var" in een pointervariabele, i.e., "p". Binnen de functie hallo wordt de waarde van "var" gewijzigd in 200 met behulp van de aanwijzer. Daarom wordt de waarde van "var" gewijzigd in 200 binnen de functie "main()" na de functieaanroep "hello()".

#include
namespace std; gebruiken;
ongeldig hallo(int *p)

cout << endl << "Inside hello() function : " << endl;
cout << "Value of *p = " << *p << endl;
*p = 200;
cout << "Value of *p = " << *p << endl;
cout << "Exiting hello() function." << endl;

int hoofd()

int var = 100;
cout << "Value of var inside main() function = " << var << endl;
hallo(&var);
cout << endl << "Value of var inside main() function = " << var << endl;
retourneer 0;

Voorbeeld-2 - Bellen op adres (2)

Dit is een ander voorbeeld van de methode call by address. In dit voorbeeld gaan we uitleggen hoe de call by address-methode kan worden gebruikt om een reëel probleem op te lossen. We willen bijvoorbeeld een functie schrijven om twee variabelen om te wisselen. Als we het call by value-mechanisme gebruiken om twee variabelen te verwisselen, worden de werkelijke variabelen niet verwisseld in de aanroepfunctie. De call by address-methode kan in een dergelijk scenario worden gebruikt. In dit voorbeeld geven we het adres van zowel var_1 (&var_1) als var_2 (&var_2) door aan de functie "mySwap()". Binnen de functie "mySwap()" wisselen we de waarden van deze twee variabelen om met behulp van de aanwijzers. Zoals je kunt zien in de onderstaande uitvoer, wordt de werkelijke waarde van deze variabelen verwisseld in de functie "main()" nadat de functie "mySwap()" is uitgevoerd.

#include
namespace std; gebruiken;
ongeldig mySwap(int *vptr_1, int *vptr_2)

int temp_var;
temp_var = *vptr_1;
*vptr_1 = *vptr_2;
*vptr_2 = temp_var;

int hoofd()

int var_1 = 100;
int var_2 = 300;
cout << "Before calling mySwap() function, value of var_1 : " << var_1 << endl;
cout << "Before calling mySwap() function, value of var_2 : " << var_2 << endl << endl;
cout << "Calling mySwap() function - Call by address." << endl << endl;
mijnSwap(&var_1, &var_2);
cout << "After calling mySwap() function, value of var_1 : " << var_1 << endl;
cout << "After calling mySwap() function, value of var_2 : " << var_2 << endl;
retourneer 0;

Voorbeeld-3 - Bellen op referentie (1)

In dit voorbeeld gaan we demonstreren hoe call by reference werkt in C++. In de functiedefinitie "hello()" wordt de waarde ontvangen als een referentievariabele (&p). Met behulp van de referentievariabele (i.e., p), kunnen we de waarde van de werkelijke parameter (var) binnen de functie "main()" wijzigen.

#include
namespace std; gebruiken;
nietig hallo(int &p)

cout << endl << "Inside hello() function : " << endl;
cout << "Value of p = " << p << endl;
p = 200;
cout << "Value of p = " << p << endl;
cout << "Exiting hello() function." << endl;

int hoofd()

int var = 100;
cout << "Value of var inside main() function = " << var << endl;
hallo (var);
cout << endl << "Value of var inside main() function = " << var << endl;
retourneer 0;

Voorbeeld-4 - Bellen op referentie(2)

Dit is een ander voorbeeld van een oproep op basis van referentie. In dit voorbeeld gaan we demonstreren hoe call by reference werkt in C++ met behulp van een praktijkvoorbeeld. De functie "mySwap()" wordt aangeroepen vanuit de functie "main()" met de volgende parameters - var_1 en var_2. Binnen de functie "mySwap()" ontvangen we de parameters als referentievariabelen.

#include
namespace std; gebruiken;
void mySwap(int &vref_1, int &vref_2)

int temp_var;
temp_var = vref_1;
vref_1 = vref_2;
vref_2 = temp_var;

int hoofd()

int var_1 = 100;
int var_2 = 300;
cout << "Before calling mySwap() function, value of var_1 : " << var_1 << endl;
cout << "Before calling mySwap() function, value of var_2 : " << var_2 << endl << endl;
cout << "Calling mySwap() function - Call by reference." << endl << endl;
mijnSwap(var_1, var_2);
cout << "After calling mySwap() function, value of var_1 : " << var_1 << endl;
cout << "After calling mySwap() function, value of var_2 : " << var_2 << endl;
retourneer 0;

Conclusie

Inzicht in de methodes voor het doorgeven van parameters in C++ is erg cruciaal. De programmeertaal C ondersteunt alleen de Call by value en Call by address. Maar C++ ondersteunt Call by reference samen met de vorige twee mechanismen. In dit artikel hebben we verschillende werkvoorbeelden gezien om het concept van Call by address en Call by reference te begrijpen. Bellen op adres is een zeer krachtige en populaire methode in embedded domeintoepassingen.