Zeiger, C-Arrays und C-Strings Pearson Education, Inc. All rights reserved.

Transkript

1 1 8 Zeiger, C-Arrays und C-Strings

2 2 8.1 Einführung 8.2 Deklaration und Initialisierung von Zeigervariablen 8.3 Operatoren für Zeiger 8.4 Referenzmäßige Übergabe von Argumenten mit Hilfe von Zeigern 8.5 C-Arrays 8.6 Gebrauch von const bei Zeigern 8.7 Selection-Sort mit referenzmäßiger Übergabe 8.8 Der sizeof Operator 8.9 Zeigerausdrücke und Zeigerarithmetik 8.10 Zusammenhang zwischen Zeigern und C-Arrays 8.11 Zeigerarrays 8.12 Fallstudie: Kartenmisch- und Gebesimulation 8.13 Funktionszeiger 8.14 Einführung in zeigerbasierte C-Strings Grundlagen von Zeichen und C-Strings Verarbeitung von C-Strings mit Bibliotheksfunktionen

3 3 8.1 Einführung Zeiger Klassische, in C verfügbare Methode, um einen zweiten Namen für eine Variable zu definieren Können für referenzmäßige Übergabe eingesetzt werden Stehen in engem Zusammenhang mit C-Arrays und C-Strings (zeigerbasierte Zeichenketten) Müssen bei der Erzeugung und Verarbeitung dynamischer Datenstrukturen eingesetzt werden Können für die Implementierung einer Assoziation zwischen zwei Objekten eingesetzt werden Können für polymorphe Methodenaufrufe eingesetzt werden

4 8.2 Deklaration und Initialisierung von Zeigervariablen 4 Zeigervariablen Enthalten Speicheradressen als Werte Normalerweise enthält eine Variable einen bestimmten Wert (direkte Referenz). Ein Zeiger enthält die Adresse einer Variablen, die einen bestimmten Wert enthält (indirekte Referenz) und kann somit als zweiter Name für diese Variable benutzt werden. Indirekter Zugriff (Indirection) Einen Wert über einen Zeiger ansprechen

5 8.2 Deklaration und Initialisierung von Zeigervariablen 5 Deklaration von Zeigern * zeigt an, dass eine Variable ein Zeiger ist. Beispiel int* myptr; Deklariert einen Zeiger auf int, mit dem Typ int* Mehrere Zeiger in einer einzigen Deklaration erfordern mehrere Sternchen: int *myptr1, *myptr2; Initialisierung von Zeigern Werden mit 0, nullptr oder einer Adresse initialisiert 0 oder nullptr zeigt auf Nichts (Nullzeiger)

6 6 Häufiger Programmierfehler Die Annahme, dass das * bei der Zeigerdeklaration für alle Variablennamen in einer kommaseparierten Liste von Variablen gilt, ist falsch. Jeder Zeiger muss mit einem * vor dem Namen deklariert werden (Leerzeichen dazwischen werden vom Compiler ignoriert). Deklariert man grundsätzlich nur eine Variable pro Deklarationsanweisung wird dieser Fehler vermieden und die Lesbarkeit des Programms erhöht.

7 7 Praxis-Tipp Wenn die Buchstaben Ptr in den Namen von Zeigervariablen vorkommen, wird dadurch klar gemacht, dass diese Variablen Zeiger sind und dass sie entsprechend behandelt werden müssen.

8 8 Fig. 8.1 Direkte und indirekte Referenzierung einer Variablen.

9 9 Tipp zur Fehlervermeidung Zeiger sollten initialisiert werden, um zu vermeiden, dass auf unbekannte oder nicht initialisierte Speicherbereiche gezeigt wird.

10 Operatoren für Zeiger Adressoperator & Gibt die Speicheradresse seines Operanden zurück Beispiel int y = 5; int* yptr; yptr = &y; weist die Adresse der Variablen y der Zeigervariablen yptr zu Variable yptr zeigt auf y yptr referenziert den Wert der Variablen y indirekt.

11 11 Fig. 8.2 Graphische Darstellung eines Zeigers, der auf eine Variable im Speicher zeigt.

12 Operatoren für Zeiger Dereferenzierungsoperator * Auch Indirektionsoperator genannt Gibt den Wert der Variablen zurück, auf die sein Operand zeigt *yptr gibt y zurück (weil yptr auf y zeigt) Ein dereferenzierter Zeiger ist ein L-Wert *yptr = 9; * und & sind invers zueinander Kürzen sich weg, wenn sie nacheinander in beliebiger Reihenfolge - angewendet werden.

13 13 Fig. 8.3 Darstellung von y und yptr im Speicher.

14 14 Häufiger Programmierfehler Wird versucht eine Variable zu dereferenzieren, die kein Zeiger ist, führt dies zu einer Fehlermeldung des Compilers. Wird versucht einen Nullzeiger zu dereferenzieren, tritt in der Regel ein schwerer Laufzeitfehler auf.

15 15 Portabilitäts-Tipp Das Format, in dem ein Zeiger ausgegeben wird, ist compilerabhängig. Einige Systeme geben Zeigerwerte als hexadezimale ganze Zahlen aus (so auch MS Visual C++), andere benutzen dafür ganze Zahlen in Dezimaldarstellung.

16 1 // Fig. 8.4: fig08_04.cpp 2 // Using the & and * operators. 3 #include <iostream> 4 using namespace std; 5 6 int main() 7 { 8 int a; // a is an integer 9 int* aptr; // aptr is an int* -- pointer to an integer a = 7; // assign 7 to a 12 aptr = &a; // assign the address of a to aptr cout << "The address of a is " << &a 15 << "\nthe value of aptr is " << aptr; 16 cout << "\n\nthe value of a is " << a 17 << "\nthe value of *aptr is " << *aptr; 18 cout << "\n\nshowing that * and & are inverses of " 19 << "each other.\n&*aptr = " << &*aptr 20 << "\n*&aptr = " << *&aptr << endl; 21 } // end main The address of a is 0012F580 The value of aptr is 0012F580 Adresse von a und Wert von aptr sind identisch Outline fig08_04.cpp (1 von 1) Wert von a und der dereferenzierte aptr sind identisch * und & sind invers zueinander 16 The value of a is 7 The value of *aptr is 7 Showing that * and & are inverses of each other. &*aptr = 0012F580 *&aptr = 0012F Pearson Education, Inc. All rights reserved.

17 17 Operatoren Assoziativität Typ () [] links nach rechts Klammer, Index static_cast< Typ >( Operand ) links nach rechts unär (postfix) ! & * rechts nach links unär (präfix) * / % links nach rechts multiplikativ + - links nach rechts additiv << >> links nach rechts Ausgabe / Eingabe < <= > >= links nach rechts Vergleich ==!= links nach rechts Gleichheit && links nach rechts logisches UND links nach rechts logisches ODER?: rechts nach links Bedingung = += -= *= /= %= rechts nach links Zuweisung, links nach rechts Komma Fig. 8.5 Operatorvorrang und Assoziativität.

18 8.4 Referenzmäßige Übergabe von Argumenten mit Hilfe von Zeigern 18 Drei Möglichkeiten, um Argumente an eine Funktion zu übergeben wertmäßige Übergabe referenzmäßige Übergabe mit Referenzargumenten referenzmäßige Übergabe mit Zeigerargumenten Eine Funktion kann nur einen Wert zurückgeben. Falls Argumente an die Funktion als Referenzen oder über Zeiger übergeben werden: Die Funktion kann die Originalwerte der Argumente verändern. Auf diese Art kann mehr als ein Wert zurückgegeben werden.

