Kopierinitialisierung in C++

Kopierinitialisierung in Deklaration bei Typgleichheit

Das folgende Programm zeigt eine Kopierinitialisierung in einer Variablendefinition.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main()
{ ::std::string const a{ "alpha"s }; 
  ::std::string const b = a;
  ::std::cout << a << '\n';
  ::std::cout << b << '\n'; }

transcript

alpha
alpha

Die Initialisierung von »b« mit »a« in »::std::string const b = a;« wird Kopierinitialisierung genannt, weil sie mit einem Gleichheitszeichen »=« geschrieben ist. Man beachte, daß es sich hierbei nicht um eine Zuweisung handelt!

(Die Schreibweise der Initialisierung mit geschweiften Klammern hilft auch dabei, den in C++ wichtigen Unterschied zwischen Initialisierung und Zuweisung zu verdeutlichen.)

C++ 2015 8.5p15: The initialization that occurs in the = form of a brace-or-equal-initializer or condition (6.4), as well as in argument passing, function return, throwing an exception (15.1), handling an exception (15.3), and aggregate member initialization (8.5.1), is called copy-initialization. [ Note: Copy-initialization may invoke a move (12.8). —end note ]

Der Ausdruck »a« hat denselben Typ wie die neue Variable »b«, so daß der Wert von »a« (ein ::std::string-Exemplar) direkt nach »b« kopiert werden kann. Es gibt danach also zwei verschiedene ::std::string-Exemplare, nämlich »a« und »b« und beide enthalten jeweils eine eigene Kopie des Textes »alpha«.

Durch eine Veränderung der Variablen, können wir sehen, daß sie wirklich zwei verschiedene Kopien desselben Textes enthalten.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main()
{ ::std::string a{ "alpha"s }; 
  ::std::string b = a;
  a.push_back( '0' );
  b.push_back( '1' );
  ::std::cout << a << '\n';
  ::std::cout << b << '\n'; }

transcript

alpha0
alpha1

Eine Erzeugung eines neuen Exemplars aus einem anderen Exemplar desselben Typs wird Kopierkonstruktion genannt. In dem Fall, daß der Initialisierungsausdruck denselben Typ wie das zu initialisierende Objekt hat, ist die Kopierinitialisierung also eine reine Kopierkonstruktion.

Kopierinitialisierung ohne Typwandlung

Wenn der Typ des Initialisierungsausdrucks dem Typ des deklarierten Objekts gleicht, dann wird der Wert des Initialisierungsausdrucks einfach unter Heranziehung des Kopierkonstruktors in das neue Objekt kopiert.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
int main()
{ double const x = 2.3;
  ::std::cout << x << '\n'; }

Protokoll

2.3

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>
using namespace ::std::literals;
int main()
{ ::std::string const s = "abc"s;
  ::std::cout << s << '\n'; }

Protokoll

abc

Kopierinitialisierung bei Deklaration mit impliziter Typwandlung

Bei der Kopierinitialisierung ist es ebenfalls möglich, einen Initialisierungsausdruck eines Typs (des Quelltyps) zu verwenden, der sich vom Typ des zu initialisierenden Objektes (dem Zieltyp) unterscheidet. In diesem Fall wird vorausgesetzt, daß es eine Möglichkeit der Wandlung des Initialisierungsausdrucks in den Zieltyp gibt.

Wir können solch eine implizite Typwandlung bereits mit den fundamentalen Datentypen des Grundkurses illustrieren:

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
int main()
{ double const x = 2;
  ::std::cout << x << '\n'; }

transcript

Hier wird der int-Wert »2« zunächst in den double-Wert »2.0« gewandelt und dann in das Objekt »x« gespeichert.

Wir haben eine Art von „Wandlungsmöglichkeit“ in Lektion 28.4. kennengelernt: Eine char-*-Zeichenfolge kann in eine ::std::string-Zeichenfolge gewandelt werden.

