Softwareentwicklung in C++ - ASC

9.2 Einfache Klassen 191
String auch einfach mit einem char initialisieren kann. Der Compiler hat
sich auch in keinster Weise darüber beschwert, der Output des Programms
zeigt jedoch, dass hier nicht wirklich das passiert, was man gerne hätte:
DummyString : constructor with s t r i n g
DummyString : copy constructor
DummyString : constructor with length
DummyString : d e s t r u c t o r
DummyString : d e s t r u c t o r
DummyString : d e s t r u c t o r
Sieht man sich die dritte Zeile des Outputs an, so wird doch glatt hier der
Konstruktor aufgerufen, der als Parameter die Länge des Strings enthält!
Was aber wahrscheinlich beabsichtigt war, war die Initialisierung des Strings,
so dass er einfach ein x enthalten sollte. Der Compiler, der von der Absicht
der Entwickler keine Ahnung hat, hat das allerdings ganz anders gesehen: Er
hat einen Konstruktor gesucht, der als Datentyp einen char nimmt. Diesen
gibt es nicht. Sehr wohl aber gibt es einen Konstruktor, der dazu kompatibel
ist, nämlich den Konstruktor, der die Länge als Parameter nimmt. Ein char
ist ja eine Ganzzahl und der Konstruktor nimmt eine Ganzzahl. Also ist mit
einer kleinen Typumwandlung alles bestens – oder, wie in unserem Fall hier,
ganz und gar nichts mehr in Ordnung.
Zum Glück gibt es einen sauberen Weg, es gleich gar nicht zu einer solchen
Gefahr kommen zu lassen: Man kann dem Compiler mitteilen, dass
bestimmte Konstruktoren niemals implizit eingesetzt werden sollen, sondern
nur explizit aufgerufen werden dürfen. Das Zauberwort dazu nennt sich intuitiverweise
explicit. Vorausschauende Entwickler würden also die String
Klasse folgendermaßen deklarieren (forcing_explicit_constructor.cpp):
19 class DummyString
20 {
21 char ∗ s t r i n g ;
22 uint32 l e n g t h ;
23 public :
24 explicit DummyString( uint32 length ) ;
25 DummyString( const char ∗ s t r ) ;
26 DummyString( const DummyString & s r c ) ;
27 ˜DummyString ( ) ;
28 } ;
In Zeile 24 wurde der gefährliche Konstruktor als explicit deklariert. Wie
man an folgender Implementation von main sieht, ist hiermit die Fehlverwendung
unterbunden, denn Zeile 81 würde in einem Compilerfehler resultieren:
76 int main ( int argc , char ∗ argv [ ] )
77 {
78 DummyString s t r i n g 1 = ” otto ” ;
79 DummyString s t r i n g 2 = s t r i n g 1 ;
80 // the f o l l o w i n g l i n e would r e s u l t in a compiler e r r o r
81 // DummyString s t r i n g 3 = ’ x ’ ;
82
83 // t h i s works , because of the e x p l i c i t c a l l
84 DummyString s t r i n g 4 ( 1 2 ) ;