19 8.4 Referenzmäßige Übergabe von Argumenten mit Hilfe von Zeigern 19 Referenzmäßige Übergabe mit Zeigerargumenten War die einzige Möglichkeit, um eine referenzmäßige Übergabe von Argumenten in C zu realisieren Benutzt Zeiger und Dereferenzierungsoperator Als Funktionsargument wird die Adresse einer Variablen (ermittelt mit dem &-Operator) übergeben. Diese Adresse wird in einen Funktionsparameter vom Zeigertyp übernommen. In der Funktion wird der mit dem *-Operator dereferenzierte Zeiger als Zweitname für die Variable benutzt. C-Arraynamen sind schon Zeiger und werden direkt übergeben.

20 1 // Fig. 8.6: fig08_06.cpp 2 // Cube a variable using pass-by-value. 3 #include <iostream> 4 using namespace std; 5 6 int cubebyvalue( int ); // prototype 7 8 int main() 9 { 10 int number = 5; 11 cout << "The original value of number is " << number; 12 number = cubebyvalue( number ); // pass number by value to cubebyvalue 13 cout << "\nthe new value of number is " << number << endl; 14 } // end main // calculate and return cube of integer argument 17 int cubebyvalue( int n ) 18 { 19 return n * n * n; // cube local variable n and return result 20 } // end function cubebyvalue The original value of number is 5 The new value of number is 125 Wertmäßige Übergabe des Arguments Parameter ist Kopie des Arguments Outline fig08_06.cpp (1 von 1) Pearson Education, Inc. All rights reserved.

21 1 // Fig. 8.7: fig08_07.cpp 2 // Cube a variable using pass-by-reference with a pointer argument. 3 #include <iostream> 4 using namespace std; 5 6 void cubebyreference( int* ); // prototype 7 8 int main() 9 { 10 int number = 5; 11 cout << "The original value of number is " << number; 12 cubebyreference( &number ); // pass number address to cubebyreference 13 cout << "\nthe new value of number is " << number << endl; 14 } // end main // calculate cube of *nptr; modifies variable number in main 17 void cubebyreference( int* nptr ) 18 { 19 *nptr = *nptr * *nptr * *nptr; // cube *nptr 20 } // end function cubebyreference The original value of number is 5 The new value of number is 125 Kein Rückgabetyp, dafür ein Zeiger als Parameter Über den Zeigerparameter kann die Variable number in main modifiziert werden Outline fig08_07.cpp (1 von 1) Pearson Education, Inc. All rights reserved.

22 C-Arrays C-Array ( eingebautes Array ) Ein C-Array ist eine Gruppe aufeinanderfolgender Speicherplätze vom selben Typ. Sein Name bezeichnet aber an den meisten Stellen, wo er verwendet wird, allein die Adresse des ersten Elementes (und nicht wie bei einem array-objekt die Zusammenfassung aller Elemente). Die Anzahl der Elemente eines C-Arrays ist zwar Bestandteil seines Typs bei der Deklaration - wenn das C-Array dann aber verwendet wird, wird es vom Compiler in den meisten Fällen in einen Zeiger auf das erste Element umgewandelt. Dies bedeutet, dass der Name eines C-Arrays in der Regel keine Information über die Größe des Arrays bzw. die Anzahl seiner Elemente liefern kann.

23 C-Arrays C-Array ( eingebautes Array ) Erzeugung durch Angabe von Typ und Anzahl der Elemente: int c[ 12 ]; c ist ein C-Array von 12 intsimspeicher. c ist ein int*,der auf c[ 0 ] zeigt. Die C-Arraygröße muss eine ganzzahlige Konstante größer als Null sein. C-Arrays können Werte jedes Datentyps (auch selbstdefinierte Klassen) enthalten, jedoch keine Referenzen. Indizierung der einzelnen Elemente genauso wie bei array: c[ i ] = 42;

24 C-Arrays C-Arrays Sind sehr fehleranfällig und haben verschiedene weitere Nachteile: Der Compiler überprüft nicht, ob Indices in dem für ein bestimmtes C-Array gültigen Bereich liegen. Auf zwei C-Arrays können Gleichheits- und Vergleichsoperatoren nicht sinnvoll angewendet werden. Ein C-Array kann nicht einem anderen C-Array unter Verwendung des Zuweisungsoperators zugewiesen werden. Müssen aus Gründen der Rückwärtskompatibilität mit C an einigen Stellen (z.b. Einsatz einiger Bibliotheksfunktionen) verwendet werden.

25 25 Häufiger Programmierfehler Der Zugriff auf ein Element außerhalb der Grenzen eines C-Arrays ist ein logischer Fehler zur Ausführungszeit und kein Syntaxfehler.

26 1 // Fig. 8.8: fig08_08.cpp 2 // Set C-Array s to the even integers from 2 to #include <iostream> 4 #include <iomanip> 5 using namespace std; 6 7 int main() 8 { 9 // constant variable can be used to specify C-Array size 10 const int arraysize = 10; 11 int s[ arraysize ]; // C-Array s has 10 elements for( int i = 0; i < arraysize; ++i ) { // set the values 14 s[ i ] = * i; 15 } 16 cout << "Element" << setw( 13 ) << "Value" << endl; // output contents of C-Array s in tabular format 19 for( int i = 0; i < arraysize; ++i ) { 20 cout << setw( 7 ) << i << setw( 13 ) << s[ i ] << endl; 21 } 22 } // end main Outline fig08_08.cpp (1 von 1) Soll die C-Arraygröße mit einer Variablen festgelegt werden, muss diese als const erklärt werden. 26 Element Value Pearson Education, Inc. All rights reserved.

27 1 // Fig. 8.9: fig08_09.cpp 2 // Computing the sum of the elements of a C-Array. 3 #include <iostream> 4 using namespace std; 5 6 int main() 7 { 8 const int arraysize = 10; // constant variable indicating size of C-Array 9 int numbers[ arraysize ] = { 87, 68, 94, 100, 83, 78, 85, 91, 76, 87 }; 10 int total = 0; // sum contents of C-Array numbers 13 for( int n : numbers ) { 14 total += n; 15 } 16 cout << "Total of array elements: " << total << endl; 17 } // end main Outline fig08_09.cpp (1 von 1) Bereichsbasierte for-schleife funktioniert auch bei C-Arrays; aber nur innerhalb der Funktion, in der das C-Array definiert wurde! 27 Total of array elements: Pearson Education, Inc. All rights reserved.

28 C-Arrays Funktionsprototypen von Funktionen, die C-Arrays als Argumente übernehmen Die Parameterliste der Funktion muss C-Arrayparameter festlegen: void modifyarray( int b[], size_t sizeofarray ); Der C-Arrayparameter b[] darf die C-Arraygröße einschließen. Der Compiler wird sie aber ignorieren. Den Compiler interessiert allein die Adresse des ersten C-Arrayelementes => identischer Funktionsprototyp: void modifyarray( int* b, size_t sizeofarray );