Hiervon wird in dem folgenden Programm Gebrauch gemacht. Es verwendet eine Kopierinitialisierung mit einem Gleichheitszeichen »=«, obwohl die rechte Seite gar nicht den Typ der linken Seite hat. Die Programmiersprache verwendet aber zunächst die Typwandlungsmöglichkeit, welche durch den Wandlungskonstruktor der Klasse »::std::string« gegeben ist.

Das folgende Programm zeigt eine Kopierinitialisierung mit impliziter Typwandlung.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
int main()
{ ::std::string const b = "beta"; 
  ::std::cout << b << '\n'; }

::std::cout

beta

Bei der Kopierinitialisierung wird die Zeichenfolge »beta« erst einmal in ein ::std::string-Exemplar konvertiert, das dann nach »b« kopiert wird. Also ähnlich wie in dem folgenden Programm.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
int main()
{ ::std::string const b = static_cast< ::std::string >( "beta" ); 
  ::std::cout << b << '\n'; }

Protokoll

beta

Beziehungsweise wie in:

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
int main()
{ ::std::string const b { static_cast< ::std::string >( "beta" ) }; 
  ::std::cout << b << '\n'; }

Protokoll

beta

Eine Kopierinitialisierung mit impliziter Typwandlung umfaßt im allgemeinen zwei Schritte:

1.) der Wert des Initialisierungsausdrucks wird implizit in den Typ des zu initialisierenden Objektes gewandelt (beispielsweise mit einem Wandlungskonstruktor),

2.) der im vorigen Schritt erhaltene Wert wird mit einem Kopierkonstruktor in das zu initialisierende Objekt kopiert.

Zur Durchführung der Kopierinitialisierung wird also immer der Kopierkonstruktor herangezogen, und bevor dies geschieht, könnten noch Typwandlungen durchgeführt werden. (Es ist möglich, daß eine Implementation zur Beschleunigung des Programmablaufs den Kopierkonstruktor nicht wirklich aufruft, aber selbst dann muß er wenigstens vorhanden sein.)

Das folgende Programm zeigt die uns bekannten Möglichkeiten der Initialisierung eines Objektes.

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
void p( ::std::string const s ) { ::std::cout << s << '\n'; }
int main ()
{ { ::std::string const s { "1"s }; p( s ); }  /* Geschweifte-Klammer-Initialisierung */
  { ::std::string const s { "2"  }; p( s ); }  /* Geschweifte-Klammer-Initialisierung */
  { ::std::string const s = "3"s;   p( s ); }  /* Kopierinitialisierung ohne Wandlung */
  { ::std::string const s = "4";    p( s ); }} /* Kopierinitialisierung mit  Wandlung */

transcript

»`auto`« schützt vor unabsichtlicher Typwandlung

Bei Ausführung der Deklaration »::std::string s = "4";« wird »"4"« zuerst in ein ::std::string-Objekt gewandelt, und anschließend wird dieses Objekt in ein anderes ::std::string-Objekt kopiert. Dies hat damit zu tun, daß der Typ des Initialisierungsausdrucks nicht dem Typ des zu initialisierenden Objektes gleicht. Durch die Verwendung von »auto« werden solche umständlichen Zwei-Schritt-Initialisierungen stets vermieden:

main.cpp

#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
void p( ::std::string const s ) { ::std::cout << s << '\n'; }
int main ()
{ { auto const s { "1"s }; p( s ); }  /* Geschweifte-Klammer-Initialisierung */
  { auto const s { "2"  }; p( s ); }  /* Geschweifte-Klammer-Initialisierung */
  { auto const s = "3"s;   p( s ); }  /* Kopierinitialisierung ohne Wandlung */
  { auto const s = "4";    p( s ); }} /* Kopierinitialisierung ohne Wandlung */

transcript

Allerdings ist der Typ des letzten »s« nun nicht mehr »::std::string«, sondern »char const * const«.

Kopierinitialisierung in C++

Kopierinitialisierung in Deklaration bei Typgleichheit

Kopierinitialisierung ohne Typwandlung

Kopierinitialisierung bei Deklaration mit impliziter Typwandlung

»auto« schützt vor unabsichtlicher Typwandlung

»`auto`« schützt vor unabsichtlicher Typwandlung