Wat is gestructureerde binding in C++?
Structuurbinding is een C++-functie die is toegevoegd in C++17 en waarmee ook een struct of tuple kan worden ontbonden in afzonderlijke variabelen, waardoor de code beknopter wordt. Het kan worden gebruikt om de toegangssyntaxis van struct-leden eenvoudiger te maken en de kans op fouten veroorzaakt door typefouten of onjuiste indexering te verkleinen.
Syntaxis
De syntaxis van structuurbinding in C++ is als volgt:
auto [ var1 , var2 , ... ] = uitdrukking ;
In de syntaxis voor structuurbinding in C++, waarbij 'var1' en 'var2' variabelenamen zijn en 'expressie' een uitdrukking is die een structuur of klasse oplevert. We gebruiken automatische trefwoorden om variabelen te declareren die automatisch worden gemaakt.
Modificaties
Modifiers kunnen worden gebruikt in combinatie met gestructureerde bindingen. Hun syntaxis wordt hieronder vermeld:
auto & [ A , B , C , ... ] = uitdrukking ;
auto && [ A , B , C , ... ] = uitdrukking ;
De operator '&' of '&&' die in de declaratie wordt gebruikt, definieert of de binding een lvalue- of rvalue-referentie is. Een lvalue-referentie weergegeven door '&' vormt een referentie die kan worden gebruikt om de waarden van de bindingsvariabelen te wijzigen. Wijzigingen in de waarden die met behulp van de referentie zijn aangebracht, worden in de originele structuur of tuple gezien.
De rvalue-referentie weergegeven door '&&' biedt daarentegen een referentie die beperkt is tot gebruik voor het lezen van de waarde van de variabelen die in de binding zijn opgenomen. Het is handig om te binden aan voorbijgaande objecten of rwaarden die moeten worden vernietigd, omdat het voorkomt dat er een replica van het object wordt gemaakt, dit kan geheugen en tijdrovend zijn.
Voorbeeld 1: structuurbinding in C++
Het volgende is een voorbeeld van C++ structuurbinding:
#includenamespace std; gebruiken ;
structuur kubus
{
int X ;
int En ;
int Met ;
} ;
int voornaamst ( )
{
c-kubus = { 10 , twintig , 30 } ;
auto [ x_coördinaat , y_coördinaat , z_coördinaat ] = C ;
cout << 'X-as: ' << x_coördinaat << eindel ;
cout << 'Y-as : ' << y_coördinaat << eindel ;
cout << 'Z-as: ' << z_coördinaat << eindel ;
opbrengst 0 ;
}
In het bovenstaande voorbeeld declareren we een struct-kubus met drie gehele getallen x, y en z. De structuur toont een kubus in de ruimte. Er wordt een variabele c van het type kubus gemaakt en geïnitialiseerd met waarden (10,20,30). In deze codestructuur wijst binding waarden van leden x, y en z van struct toe aan respectievelijk de individuele variabelen x_coordinate, y_coordinate, z_coordinate door gebruik te maken van de syntaxis auto[x_coordinate, y_coordinate, z_coordinate] = c. De uitvoer van het bovenstaande wordt hieronder weergegeven:
Voorbeeld 2: structuurbinding in C++ om een structuur uit te pakken
Hieronder volgt een voorbeeld van structuurbinding bij het uitpakken van een structuur:
#include#include
namespace std; gebruiken ;
structuur Student {
tekenreeks naam ;
int leeftijd ;
} ;
int voornaamst ( ) {
Student s { 'Hamza' , 32 } ;
auto [ naam , leeftijd ] = S ;
cout << naam << ' is ' << leeftijd << ' jaar oud.' << eindel ;
opbrengst 0 ;
}
In de bovenstaande code heeft een Student-struct twee leden: a naam dat is een string en een leeftijd dat is een geheel getal. Vervolgens maken we het Student-object en kennen beginwaarden toe aan elk van zijn leden. De leden van s worden vervolgens gescheiden in de naam en leeftijd van de variabele met behulp van structurele binding, en deze waarden worden vervolgens afgedrukt zoals in de onderstaande schermafbeelding:
Voorbeeld 3: structuurbinding in C++ met modifiers
Hieronder ziet u een voorbeeld van structuurbinding die gebruikmaakt van een modifier om de waarde van een variabele bij te werken als num1 en num2:
#include#include
namespace std; gebruiken ;
int voornaamst ( ) {
tupel < int , int > T { 25 , twintig } ;
auto & [ nummer1 , nummer2 ] = T ;
cout << 'De waarde van num1 = ' << nummer1 << ', num2 = ' << nummer2 << ' \N ' ;
nummer1 = 30 ;
cout << 'De gewijzigde waarde van num1 = ' << nummer1 << ', num2 = ' << nummer2 <<
' \N ' ;
auto && [ nummer 3 , nummer4 ] = make_tuple ( 100 , 250 ) ;
cout << 'Nu de waarde van num3 = ' << nummer 3 << ', num4 = ' << nummer4 << ' \N ' ;
opbrengst 0 ;
}
In de voorgaande code bouwen we een tuple t en gebruiken we de lvalue-referentie om de componenten ervan te koppelen aan num1 en num2. Vervolgens wijzigen we de waarde van num1 in 30 en voeren we de num1- en num2-waarden uit. Bouw ook een tijdelijke tuple via make_tuple(100, 250) en gebruik een rvalue-referentie om de elementen ervan te koppelen aan num3 en num4. De waarden van num3 en num4 worden vervolgens afgedrukt omdat num3 en num4 zijn gekoppeld aan een rvalue-referentie, ze kunnen niet worden gebruikt om de tijdelijke tuple gevormd door make_tuple(100, 250) te wijzigen. Ze kunnen er alleen maar uit lezen. Wanneer u het programma uitvoert, wordt het volgende resultaat op het scherm weergegeven:
Conclusie
Structure binding is een functie in C++ die meerdere waarden van een struct of klasse uitpakt in individuele variabelen in een enkele uitdrukking, wat resulteert in beknoptere, leesbare en veiligere code. Structuurbinding met behulp van modifiers stroomlijnt het proces van het wijzigen van waarden binnen gestructureerde objecten.