29 C-Arrays Übergabe eines C-Arrays als Argument an eine Funktion Angabe des C-Arraynamens (ohne eckige Klammern!) C-Array a ist deklariert als int a[ arraysize ]; Der Funktionsaufruf modifyarray( a, arraysize ); übergibt das C-Array a und die Anzahl arraysize seiner Elemente an die Funktion modifyarray Die C-Arraygröße muss als weiteres Argument übergeben werden, damit die Funktion die richtige Anzahl von Elementen in dem C-Array verarbeiten kann.

30 30 Betrachtung zum Software Engineering Wenn ein C-Array an eine Funktion übergeben wird, sollte auch die C-Arraygröße mit übergeben werden. Da die Übergabe eines C-Arrays an eine Funktion nur die Übermittlung der Anfangsadresse des C- Arrays bedeutet, ist andernfalls keine Information über die C-Arraygröße innerhalb der Funktion bekannt.

31 C-Arrays C-Arrays werden referenzmäßig übergeben. Der Funktionsaufruf übergibt in Wirklichkeit die Anfangsadresse des C-Arrays. Auf diese Weise weiß die Funktion, wo sich das C-Array im Speicher befindet. Die aufrufende Funktion gibt der aufgerufenen Funktion direkten Zugriff auf ihre Daten. Die aufgerufene Funktion kann diese Daten direkt manipulieren. Einzelne C-Arrayelemente werden wertmäßig übergeben.

32 1 // Fig. 8.10: fig08_10.cpp 2 // Passing C-Arrays and individual C-Array elements to functions. 3 #include <iostream> 4 #include <iomanip> 5 using namespace std; 6 Funktion übernimmt ein C-Array als Argument 7 void modifyarray( int[], size_t ); // appears strange 8 void modifyelement( int ); 9 10 int main() 11 { 12 const int arraysize = 5; // size of C-Array a 13 int a[ arraysize ] = { 0, 1, 2, 3, 4 }; // initialize C-Array a cout << "Effects of passing entire C-Array by reference:" 16 << "\n\nthe values of the original C-Array are:\n"; // output original C-Array elements 19 for( const int& element : a ) { 20 cout << setw( 3 ) << element; 22 } 22 cout << endl; 23 Outline fig08_10.cpp (1 von 3) Pearson Education, Inc. All rights reserved.

33 24 // pass C-Array a to modifyarray by reference 25 modifyarray( a, arraysize ); cout << "The values of the modified C-Array are:\n"; 28 // output modified C-Array elements 29 for( const int& element : a ) { 30 cout << setw( 3 ) << element; 31 } 32 cout << "\n\n\neffects of passing C-Array element by value:" 33 << "\n\na[3] before modifyelement: " << a[ 3 ] << endl; modifyelement( a[ 3 ] ); // pass array element a[ 3 ] by value 36 cout << "a[3] after modifyelement: " << a[ 3 ] << endl; 37 } // end main // in function modifyarray, "b" points to the original C-Array "a" in memory 40 void modifyarray( int b[], size_t sizeofarray ) 41 { 42 // multiply each C-Array element by 2 43 for( size_t k = 0; k < sizeofarray; ++k ) { 44 b[ k ] *= 2; 45 } 46 } // end function modifyarray // in function modifyelement, "e" is a local copy of 49 // C-Array element a[ 3 ] passed from main 50 void modifyelement( int e ) 51 { 52 // multiply parameter by 2 53 cout << "Value of element in modifyelement: " << ( e *= 2 ) << endl; 54 } // end function modifyelement Outline fig08_10.cpp (2 von 3) Hier funktioniert keine bereichsbasierte for- Schleife, da ein C-Array übergeben wird Pearson Education, Inc. All rights reserved.

34 Effects of passing entire C-Array by reference: The values of the original C-Array are: The values of the modified C-Array are: Effects of passing C-Array element by value: a[3] before modifyelement: 6 Value of element in modifyelement: 12 a[3] after modifyelement: 6 Outline fig08_10.cpp (3 von 3) Pearson Education, Inc. All rights reserved.

35 C-Arrays const C-Arrayparameter Der Qualifizierer const verhindert die Modifikation von C-Arraywerten der aufrufenden Funktion durch Code in der aufgerufenen Funktion. Die Elemente des C-Arrays sind innerhalb des Funktionskörpers konstant. Hierdurch wird eine versehentliche Änderung der Daten durch den Programmierer vermieden.

36 36 Betrachtung zum Software Engineering Ein wichtiges Mittel zur Umsetzung des principle of least privilege ist der Gebrauch des const Qualifizierers. Wir werden noch viele Varianten für seinen richtigen Einsatz kennenlernen. (Stichwort: const-correctness ) Die Entwicklung von Software anhand des principle of least privilege kann die zum Debuggen notwendige Zeit sowie unerwünschte Seiteneffekte stark verringern und Änderung und Wartung eines Programms deutlich vereinfachen.

37 37 Betrachtung zum Software Engineering Die Anwendung des const Typqualifizierers auf C-Arrayparameter in einer Funktionsdefinition, um die Veränderung des ursprünglichen C-Arrays im Funktionskörper zu verhindern, ist ein Beispiel des principle of least privilege. Funktionen sollten ein übergebenes C-Array nur verändern dürfen, wenn dies absolut notwendig ist.

38 1 // Fig. 8.11: fig08_11.cpp 2 // Using the const type qualifier with a C-Array. 3 #include <iostream> 4 using namespace std; 5 6 void printarray( const int b[], size_t size ); // function prototype 7 8 int main() 9 { 10 const size_t SIZE = 3; 11 int a[ SIZE ] = { 10, 20, 30 }; 12 printarray( a, SIZE ); 13 } // end main // In function printarray, the name b for the array is const, 16 // so it cannot be used to modify the original array a in main. 17 void printarray( const int b[], size_t size ) 18 { 19 b[ 0 ] /= 2; // error 20 b[ 1 ] /= 2; // error 21 b[ 2 ] /= 2; // error 22 } // end function printarray Einsatz von const Das C-Array kann nicht verändert werden; es ist const im Funktionskörper. Outline fig08_11.cpp (1 von 1) 38 fig08_11.cpp(19) : error C2166: l-value specifies const object fig08_11.cpp(20) : error C2166: l-value specifies const object fig08_11.cpp(21) : error C2166: l-value specifies const object 2006 Pearson Education, Inc. All rights reserved.

39 1 // Fig. 8.11a: fig08_11a.cpp 2 // Using the const type qualifier with a C-Array. 3 #include <iostream> 4 using namespace std; 5 6 void printarray( const int b[], size_t size ); // function prototype 7 8 int main() 9 { 10 const size_t SIZE = 3; 11 int a[ SIZE ] = { 10, 20, 30 }; 12 printarray( a, SIZE ); 13 } // end main // In function printarray, the name b for the array is const, 16 // so it cannot be used to modify the original array a in main. 17 void printarray( const int b[], size_t size ) 18 { 19 for( size_t i = 0; i < size; ++i ) 20 cout << b[ i ] << endl; 21 } // end function printarray Einsatz von const Das C-Array wird nicht verändert; es ist const im Funktionskörper. Outline fig08_11a.cpp (1 von 1) Pearson Education, Inc. All rights reserved.

40 Gebrauch von const bei Zeigern Die vier Möglichkeiten, um einen Zeiger an eine Funktion zu übergeben (1) Nichtkonstanter Zeiger auf nichtkonstante Daten Variante mit den meisten Veränderungsmöglichkeiten Daten können über den dereferenzierten Zeiger verändert werden Zeiger kann verändert werden, so dass er auf andere Daten zeigt Zeigerarithmetik Operator ++ bewirkt, dass der Zeiger auf das nächste Arrayelement zeigt.

