Programmierung I Arrays und Strings

Transkript

1 Das C++ Typsystem Programmierung I Arrays und Strings simple address poer reference structured Wersemester 2004/2005 University Bonn Dr. Gabriel Zachmann egral enum floating char bool short long float double long double struct union array Problem Arrays! Meßwertreihe einlesen, Mittelwert berechnen, von allen Werten abziehen, mittelwertbereinigte Reihe wieder rausschreiben! Programm muß Reihe 2x durchgehen! Lösung: Daten ern zunächst abspeichern, dann über diese 2x laufen! Benötigt: Datenstruktur zur einfachen Verwaltung vieler Daten mit identischem Typ! Lösung: neues Sprachkonstrukt! Wahrscheinlich häufigste Datenstruktur! Zusammenhängender Speicherblock, der Folge von gleichartigen Elementen enthält (Bsp. Vektor)! Deklaration: Typ arrayname[n]; wobei Typ ein bekannter Typ ist, n Konstante.! Terminologie:! Arrayname heißt "Array von Elementen des Typs T"! Kurz "T-Array" (Bsp. "float-array")! T selbst kann einfach oder wieder zusammengesetzt sein! T heißt auch "Basistyp" a[8]; n = 5; char b[n]; // 8 's // n char's! Danach sieht a im Speicher so aus: a[0] a[1] a[2] a[7]????????????????! Speicher ist also reserviert ("allocated"), aber nicht initialisiert (daher??)! Zugriff: arrayname[-expr] wobei -expr ein Ausdruck ist, der ein liefert.! Achtung! Index läuft ab 0! D.h., die Elemente von a[8] laufen von a[0],, a[7].! Kein Bounds-Checking!! Zugriff auf a[17] und a[-1] liefert höchstens ein Warnung vom Compiler!! I.A. erfolgt Zugriff über nicht-konstante -expr, deren Wert man nicht kennt

2 Beziehung zwischen Arrays und Poern a[8]; // -array mit 8 Elementen for ( k = 0; k < 8; k ++ ) a[k] = k; // Initialisierung a[0] a[1] a[2] a[7] ! Arrays gibt es eigentlich gar nicht in C++!! Arrays werden mit const-poer und Poer-Arithmetik implementiert:! Deklaration a[10] tut 2 Dinge:! Reserviert Speicherblock für 10 's! Deklariert * const a; und initialisiert a mit Adresse des ersten Elements! Elementzugriff ist Poer-Arithmetik:! Ausdruck a[i] ist äquivalent zu *(a+i)! Dieser Zusammenhang ist sehr wichtig, sonst wird man Arrays in C++ nie ganz verstehen! Dynamische Arrays a a[0] 1.5 a[1] a[2] a[3] a[4] a+1 a+3 a[3] = 0, 1, 2, 3 ; * q = a; // Zuweisung von Poern * p = & a[0]; // Anfangsadr. über Adress-Operator // p, q zeigen jetzt auf dasselbe Element *p = 1; // a = 1, 1, 2, 3 q[1] = *(a+2); // a = 1, 2, 2, 3 q += 2; // q zeigt jetzt auf a[2] q[0] = 3; // a = 1, 2, 3, 3! Problem: Größe der Arrays ist zur Compile-Zeit nicht klar! Lösung: Arrays auf dem Heap! Featured in C++: new T[n]; delete [] poer;! Resultat von new T[n] = Poer auf T = T* float* fa = new [n]; delete[] fa; a = q; // error Mehrdimensionale Arrays beliebig große Vektoren einlesen anzahl; prf("geben Sie die Anzahl ein: "); scanf( "%d", &anzahl ); float* vector = new float[anzahl]; for ( i = 0; i < anzahl; i ++ ) scanf("%f", &vector[i] );! Als Basistyp kann man wieder Array schreiben float a[6][4]; // matrix mit 6 Zeilen und 4 Spalten! Allgemein: T arrayname[n 1 ][n 2 ] [n d ] deklariert d-dimensionales T-Array.! Speicherlayout:! Ein-dimensionales Array (logisch)! Die ersten n d Elemente entsprechen a[0] [0][0],, a[0] [0][n d -1]! Die nächsten n d Elemente entsprechen a[0] [1][0],, a[0] [1][n d -1]! Heißt "row-major ordering"

