Inhaltsreferenzen

Wenn ein Individuum durch seine Speicheradresse identifiziert wird, so spricht man von „Referenzzsemantik“. Wird es durch einen von einer Speicherposition unabhängigen Wert identifiziert, so spricht man von „Wertsemantik“.

Beispiel zur Referenzsemantik: Das folgende Programm zeigt, daß s und t zwei verschiedene Identifikationen sind, wenn man Referenzsemantik zugrundelegt, aber zwei gleiche Identifikationen, wenn man Wertsemantik zugrundelegt. Im ersten Fall wird die Identität durch die Adresse bestimmt, die in beiden Fällen unterschiedlich ist, im zweiten Fall durch den Inhalt, der in beiden Fällen 7 ist.

main.cpp

#include <iostream>
#include <ostream>
#include <string> 
#include <initializer_list> 

int main()
{ int s{ 7 };
  int t{ 7 };
  ::std::cout <<( &s == &t )<< '\n';
  ::std::cout <<(  s ==  t )<< '\n'; }

::std::cout

0
1

Während eine Objektreferenz (lvalue-Referenz) sich an einen bestimmten Speicherort bindet (lvalue), bindet sich eine Wertreferenz (rvalue-Referenz) an einen bestimmten Inhalt (rvalue).

Verschieben

Wenn ein Exemplar als Inhaltsspender gekennzeichnet wurde, so ist es erlaubt, den Inhalt des Exemplars zu entnehmen und das Exemplar leer zurückzulassen. Dies wird man also immer dann tun, wenn es nicht wichtig ist, daß das Exemplar nach der Spende weiterhin den gespendeten Inhalt besitzt.

Das Verschieben eines Inhalts kann in vielen Fällen wesentlich schneller erfolgen als das Kopieren.

In dem folgenden Programm wird das Exemplar »::std::move( a )« mit »::std::move« als Inhaltsspender gekennzeichnet. Bei der Zuweisung an b kann dann der Inhalt von a entnommen werden. a ist danach leer. b hat nun den Inhalt von a.

main.cpp

#include <iostream>

#include <ostream>

#include <string> 

#include <initializer_list> 

#include <utility> /* ::std::move */



int main()

{ ::std::string a{ "abc" };

  ::std::string b;

  b = ::std::move( a );

  a.push_back( '0' );

  b.push_back( '1' );

  ::std::cout << a << '\n';

  ::std::cout << b << '\n'; }

::std::cout

0

abc1

Ein Temporär kann ohnehin nicht mehr später verwendet werden, deswegen kann er immer als Inhaltsspender verwendet werden. In dem folgenden Programm gilt das Exemplar »a + d« bereits ohne »::std::move« als Inhaltsspender, weil es ein Temporär ist. Bei der Zuweisung an t kann dann der Inhalt von a + d entnommen werden.

#include <iostream>

#include <ostream>

#include <string> 

#include <initializer_list> 

int main()

{

  string a{ "abc" };

  string d{ "def" };

  string t;

  t = a + d; 

  ::std::cout << t << '\n'; }

Ein Objekt, dessen Inhalt entnommen werden darf, wird als rvalue bezeichnet. Eine Referenz auf ein rvalue wird in der Dokumentation mit zwei direkt aufeinanderfolgenden kommerziellen Und-Zeichen angegeben.

nach n3797, 21.4.2 (vereinfacht)

namespace std
{ class string
  { string();
    string( const string & str );
    string( char const * s );
    string( size_type n, char c );
    string( ::std::initializer_list< char >l ); 

    string * operator=( string ); }}

Bei der Entnahme des Inhalts eines Objekts werden größere Puffer jenes Objekts (Speicherbereiche) weiterverwendet und nicht kopiert. Daher sind Entnahmen in der Regel schneller als klassische Kopien von Objektinhalten.