1 Statische Felder. Hinweise zur Speicherung von Feldern in C++ und C

Transkript

1 TU Ilmenau, Institut für Mathematik FG Numerische Mathematik und Informationsverarbeitung PD Dr. rer. nat. habil. W.Neunrf Datei: C FELDER.TEX Hinweise zur Speicherung von Feldern in C++ und C Es soll jech noch einmal in übersichtlicher Form die Deklaration, Definition und Verarbeitung von Feldern unter verschiedenen Aspekten dargestellt werden. Das betrifft nicht nur die Unterschiede zwischen den Sprachdialekten C++ und C, sondern auch die Verwendung von statischen und dynamischen Strukturen. Zunächst noch einmal die Zuordnung von einigen Objekten und Standardbezeichnern zu Header-Files. C++ #include <iostream.h> // fuer Objekte wie // cin, cout,... // getch, printf, scanf, stdin,... // EXIT_FAILURE,... #include <stdio.h> C //#include <iostream.h> //getch, printf, scanf,... #include <stdio.h> // koennen sonst entfallen // muss entfallen // falls mathematische Standardfunktionen auftreten werden automatisch erkannt // fuer Objekte wie // EXIT_FAILURE,... // stdin, stderr, stut,... // stdin,... enthaelt Header-File stdio.h 1 Statische Felder Statische bzw. nichtdynamische Felder (Array) sind hintereinander abgelegte Objekte gleichen Datentyps. Hier muss die Anzahl der Dimensionen und Elemente in einem Feld bei seiner Deklaration (also zur Programmierzeit) angegeben werden. Die Anwendung des Indizierungsoperators auf den Feldnamen ist nur deshalb möglich, weil der Compiler den Feldnamen in Anweisungen als Zeiger auf das erste Element de Feldes ansieht. Die Indizierung wird intern in die Zeigerberechnung umgewandelt. Eindimensionales Feld: feld[i] *(feld+i), i=0,1,2,... Zeigerarithmetik bedeutet, dass der Wert eines Zeigers bei der Addition oder Subtraktion nicht in Einheiten von Bytes, sondern in Einheiten von der Größe der Objekte, auf die der Zeiger zeigt, erhöht oder vermindert wird. Die gezeigten Programme arbeiten mit einem zweidimensionalen Feld. Es sind verschiedene Möglichkeiten der Deklaration der Anzahl der Elemente in den beiden Dimensionen gezeigt. Von diesem maximalen Feld wird in Abhängigkeit von der eingegebenen Zeilen- und Spaltenzahl nur ein Teil genutzt. Würden diese beiden Angaben (oder auch nur eine davon) die vereinbarte obere Grenze übersteigen, kommt es i. Allg. irgendwann während der Programmabarbeitung zu einer Fehlermeldung, in C++ eher als in C. a1stat.exe hat Fehler verursacht und wird geschlossen. Starten Sie das Programm neu. Ein Fehlerprotokoll wird erstellt. 1

2 C++ // a1stat.cpp // Felder: statisch #include <iostream.h> //#define nmax 50 const int nmax=50; // bzw. int nmax=50; uble A[nmax][nmax],sum,max; int n,m,i,j; cout<<"zeilensummennorm einer max. (50,50)-Matrix\n\n"; cout<<"eingabe Zeilenzahl n (0<n<=50): "; cin>>n; while ((n<=0) (n>50)); cout<<"eingabe Spaltenzahl m (0<m<=50): "; cin>>m; while ((m<=0) (m>50)); cout<<"a["<<i<<","<<j<<"] = "; cin>>a[i][j]; cout<<"\nzeilensummennorm = "<<max; C // a1stat.c // Felder: statisch //#include <iostream.h> //#define nmax 50 const int nmax=50; // bzw. int nmax=50; uble A[nmax][nmax],sum,max; int n,m,i,j; char ret; printf("zeilensummennorm einer max. (50,50)-Matrix\n\n"); printf("eingabe Zeilenzahl n (0<n<=50): "); scanf("%i",&n); while ((n<=0) (n>50)); 2