41 Gebrauch von const bei Zeigern C-Arrays mit dem Elementtyp char können zum Speichern und Verarbeiten von Zeichenketten benutzt werden ( C-Strings ). C-Arrays können von jedem Typ sein, chars eingeschlossen. Zeichenketten können in char-arrays gespeichert werden. Sie können mit einem Stringliteral initialisiert werden: Beispiel char string1[] = "Hi"; Dies ist äquivalent mit char string1[] = { 'H', 'i', '\0' }; Das C-Array enthält jedes Zeichen (char) der Zeichenkette und ein zusätzliches spezielles Zeichen zum Abschluss der Zeichenkette, eine binäre Null ('\0').

42 1 // Fig. 8.12: fig08_12.cpp 2 // Converting lowercase letters to uppercase letters 3 // using a non-constant pointer to non-constant data. 4 #include <iostream> 5 #include <cctype> // islower, toupper 6 using namespace std; 7 8 void converttouppercase( char* sptr ); 9 10 int main() 11 { 12 char phrase[] = "characters and $42.23"; cout << "The phrase before conversion is: " << phrase; 15 converttouppercase( phrase ); 16 cout << "\nthe phrase after conversion is: " << phrase << endl; 17 } // end main // convert C-String to uppercase letters 20 void converttouppercase( char* sptr ) 21 { 22 while( *sptr!= '\0' ) { // loop while current character is not '\0' 23 *sptr = toupper( *sptr ); // convert to uppercase 24 ++sptr; // make sptr point to the next character 25 } // end while 26 } // end function converttouppercase The phrase before conversion is: characters and $42.23 The phrase after conversion is: CHARACTERS AND $42.23 Parameter sptr ist ein nichtkonstanter Zeiger auf nichtkonstante Daten. converttouppercase ändert die Variable phrase Outline fig08_12.cpp (1 von 1) Funktion toupper gibt immer die groß geschriebene Version eines Buchstabens zurück. Die in sptr gespeicherte Speicheradresse wird geändert, so dass sie auf das nächste C-Arrayelement zeigt Pearson Education, Inc. All rights reserved.

43 Gebrauch von const bei Zeigern Die vier Möglichkeiten, um einen Zeiger an eine Funktion zu übergeben (2) Nichtkonstanter Zeiger auf konstante Daten Zeiger kann geändert werden, um auf jedes gewünschte Datenelement zu zeigen. Daten können über diesen Zeiger nicht verändert werden. Stellt die Performanz der referenzmäßigen Übergabe und die Sicherheit der wertmäßigen Übergabe zur Verfügung

44 1 // Fig. 8.13: fig08_13.cpp 2 // Printing a C-String one character at a time using 3 // a non-constant pointer to constant data. 4 #include <iostream> 5 using namespace std; 6 7 void printcharacters( const char* sptr ); // print using pointer to const data 8 9 int main() 10 { 11 const char phrase[] = "characters and $42.23"; cout << "The C-String is:\n"; 14 printcharacters( phrase ); 15 cout << endl; 16 } // end main // sptr can be modified, but it cannot modify the character to which 19 // it points, i.e., sptr is a "read-only" pointer 20 void printcharacters( const char* sptr ) 21 { 22 for( ; *sptr!= '\0'; ++sptr ) // no initialization 23 cout << *sptr; // display character without modification 24 } // end function printcharacters Parameter ist ein nichtkonstanter Zeiger auf konstante Daten Outline fig08_13.cpp (1 von 1) Übergabe des Zeigers phrase an die Funktion printcharacters sptr ist ein nichtkonstanter Zeiger auf konstante Daten; er kann das Zeichen, auf das er zeigt, nicht verändern. Inkrementierung von sptr, um auf das nächste Zeichen zu zeigen 44 The C-String is: characters and $ Pearson Education, Inc. All rights reserved.

45 Gebrauch von const bei Zeigern Die vier Möglichkeiten, um einen Zeiger an eine Funktion zu übergeben (3) Konstanter Zeiger auf nichtkonstante Daten Zeigt immer auf den gleichen Speicherplatz Kann andere Arrayelemente aber über Zeigerarithmetik oder über die Indexschreibweise ansprechen Daten können über den Zeiger verändert werden. Ist der Standard für einen C-Arraynamen Kann von einer Funktion für die Übernahme eines C-Arrays als Argument benutzt werden Muss bei der Deklaration initialisiert werden

46 1 // Fig. 8.14: fig08_14.cpp 2 // Changing single letters in a C-String 3 // using a constant pointer to non-constant data. 4 #include <iostream> 5 using namespace std; 6 7 int main() 8 { 9 char phrase[] = "characters and $42.23"; // type of phrase is char* const 10 cout << phrase << endl; *phrase = 'C'; 13 cout << phrase << endl; // ++phrase; // not allowed: pointer phrase is const! *( phrase + 1 ) = 'h'; 18 cout << phrase << endl; 19 } // end main phrase ist ein konstanter Zeiger auf char Outline fig08_14.cpp (1 von 1) *phrase (erstes C-Arrayelement) kann modifiziert werden phrase kann nicht modifiziert werden, um auf eine neue Adresse zu zeigen Zum konstanten phrase darf aber ein Wert (z.b. 1) addiert werden 46 characters and $42.23 CHaRaCters and $42.23 ChaRaCters and $ Pearson Education, Inc. All rights reserved.

47 47 Häufiger Programmierfehler Wenn ein Zeiger, der als const deklariert wird, nicht initialisiert wird, meldet der Compiler einen Fehler.

48 Gebrauch von const bei Zeigern Die vier Möglichkeiten, um einen Zeiger an eine Funktion zu übergeben (4) Konstanter Zeiger auf konstante Daten Variante mit den wenigsten Veränderungsmöglichkeiten Zeigt immer auf den gleichen Speicherplatz Daten können über diesen Zeiger nicht verändert werden

49 1 // Fig. 8.15: fig08_15.cpp 2 // Printing single letters in a C-String 3 // using a constant pointer to constant data. 4 #include <iostream> 5 using namespace std; 6 7 int main() 8 { 9 const char* const phrase = "characters and $42.23"; 10 cout << phrase << endl; // *phrase = 'C'; // not allowed: data *phrase is const! 13 cout << *phrase << endl; // ++phrase; // not allowed: pointer phrase is const! cout << *( phrase + 1 ) << endl; 18 cout << phrase + 15 << endl; 19 } // end main phrase ist ein konstanter Zeiger auf konstante char Outline fig08_15.cpp (1 von 1) *phrase (auf das phrase zeigt) kann nicht modifiziert werden phrase kann nicht modifiziert werden, um auf eine neue Adresse zu zeigen 49 characters and $42.23 c H $42.23 Zum konstanten phrase dürfen Werte addiert werden 2006 Pearson Education, Inc. All rights reserved.

50 50 Betrachtung zum Software Engineering Nichtkonstante Zeigerargumente können an konstante Zeigerparameter übergeben werden. Das ist hilfreich, wenn ein Programm einen nichtkonstanten Zeiger benutzt, um auf Daten zuzugreifen, aber wenn nicht gewünscht wird, dass Daten innerhalb einer Funktion modifiziert werden, die von diesem Programm aufgerufen wird.

