Blockvariablendefinitionen und die Zuweisung in C++
Definition von Blockvariablen
Eine Blockvariable wird wie eine Konstante definiert, nur ohne »const«.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto v { 12 }; // Definition von und Initialisierung mit 12
::std::cout << v << "\n"s; }std::cout12
Ein Objekt ist ein Speicherplatz, dem ein Typ zugeordnet ist und der einen Wert jenes Typs speichern kann.
Durch die Definition wird ein bisher nicht verwendetes Objekt des Typs der Variablen ausgewählt, der Name der Variablen steht dann für jenes Objekt.
Die erste Festlegung eines Wertes einer Variablen in der Definition nennt man Initialisierung.
Im Gegensatz zu einer Konstanten kann der Wert eine Variablen nach ihrer Initialisierung durch eine Wirkoperation, die Zuweisung genannt wird, verändert werden.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto v { 12 };
::std::cout << v << "\n"s;
v = -9;
::std::cout << v << "\n"s; }std::cout12
-9
Normalerweise kann eine Variable durch ihren Wert ersetzt werden. Auf der linken Seite der Zuweisung ist dies jedoch nicht möglich. »v = -9« bedeutet also nicht »12 = -9«.
Im Gegensatz zu einer Konstanten muß eine Variable nicht gleich bei der Definition initialisiert werden. Allerdings kann dann nicht »auto« verwendet werden.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ int v;
v = -9;
::std::cout << v << "\n"s; }std::cout-9
Die Verwendung des Wertes einer nicht-initialisierten Variablen führt zu „undefiniertem Verhalten“ und ist deswegen ein schwerer Fehler.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ int v;
::std::cout << v << "\n"s; }
Ein Programm, in dem eine nicht-initialisierte Variable verwendet wird, kann in der Regel übersetzt und gestartet werden, aber trotzdem sollte die Verwendung einer nicht-initialisierten Variablen vermieden werden. Dies geschieht am besten dadurch, daß Variablen von Anfang an immer initialisiert werden.
Variablen sollten immer initialisiert werden.
Obwohl die Variable in »int v;« nicht initialisiert wurde, nennt man »int v;« doch eine Definition, weil nämlich der Name der Variablen als Name für ein bestimmtes int-Objekt definiert wird. Dieses int-Objekt hat allerdings durch die Definition keinen Wert erhalten.
- Zitat *
- “When storage for an object with automatic or dynamic storage duration is obtained, the object has an indeterminate value, and if no initialization is performed for the object, that object retains an indeterminate value until that value is replaced. If an indeterminate value is produced by an evaluation, the behavior is undefined”
- C++ 2016, 8.6p12; C++ 2017, 11.6p12
Wie bei Konstanten kann auch »auto« verwendet werden.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto v { 12 }; /* int-Variable */
::std::cout << v << "\n"s; }std::cout12
Vorteil von »auto«: Man kann das Initialisieren nie vergessen, wenn man einmal »auto« geschrieben hat, da man durch »auto« zum Initialisieren gezwungen wird.
Die Verwendung nicht-initialisierter Variablen ist eine häufig anzutreffende Quelle von Fehlern. Um eine Variablen mit einem „neutralen“ Wert zu initialisieren, kann man eine Wertinitialisierung verwenden, jedoch kann dann »auto« nicht verwendet werden.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ int v {}; /* Wertinitialisierung */
::std::cout << v << "\n"s; }transcript0
Die „Wertinitialisierung“ stellt hier sicher, daß »v« einen bestimmten Wert (nämlich »0«) erhält.
Durch »const« wird festgelegt, daß über diesen Namen (»v«) nach der Initialisierung (die dann bei der Definition erfolgen muß) nur gelesen werden dann.
Eine solche const-Variable wird hier oft einfach „Konstante“ genannt werden, aber korrekter ist die Bezeichnung const-Variable.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto const v { 12 }; // Lese-int-Variable
::std::cout << v << "\n"s; }std::cout12
Bei der Zuweisung ist Informationsverlust möglich.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto v { 12 }; // int-Variable
v = 14.5;
::std::cout << v << "\n"s; }std::cout14
Der Typ und Wert der Zuweisung ist der Typ und Wert der linken Seite der Zuweisung nach der Zuweisung.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto v { 12 }; // int-Variable
::std::cout <<( v = 14.5 )+ 1 << "\n"s;
::std::cout << v << "\n"s; }std::cout15
14
Die Priorität der Zuweisung ist niedriger als die der Grundrechenarten, so daß das Ergebnis einer Berechnung mit Grundrechenarten ohne Klammern auf der rechten Seite einer Zuweisung verwendet werden kann. Die Zuweisung ist rechtsassoziativ, so daß »( a = b = 1 )« als »( a =( b = 1 ))« interpretiert wird. (Man vergleiche dies mit »::std::cout << 1 << 2«.)
#include <initializer_list>
#include <iostream> // ::std::cout
#include <ostream> // <<
#include <string> // ::std::stringusing namespace ::std::literals;
int main()
{ ::std::string v; /* <-- Erzeugung eines ::std::string-Objekts */
v = "2"s; /* <-- Schreiboperation */
::std::cout << v; /* <-- Leseoperation */
::std::cout << '\n'; }
Die Schreibweise der Initialisierung mit geschweiften Klammern hilft auch dabei, den in C++ wichtigen Unterschied zwischen Initialisierung und Zuweisung zu verdeutlichen.
Veränderbare Variablen bieten gegenüber Konstanten noch zusätzliche Möglichkeiten: sie stehen nicht für einen Wert, sondern für einen Speicherplatz, der einen Wert des Typs der Variablen aufnehmen kann. Dieser Wert kann sich während der Ausführung des Blocks der Variablen ändern. (Wir werden etwas später sehen, wie genau dies möglich ist.) Jedoch ist der Typ einer Variablen immer konstant, sowohl bei einer Konstanten als auch bei einer veränderbaren Variablen.
Die Zuweisung und die Blockstruktur
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto a{ 2 };{ a = 4;
auto a{ 6 };
a = 8;
::std::cout << a << "\n"s; }::std::cout << a << "\n"s; }
- Protokoll
8
4
Die Bedeutung von »const«
Wenn eine Variable mit »const« definiert wird, dann bedeutet dies, daß sie unter Verwendung des in der Definition angegebenen Namens nicht durch eine Zuweisung verändert werden darf.
Mehrere Zuweisungen an das gleiche Objekt in einem Ausdruck
Die Auswertung von »a =( a = 2 )« hatte in älteren C++ -Versionen undefiniertes Verhalten, weil zwei Schreibzugriffe auf dasselbe Objekte stets in einer bestimmten zeitlichen Reihenfolge erfolgen müssen, die aber durch den Ausdruck nicht gegeben ist, weil früher nicht garantiert war, daß die rechte Seite einer Zuweisung vor der linken ausgewertet wird.
Inzwischen hat sich dies geändert, und »a =( a = 2 )« hat kein undefiniertes Verhalten (seit 2018).
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto a{ 2 };a =( a = 2 );
::std::cout << a << "\n"s; }- Protokoll
2
In einigen Teilen dieses Kurses sind noch Aussagen über undefiniertes Verhalten enthalten, die inzwischen veraltet sind, weil die Sprache sich verändert hat. In einigen Fällen haben Auswertungen, die früher wegen einer unbestimmten zeitlichen Reihenfolge undefiniertes Verhalten hatten, nun kein undefiniertes Verhalten mehr, weil inzwischen ein bestimmte zeitliche Reihenfolge festgelegt wurde.
Quellen *
- n4762 7.6.18p1
- In all cases, the assignment is sequenced after the value computation of the right and left operands, and before the value computation of the assignment expression. The right operand is sequenced before the left operand.
- Webseite
- https://en.cppreference.com/w/cpp/language/eval_order
Beispiel Auflösung von Verschachtelungen (Refaktor)
Wenn verschachtelte Funktionsaufrufe als unübersichtlich erscheinen, können sie durch Einführung einer Konstanten aufgelöst werden. Jedoch ist es nicht möglich, allgemein zu sagen, welche der beiden Varianten nun besser ist. Falls ein verschachtelter Aufruf schwer verständlich ist, kann die Einführung einer Konstanten mit einem erklärenden Namen aber wahrscheinlich hilfreich sein.
- Verschachtelter Aufruf
::std::srand( ::std::time( 0 ) );
- Aufgelöste Verschachtelung
{ auto const time { ::std::time( 0 ) }; /* C++17 */
::std::srand( time ); }
»auto« ist hier wirklich hilfreich, da der genaue Typ des Aufrufs »::std::time( 0 );« noch gar nicht behandelt wurde.
Manchmal werden Informationen über Fehler in einem Programm auch unter Angabe einer Zeilennummer angezeigt. Wenn mehr kurze Zeilen verwendet werden, kann man dann die Information genauer zuordnen.
Beispiel Doppelte und einfache Berechnung
Wenn ein Wert unnötigerweise doppelt berechnet wird, kann die doppelte Berechnung durch Einführung einer Konstanten vermieden werden.
- unnötige doppelte Berechnung
{ ::std::cout << ::std::floor( 2.7 )<< "\n"s;
::std::cout << ::std::floor( 2.7 )<< "\n"s; }- einmalige Berechnung
{ auto const floor { ::std::floor( 2.7 ) }; /* C++17 */
::std::cout << floor << "\n"s;
::std::cout << floor << "\n"s; }
Man beachte, wie der Namensraumvorsatz »::std::« es erlaubt, zwischen »floor« und »::std::floor« zu unterscheiden!
Das folgende Gegenbeispiel zeigt eine Situation, in welcher der zwiefache Aufruf einer Funktion nicht durch einen einmaligen Aufruf ersetzt werden kann, ohne daß sich das Verhalten verändert, weil bei der doppelten Berechnung meist zwei verschiedene Werte ausgegeben werden, während bei der einmaligen Berechnung derselbe Wert doppelt ausgegeben wird.
- doppelte Berechnung
::std::cout << ::std::rand() << "\n"s;
::std::cout << ::std::rand() << "\n"s;- einmalige Berechnung
{ auto const rand { ::std::rand() }; /* C++17 */
::std::cout << rand << "\n"s;
::std::cout << rand << "\n"s; }
Zeichenfolgenvariablen ⃗
main.cpp#include <initializer_list>
#include <iostream> // ::std::cout
#include <ostream> // <<
#include <string> // ::std::stringusing namespace ::std::literals;
int main()
{ ::std::string v;
v = "abc"s; ::std::cout << v << "\n"s;
v = "abcdef"s; ::std::cout << v << "\n"s; }::std::coutabc
abcdef
Zeichenfolgen unterschiedlicher Länge können Platz unterschiedlicher Größe im Speicher benötigen, während int- und double-Werte alle denselben Speicherplatz benötigen. Der C++ -Programmierer kann ::std::string-Variablen für Zeichenfolgen aber so einfach verwenden wie int- und double-Variablen, weil C++ für ihn Variablen ermöglicht, die sich automatisch an jede Länge anpassen, ohne daß der Programmierer dies wissen muß. Der C++ -Programmierer kann die Variablen mit dem Typ »::std::string« also so verwenden, als ob sie einen Text beliebiger Länge aufnehmen können.
main.cpp#include <initializer_list>
#include <iostream> // ::std::cout
#include <ostream> // <<
#include <string> // ::std::stringusing namespace ::std::literals;
int main()
{ ::std::string const v { "abc"s }; /* <-- Erzeugung und Initialisierung */
::std::cout << v; /* <-- Verwendung */
::std::cout << "\n"s; }::std::coutabc
An ein C++-Zeichenfolgenobjekt kann auch eine Initialisierungsliste oder eine C -Zeichenfolge zugewiesen werden. Dabei wird das C++ -Zeichenfolgenobjekt dann entsprechend auf die Schriftzeichen gesetzt, deren Kennzahlen in der Initialisierungsliste stehen beziehungsweise die in der C -Zeichenfolge enthalten sind.
main.cpp#include <initializer_list>
#include <iostream> // ::std::cout
#include <ostream> // <<
#include <string> // ::std::stringusing namespace ::std::literals;
int main()
{ ::std::string v;{ ::std::string v{ 65, 66, 67 }; /* Definition und Initialisierung */
::std::cout << v << "\n"s; }v = { 65, 66, 67 }; /* Zuweisung */
::std::cout << v << "\n"s;{ ::std::string v = "abc"; /* Definition und Initialisierung */
::std::cout << v << "\n"s; }v = "abc"; /* Zuweisung */
::std::cout << v << "\n"s; }ProtokollABC
ABC
abc
abc
Übungsfragen
Wie schreibt man eine Anweisung, welche den Wert einer int-Variablen v um 1 erhöht?
Wie bei allen Übungsaufgaben sollten auch hier nur die bisher im Kurs vorgestellten Sprachelemente verwendet werden.
Was muß man in das folgende Programm an der Stelle von »/* ... */« einsetzen, um die Werte von x und y zu vertauschen (so daß dann nicht mehr »22, 47«, sondern »47, 22« ausgegeben wird)?
(Die ersten sieben Zeilen und die letzte Zeile sollen also nicht verändert werden. Das gesuchte Verfahren soll auch andere Werte als »22« und »47« vertauschen können.)
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ auto x { 22 };
auto y { 47 };/* ... */
::std::cout << x << ", "s << y << "\n"s; }
std::cout22, 47
- Zitat
- “Use const whenever possible.” -- Scott Meyers
- Zitat
- “Guideline: Con.4: Use const to define objects with values that do not change after construction ”
- C++ Core Guidelines ; April 7, 2016; Bjarne Stroustrup and Herb Sutter
- “P.10: Prefer immutable data to mutable data.”
- C++ Core Guidelines ; June 30, 2018; Bjarne Stroustrup and Herb Sutter
Bjarne Stroustrup, Herb Sutter und Scott Meyers sind die drei weltweit führenden Autoren von Büchern zum Thema C++. Bjarne Stroustrup ist der Schöpfer der Sprache und Herb Sutter der Vorsitzende des Normierungsgremiums (Stand 2017). Und alle drei sind sich in diesem Punkte einig! Ich selber (Stefan Ram) folge diesem Prinzip schon seit den 80er Jahren, als ich »const« in der Programmiersprache Pascal verwendete und unterrichtete.
- Zitat
- “Keep scopes small ”
- C++ Core Guidelines ; Bjarne Stroustrup and Herb Sutter
Ergänzungen *
Narrowing *
Das Einschließen in eine geschweifte Klammer verbietet das “narrowing ” („Einengen“, also den Informationsverlust) bei der Zuweisung.
main.cpp#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string> // ""susing namespace ::std::literals;
int main()
{ int v { 12 };
v ={ 14.5 };
::std::cout << v << "\n"s; }transcriptmain.cpp: In function 'int main()':
main.cpp:9:5: error: narrowing conversion of '1.45e+1' from 'double' to 'int' inside { } [-Wnarrowing]
v ={ 14.5 };
^