3 printf("eingabe Spaltenzahl m (0<m<=50): "); scanf("%i",&m); while ((m<=0) (m>50)); printf("a[%i,%i] = ",i,j); scanf("%lf",&a[i][j]); printf("\nzeilensummennorm = %lf",max); // Tastaturpuffer leeren fflush(stdin); // stdin in stdio.h bzw. conio.h // anstelle von getch() Eingabe- und Ergebnisfenster zu a1stat.c C:\d\Neunrf\nwptexte\tech phy\05\cpp gpp gcc\a1stat.exe Zeilensummennorm einer max. (50,50)-Matrix Eingabe Zeilenzahl n (0<n<=50): 2 Eingabe Spaltenzahl m (0<m<=50): 5 A[0,0] = 1 A[0,1] = 2 A[0,2] = 3 A[0,3] = -1 A[0,4] = -2 A[1,0] = 4 A[1,1] = 5 A[1,2] = 6 A[1,3] = 0 A[1,4] = -1 Zeilensummennorm =

4 2 Dynamische Felder Dynamische Felder (Array) sind ebenfalls Objekte gleichen Datentyps. Hier muss die Anzahl der Dimensionen und Elemente in einem Feld erst zur Laufzeit des Programms feststehen und kann sich daher den aktuellen Gegegebenheiten anpassen. Die dynamische Reservierung von Feldern ist mit der Verwendung von Zeigern verbunden. Die Anwendung des Indizierungsoperators auf den Feldnamen ist deshalb möglich, weil der Compiler den Feldnamen in Anweisungen als Zeiger auf das erste Element de Feldes ansieht. Die Indizierung und Zeigerberechnung sind ineinander umwandelbar. Die dynamische Speicherallokation mittels den Zeiger reserviert den gewünschten Speicherplatz, der dann üblicherweise auch wieder freizugeben ist, bevor der Zeiger nicht mehr genutzt, ungültig oder umgelenkt wird (Vermeidung von so genannten Speicherlecks). Speicherallokation Speicherfreigabe C++ new delete C++/C malloc() free() In der Zeigerprogrammierung sind u. a. wichtig die Deklaration von Zeigern mit dem bestimmten Datentyp, generische Zeiger (void) ohne Typbezogenheit, explizite Typumwandlung bei Zeigern, Zeiger und Felder, Zeigerarithmetik und Zeiger auf Zeiger. Die Typumwandlung bei Zeigern ist in den Projekten gauss4c,..., gauss4cpp2 zum Gauß-Algorithmus und speziell in der Funktion lamatrixneu_ schon mehrfach verwendet worden. Am Beispiel eines zweidimensionalen Felds (rechteckige Matrix) sollen einige Aspekte demonstriert werden. Halbdynamische Felder Zunächst soll speicherplatzsparend dadurch gearbeitet werden, dass bei fester maximaler Matrixzeile mit spmax Elementen (=Spalten) die Anzahl der Zeilen in Abhängigkeit von der aktuell eingegebenen Größe n festgelegt wird. Für die Matrixelemente braucht man dann n*spmax Speicherplatz von gegebenem Elementtyp (hier uble). Dazu kommt noch Speicherplatz für etwas Adressverwaltung. C++ Das ist die kurze und elegante Version unter Verwendung eines Zeigervektors (Vektor von Zeigern). Damit liegen die Matrixzeilen im Speicher genau hintereinander und es ist A[i] = *(A+i). Die Matrixelemente können mittels A[i][j] oder *(*(A+i)+j) aufgerufen werden. // a1hdyn1.cpp // Felder: halbdynamisch, Zeigervektor, new-delete #include <iostream.h> 4