51 8.7 Selection-Sort mit referenzmäßiger Übergabe 51 Sortieren durch Auswählen soll mit Einsatz von Zeigern realisiert werden Algorithmus: Sortieren durch Auswählen (Selection-Sort) Vertauschen des kleinsten Elementes mit dem ersten Element Vertauschen des zweitkleinsten Elementes mit dem zweiten Element usw. Die Funktion zum Vertauschen (swap) soll auf einzelne C- Arrayelemente zugreifen. Einzelne C-Arrayelemente: Skalare Werden normalerweise wertmäßig übergeben Sollen referenzmäßig übergeben werden, indem Zeiger und der Adressoperator & sowie der Dereferenzierungsoperator * benutzt werden

52 1 // Fig. 8.16: fig08_16.cpp 2 // Putting values into a C-Array, sorting the values into 3 // ascending order and printing the resulting C-Array. 4 5 #include <iostream> 6 #include <iomanip> 7 using namespace std; 8 9 void selectionsort( int * const a, const size_t size ); // prototype 10 void swap( int * const, int * const ); // prototype int main() 13 { 14 const size_t arraysize = 10; 15 int a[ arraysize ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; cout << "Data items in original order\n"; 18 for( const int& element : a ) { 19 cout << setw( 4 ) << element; 20 } 21 selectionsort( a, arraysize ); // sort the C-Array cout << "\ndata items in ascending order\n"; 24 for( const int& element : a ) { 25 cout << setw( 4 ) << element; 26 } 27 cout << endl; 28 } // end main 29 Outline fig08_16.cpp (1 von 2) Pearson Education, Inc. All rights reserved.

53 30 // function to sort a C-Array 31 void selectionsort( int * const a, const size_t size ) 32 { 33 size_t smallest; // index of smallest element 34 // loop over size - 1 elements 35 for( size_t i = 0; i < size - 1; ++i ) { 36 smallest = i; // first index of remaining elements 37 // loop to find index of smallest element: 38 for( size_t k = i + 1; k < size; ++k ) { 39 if( a[ k ] < a[ smallest ] ) { 40 smallest = k; 41 } // end if 42 } // end inner for 43 swap( &a[ i ], &a[ smallest ] ); 44 } // end outer for 45 } // end function selectionsort // swap values at memory locations to which e1ptr and e2ptr point 48 void swap( int * const e1ptr, int * const e2ptr ) 49 { 50 int hold = *e1ptr; 51 *e1ptr = *e2ptr; 52 *e2ptr = hold; 53 } // end function swap Das C-Arrayargument aoutline wird hier als int * const deklariert (statt als int array[]) Die Argumente werden referenzmäßig übergeben, damit die Funktion die Original- Arraywerte in main vertauschen kann fig08_16.cpp (2 von 2) 53 Data items in original order Data items in ascending order Pearson Education, Inc. All rights reserved.

54 Der sizeof Operator sizeof Operator Gibt die Größe seines Operanden in Bytes zurück Für ein C-Array gibt sizeof innerhalb der Funktion, in der es definiert wird, folgenden Wert zurück: ( Größe eines Elements ) * ( Anzahl der Elemente ) Falls sizeof( int ) den Wert 4 zurückgibt, dann wird int myarray[ 10 ]; cout << sizeof( myarray ); den Wert 40 ausgeben. sizeof kann benutzt werden mit Variablennamen Typnamen Konstanten Werten

55 55 Häufiger Programmierfehler Benutzt man den sizeof Operator in einer Funktion, um von einem C-Arrayparameter die Größe in Bytes zu bestimmen, erhält man die Größe des Zeigers in Bytes und nicht die Größe des C-Arrays in Bytes.

56 1 // Fig. 8.17: fig08_17.cpp 2 // Sizeof operator when used on a C-Array name 3 // returns the number of bytes in the C-Array. 4 #include <iostream> 5 using namespace std; 6 7 size_t getsize( double* const ptr ); // prototype 8 9 int main() 10 { 11 double a[ 20 ]; // 20 doubles; occupies 160 bytes on our system cout << "The number of bytes in the C-Array is " << sizeof( a ); cout << "\nthe number of bytes returned by getsize is " 16 << getsize( a ) << endl; 17 } // end main // return size of ptr 20 size_t getsize( double* const ptr ) 21 { 22 return sizeof( ptr ); 23 } // end function getsize The number of bytes in the C-Array is 160 The number of bytes returned by getsize is 4 Outline sizeof auf ein innerhalb der gleichen Funktion definiertes C-Array angewendet gibt die Gesamtzahl von Bytes im Array (1 von zurück 1) Die Funktion getsize liefert die Anzahl von Bytes, die zum Speichern der Anfangsadresse des C-Arrays benötigt werden sizeof gibt die Anzahl von Bytes für den Zeiger zurück fig08_17.cpp Pearson Education, Inc. All rights reserved.

57 Der sizeof Operator sizeof Operator Wird bereits zur Übersetzungszeit (nicht erst zur Laufzeit des Programms) ausgeführt Klammern für seinen Operanden sind nur erforderlich, falls dieser Operand ein Typname ist, bei einem Variablennamen können sie weggelassen werden. Für double realarray[ 22 ]; kann sizeof realarray / sizeof( double ) benutzt werden, um die Anzahl der Elemente in realarray zu berechnen.

58 1 // Fig. 8.18: fig08_18.cpp 2 // Demonstrating the sizeof operator. 3 4 #include <iostream> 5 using namespace std; 6 7 int main() 8 { 9 char c; 10 short s; 11 int i; 12 long l; 13 long long ll; 14 float f; 15 double d; 16 long double ld; 17 double arr[ 20 ]; // C-Array of 20 double elements 18 double* ptr = arr; // pointer to double as second name for C-Array Outline fig08_18.cpp (1 von 2) Pearson Education, Inc. All rights reserved.

59 19 20 cout << "sizeof c = " << sizeof c 21 << "\tsizeof(char) = " << sizeof( char ) 22 << "\nsizeof s = " << sizeof s 23 << "\tsizeof(short) = " << sizeof( short ) 24 << "\nsizeof i = " << sizeof i 25 << "\tsizeof(int) = " << sizeof( int ) 26 << "\nsizeof l = " << sizeof l 27 << "\tsizeof(long) = " << sizeof( long ) 28 << "\nsizeof ll = " << sizeof ll 29 << "\tsizeof(long long) = " << sizeof( long long ) 30 << "\nsizeof f = " << sizeof f 31 << "\tsizeof(float) = " << sizeof( float ) 32 << "\nsizeof d = " << sizeof d 33 << "\tsizeof(double) = " << sizeof( double ) 34 << "\nsizeof ld = " << sizeof ld 35 << "\tsizeof(long double) = " << sizeof( long double ) 36 << "\nsizeof arr = " << sizeof arr 37 << "\nsizeof ptr = " << sizeof ptr 38 << "\nsizeof *ptr = " << sizeof *ptr << endl; 39 } // end main Operator sizeof bei einem Variablennamen Operator sizeof bei einem Typnamen Outline fig08_18.cpp (2 von 2) 59 sizeof c = 1 sizeof(char) = 1 sizeof s = 2 sizeof(short) = 2 sizeof i = 4 sizeof(int) = 4 sizeof l = 4 sizeof(long) = 4 sizeof ll = 8 sizeof(long long) = 8 sizeof f = 4 sizeof(float) = 4 sizeof d = 8 sizeof(double) = 8 sizeof ld = 8 sizeof(long double) = 8 sizeof arr = 160 sizeof ptr = 4 sizeof *ptr = Pearson Education, Inc. All rights reserved.