3 2D Arrays (Matrix) Arrays von Arrays matrix[6][4]; // fill with *p = matrix[0]; *p *(matrix[4] 4) matrix[0][0] *(p+7) p * 0x259f67c 0x259f678 0x259f674 0x259f670 0x259f66c 0x259f668 0x259f62c 0x259f628 0x259f624 0x259f620 matrix ** matrix[0] *! Achtung: Man kann mehr-dimensionale Arrays wie eben beschrieben erzeugen, oder als Arrays von Arrays!! Array von Array: * array_of_array[6]; // Array von Zeigern auf for ( i = 0; i < 6; i ++ ) array_of_array[i] = new [4];! Zugriff wie gehabt: x = m[i][j]; matrix[5][3] Gleiche Adresse, verschiedener Typ! Was passiert ern beim Zugriff?! Damit kann man auch nicht-rechteckige mehrdimensionale Arrays erzeugen: * diag_matrix[6]; for ( i = 0; i < 6; i ++ ) diag_matrix[i] = new [6-i];! Rechteckiges mehrdimensionales Array: float m[6][4]; x = m[i][j]; // ist äquivalent zu x = *( m + 6*i + j); // Poer-Arithmetik! Array von Arrays: diag_matrix float* m[6]; for ( i = 0; i < 6; i ++ ) m[i] = new [4]; x = m[i][j]; // ist äquivalent zu x = *(*( m + 6*i) + j); // "Poer-Chasing"!! Fazit: Zugriff auf Array von Arrays ist i.a. langsamer! Zugriff auf Speicher ist langsamer als Rechenoperationen! Cache-Misses! Poers in Array-Deklarationen Statische Initialisierung! Was ist der Unterschied zwischen! Die erste Deklaration liefert ein Array von Zeigern j *j[4]; (*p)[4];! Syntax: smallprimes[7] = 2, 3, 5, 7, 11, 13, 17; float rotmatrix[2][2] = cos(a), sin(a), -sin(a), cos(a) ;! Die zweite liefert einen Zeiger auf ein Array p

4 Funktionentabelle Übersetzungstabellen enum SuitE HEARTS = 0, DIAMONDS, CLUBS, SPADES, NUM_SUITES ; char *suit[ NUM_SUITES ] = "Hearts", "Diamonds", "Clubs", "Spades" ; foo() SuitE card; prf(" %s \n", suit[card] );! Array von Funktionszeigern float a( float x ); // analog Fkt.en b(), c(), float (*func_table[])( float ) = a, b, c, d, e ; char c = getchar(); while ( c!= EOF ) i = c 'a'; prf("%f", (*func_table[i])( x ) ); Arrays als Parameter von Funktionen Mehrdimensionale Arrays als Parameter! Erinnerung: Arrays sind spezielle, konstante Poer! Konsequenz:! Call-by-Value geht nicht mit Arrays! Folgende drei Deklarationen sind äquivalent! Achtung: man muß alle Dimensionen (außer evtl. der letzten) im Prototyp angeben! void foo( m[4][4] ); void foo( m[4][] ); // äquivalent zur ersten Dekl. void foo( * a ); void foo( a[sizeofa] ); void foo( a[] );! Macht auch Sinn (Performance)! Es gibt ja immer noch const! Läßt man alle Dimensionen weg, denkt der Compiler, die Funktion bekommt ein Array von Arrays! Erinnerung: Zugriff auf Elemente geschieht durch "poer chasing", bei mehrdimensionalen Arrays durch Poer-Arithmetik void foo( m[][] ); // Fehlermeldung vom Compiler void foo( ** m ); // Array von Arrays Strings C-Strings! 2 Arten:! Ist ein 0-terminiertes Char-Array! "C-Strings"! "C++ Strings" char s[5]; s[0] = 'h'; s[4] = 'o'; s[5] = '\0'; h e l l o \0! Initialisierung von Char-Arrays char s[] = "hello";! Compiler erzeugt automatisch Array passender Größe! String-Konstante "hello" ist selbst 0-terminiert, also wird diese 0 mit ins Array kopiert.