5 //#define spmax 50 const int spmax=50; typedef uble vektor[spmax]; // maximale Spaltenzahl // Typ des Zeilenvektors uble max,sum; cout<<"zeilensummennorm einer (n,m)-matrix, m<=50\n\n"; cout<<"eingabe Zeilenzahl n (0<n): "; cin>>n; while (n<=0); cout<<"eingabe Spaltenzahl m (0<m<=50): "; cin>>m; while ((m<=0) (m>50));, damit A[i] = *(A+i) vektor *A = new vektor[n]; // n beliebig cout<<"a["<<i<<","<<j<<"]= "; cin>>a[i][j]; cout<<"\nzeilensummennorm = "<<max; delete []A; C Verwendung des Zeigervektors. Ein Feld von Zeigern (Zeigerfeld) auf den Datentyp T wird als T *ptr[anzahl] deklariert. Dies ist nicht mit einem Zeiger auf ein Feld vom Typ T gemäß T (*ptr)[anzahl] zu verwechseln. Da die Deklaration des Zeigerfelds mit einer festen Feldgrenze erfolgen muss, gibt man rt eine maximale obere Schranke an. Die eingegebene Anzahl der Zeilen sollte dann nicht größer als diese Schranke sein. Die Dynamik der Allokation von Speicherplatz für die Matrixzeilen besteht dann darin, dass man nur Platz für die gewünschten Zeilen allokiert. Ist die eingegebene Zeilenzahl größer als die Schranke, wird es i. Allg. während der Programmabarbeitung zur Fehlermeldung und damit zum Abbruch kommen. Programmfehler a1stat.exe hat Fehler verursacht und wird geschlossen. Starten Sie das Programm neu. Ein Fehlerprotokoll wird erstellt. Damit ist die dynamische Speicherverwaltung bezüglich der Zeilen nicht vollständig machbar. 5

6 // a1hdyn1.c // Felder: halbdynamisch mit Kontrolle, Zeigervektor, malloc-free //#define spmax 50 //#define zemax 50 const int spmax=50; const int zemax=50; typedef uble vektor[spmax]; uble *A[zemax]; // maximale Spaltenzahl // maximale Zeilenzahl // Typ des Zeilenvektors // Feld (Vektor) von Zeigern uble max,sum; char ret; printf("zeilensummennorm einer (n,m)-matrix, n,m<=50\n\n"); printf("eingabe Zeilenzahl n (0<n<=50): "); scanf("%i",&n); while ((n<=0) (n>50)); printf("eingabe Spaltenzahl m (0<m<=50): "); scanf("%i",&m); while (m<=0 m>50); //if ((*(A+i) = (uble*) malloc(sizeof(vektor)))==null) if ((A[i] = (uble*) malloc(sizeof(vektor)))==null) // analog printf("a[%i,%i] = ",i,j); scanf("%lf",&a[i][j]); // sum=sum+fabs(*(*(a+i)+j)); printf("\nzeilensummennorm = %lf",max); fflush(stdin); for (i=0;i<n;i++) free(*(a+i)); Nun soll ein Zeiger auf Zeiger genutzt werden. Dabei erkennt man, was notwendig wäre, um auch in der Spaltendimension dynamisch zu werden. Man braucht die Reservierung der Matrixzeilen nur mit der eingelesenen Länge m anstelle von spmax zu machen. 6

7 // a1hdyn2.c // Felder: halbdynamisch mit Kontrolle, Zeiger auf Zeiger, malloc-free //#define spmax 50 const int spmax=50; typedef uble vektor[spmax]; uble **A; // maximale Spaltenzahl // Typ des Zeilenvektors uble max,sum; char ret; printf("zeilensummennorm einer (n,m)-matrix, m<=50\n\n"); printf("eingabe Zeilenzahl n (0<n): "); scanf("%i",&n); while (n<=0); printf("eingabe Spaltenzahl m (0<m<=50): "); scanf("%i",&m); while ((m<=0) (m>50)); if ((A = (uble**) malloc(n*sizeof(uble*)))==null) // if ((*(A+i) = (uble*) malloc(spmax*sizeof(uble)))==null) // analog if ((*(A+i) = (uble*) malloc(sizeof(vektor)))==null) printf("a[%i,%i] = ",i,j); scanf("%lf",&a[i][j]); printf("\nzeilensummennorm = %lf",max); fflush(stdin); free(*(a+i)); free(a); 7