60 60 Portabilitäts-Tipp Die Anzahl von Bytes, die zum Speichern eines bestimmten Datentyps benötigt werden, kann zwischen verschiedenen Systemen variieren. Programme, die von der Größe von Datentypen abhängen und die auf verschiedenen Plattformen laufen sollen, sollten sizeof benutzen, um den Speicherbedarf der einzelnen Datentypen zu bestimmen.

61 61 Tipp zur Performanz Da sizeof ein Operator ist, der zur Übersetzungszeit und nicht zur Laufzeit ausgewertet wird, beeinflusst der Einsatz von sizeof die Performanz beim Ablauf des Programms nicht.

62 8.9 Zeigerausdrücke und Zeigerarithmetik 62 Zeigerarithmetik Zeigerarithmetik ist nur für Zeiger auf ein C-Array sinnvoll. Inkrementieren und Dekrementieren von Zeigern (++ oder --) Addieren/Subtrahieren einer ganzen Zahl zu/von einem Zeiger (+ oder +=, - oder -=) Zeiger dürfen voneinander subtrahiert werden.

63 8.9 Zeigerausdrücke und Zeigerarithmetik 63 Gegeben sei ein int-array mit 5 Elementen auf einer Plattform mit 4 Byte ints vptr zeigt auf erstes Element v[ 0 ] am Speicherplatz 3000 vptr = &v[ 0 ]; vptr += 2; setzt vptr auf 3008 ( * 4) vptr zeigt auf v[ 2 ] Subtrahieren von Zeigern Ergibt die Anzahl der Elemente zwischen zwei Adressen vptr2 = &v[ 2 ]; vptr = &v[ 0 ]; vptr2 - vptr ist 2

64 64 Fig. 8.19a C-Array v und eine Zeigervariable vptr, die auf v zeigt.

65 65 Fig. 8.19b Zeiger vptr nach Zeigerarithmetik.

66 66 Portabilitäts-Tipp Die meisten Rechner haben heute vier-byte integer. Neuere (64-Bit)-Plattformen nutzen oft acht-byte integer. Da die Zeigerarithmetik die Größe der Objekte, auf die der Zeiger zeigt, berücksichtigt, führt sie auf beiden Plattformen zum gleichen Ergebnis.

67 67 Häufiger Programmierfehler Die Anwendung von Zeigerarithmetik auf einen Zeiger, der nicht auf ein Element eines C-Arrays zeigt, ist ein logischer Fehler. Die Subtraktion oder der Vergleich von zwei Zeigern, die nicht auf Elemente desselben C-Arrays zeigen, ist ein logischer Fehler.

68 8.9 Zeigerausdrücke und Zeigerarithmetik 68 Zeigerzuweisung Ein Zeiger kann einem anderen zugewiesen werden, wenn beide den gleichen Typ haben. Falls die Typen nicht gleich sind, muss ein Typumwandlungsoperator (cast) benutzt werden. Ausnahme Zeiger auf void (Typ void*) Generischer Zeiger, kann jeden Typ darstellen Keine Typumwandlung erforderlich, um einen Zeiger in void* umzuwandeln Um void* in einen anderen Typ umzuwandeln, ist eine explizite Typumwandlung erforderlich. void Zeiger können nicht dereferenziert werden.

69 69 Häufiger Programmierfehler Mit einem void* Zeiger sind nur folgende Operationen ohne Fehlermeldung des Compilers möglich: Vergleich von void* Zeigern mit anderen Zeigern, Umwandlung von void* Zeigern in gültige Zeigertypen, Zuweisung von Adressen an void* Zeiger.

70 8.9 Zeigerausdrücke und Zeigerarithmetik 70 Vergleich von Zeigern Mit Hilfe von Gleichheits- und Vergleichsoperatoren Wird oft benutzt um zu bestimmen, ob ein Zeiger ein Nullzeiger ist (nullptr). Die in den Zeigern gespeicherten Adressen werden verglichen. Vergleiche sind nur dann sinnvoll, wenn Zeiger auf Elemente desselben C-Arrays zeigen. Beispiel Es könnte ermittelt werden, dass ein Zeiger auf ein C-Arrayelement mit höherem Index zeigt als ein anderer Zeiger.

71 8.10 Zusammenhang zwischen Zeigern und C-Arrays 71 C-Arrays und Zeiger hängen eng miteinander zusammen Ein C-Arrayname ist im Prinzip ein konstanter Zeiger. Zeiger können benutzt werden, um auf C-Arrayelemente zuzugreifen.

72 8.10 Zusammenhang zwischen Zeigern und C-Arrays 72 Zugriff auf C-Arrayelemente mit Zeigern Folgende Definitionen seien vorausgesetzt: int b[ 5 ]; int* bptr; bptr = b; Auf Element b[ n ] kann mit *( bptr + n ) zugegriffen werden. Wird als Zeiger/Versatz-Schreibweise bezeichnet Adressen: &b[ 3 ] ist identisch mit bptr + 3 Der C-Arrayname kann als Zeiger aufgefasst werden: b[ 3 ] ist identisch mit *( b + 3 ) Zeiger können indiziert werden (Zeiger/Index-Schreibweise ): bptr[ 3 ] ist identisch mit b[ 3 ]

73 73 Häufiger Programmierfehler Obwohl C-Arraynamen Zeiger auf den Anfang eines C-Arrays sind und obwohl Zeiger in arithmetischen Ausdrücken modifiziert werden können, können C-Arraynamen nicht in arithmetischen Ausdrücken modifiziert werden, denn C-Arraynamen sind konstante Zeiger.

74 74 Praxis-Tipp Aus Gründen der Klarheit sollte bei der Manipulation von C-Arrays die Arrayschreibweise (mit Einsatz von Indices) der Zeigerschreibweise vorgezogen werden.

75 1 // Fig. 8.20: fig08_20.cpp 2 // Using subscripting and pointer notations with C-Arrays. 3 #include <iostream> 4 using namespace std; 5 6 int main() 7 { 8 int b[] = { 10, 20, 30, 40 }; // create 4-element C-Array b 9 int* bptr = b; // set bptr to point to C-Array b // output C-Array b using array subscript notation 12 cout << "C-Array b printed with:\n\narray subscript notation\n"; 13 for( size_t i = 0; i < 4; ++i ) 14 cout << "b[" << i << "] = " << b[ i ] << '\n'; // output C-Array b using the array name and pointer/offset notation 17 cout << "\npointer/offset notation where " 18 << "the pointer is the C-Array name\n"; 19 for( size_t offset = 0; offset < 4; ++offset ) 20 cout << "*(b + " << offset << ") = " << *( b + offset ) << '\n'; // output C-Array b using bptr and array subscript notation 23 cout << "\npointer subscript notation\n"; 24 for( size_t i = 0; i < 4; ++i ) 25 cout << "bptr[" << i << "] = " << bptr[ i ] << '\n'; // output C-Array b using bptr and pointer/offset notation 28 cout << "\npointer/offset notation\n"; 29 for( size_t offset = 0; offset < 4; ++offset ) 30 cout << "*(bptr + " << offset << ") = " 31 << *( bptr + offset ) << '\n'; 32 } // end main Outline fig08_20.cpp (1 von 2) Normale Arrayschreibweise C-Arrayname und Zeiger/Versatz-Schreibweise Zeiger/Index-Schreibweise Zeigername und Zeiger/Versatz-Schreibweise Pearson Education, Inc. All rights reserved.