5 Standard-Library-Funktionen zu C-Strings! Bekommt man durch! #include <string.h> char *strcpy( char *s1, const char *s2 ); char *strcat( char *s1, const char *s2 ); strcmp( const char *s1, const char *s2 ); size_t strlen( const char *s ); Copies the string s2 o the character array s1. The value of s1 is returned. Appends the string s2 to the string s1. The first character of s2 overwrites the terminating null character of s1. The value of s1 is returned. Compares the string s1 with the string s2. The function returns a value of zero, less than zero or greater than zero if s1 is equal to, less than or greater than s2, respectively. Determines the length of string s. The number of characters preceding the terminating null character is returned.! Achtung: Kein Bounds-Checks!! Verwende immer die strn -Variante, wenn möglich! char *strncpy( char *s1, const char *s2, size_t n );! Weitere Funktionen: siehe man string! Zeichenklassen: isalpha( char c ); isalnum, isupper, ispr, isspace, Copies at most n characters of the string s2 o the character array s1. The value of s1 is returned. Test, ob Zeichen einer bestimmten Klasse angehört. Kommandozeilenparameter! Umwandlungen: atoi, atol, strtol, atof, strtod sprf( char *str, const char *format, ); toupper( char c ); tolower( char c ); Umwandlung von String nach Zahl. Umwandlung der built-in types nach String. Konvertierung zwischen lower-case und upper-case (gemäß dem aktuellen Locale)! Spezielles Array von Poern: t e s t \0 h e l l o \0 0xefffa0d0 0xefffaad0 char* argv[]! Einlesen / Ausgeben: prf(), puts, fprf, fputs gets, fgets, getchar, getc Ausgeben auf stdout bzw. einem anderen File String bzw. Einzelnes Zeichen lesen. myprog a v infile outfile! Unix erzeugt daraus folgendes char*-array a:! Solch eine Array wird immer von Unix an main() übergeben (1. und 2. Parameter)! Enthält Kommandozeilenparameter und -optionen! Der Prototyp von main lautet darum immer: a[0] a myprog\0 a[0][6] main( argc, char* argv[] );! Manche schreiben auch: char **argv -a\0 -v\0 all\0 infile\0 outfile\0

6 Parsen main( argc, char* argv[] ) parsecommandline( argc, argv ); void parsecommandline( argc, char* argv[] ) argv ++ ; argc -- ; // skip program name while ( argc > 0 ) if ( argv[0][0] == '-' ) // option switch ( argv[0][1] ) case 'h': commandlineerror( NULL ); break; case 'v': Verbose = true; break; case 'a': Acceleration = atof( argv[1] ); argv ++ ; argc -- ; break; default: commandlineerror( argv[0] ); argv ++ ; argc -- ; else // Parameter // Überprüfe Konsistenz und Wertebereich der // Optionen und Parameter! Der argv[0]-trick void commandlineerror( char* option ) if ( option ) fprf( stderr, "Cannot parse command line option %s!\n", option ); fputs("usage: program [options ]\n" "-h help\n" "-a float acceleration\n" "-v verbose\n", stderr ); exit(1);! In argv[0] steht der Name des Programms! Damit kann das Programm 2 Dinge herausfinden: 1. Wo befindet sich mein Exec auf der Platte?! Falls argv[0] mit / anfängt ist alles klar! Sonst: PWD davor hängen (getcwd()) 2. Wie heißt das Executable?! Durch Symlinks (und Hardlinks) kann ein Programm über beliebig viele Namen gestartet werden gzip/gunzip! gunzip = gzip d