8 Dynamische Felder Verwendung des Konzepts Zeiger auf Zeiger für beide Sprachdialekte. C++ 4 Programmversionen // a1dyn1.cpp // Felder: dynamisch, Zeiger auf Zeiger, new-delete #include <iostream.h> typedef uble **matrix; // Typ der Matrix matrix A; // uble **A; // einfache Schreibweise uble max,sum; cout<<"zeilensummennorm einer (n,m)-matrix\n\n"; cout<<"eingabe Zeilenzahl n (0<n): "; cin>>n; while (n<=0); cout<<"eingabe Spaltenzahl m (0<m): "; cin>>m; while (m<=0); // mit Umtypisierung // einfache Variante a1dyn2.cpp (char*)a = new char[n*sizeof(uble*)]; // A = new uble*[n]; *(A+i) = new uble[m]; cout<<"a["<<i<<","<<j<<"]= "; cin>>a[i][j]; cout<<"\nzeilensummennorm = "<<max; delete [](*(A+i)); delete [](char*)a; // einfache Variante a1dyn2.cpp // delete []A; /* */ 8

9 // a1dyn3.cpp // Felder: dynamisch mit Kontrolle, Zeiger auf Zeiger, new-delete #include <iostream.h> typedef uble **matrix; // Typ der Matrix matrix A; // uble **A; // einfache Schreibweise uble max,sum; cout<<"zeilensummennorm einer (n,m)-matrix\n\n"; cout<<"eingabe Zeilenzahl n (0<n): "; cin>>n; while (n<=0); cout<<"eingabe Spaltenzahl m (0<m): "; cin>>m; while (m<=0); // Fehlermeldung? // ev. "Nicht genuegend virtueller Speicher, // Auslagerungsdatei vergroessern,..." if ((A = new uble*[n])==null) if ((*(A+i) = new uble[m])==null) cout<<"a["<<i<<","<<j<<"]= "; cin>>a[i][j]; cout<<"\nzeilensummennorm = "<<max; delete [](*(A+i)); delete [](char*)a; /* */ 9

10 // a1dyn4.cpp // Felder: dynamisch mit Kontrolle, Zeiger auf Zeiger, malloc-free //#include <iostream.h> typedef uble **matrix; // Typ der Matrix matrix A; // uble **A; // einfache Schreibweise uble max,sum; char ret; printf("zeilensummennorm einer (n,m)-matrix\n\n"); printf("eingabe Zeilenzahl n (0<n): "); scanf("%i",&n); while (n<=0); printf("eingabe Spaltenzahl m (0<m): "); scanf("%i",&m); while (m<=0); if (((void*)a = malloc(n*sizeof(uble*)))==null) if (((void*)(*(a+i)) = malloc(m*sizeof(uble)))==null) printf("a[%i,%i] = ",i,j); scanf("%lf",&a[i][j]); printf("\nzeilensummennorm = %lf",max); fflush(stdin); free(*(a+i)); free(a); Die Analogie zur Version a1dyn4.cpp ohne den generischen Zeiger void* gibt es auch in C. 10

11 C // a1dyn4.c // Felder: dynamisch mit Kontrolle, Zeiger auf Zeiger, malloc-free typedef uble **matrix; // Typ der Matrix matrix A; // uble **A; // einfache Schreibweise uble max,sum; char ret; printf("zeilensummennorm einer (n,m)-matrix\n\n"); printf("eingabe Zeilenzahl n (0<n): "); scanf("%i",&n); while (n<=0); printf("eingabe Spaltenzahl m (0<m): "); scanf("%i",&m); while (m<=0); // Fehlermeldung? // ev. "Nicht genuegend virtueller Speicher, // Auslagerungsdatei vergroessern,..." if ((A = malloc(n*sizeof(uble*)))==null) if ((*(A+i) = malloc(m*sizeof(uble)))==null) printf("a[%i,%i] = ",i,j); scanf("%lf",&a[i][j]); printf("\nzeilensummennorm = %lf",max); fflush(stdin); free(*(a+i)); free(a); 11