76 C-Array b printed with: Array subscript notation b[0] = 10 b[1] = 20 b[2] = 30 b[3] = 40 Pointer/offset notation where the pointer is the C-Array name *(b + 0) = 10 *(b + 1) = 20 *(b + 2) = 30 *(b + 3) = 40 Pointer subscript notation bptr[0] = 10 bptr[1] = 20 bptr[2] = 30 bptr[3] = 40 Pointer/offset notation *(bptr + 0) = 10 *(bptr + 1) = 20 *(bptr + 2) = 30 *(bptr + 3) = 40 Outline fig08_20.cpp (2 von 2) Pearson Education, Inc. All rights reserved.

77 Zeigerarrays C-Arrays können Zeiger enthalten (arrays und vectors natürlich auch, s. Kap 13 Polymorphie) Im Fall von C-Arrays kann dies zur Speicherung von C-Strings (C-Arrays mit Elementtyp char, s. Abschnitt 8.14) genutzt werden Ein solches C-Array speichert nicht die C-Strings selbst, sondern Zeiger auf (irgendwo anders im Speicher vorhandene) C-Strings. Beispiel const char* suit[ 4 ] = { "Hearts", "Diamonds", "Clubs", "Spades" }; Jedes Element von suit zeigt auf einen char* (C-String) Das suit C-Array hat eine feste Größe (4 Zeiger mit je 4 Byte), aber die C-Strings können beliebig groß sein.

78 78 Fig Graphische Darstellung des suit C-Arrays.

79 8.11 Zeigerarrays 79 Befehlszeilenargumente Zeigerarrays werden auch für Befehlszeilenargumente von main benutzt: int main( int argc, char* argv[ ] ) { } Wird z.b. ein Programm prog.exe auf der Befehlszeile der Eingabeaufforderung folgendermaßen aufgerufen: prog.exe d o ofile data0 Dann enthält der int-parameter argc die Anzahl der C- Strings in dem Zeigerarray argv[ ] und argv[ ] selbst die einzelnen Werte: argv[ 0 ] = "prog.exe"; argv[ 1 ] = "-d"; argv[ 2 ] = "-o"; argv[ 3 ] = "ofile"; argv[ 4 ] = "data0";

80 8.12 Fallstudie: Kartenmisch- und Gebesimulation 80 Programm zur Simulation des Mischens und Gebens von Spielkarten Nutzung von zwei Zeigerarrays mit Zeigern auf C-Strings, um Kartenfarben und werte zu speichern Zur Darstellung eines Kartenspiels wird ein zweidimensionales C-Array benutzt, dessen eine Dimension die Kartenfarben, die andere die Kartenwerte darstellt. Die Werte 1-52 in diesem C-Array legen die Reihenfolge fest, in der die Karten gegeben werden. Anmerkung: Sinnvoller ist eine objektorientierte Darstellung eines Kartenspiels durch ein Array, das Instanzen einer Klasse Card enthält (s. Praktikum 5).

81 81 Fig Darstellung eines Kartenspiels durch ein zweidimensionales C-Array.

82 8.12 Fallstudie: Kartenmisch- und Gebesimulation 82 Pseudocode: Simulation des Mischens und Gebens Erste Verfeinerung Initialisierung suit-array Initialisierung face-array Initialisierung deck-array (1-52) ZweiteVerfeinerung Für jede der 52 Karten Vertausche die Karte mit einer zufällig gewählten anderen Karte aus deck DritteVerfeinerung Wähle einen zufälligen Platz Vertausche beide Plätze Kartenspiel mischen 52 Karten geben Für jede der 52 Karten Nummer der Karte in deck finden Farbe / Wert der Karte ausgeben Für jeden Platz von deck-array Falls Kartennummer stimmt Farbe und Wert der Karte ausgeben

83 1 // Fig. 8.27: fig08_27.cpp 2 // Card shuffling and dealing program. 3 4 #include <iostream> 5 #include <iomanip> 6 #include <cstdlib> 7 #include <ctime> 8 using namespace std; 9 10 void shuffle( unsigned int deck[][ 13 ] ); 11 void deal( unsigned int deck[][ 13 ] ); int main() 14 { 15 srand( static_cast<unsigned>( time( nullptr ) ) ); // seed random unsigned int card = 1; // number of card (1-52) 18 unsigned int deck[ 4 ][ 13 ] = { 0 }; // 2-dim C-Array models card deck 19 // initialize card deck 20 for( size_t row = 0; row <= 3; ++row ) { 21 for( size_t column = 0; column <= 12; ++column ) { 22 deck[ row ][ column ] = card++; 23 } 24 } shuffle( deck ); 27 deal( deck ); 28 } // end main Outline fig08_27.cpp (1 von 4) Pearson Education, Inc. All rights reserved.

84 29 30 // shuffle cards in deck 31 void shuffle( unsigned int deck[ 4 ][ 13 ] ) 32 { 33 unsigned int temp; // holds card to swap 34 size_t randrow, randcolumn; // represent a random card in deck // for each of the 52 cards, choose random card and swap 37 for( size_t row = 0; row <= 3; ++row ) { 38 for( size_t column = 0; column <= 12; ++ column ) { 39 randrow = rand() % 4; // randomly select the row 40 randcolumn = rand() % 13; // randomly select the column 41 temp = deck[ row ][ column ]; // save current card 42 deck[ row ][ column ] = deck[ randrow ][ randcolumn ]; 43 deck[ randrow ][ randcolumn ] = temp; 44 } // end inner for 45 } // end outer for 46 } // end function shuffle 47 Outline fig08_27.cpp (2 von 4) Pearson Education, Inc. All rights reserved.

85 48 49 // deal cards in deck 50 void deal( unsigned int deck[ 4 ][ 13 ] ) 51 { 52 // initialize suit array 53 static const char* suit[ 4 ] = 54 { "Hearts", "Diamonds", "Clubs", "Spades" }; 55 // initialize face array 56 static const char* face[ 13 ] = 57 { "Ace", "Deuce", "Three", "Four", "Five", "Six", "Seven", 58 "Eight", "Nine", "Ten", "Jack", "Queen", "King" }; // for each of the 52 cards 61 for( size_t card = 1; card <= 52; ++card ) { 62 // loop through rows of deck 63 for( size_t row = 0; row <= 3; ++row ) { 64 // loop through columns of deck for current row 65 for( size_t column = 0; column <= 12; ++column ) { 66 // if slot contains current card, display card 67 if( deck[ row ][ column ] == card ){ 68 cout << setw( 5 ) << right << face[ column ] 69 << " of " << setw( 8 ) << left << suit[ row ] 70 << ( card % 2 == 0? '\n' : '\t' ); 71 column = 13; // leave column loop 72 row = 4; // leave row loop 73 } // end if 74 } // end for 75 } // end for 76 } // end for 77 cout << endl; 78 } // end function deal Ist das gesuchte Element gefunden, wird die lineare Suche abgebrochen Outline Suit C-Array enthält 4 Zeiger auf char-arrays fig08_27.cpp Face C-Array enthält 13 Zeiger (3 auf von char-arrays 4) face wird rechtsbündig ausgegeben in einem Feld von 5 Zeichen Breite suit wird linksbündig ausgegeben in einem Feld von 8 Zeichen Breite Pearson Education, Inc. All rights reserved.

