Tilldelningsoperation i C++

Den aktuella versionen av sidan har ännu inte granskats av erfarna bidragsgivare och kan skilja sig väsentligt från versionen som granskades den 4 juni 2017; kontroller kräver 5 redigeringar .

Tilldelningsoperatören i programmeringsspråket C++ betecknas med '='-tecknet. Liksom andra operatörer i C++ kan den överbelastas med .

Kopieringsoperationen är en speciell typ av tilldelningsoperation som används för att tilldela objekt av samma klass till varandra. Det är en av specialfunktionsmedlemmarna och genereras automatiskt av kompilatorn om det inte finns någon explicit deklaration från programmeraren. Koden som genereras av kompilatorn gör en bitvis kopia.

Operatören för kopieringstilldelning skiljer sig från kopieringskonstruktören genom att den måste rensa upp datamedlemmarna för uppdragets mål (och hantera självtilldelning på rätt sätt), medan kopieringskonstruktorn tilldelar värden till oinitierade datamedlemmar. [1] Till exempel:

My_Array först ; // initiering med standardkonstruktorn My_Array second = first ; // initiering med kopia konstruktor andra = första ; // tilldelning genom kopiering tilldelning operation

Som ett specialfall bör följande variant av initiering av kopieringskonstruktören noteras:

My_Array second = My_Array ();

I det här fallet utför kompilatorn (till exempel VC2013) omedelbart, utan några optimeringsalternativ, returvärdeoptimering (RVO, returvärdesoptimering) och kopieringskonstruktorn anropas inte.

Kopiera uppdrag överbelastning

När det gäller att göra djupa kopior av objekt måste även undantagshantering beaktas . Ett sätt att undvika resursflyttningsfelet är följande:

  1. Få nya resurser
  2. Frigör gamla resurser
  3. Tilldela objektet värdena för den nya resursen
klass My_Array { int * array ; int count ; offentliga : My_Array & operator = ( const My_Array och annat ) { if ( this != & other ) // skydd mot felaktig självtilldelning { // 1: allokera "nytt" minne och kopiera element int * new_array = new int [ annan . räkna ]; std :: copy ( annan . array , annan . array + annan . count , new_array ); // 2: ledigt "gammalt" minne radera [] array ; // 3: tilldela värden i "nytt" minne till objektmatrisen = new_array ; räkna = annat . räkna ; } // returnerar alltid *this return * this ; } ... };

Men om en framgångsrik utbytesmetod är tillgänglig för alla medlemmar och klassen implementerar en kopieringskonstruktör och en destruktor (enligt regeln om tre ), skulle det kortaste sättet att implementera en kopieringsuppgift vara [2] :

offentliga : void swap ( My_Array & other ) // swap member funktion (bör inte misslyckas!) { // swap alla medlemmar (och underliggande sub-objekt om möjligt) med andra std :: swap ( array , other . array ); std :: swap ( count , other . count ); } My_Array & operator = ( My_Array other ) // Notera: argumentet skickas av värde! { // swap this with other swap ( other ); // returnerar alltid *this return * this ; // annat är förstört, frigör minne }

Anledningen till att operationen =återvänder My_Array&istället för voidär enkel. Det är tillåtet att kombinera uppdrag som:

array_1 = array_2 = array_3 ; // värdet av array_3 tilldelas array_2 // sedan tilldelas värdet av array_2 till array_1

Se även

Länkar

  1. ↑ Bjarne Stroustrup . Programmeringsspråket C++  (neopr.) . - 3. - Addison-Wesley , 2000. - S. 244. - ISBN 978-0201700732 .
  2. ↑ Sutter, H. & Alexandrescu, A. (oktober 2004), C++ Coding Standards , Addison-Wesley , ISBN 0-321-11358-6