86 Nine of Spades Seven of Clubs Five of Spades Eight of Clubs Queen of Diamonds Three of Hearts Jack of Spades Five of Diamonds Jack of Diamonds Three of Diamonds Three of Clubs Six of Clubs Ten of Clubs Nine of Diamonds Ace of Hearts Queen of Hearts Seven of Spades Deuce of Spades Six of Hearts Deuce of Clubs Ace of Clubs Deuce of Diamonds Nine of Hearts Seven of Diamonds Six of Spades Eight of Diamonds Ten of Spades King of Hearts Four of Clubs Ace of Spades Ten of Hearts Four of Spades Eight of Hearts Eight of Spades Jack of Hearts Ten of Diamonds Four of Diamonds King of Diamonds Seven of Hearts King of Spades Queen of Spades Four of Hearts Nine of Clubs Six of Diamonds Deuce of Hearts Jack of Clubs King of Clubs Three of Spades Queen of Clubs Five of Clubs Five of Hearts Ace of Diamonds Outline fig08_27.cpp (4 von 4) Pearson Education, Inc. All rights reserved.

87 Funktionszeiger Zeiger auf Funktionen Enthalten Adressen von Funktionen Genau wie ein C-Arrayname die Adresse des ersten Elements des C-Arrays ist, ist ein Funktionsname die Startadresse des Codes, der die Funktion definiert. Funktionszeiger können An Funktionen übergeben werden Von Funktionen zurückgegeben werden In Arrays gespeichert werden Anderen Funktionszeigern zugewiesen werden

88 Funktionszeiger Aufruf von Funktionen über Zeiger Deklaration eines Funktionszeigers: bool ( *compare ) ( int, int ) Funktion über Zeiger ausführen entweder durch ( *compare ) ( int1, int2 ) Funktionszeiger wird explizit dereferenziert Oder einfach compare( int1, int2 ) Funktionszeiger wird automatisch dereferenziert (ähnlich wie bei C-Arraynamen)

89 Funktionszeiger Beispiel: Verallgemeinerung des Selection-Sort Algorithmus aus Abschnitt 8.7 für den Fall, dass der Benutzer durch ein Befehlszeilenargument vorgeben kann, ob aufsteigend oder absteigend sortiert werden soll selectionsort wird als Funktion höherer Ordnung realisiert, die als zusätzlichen Parameter einen Funktionszeiger für eine Prädikatsfunktion bekommt. Diese Prädikatsfunktion bestimmt die Sortierrichtung (ascending oder descending).

90 1 // Fig. 8.28: fig08_28.cpp 2 // Multipurpose sorting program using function pointers. 3 #include <iostream> 4 #include <iomanip> 5 #include <cstdlib> // exit and EXIT_FAILURE 6 using namespace std; 7 8 // prototypes Dieser Parameter ist ein Funktionszeiger auf eine Funktion, die zwei int Parameter übernimmt und ein bool Ergebnis zurückgibt 9 void selectionsort( int [], const size_t, bool (*)( int, int ) ); 10 bool ascending( int, int ); // implements ascending order 11 bool descending( int, int ); // implements descending order int main( int argc, char* argv[] ) // or:..., char** argv ) 14 { 15 const size_t arraysize = 10; 16 int a[ arraysize ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 }; // check number of command-line arguments 19 if( argc!= 2 ) { 20 cout << "Usage: fig08_28.exe -a (for sorting in ascending order)\n" 21 << " fig08_28.exe -d (for sorting in descending order)\n"; 22 exit( EXIT_FAILURE ); 23 } // output original array 26 cout << "Data items in original order\n"; 27 for( const int& element : a ) { 28 cout << setw( 4 ) << element; 29 } Outline fig08_28.cpp (1 von 4) Zeiger auf Zeiger auf char Pearson Education, Inc. All rights reserved.

91 30 // sort array in ascending or descending order 31 switch( argv[ 1 ][ 1 ] ) { // or: switch( *( *( argv + 1 ) + 1 ) ) { 32 case 'a': 33 selectionsort( a, arraysize, ascending ); 34 cout << "\ndata items in ascending order\n"; 35 break; 36 case 'd': 37 selectionsort( a, arraysize, descending ); 38 cout << "\ndata items in descending order\n"; 39 break; 40 default: 41 cout << "\nwrong command-line argument -> No sorting!\n"; 42 } // output sorted array 45 for( const int& element : a ) { 46 cout << setw( 4 ) << element; 47 } cout << endl; 50 } // end main Outline C-Arrayname und Zeiger/Versatz-Schreibweise fig08_28.cpp Übergabe der Funktionszeiger (2 von 4) ascending und descending in Parameter der Funktion selectionsort Pearson Education, Inc. All rights reserved.

92 51 52 // multipurpose selection sort; the parameter compare is a pointer to 53 // the comparison function that determines the sorting order 54 void selectionsort( int a[], const size_t size, 55 bool (*compare)( int, int ) ) 56 { 57 void swap( int * const e1ptr, int * const e2ptr ); // prototype 58 size_t smallestorlargest; // index of smallest (or largest) element // loop over size - 1 elements 61 for( size_t i = 0; i < size - 1; ++i ) { 62 smallestorlargest = i; // first index of remaining elements // loop to find index of smallest (or largest) element 65 for( size_t k = i + 1; k < size; ++k ) { 66 if ( compare( a[ k ], a[ smallestorlargest ] ) ) { 67 smallestorlargest = k; 68 } // end if 69 } // end inner for swap( &a[ smallestorlargest ], &a[ i ] ); 72 } // end outer for 73 } // end function selectionsort // swap values at memory locations to which e1ptr and e2ptr point 76 void swap( int * const e1ptr, int * const e2ptr ) 77 { 78 int hold = *e1ptr; 79 *e1ptr = *e2ptr; 80 *e2ptr = hold; 81 } // end function swap Outline compare ist ein Funktionszeiger auf eine Funktion, die zwei int Parameter übernimmt und ein bool fig08_28.cpp Ergebnis zurückgibt (3 von 4) Die Klammern sind notwendig als Hinweis auf einen Funktionszeiger Automatische Dereferenzierung des Zeigers compare, um Funktion auszuführen Pearson Education, Inc. All rights reserved.

93 82 83 // determine whether element a is less than 84 // element b for an ascending order sort 85 bool ascending( int a, int b ) 86 { 87 return a < b; // returns true if a is less than b 88 } // end function ascending // determine whether element a is greater than 91 // element b for a descending order sort 92 bool descending( int a, int b ) 93 { 94 return b < a; // returns true if a is greater than b 95 } // end function descending Outline fig08_28.cpp (4 von 4) 93 C:\fig08_28\Debug\fig08_28.exe Usage: fig08_28.exe -a (for sorting in ascending order) fig08_28.exe -d (for sorting in descending order) C:\fig08_28\Debug\fig08_28.exe -a Data items in original order Data items in ascending order C:\fig08_28\Debug\fig08_28.exe -d Data items in original order Data items in descending order Pearson Education, Inc. All rights reserved.