Programmieren in C Klausur im Sommersemester 2015 Seite 1 von 1

Klausur im Sommersemester 2015 Seite 1 von 1 Aufgabe 1 ( 20 % ) Ergänzen Sie das folgende Programm um die Funktion nulldurchgang. Sie soll den Index des Feldelements bestimmen, nach welchem die monoton steigenden Werte im übergebenen Feld das Vorzeichen wechseln. // Vorlageprogramm /////////////////////////////////////////////////////////////// // #include <cstdio> int main( void ) int i; double x[]= -10.0,-9.0,-8.0,-7.0,-6.0,-5.0,-4.0,-3.0,-2.0,-1.0,0.1,1.0,2.0 ; i = nulldurchgang( x, sizeof(x)/sizeof(double) ); if( i >= 0 ) fprintf( stdout, "*** Nulldurchgang nach Element %d\n", i ); fprintf( stdout, "*** Nulldurchgang vor Element 0\n", i ); // ////////////////////////////////////////////////////////////////////////////////// Aufgabe 2 ( 25 % ) Ändern Sie das Programm. Mit main soll es nun über das Terminal eine Feldlänge abfragen, eingeben und den Speicher dafür anfordern. Die neu zu erstellende Funktion werte soll dann die Werte wie in der Vorlage oben in den angeforderten Speicher kopieren, je nach der angeforderten Größe des Speichers aber evtl. nicht alle. Danach soll nulldurchgang unverändert weiter genutzt werden. Programmabsturz oder die Verarbeitung undefinierter Werte sind selbstverständlich verboten. Aufgabe 3 ( 25 % ) Ersetzen Sie die Terminaleingabe aus Aufgabe 2, indem Ihr Programm die Feldlänge aus der Kommandozeile des Programmaufrufs übernimmt, anstatt über den Terminaldialog. Aufgabe 4 ( 30 % ) Das Programm soll nun die Werte des Felds aus einer Datei lesen. Der Name der Datei wird mit dem Aufruf in der Kommandozeile an das Programm übergeben. Die Anzahl Feldelemente soll das Programm aus der Anzahl der Werte bestimmen, die in der Datei vorhanden sind. Schreiben Sie dafür die Funktion gibanzahl, die diese Anzahl an main zurückgibt. Die Standardfunktion int feof( FILE * stream ); hilft dabei: mit Rückgabe TRUE zeigt sie an, wenn im Lesevorgang das Ende der Datei erreicht ist. Schreiben Sie außerdem die Funktion gibwerte, die alle Werte aus der Datei in das vorher von main angeforderte Feld schreibt. Damit Sie Ihre Lösung erproben können, legen Sie mit der Entwicklungsumgebung die Datei werte.txt mit Inhalt wie in der Vorlage oben an: Menü "Datei", "Neue Datei", Kategorie Textdatei, Werte von oben mit Copy-Paste, Leerzeichen anstelle Komma als Trenner zwischen den Zahlen, "Speichern unter " im Debug- Ordner Ihres Projekts.

Klausur im Sommersemester 2015 Seite 1 von 3 Aufgabe 1 ( 25 % ) #include <cstdio> int nulldurchgang( double * w, int n ); // P // int main( void ) // s. Vorlage int nulldurchgang( double * w, int n ) int i; for( i=0 ; i<n /* P */ ; ++i ) // P // if( w[i] >= 0.0 ) // P // break; // P // return i-1; // P // Aufgabe 2 ( 40 % ) #define _CRT_SECURE_NO_WARNINGS #include <cstdio> int werte( double * w, int n ); int nulldurchgang( double * w, int n ); int main( void ) int i, n; double * x; // P // fprintf( stdout, "*** Feldlaenge eingeben: N = " ); fflush( stdin ); fscanf( stdin, "%d", & n ); // P // x = new double[n]; // P // if( x == NULL ) // P // fprintf( stdout, "*** Fehler: kein Speicher!\n" ); if( werte( x, n ) < n ) // P // fprintf(stdout,"*** Anzahl W < Feldlaenge N! Verarbeite nur W Werte.\n" ); i = nulldurchgang( x, n ); if( i >= 0 ) fprintf( stdout, "*** Nulldurchgang nach Element %d\n", i ); fprintf( stdout, "*** Nulldurchgang vor Element 0\n", i ); delete x; int werte( double * w, int n ) // P // double y[]=-10.0,-9.0,-8.0,-7.0,-6.0,-5.0,-4.0,-3.0,-2.0,-1.0,0.1,1.0,2.0,3.0 ; if( n > sizeof(y)/sizeof(double) ) // P // n = sizeof(y)/sizeof(double); for( int i=0 ; i<n ; ++i ) // P // w[i] = y[i]; return n; int nulldurchgang( double * w, int n ) //...

Klausur im Sommersemester 2015 Seite 2 von 3 Aufgabe 3 ( 25 % ) #define _CRT_SECURE_NO_WARNINGS #include <cstdio> #include <cstdlib> int werte( double * w, int n ); int nulldurchgang( double * w, int n ); int main( int argc, char * argv[] ) // P // int i, n; char * cp; // P // double * x; if( argc!= 2 ) // P // fprintf( stdout, "*** Fehler: Programmaufruf ohne Anzahl Feldelemente - Ende" ); n = strtoul( argv[1], &cp, 10); // P // if( cp == NULL ( *cp!= '\0' && *cp!= '\n' ) ) // P // fprintf( stdout, "*** Fehler: falsche Anzahl im Programmaufruf - Ende" ); x = new double[n]; if( x == NULL ) fprintf( stdout, "*** Fehler: kein Speicher!\n" ); if( werte( x, n ) < n ) fprintf(stdout,"*** Anzahl W < Feldlaenge N! Verarbeite nur W Werte.\n" ); i = nulldurchgang( x, n ); if( i >= 0 ) fprintf( stdout, "*** Nulldurchgang nach Element %d\n", i ); fprintf( stdout, "*** Nulldurchgang vor Element 0\n", i ); delete x; int werte( double * w, int n ) //... int nulldurchgang( double * w, int n ) //...

Klausur im Sommersemester 2015 Seite 3 von 3 Aufgabe 4 ( 50 % ) //... int gibanzahl( char * filename ); // P // int gibwerte( char * filename, double * x, int n ); // P // int nulldurchgang( double * w, int n ); int main( int argc, char * argv[] ) int i, n; double * x; if( argc!= 2 ) fprintf( stdout, "*** Fehler: Programmaufruf ohne Eingabedatei - Ende" ); if( ( n = gibanzahl( argv[1] ) ) < 0 ) // P // fprintf( stdout, "*** Fehler: kann Datei %s nicht oeffnen - Ende" ); if( n == 0) fprintf( stdout, "*** Fehler: Eingabedatei ohne Inhalt- Ende" ); x = new double[n]; if( x == NULL ) fprintf( stdout, "*** Fehler: kein Speicher!\n" ); gibwerte( argv[1], x, n ); // P // i = nulldurchgang( x, n ); if( i > 0 ) fprintf( stdout, "*** Nulldurchgang nach Element %d\n", i ); fprintf( stdout, "*** Nulldurchgang vor Element 0\n", i ); delete x; int gibanzahl( char * filename ) FILE * fp; // P // char eingabe[21]; int i, n; if( ( fp = fopen( filename, "r" )) == NULL ) // P // n = -1; for( i=0;!feof(fp) ; ++i ) // P // fscanf( fp, "%s", eingabe ); // P // n = i; fclose( fp ); // P // return n; // P // int gibwerte( char * filename, double * x, int n ) int i; FILE * fp = fopen( filename, "r" ); if( fp == NULL ) return -1; for( i=0; i<n ; ++i ) fscanf( fp, "%lg", x+i ); fclose( fp ); return i; int nulldurchgang( double * w, int n ) /*... */

Klausur im WS 2014/15 Seite 1 von 1 Bearbeitungszeit: 90 min Hilfsmittel: Eigene Unterlagen nach Wahl Aufgabe 1 ( 30 % ) ////////////////////////////////////////////////////////////////// #ifdef WIN32 #define _CRT_SECURE_NO_WARNINGS #endif #include <cstdio> #define N 120 int main( void ) pkt punktefeld[n]; // Folge nummerierter Punkte in 2D int n=n; punkte_eingabe( punktefeld, n, stdin ); ////////////////////////////////////////////////////////////////// Vervollständigen Sie dies Vorlageprogramm um folgende Eigenschaften: 1.1 die Datentypdefinition für einen Punkt in 2D mit Nummer und den Koordination x und y. 1.2 den Prototype der Funktion punkte_eingabe. 1.3 die Funktionsdefinition. Sie soll die Punkte beginnend mit 0 in der Reihenfolge ihrer Eingabe nummerieren. Aufgabe 2 ( 40 % ) //... int main( void ) char dateiname[] = "punktefolge.txt"; // Eingabedatei für die Punkte //... Ihr Vorlage- oder das Lösungsprogramm der Aufgabe 1 soll nun die Werte der Punkte aus der Eingabedatei übernehmen und die Punktefolge in einem dynamisch angelegten Feld speichern. Seine Größe oder Länge bestimmt es aus der Anzahl der Werte in der Eingabedatei. Ändern Sie das Programm entsprechend. Aufgabe 3 ( 30 % ) 3.1 Ändern Sie die Vorlage oder Ihre Lösung zur Aufgabe 2 nun so, dass das Programm mit seinem Aufruf den Namen der Eingabedatei aus der Kommandozeile übernimmt. 3.2 Falls das Programm zusätzlich zum Namen der Eingabedatei mit einen weiteren Parameter aufgerufen wird (auf dessen Inhalt es nicht ankommt), soll es eine Kontrollausgabe der eingegebenen Punkte ausführen. Aufgabe 4 ( 30 % ) Um jederzeit stabil zu laufen, muss das Programm dieser Klausur in seinem Ablauf an einigen Stellen Erfolg und Misserfolg (Fehler) unterscheiden, z.b. wenn es die Eingabedatei nicht öffnen kann. Jeden irgendwann eingetretenen Fehler soll das Programm Bit für Bit in einem Statuswort vermerken. Dieses soll am Ende als Argument von return an irgendeinen aufrufenden Prozess übergeben werden: int main( /*... */ ) int status = 0; // hier können sich bei Fehlern im Ablauf einige Bits von status ändern... return status; 4.1 Formulieren Sie einen Header, der für jeden aus Ihrer Sicht zu berücksichtigenden Fehler ein Makro für das entsprechende Bit im Statuswort festlegt. 4.2 Ergänzen Sie Ihr Lösungsprogramm aus Aufgabe 3 oder ersatzweise Aufgabe 2 um die Aktualisierung des Statusworts bei Fehlern. 4.3 Stellen Sie unmittelbar vor dem return am Ende des Programms den Aufruf einer Funktion, die für jedes gesetzte Bit im Statuswort eine entsprechende Meldung auf der Konsole ausgibt.

Klausur im WS 2014/15 Seite 1 von 4 Aufgabe 1 ( 30 % ) 1.1 ////////////////////////////////////////////////////////////////// struct pkt int nr; double x, y; ; ////////////////////////////////////////////////////////////////// 1.2 ////////////////////////////////////////////////////////////////// void punkte_eingabe( pkt * p, int n, FILE * eingabe ); ////////////////////////////////////////////////////////////////// 1.3 ////////////////////////////////////////////////////////////////// void punkte_eingabe( pkt * w, int n, FILE * eingabe ) // // for( int i=0; i<n ; ++i ) // w[i].nr = i; fscanf( eingabe, "%lg", & (w+i)->x ); fscanf( eingabe, "%lg", & (w+i)->y ); //////////////////////////////////////////////////////////////////

Klausur im WS 2014/15 Seite 2 von 4 Aufgabe 2 ( 40 % ) ////////////////////////////////////////////////////////////////// //... void punkte_eingabe( pkt * p, int n, FILE * eingabe ); int punkte_anzahl( FILE * eingabe ); //... int main( void ) char dateiname[] = "punktefolge.txt"; // Eingabedatei für die Punkte //... FILE * input; // if( ( input = fopen( dateiname, "r" ) )!= NULL ) n = punkte_anzahl( input ); if( ( punktefeld = new pkt[n] )!= NULL ) punkte_eingabe( punktefeld, n, input ); fclose( input ); ////////////////////////////////////////////////////////////////// int punkte_anzahl( FILE * eingabe ) // // int zaehler = 0; char buffer1[61], buffer2[61]; while (! feof( eingabe ) ) if( fscanf( eingabe, "%s %s", buffer1, buffer2 ) == 2 ) ++zaehler; rewind( eingabe ); return zaehler; // // ////////////////////////////////////////////////////////////////// void punkte_eingabe( pkt * w, int n, FILE * eingabe ) // // // wie bei Aufgabe 1.2 //////////////////////////////////////////////////////////////////

Klausur im WS 2014/15 Seite 3 von 4 Aufgabe 3 ( 30 % ) 3.1 ////////////////////////////////////////////////////////////////// int main( int argc, char * argv[] ) pkt * punktefeld; int n; FILE * input; // if( argc == 2 ) if( ( input = fopen( argv[1], "r" ) )!= NULL ) // wie A 2 ////////////////////////////////////////////////////////////////// 3.2 ////////////////////////////////////////////////////////////////// //... //... if( argc == 2 argc == 3 ) // anstelle if( argc == 2 ) in 3.1 //... wie A 3.1 if( argc == 3 ) for( int i=0 ; i<n ; ++i ) fprintf( stdout, "punkt=%d x=%lg y=%lg\n", punktefeld[i].nr, punktefeld[i].x, punktefeld[i].y ); //... //////////////////////////////////////////////////////////////////

Klausur im WS 2014/15 Seite 4 von 4 Aufgabe 4 ( 30 % ) 4.1 ////////////////////////////////////////////////////////////////// #define ERR_PROGARG 0 // falscher Programmaufruf #define ERR_NOFILE 1 // keine Eingabedatei #define ERR_NOVAL 2 // keine Daten in der Eingabedatei #define ERR_NOMEM 3 // kein Speicher für die Eingabedaten ////////////////////////////////////////////////////////////////// 4.2 ////////////////////////////////////////////////////////////////// //... if( ( input = fopen( argv[1], "r" ) )!= NULL ) if( ( n = punkte_anzahl( input ) ) > 0 ) if( ( punktefeld = new pkt[n] )!= NULL ) //... wie 3.1, 3.2 status = 1<<ERR_NOMEM; status = 1<<ERR_NOVAL; fclose( input ); status = 1<<ERR_NOFILE; status = 1<<ERR_PROGARG; ////////////////////////////////////////////////////////////////// 4.3 //... punkte_err( status ); //... void punkte_err( int flags ) if( flags & 1<<ERR_PROGARG ) fprintf(stdout, "*** Fehler: kein Programmargument\n"); if( flags & 1<<ERR_NOFILE ) fprintf(stdout, "*** Fehler: keine Eingabedatei\n"); if( flags & 1<<ERR_NOVAL ) fprintf(stdout, "*** Fehler: kein Eingabewerte\n"); if( flags & 1<<ERR_NOMEM ) fprintf(stdout, "*** Fehler: kein Speicher\n"); //////////////////////////////////////////////////////////////////

Klausur im Sommersemester 2014 Seite 1 von 1 Die Software zur Steuerung einer Aufzugsanlage soll in C entwickelt werden. Ein Anfang ist schon gemacht: struct aufzug struct stockwerk int ; stw; anzahl_stw, stockwerk_soll, stockwerk_ist, aktion; int main( void ) aufzug lift1; //... Aufgabe 1 ( 20 % ) Ergänzen Sie den Header um die Datentypdefinition für struct stockwerk, in der die Stockwerknummer, das Statuswort (16 Bit ohne Vorzeichen) und das von hier angeforderte Zielstockwerk der Aufzugskabine enthalten sind. Aufgabe 2 ( 20 % ) Mit dem obigen Typ aufzug gibt es nur ein Stockwerk pro Aufzug. Verändern Sie die Typdefinition so, dass eine sinnvolle Anzahl Stockwerke möglich ist: 2.1 zur Laufzeit konstant 2.2 zur Laufzeit variabel. Aufgabe 3 ( 20 % ) 3.1 Formulieren Sie den Code zur Initialisierung eines Objekts des Typs aufzug in der Funktion aufzug aufzug_init( int anzahl_stockwerke ); 3.2 Ergänzen Sie main um den Aufruf von aufzug_init. Aufgabe 4 ( 20 % ) Das Programm soll die Anzahl der Stockwerke aus seiner Kommandozeile übernehmen. Ergänzen Sie dazu main. Aufgabe 5 ( 20 % ) Nach erfolgreichem Hochlauf soll main in eine Endlosschleife eintreten und darin zyklisch zwei hier nicht näher betrachtete Funktionen aufrufen: void aufzug_status( struct aufzug * lift ); void aufzug_aktion( struct aufzug * lift ); sowie die Windows-Funktion void Sleep( unsigned long milliseconds ); // Prototype in <Windows.h> Ergänzen Sie das Programm entsprechend, mit Sleep - Zeit 1000. Definieren Sie für beide aufzug_... - Funktionen je einen leeren Rumpf ;, damit die Erstellung des Programms formal möglich ist. Aufgabe 6 ( 25 % ) Bei Rückkehr aus aufzug_status enthält das Objekt lift u.a. auch die aktuellen Statusworte aller Stockwerke. Auf Bit Nummer 9 im Statuswort jedes Stockwerks liegt das Flag "Aufzug ist in diesem Stockwerk angekommen". Formulieren Sie eine Funktion, die darauf aufbauend die Angabe zurückgibt, in welchem Stockwerk der Aufzug gerade angekommen ist, und deren Aufruf im Hauptprogrammzyklus.

Klausur im Sommersemester 2014 Seite 1 von 3 Aufgabe 1 ( 20 % ) typedef unsigned short int UWORD; struct stockwerk int nummer; UWORD flags; int stockwerk_soll; ; // vor Definition aufzug Aufgabe 2 ( 20 % ) 2.1 const int anzahl = 3; struct aufzug struct stockwerk int ; 2.2 struct aufzug struct stockwerk int ; stw[anzahl]; anzahl_stw, stockwerk_soll, stockwerk_ist, aktion; * stw; anzahl_stw, stockwerk_soll, stockwerk_ist, aktion; Aufgabe 3 ( 20 % ) 3.1 aufzug aufzug_init( int anzahl_stockwerke ) aufzug lift; lift.stw = new stockwerk[anzahl_stockwerke]; if( lift.stw == NULL ) lift.anzahl_stw = 0; lift.anzahl_stw = anzahl_stockwerke; for( int i=0 ; i<anzahl_stockwerke ; ++i ) lift.stw[i].nummer = i; lift.stw[i].flags = (UWORD)0x0; return lift; 3.2 aufzug aufzug_init( int anzahl_stockwerke ); int main( void ) aufzug lift1; int n=anzahl; lift1 = aufzug_init( n ); //...

Klausur im Sommersemester 2014 Seite 2 von 3 Aufgabe 4 ( 20 % ) int main( int argc, char * argv[] ) struct aufzug lift1; int n; char * p; if( argc!= 2 ) fprintf( stdout, "*** Fehler: Anzahl Stockwerke fehlt\n" ); n = strtoul( argv[1], & p, 10 ); if( *p!= '\0' ) fprintf( stdout, "*** Fehler: Anzahl Stockwerke ist keine ganze Zahl\n" ); if( n <= 0 ) fprintf( stdout, "*** Fehler: Anzahl Stockwerke ist ungueltig\n" ); lift1 = aufzug_init( lift1, n ); //... Aufgabe 5 ( 20 % ) void aufzug_status( aufzug * lift ); void aufzug_aktion( aufzug * lift ); int main( int argc, char * argv[] ) struct aufzug lift1; int n; char * p; if( argc!= 2 ) fprintf( stdout, "*** Fehler: Anzahl Stockwerke fehlt\n" ); n = strtoul( argv[1], & p, 10 ); if( *p!= '\0' ) fprintf( stdout, "*** Fehler: Anzahl Stockwerke ist keine ganze Zahl\n" ); if( n <= 0 ) fprintf( stdout, "*** Fehler: Anzahl Stockwerke ist ungueltig\n" ); lift1 = aufzug_init( lift1, n ); do aufzug_status( & lift1 ); aufzug_aktion( & lift1 ); Sleep( 1000 ); while(1);

Klausur im Sommersemester 2014 Seite 3 von 3 Aufgabe 6 ( 25 % ) //... int aufzug_angekommen( aufzug lift ); //... int main( int argc, char * argv[] ) //... do aufzug_status( & lift1 ); hier = aufzug_angekommen( lift1 ); aufzug_aktion( & lift1 ); while(1); int aufzug_angekommen( aufzug lift ) for( int i=0 ; lift.anzahl_stw ; ++i ) if( lift.stw[i].flags & (1 << 9) ) return i;

Klausur im Wintersemester 2013/14 Seite 1 von 1 Für eine Anwendung sollen Uhrzeitangaben programmiert werden. Ohne Rücksicht auf den vorhandenen Standard <ctime> definieren die Entwickler einen eigenen Datentyp sowie zwei Funktionen für Eingabe und Ausgabe einer Uhrzeit: struct uhrzeit int stunde, minute, sekunde; ; uhrzeit uhrzeiteingabe( FILE * eingabe ); void uhrzeitausgabe( FILE * ausgabe, uhrzeit t ); Aufgabe 1 ( 20% ) Formulieren Sie mit diesem Header, wie die Funktion main die Eingabe einer Zeitangabe von stdin und die Ausgabe an stdout ausführt. Aufgabe 2 ( 20% ) Formulieren Sie auch den Code der beiden Funktionen uhrzeiteingabe und uhrzeitausgabe. Aufgabe 3 ( 20% ) Man gibt einen neuen Prototyp für die Uhrzeit-Eingabefunktion vor: void uhrzeiteingabe( FILE * eingabe, uhrzeit * ta ); Formulieren Sie den Code für main und uhrzeiteingabe entsprechend. Aufgabe 4 ( 30% ) Nun soll das Programm die Uhrzeit mit seinem Aufruf übernehmen, also ohne die Eingabefunktion. Formulieren Sie den Code von main dazu passend. Behandeln Sie den Fall eines unvollständigen oder unkorrekten Programmaufrufs mit der voll parametrischen Funktion uhrzeithelp. Benutzen zur Erzeugung einer ganzen Zahl aus einem String die Standardfunktion unsigned long int strtoul( const char * str, char ** endptr, int base ); die z.b. in der "C-Reference" unter <cstdlib> erklärt ist. Die Zahlenwerte aus dem Kommandozeile müssen eindeutig ganze Zahlen sein und korrekte Werte haben. Formulieren Sie eine Funktion uhrzeitcheck, die entsprechende Überprüfungen durchführt und eine Uhrzeit-Instanz zurückgibt. Mit einem Referenzparameter status informiert die Funktion über den Beendigungsstatus der Überprüfung: ist nach Rückkehr dessen Wert 0, sind Zahlen und Werte OK, ist der Wert -1, gab es irgendwo einen Fehler. Aufgabe 5 ( 20% ) Die Funktion uhrzeitcheck soll nun genauer prüfen, wo Fehler liegen. Mit den gesetzten Bits 0, 1, und 2 soll das Statuswort status anzeigen, dass Stunde, Minute bzw. Sekunde keine echten Zahlen sind. Mit den Bits 3, 4 und 5 soll es anzeigen, dass Stunde, Minute bzw. Sekunde falsche Werte haben. Das aufrufende main soll das Statuswort testen und entsprechend gesetzter Bits Fehlermeldungen an der Konsole ausgeben. Aufgabe 6 ( 20% ) Formulieren Sie main so um, dass die Ausgabe der Uhrzeit immer auch in die Datei uhrzeit.txt geht, anstatt wie bisher nur an die Konsole.

Klausur im Wintersemester 2013/14 Seite 1 von 4 Aufgabe 1 ( 20% ) int main( int argc, char * argv[] ) uhrzeit t1; t1 = uhrzeiteingabe( stdin ); uhrzeitausgabe( stdout, t1 ); Aufgabe 2 ( 20% ) uhrzeit uhrzeiteingabe( FILE * eingabe ) uhrzeit t; if( eingabe == stdin ) fprintf( stdout, "Geben Sie die Uhrzeit ein wie folgt:\nstunde Minute Sekunde " ); fflush( eingabe ); fscanf( eingabe, "%d %d %d", & t.stunde, & t.minute, & t.sekunde ); return t; void uhrzeitausgabe( FILE * ausgabe, uhrzeit t ) fprintf(ausgabe,"%d Uhr %d Minuten und %d Sekunden\n",t.stunde,t.minute,t.sekunde); Aufgabe 3 ( 20% ) int main( int argc, char * argv[] ) uhrzeit t1; uhrzeiteingabe( stdin, & t1 ); uhrzeitausgabe( stdout, t1 ); void uhrzeiteingabe( FILE * eingabe, uhrzeit * ta ) uhrzeit t = * ta; if( eingabe == stdin ) fprintf( stdout, "Geben Sie die Uhrzeit ein wie folgt:\nstunde Minute Sekunde " ); fflush( eingabe ); fscanf( eingabe, "%d %d %d", & t.stunde, & t.minute, & t.sekunde ); * ta = t;

Klausur im Wintersemester 2013/14 Seite 2 von 4 Aufgabe 4 ( 30% ) void uhrzeithelp( char * programm ); uhrzeit uhrzeitcheck( int anzahl, char ** stringfeld, unsigned short * flags ); int main( int argc, char * argv[] ) uhrzeit t1; unsigned short eingabestatus = 0; if( argc!= 4 ) uhrzeithelp( argv[0] ); t1 = uhrzeitcheck( argc-1, argv, & eingabestatus ); if( eingabestatus ) uhrzeithelp( argv[0] ); uhrzeitausgabe( stdout, t1 ); return eingabestatus; void uhrzeithelp( char * programm ) fprintf( stdout, "*** Rufen Sie das Programm so auf:\n" ); fprintf( stdout, " %s Stunde Minute Sekunde\n", programm ); fprintf( stdout, " mit 0<=Stunde<=23 0<=Minute<=59 0<=Sekunde<=59\n", programm ); uhrzeit uhrzeitcheck( int anzahl, char ** stringfeld, unsigned short * flags ) // hier ist anzahl=argc-1, stringfeld=argv also stringfeld[i]=argv[i] char * p; int i; uhrzeit t; int uhrzeit_buf[3] = 0, 0, 0 ; // Puffer für Stunde, Minute, Sekunde // Werte vorbesetzt wegen break unten int uhrzeit_og[3] = 23, 59, 59 ; // max. Werte zum Vergleich t.stunde=t.minute=t.sekunde=0; // mit return immer definierte Werte zurückgeben for( i=0 ; i<anzahl ; ++i ) // prüft in dieser Anwendung alle argv[i] außer argv[0] uhrzeit_buf[i] = strtoul( stringfeld[i+1], & p, 10 ); if( * p!= '\0' && * p!= '\n' ) // dieser String ist keine Zahl *flags = (unsigned short) -1; // Fehler wegen F Zahlenformat break; // der erste Fehler beendet hier die Überprüfung // dieser String ist eine Zahl if( uhrzeit_buf[i] < 0 uhrzeit_buf[i] > uhrzeit_og[i] ) *flags = (unsigned short) -1; // Fehler wege F Wertebereich break; // der erste Fehler beendet auch hier die Überprüfung // diese Zahl ist OK if( i==0 ) t.stunde = uhrzeit_buf[i]; if( i==1 ) t.minute = uhrzeit_buf[i]; if( i==2 ) t.sekunde = uhrzeit_buf[i]; return t; // * flags!= 0 sagt aus, dass die Werte von t ungültig sind.

Klausur im Wintersemester 2013/14 Seite 3 von 4 Aufgabe 5 ( 20% ) void uhrzeithelp( char * programm ); uhrzeit uhrzeitcheck( int anzahl, char ** stringfeld, unsigned short * flags ); #define N_FEHLER 6 const char * fehlermeldung[n_fehler] = " Stunde: keine Zahl", " Minute: keine Zahl", " Sekunde: keine Zahl", " Stunde: ungueltiger Wert", " Minute: ungueltiger Wert", " Sekunde: ungueltiger Wert" ; int main( int argc, char * argv[] ) uhrzeit t1; unsigned short eingabestatus = 0; int i; if( argc!= 4 ) uhrzeithelp( argv[0] ); t1 = uhrzeitcheck( argc-1, argv, & eingabestatus ); if( eingabestatus ) fprintf( stdout, "*** Fehler\n" ); for( i=0 ; i < N_FEHLER ; ++i ) if( eingabestatus & 0x0001<<i ) printf( stdout, "%s\n", fehlermeldung[i] ); uhrzeithelp( argv[0] ); uhrzeitausgabe( stdout, t1 ); return eingabestatus; uhrzeit uhrzeitcheck( int anzahl, char ** stringfeld, unsigned short * flags ) char * p; int i; uhrzeit t; int uhrzeit_buf[3] = 0, 0, 0 ; // Puffer für Stunde, Minute, Sekunde int uhrzeit_og[3] = 23, 59, 59 ; // max. Werte dazu t.stunde=t.minute=t.sekunde=0; // auch bei Fehlern definierte Werte zurückgeben for( i=0 ; i<anzahl ; ++i ) uhrzeit_buf[i] = strtoul( stringfeld[i+1], & p, 10 ); if( * p!= '\0' && * p!= '\n' ) // dieser String ist keine Zahl * flags = * flags (unsigned short) 0x0001 << i ; // Fehler Zahlenformat // dieser String ist eine Zahl if( uhrzeit_buf[i] < 0 uhrzeit_buf[i] > uhrzeit_og[i] ) * flags = * flags (unsigned short) 0x0001 << (i+3) ; // Fehler Wertebereich // diese Zahl hat den richtigen Wert if( i==0 ) t.stunde = uhrzeit_buf[i]; if( i==1 ) t.minute = uhrzeit_buf[i]; if( i==2 ) t.sekunde = uhrzeit_buf[i]; return t; // * flags!= 0 sagt aus, dass die Werte von t ungültig sind

Klausur im Wintersemester 2013/14 Seite 4 von 4 Aufgabe 6 ( 20% ) int main( int argc, char * argv[] ) uhrzeit t1; unsigned short eingabestatus = 0; int i; FILE * ausgabefile; if( argc!= 4 ) uhrzeithelp( argv[0] ); t1 = uhrzeitcheck( argc-1, argv, & eingabestatus ); if( eingabestatus ) fprintf( stdout, "*** Fehler\n" ); for( i=0 ; i < N_FEHLER ; ++i ) if(eingabestatus & 0x0001<<i) fprintf( stdout, "%s\n", fehlermeldung[i] ); uhrzeithelp( argv[0] ); uhrzeitausgabe( stdout, t1 ); if( ( ausgabefile = fopen( "uhrzeit.txt", "w" ) ) == NULL ) fprintf( stdout, "*** Fehler beim Oeffnen der Ausgabedatei\n" ); uhrzeitausgabe( ausgabefile, t1 ); fclose( ausgabefile ); return eingabestatus;

Klausur im Sommersemester 2013 Seite 1 von 1 // Vorlageprogramm.cpp /////////////////////////////////////////////////////// #ifdef WIN32 // falls Entwicklung für MS-Windows: #define _CRT_SECURE_NO_WARNINGS // vermeide unsinnige Warnungen vor..scanf #endif #include <cstdio> #include <cmath> int main( void ) int messwert, zaehler; double summe, qsumme, stdabweich; fprintf( stdout, "*** Berechnung der Standardabweichung\n" ); zaehler = 0; do fprintf( stdout, "Neuen Messwert eingeben: "); fflush( stdin ); fscanf ( stdin, "%d", & messwert ); if( messwert >= 0 ) /**/ ++zaehler; /**/ summe = summe + messwert; /* F */ /**/ qsumme = qsumme + messwert * messwert; /* F */ /**/ stdabweich = sqrt((qsumme - summe*summe/zaehler)/(zaehler-1)); fprintf( stdout, "Standardabweichung=%lg\n", stdabweich ); while( messwert >= 0 ); ////////////////////////////////////////////////////////////////////////////// Das Vorlageprogramm berechnet mitlaufend die Standardabweichung aller Eingabewerte einer Messgröße aus den Summen der Werte und der Wertequadrate. Aufgabe 1 ( 10 % ) Die mit /* F */ kommentierten Zeilen enthalten ein Problem. Finden, benennen und beseitigen Sie sie. Aufgabe 2 ( 25% ) Formulieren Sie eine Funktion für den Code mit /**/ am Zeilenanfang, und schreiben Sie das übrige Programm entsprechend um. Beseitigen Sie dabei wenn nicht schon erledigt ein weiteres Problem der Vorlage: die Standardabweichung existiert nicht für einen Zähler < 2. Die Ausgabe darf dann auch keinen Wert anzeigen. Aufgabe 3 ( 40% ) Erweitern Sie nun das Programm so, dass es die Standardabweichung für beliebig viele verschiedene Messgrößen berechnet. 3.1 Führen Sie dazu einen strukturierten Datentyp ein. 3.2 Formulieren Sie die Übernahme der Anzahl Messgrößen aus dem Programmaufruf. 3.3 Formulieren Sie die Speicherreservierung für die gewünschte Anzahl von Messgrößen-Objekten. 3.4 Ändern Sie die Funktion aus Aufgabe 2 so, dass sie anstelle bisheriger Parameter und Variablen nur eine Messgrößenobjekt als Wertparameter übernimmt. 3.5 In der Vorlage oben sehen Sie, dass der Prozess bei Empfang eines negativen Messwerts endet. Ändern Sie in dieser Aufgabe den Kontrollfluss des Programms so, dass es in seiner Hauptschleife nur die Messgrößen der noch laufenden Prozesse in der Hauptschleife bearbeitet, und dass die Hauptschleife endet, wenn der letzte Prozess fertig ist. Aufgabe 4 ( 25% ) Ändern Sie Ihre Lösung zu 3.4 so, dass die Funktion nun mit Rückgabe void ein Messgrößen-Objekt als Referenzparameter verarbeitet. Aufgabe 5 ( 25% ) Ergänzen Sie das Programm so, dass es die Rechenergebnisse aller Messgrößen (Standardabweichung, Anzahl Messwerte, Nummer der Messgröße) in einer Ausgabedatei abspeichert. Für jeden zu Ende gehenden Messvorgang soll sofort eine Zeile in die Ausgabedatei geschrieben werden.

Klausur im Sommersemester 2013 Seite 1 von 4 Aufgabe 1 ( 10 % ) /*... */ // waren nicht initialisiert: summe = qsumme = 0.0; /* 10 */ do /*... */ while( messwert >= 0 ); /*... */ Aufgabe 2 ( 25% ) /*... */ int b_stdabweich( int mess, double * s ); // 5 // int main (void) int messwert, zaehler; double stdabweich; fprintf( stdout, "*** Berechnung der Standardabweichung\n" ); do fprintf( stdout, "Neuen Messwert eingeben: "); fflush( stdin ); fscanf ( stdin, "%d", & messwert ); if( messwert >= 0 ) if( ( zaehler = b_stdabweich( messwert, & stdabweich ) ) // 5 > 1 ) fprintf( stdout, "Standardabweichung=%lg\n", stdabweich ); while( messwert >= 0 ); // ////////////////////////////////////////////// // int b_stdabweich( int mess, double * s ) static int n=0; static double summe=0, qsumme=0; // 5 ++n; summe = summe + mess; qsumme = qsumme + mess * mess; if( n > 1 ) * s = sqrt((qsumme - summe*summe/n)/(n-1)); // 5 return n; // 5 //////////////////////////////////////////////////////////////////////////////

Klausur im Sommersemester 2013 Seite 2 von 4 Aufgabe 3 ( 40% ) 3.1 struct messgroesse int n, mess; double sum, qsum, stdabweich; int id; ; // 5 3.2 #include <cstdlib> int main( int argc, char * argv[] ) // 2 int anzahl; char * cp; if( argc!= 2 ) // 2 fprintf( stdout, "***F Aufruf: %s <Anzahl Messgroessen>\n", argv[0] ); // anzahl = (int) strtol( argv[1], & cp, 10 ); // 2 if( * cp!= '\0' ) // 2 fprintf( stdout, "***F Anzahl Messgroessen: keine ganze Zahl.\n" ); /*... */ //... 3.3 struct messgroesse * messzeig = new struct messgroesse[anzahl]; // 7 if( messzeig == NULL ) // 2 fprintf( stdout, "*** F: Speichermangel\n" ); /*... */ delete( messzeig ); 3.4 int main( int argc, char * argv[] ) /*... */ messzeig[i] = c_stdabweich( messzeig[i] ); // 3 if( messzeig[i].n > 1 ) fprintf( stdout, "Standardabweichung=%lg\n", messzeig[i].stdabweich ); /*... */ struct messgroesse c_stdabweich( struct messgroesse m ) // 3 m.sum += m.mess; m.qsum += m.mess * m.mess; // 4 if( ++ m.n > 1) m.stdabweich = sqrt( (m.qsum - m.sum*m.sum/m.n)/(m.n-1) ); return m;

Klausur im Sommersemester 2013 Seite 3 von 4 3.5 int main( int argc, char * argv[] ) /*... */ unsigned long aktiv = 0; /*... */ for( i=0 ; i<anzahl ; ++i ) /* Initialisierung... */ aktiv = ( 1 << i ); // 3 //... do for( i=0 ; i<anzahl ; ++i ) if( (1<<i) & aktiv ) // 2 fprintf( stdout, "Neuen Messwert Groesse %d eingeben: ", i); fflush( stdin ); fscanf ( stdin, "%d", & messzeig[i].mess ); if( messzeig[i].mess < 0 ) aktiv &= ~( 1 << i ); // 3 messzeig[i] = c_stdabweich( messzeig[i] ); if( messzeig[i].n > 1 ) fprintf( stdout, "Standardabweichung=%lg\n", messzeig[i].stdabweich ); while( aktiv ); // 2 /*... */

Klausur im Sommersemester 2013 Seite 4 von 4 Aufgabe 4 ( 25% ) void d_stdabweich( struct messgroesse * m ); // 5 int main( int argc, char * argv[] ) /*... */ d_stdabweich( messzeig+i ); // 5 if( messzeig[i].n > 1 ) fprintf( stdout, "Standardabweichung=%lg\n", messzeig[i].stdabweich ); /*... */ void d_stdabweich( struct messgroesse * m ) // 5 ++ m->n; // 10 m->sum += m->mess; m->qsum += m->mess * m->mess; if( ++ m->n > 1) m->stdabweich = sqrt( ( m->qsum - m->sum * m->sum / m->n )/( m->n-1 ) ); Aufgabe 5 ( 25% ) int main( int argc, char * argv[] ) /*... */ FILE * messdatei; // 5 char messdateiname[]= "messsdatei.txt"; /*... */ if( ( messdatei = fopen( messdateiname, "w+" ) ) == NULL ) // 5 fprintf( "*** Fehler beim Oeffnen der Datei %s\n", messdateiname ); // 5 /*... */ do /*... */ if( messzeig[i].mess < 0 ) // jetzt auch speichern fprintf( messdatei, "%d ", messzeig[i].id ); // 5 fprintf( messdatei, "%d %lg\n", messzeig[i].n, messzeig[i].stdabweich ); /*... */ /*... */ while( aktiv ); fclose( messdatei ); // 5 /*... */

Klausur im Wintersemester 2012/13 Seite 1 von 2 Das folgende Vorlageprogramm soll so weiterentwickelt werden, dass es aus einer gegebenen Folge von Werten das Maximum findet. Um die Werte zu erzeugen, benutzen Sie im Vorlageprogramm u:\vorlage.cpp die schon fertig programmierte Funktion erzeugewerte.. Die Funktion fktmax steht ebenfalls schon in der Vorlage, ist aber noch nicht fertig programmiert. //... hier der Standardheader und die Funktionsprototypen für // erzeugewerte und fktmax... const int n=25; int main( void ) double werte[n], max; int m; m=erzeugewerte( werte, n ); max = fktmax( werte, n ); //... hier stehen die Funktionsdefinitionen für erzeugewerte und fktmax... Aufgabe 1 ( 30% ) Formulieren Sie den Code der Funktion fktmax fertig, so dass diese das Maximum der Werte in dem übergebenen Feld zurückgibt. Aufgabe 2 ( 30% ) Ändern Sie das Programm so, dass die Anwendung main anstelle des Felds werte[n] zur Laufzeit ("dynamisch") Speicher für die Werte anfordert. Aufgabe 3 ( 30% ) Ändern Sie die Funktion fktmax so, dass diese nur das oder die lokalen Maxima sucht. Zurückgeben soll sie die Anzahl gefundener lokaler Maxima. Aufgabe 4 ( 30% ) Um den Code der Anwendung zu vereinfachen, soll nun die Funktion erzeugewerte nicht nur die Werte erzeugen, sondern auch den Speicher dafür anfordern. Ändern Sie das Programm entsprechend.

Klausur im Wintersemester 2012/13 Seite 2 von 2 Vorlageprogramm: #include <cstdlib> double fktmax ( double * werte, int anzahl ); int erzeugewerte( double * werte, int anzahl ); const int n=25; int main( void ) double werte[n], max; int m; m=erzeugewerte( werte, n ); max = fktmax( werte, n ); #include <cmath> #include <cstdlib> #include <cstring> int erzeugewerte( double * werte, int anzahl ) double a[5] = -1.0, 4.0, -3.0, 0.5, 0.001; // Koeff. für Polynom 4. Ordnung double x, x_ug = -3.0, x_delta =.5, y; int i, j; for( j=0 ; j<anzahl ; ++j ) x = x_ug + j*x_delta; y = 0.0; for ( i=0 ; i<=4 ; ++i ) y = y + a[i]*pow(x, (double)i); *(werte+j) = y; return anzahl; double fktmax( double * werte, int anzahl ) double max = * werte; //... return max;

Klausur im Wintersemester 2012/13 Seite 1 von 2 Aufgabe 1 ( 30% ) double fktmax( double * werte, int anzahl ) double max, y; int i; for( i=0, max= *(werte) ; i<anzahl ; ++i ) y = *(werte+i); if( y > max ) max = y; return max; Aufgabe 2 ( 30% ) #include <cmath> #include <cstdlib> #include <cstring> double fktmax ( double * werte, int anzahl ); int erzeugewerte( double * werte, int anzahl ); const int n=25; int main( void ) double * werte, max; int m; if( ( werte = new double[n] ) == NULL ) return -1; // Fehler m=erzeugewerte( werte, n ); max = fktmax( werte, n ); Aufgabe 3 ( 30% ) Ändern Sie die Funktion fktmax so, dass diese nur das oder die lokalen Maxima sucht. Zurückgeben soll sie die Anzahl gefundener lokaler Maxima. //... int fktrelmax ( double * werte, int anzahl ); //... int fktrelmax( double * werte, int anzahl ) double y; int i, gefunden; for( i=1, gefunden = 0; i<anzahl-1 ; ++i ) y = *(werte+i); if( *(werte+i-1) < y && *(werte+i+1) < y ) ++gefunden; return gefunden;

Klausur im Wintersemester 2012/13 Seite 2 von 2 Aufgabe 4 ( 30% ) //... int erzeugewerte( double ** werte, int anzahl ); //... int main( void ) double * werte; int m, gefunden; m=erzeugewerte( & werte, n ); if( m > 2 ) gefunden = fktrelmax( werte, n ); int erzeugewerte( double ** werte, int anzahl ) double a[5] = -1.0, 4.0, -3.0, 0.5, 0.001; // Koeff. für Polynom 4. Ordnung double x, x_ug = -3.0, x_delta =.5, y; int i, j; if( ( * werte = new double[anzahl] ) == NULL ) anzahl = 0; for( j=0 ; j<anzahl ; ++j ) x = x_ug + j*x_delta; y = 0.0; for ( i=0 ; i<=4 ; ++i ) y = y + a[i]*pow(x, (double)i); *(*werte+j) = y; return anzahl;

Klausur im Sommersemester 2012 Seite 1 von 2 Benutzername.. Name, Matrikelnummer... #include "RCHeader.h" #define ANZAHL 16 int main( int argc, char * argv[] ) FILE * fp; struct rc rc; if( argc!= 2 ) fprintf( stdout, "*** Fehler im Aufruf: keine RC-Parameterdatei angegeben\n" ); fp = fopen( argv[1], "r" ); if( fp == NULL ) exit( EXIT_FAILURE ); fscanf(fp,"%lg %lg %lg %lg %lg", &rc.rc, &rc.d, &rc.us, &rc.uc0, &rc.udelta); fclose( fp ); fp = fopen( argv[1], "a" ); if( fp == NULL ) exit( EXIT_FAILURE ); rc.maxspalten = 50; // a rc.maxwert = rc.us; // a rc.massstab = rc.maxspalten / rc.maxwert; // a rc.zeit = 0.0L; // a do rc.uc = rc.uc0 + rc.us * ( 1 - exp ( - rc.zeit/rc.rc ) ); rc.zeit = rc.zeit + rc.rc/rc.d; rc_ausgabe( fp, rc ); while ( rc.us - rc.uc > rc.udelta ); fclose( fp ); Das Programm oben liest die Kenndaten des RC-Glieds aus einer Datei und schreibt dann den Ablauf der Aufladung des Kondensators in dieselbe Datei hinter die Kenndaten. Eine Datei mit Kenndaten finden Sie ebenso wie die Datei mit der Funktion rc_ausgabe auf dem Info- Laufwerk zu dieser Klausur. Aufgabe 1 ( 20% ) Formulieren Sie den Header zum obigen Programm. Aufgabe 2 ( 30% ) Lagern Sie den mit // a kommentierten Code in eine Funktion aus. Aufgabe 3 ( 30% ) Das Programm soll nun für bis zu 16 verschiedene RC-Glieder ablaufen. Die Namen der Parameterdateien sollen wie die eine Parameterdatei bisher beim Aufruf an das Programm übergeben werden. Ändern Sie das Programm entsprechend. Falls Sie evtl. das Programm testen, begnügen Sie sich mit 2 RC-Gliedern. Aufgabe 4 ( 20% ) Das Programm soll ein Statuswort führen, in dem es für jedes erfolgreich behandelte RC-Glied eine logische 1 einträgt. Stelle 0 ist für das RC-Glied entsprechend argv[1] vorgesehen, usw. Aufgabe 5 (Zusatzaufgabe) Es soll möglich sein, beliebig viele RC-Glieder mit dem Programm zu behandeln. Formulieren Sie das Programm entsprechend um. Lassen Sie bei Ihrer Lösung die Eigenschaft aus Aufgabe 4 weg.

Klausur im Sommersemester 2012 Seite 2 von 2 Benutzername.. Name, Matrikelnummer...... Kenndaten in der Datei rc1.txt 50 4 10 0 0.01... // Programmcode rc_ausgabe #include "RCHeader.h" void rc_ausgabe( FILE * fp_aus, struct rc rc_aus ) char ausgabe[81] = ""; rc_aus.np = (int)(rc_aus.massstab * rc_aus.uc); fprintf( fp_aus, "\nt=%-10.3lf U=%-10.6lf ", rc_aus.zeit, rc_aus.uc); for ( rc_aus.k=0 ; rc_aus.k < rc_aus.np ; rc_aus.k++ ) strcat( ausgabe, "." ); fprintf( fp_aus, "%s", ausgabe );...

Klausur im Sommersemester 2012 Seite 1 von 3 Aufgabe 1 ( 20% ) #include <cstdio> #include <cstdlib> #include <cstring> #include <cmath> #include <cfloat> // struct rc double double int int ; RC, D, Us, Uc0, Zeit, Uc, Udelta; maxwert, massstab; k, maxspalten; np; // Anzahl Spalten in der Ausgabe für Uc void rc_ausgabe( FILE * fpaus, struct rc rcaus ); void rc_init( struct rc * rc_in ); Aufgabe 2 ( 30% ) void rc_init( struct rc * rc_in ) rc_in->maxspalten = 50; rc_in->maxwert = rc_in->us; rc_in->massstab = rc_in->maxspalten / rc_in->maxwert; rc_in->zeit = 0.0L; Aufgabe 3 ( 30% ) #include "RCHeader.h" void rc_init( struct rc * rc_in ); const int anzahl = 16; void main( int argc, char * argv[] ) int i; FILE * fpfeld[ anzahl ]; struct rc rcfeld[ anzahl ]; if( argc-1!= anzahl ) fprintf(stdout,"*** Fehler: Anzahl Dateien im Programmaufruf ist nicht 16!\n"); for( i=0 ; i<argc-1 ; ++i ) fpfeld[i] = fopen( argv[i+1], "r" ); if( fpfeld[i] == NULL ) exit( EXIT_FAILURE ); fscanf( fpfeld[i],"%lg %lg", & rcfeld[i].rc, & rcfeld[i].d ); fscanf( fpfeld[i],"%lg %lg", & rcfeld[i].us, & rcfeld[i].uc0 ); fscanf( fpfeld[i],"%lg", & rcfeld[i].udelta); fclose( fpfeld[i] ); fpfeld[i] = fopen( argv[i+1], "a" ); if( fpfeld[i] == NULL ) exit( EXIT_FAILURE );

Klausur im Sommersemester 2012 Seite 2 von 3 void rc_init( struct rc * rc_in ) // wie in Aufgabe 2 formuliert rc_init( & rcfeld[i] ); do rcfeld[i].uc = rcfeld[i].uc0 + rcfeld[i].us * ( 1 - exp(- rcfeld[i].zeit/rcfeld[i].rc ) ); rcfeld[i].zeit = rcfeld[i].zeit + rcfeld[i].rc / rcfeld[i].d; rc_ausgabe( fpfeld[i], rcfeld[i] ); while (rcfeld[i].us - rcfeld[i].uc > rcfeld[i].udelta ); fclose( fpfeld[i] ); Aufgabe 4 ( 20% ) Das Programm soll ein Statuswort führen, in dem es für jedes erfolgreich behandelte RC-Glied eine logische 1 einträgt. Stelle 0 ist für das RC-Glied entsprechend argv[1] vorgesehen, usw. #include "RCHeader.h" void rc_init( struct rc * rc_in ); const int anzahl = 16; void main( int argc, char * argv[] ) int i; FILE * fpfeld[ anzahl ]; struct rc rcfeld[ anzahl ]; unsigned short status = 0x0000; if( argc-1!= anzahl ) fprintf( stdout, "*** Fehler: Anzahl Dateien im Programmaufruf ist nicht 16!\n" ); for( i=0 ; i<argc-1 ; ++i ) fpfeld[i] = fopen( argv[i+1], "r" ); if( fpfeld[i] == NULL ) exit( EXIT_FAILURE ); fscanf( fpfeld[i],"%lg %lg %lg %lg %lg", & rcfeld[i].rc, & rcfeld[i].d, & rcfeld[i].us, & rcfeld[i].uc0, & rcfeld[i].udelta); fclose( fpfeld[i] ); fpfeld[i] = fopen( argv[i+1], "a" ); if( fpfeld[i] == NULL ) exit( EXIT_FAILURE ); rc_init( & rcfeld[i] ); do rcfeld[i].uc = rcfeld[i].uc0 + rcfeld[i].us * ( 1 - exp ( - rcfeld[i].zeit/rcfeld[i].rc ) ); rcfeld[i].zeit = rcfeld[i].zeit + rcfeld[i].rc / rcfeld[i].d; rc_ausgabe( fpfeld[i], rcfeld[i] ); while (rcfeld[i].us - rcfeld[i].uc > rcfeld[i].udelta ); fclose( fpfeld[i] ); status = 0x0001 << i;

Klausur im Sommersemester 2012 Seite 3 von 3 void rc_init( struct rc * rc_in ) // wie in Aufgabe 2 formuliert Aufgabe 5 (Zusatzaufgabe) #include "RCHeader.h" void rc_init( struct rc * rc_in ); void main( int argc, char * argv[] ) int i; FILE ** fpfeld = NULL; struct rc * rcfeld = NULL; fpfeld = ( FILE ** ) malloc( sizeof(file *) * (argc-1) ); rcfeld = ( struct rc * ) malloc( sizeof(struct rc) * (argc-1) ); if( fpfeld==null rcfeld==null ) exit( EXIT_FAILURE ); for( i=0 ; i<argc-1 ; ++i ) fpfeld[i] = fopen( argv[i+1], "r" ); if( fpfeld[i] == NULL ) exit( EXIT_FAILURE ); fscanf( *(fpfeld+i), "%lg %lg %lg %lg %lg", &(rcfeld+i)->rc, &(rcfeld+i)->d, &(rcfeld+i)->us, &(rcfeld+i)->uc0, &(rcfeld+i)->udelta); fclose( *(fpfeld+i) ); fpfeld[i] = fopen( argv[i+1], "a" ); if( fpfeld[i] == NULL ) exit( EXIT_FAILURE ); rc_init( & rcfeld[i] ); do (rcfeld+i)->uc = rcfeld[i].uc0 + rcfeld[i].us * ( 1 - exp ( - rcfeld[i].zeit/rcfeld[i].rc ) ); (rcfeld+i)->zeit = (rcfeld+i)->zeit + (rcfeld+i)->rc/(rcfeld+i)->d; rc_ausgabe( fpfeld[i], *(rcfeld+i) ); while ((rcfeld+i)->us - (rcfeld+i)->uc > (rcfeld+i)->udelta ); fclose( fpfeld[i] );

Klausur im Wintersemester 2011/12 Seite 1 von 1 Benutzername.. Name, Matrikelnummer... Die folgende Anwendung bestimmt den räumlichen Abstand zwischen zwei Punkten p1 und p2. Die Koordinaten der Punkte p1 und p2 sind Elemente eines Felds fester Länge N=3 vom Typ double. #include "w11punkt.h" int main( void ) struct punkt p1, p2; double abstand; w11punkteingabe( stdin, & p1 ); w11punkteingabe( stdin, & p2 ); abstand = w11abstand( p1, p2 ); w11punktausgabe( stdout, abstand = w11abstand( p1, p2 ) ); Aufgabe 1 ( 20 % ) Aufgabe 2 ( 20 % ) Formulieren Sie den Code der Headerdatei. Formulieren Sie den Code der Funktion w11abstand. Aufgabe 3 Formulieren die Funktion w11abstand um zur Funktion w11abstandref. ( 20 % ) Diese soll den Abstand als Referenzparameter zurückgeben und keinen Rückgabewert haben. Die Anwendung soll nun w11abstandref aufrufen. Formulieren Sie um, was dazu nötig ist. Aufgabe 4 Erweitern Sie die Anwendung so, dass sie die verkettete Länge einer Folge von mehr als ( 20 % ) 2 Punkten berechnet. Die Anzahl der Punkte bestimmt der Anwender beim Aufruf über das Argument der Funktion main. Aufgabe 5 Die Anwendung main in Aufgabe 4 soll nun bei ihrem Ende ein Statuswort zurückgeben, ( 20 % ) das evtl. mögliche Fehler anzeigt. Definieren Sie für jeden möglichen Fehler im Ablauf der Anwendung je ein Flag, das bei seinem Eintreten vor Programmende im Statuswort gesetzt wird. Zusatzaufgabe ( 20 % ): Aufgabe 6 Offenbar kann ein Anwender die Datenquelle für die Eingabe der Punkte wählen, ebenso das Ziel für die Ausgabe des Abstands. In der Vorlage oben benutzt die Anwendung stdin bzw. stdout. Formulieren Sie eine Anwendung, die den Namen der Ein- und Ausgabedatei aus dem Argument der Funktion main übernimmt. Falls diese im Argument fehlen, soll die Anwendung annehmen, dass Ein- bzw. Ausgabe über stdin bzw. stdout gehen.

Klausur im Wintersemester 2011/12 Seite 1 von 4 Aufgabe 1 #include <cstdio> struct punkt static const int n = 3; double p[n]; ; double w11abstand ( struct punkt p1, struct punkt p2 ); double w11eingabe ( FILE * eingabe, struct punkt * p ); Aufgabe 2 #include <cmath> #include "Aufgabe1_w11punkt.h" double w11abstand( struct punkt p1, struct punkt p2 ) int i; double qabstand = 0.0; for( i=0 ; i<p1.n ; ++i ) qabstand += (p1.p[i]-p2.p[i])*(p1.p[i]-p2.p[i]); return sqrt( qabstand ); Aufgabe 3 #include <cmath> #include <cstdio> #include "Aufgabe3_w11punkt.h" // geänderter Prototyp w11punktausgabe void w11abstandref( struct punkt p1, struct punkt p2, double * abstand ) int i; double qabstand = 0.0; for( i=0 ; i < p1.n ; ++i ) qabstand += (p1.p[i]-p2.p[i])*(p1.p[i]-p2.p[i]); * abstand = sqrt( qabstand ); // ///////////////////////////////////////////////////////////////// // #include <cstdlib> #include "Aufgabe3_w11punkt.h" // geänderter Prototyp w11punktausgabe int main( void ) struct punkt p1, p2; double abstand; w11punkteingabe( stdin, & p1 ); w11punkteingabe( stdin, & p2 ); w11abstandref( p1, p2, & abstand ); w11punktausgabe( stdout, abstand );

Klausur im Wintersemester 2011/12 Seite 2 von 4 Aufgabe 4 #include "Aufgabe3_w11punkt.h" int main( int argc, char * argv[] ) struct punkt * pkt; int laenge, i; double kette, abstand; char * f; if( argc == 2 ) laenge = strtoul( argv[1], & f, 10 ); for( i=0 ; i<laenge ; ++i ) w11punkteingabe( stdin, pkt+i ); for( i=1, kette = 0.0 ; i < laenge ; ++i ) w11abstandrefk( pkt+i-1, pkt+i, & abstand ); kette += abstand; w11punktausgabe( stdout, kette ); Aufgabe 5 #include "Aufgabe3_w11punkt.h" int main( int argc, char * argv[] ) struct punkt * pkt; int laenge, i; double kette, abstand; char * f; if( argc!= 2 ) return 1<<0; // Falsche Anzahl Parameter im Programmaufruf laenge = strtoul( argv[1], & f, 10 ); if( f == NULL ) return 1<<1; // leeres Wort als Länge im Programmaufruf if( *f!= '\0') return 1<<2; // keine Zahl als Länge im Programmaufruf if( ( pkt = new struct punkt[laenge] ) == NULL ) return 1<<3; // kein Speicher für die Anzahl Punkte for( i=0 ; i<laenge ; ++i ) w11punkteingabe( stdin, pkt+i );

Klausur im Wintersemester 2011/12 Seite 3 von 4 for( i=1, kette = 0.0 ; i < laenge ; ++i ) w11abstandrefk( pkt+i-1, pkt+i, & abstand ); kette += abstand; w11punktausgabe( stdout, kette ); // hier ist alles OK Aufgabe 6 #include "Aufgabe4_w11punkt.h" int main( int argc, char * argv[] ) struct punkt * pkt; int laenge, i; double kette, abstand; char * f; FILE * ein, * aus; int errorcode; if( argc < 4 ) ein = stdin; aus = stdout; if( argc > 4 ) errorcode = 1<<0; // Falsche Anzahl Parameter im Programmaufruf ein = fopen( argv[2], "r" ); aus = fopen( argv[3], "w" ); if( ein==null aus==null ) errorcode = 1<<4; S// Ein- oder Ausgabe nicht verfügbar laenge = strtoul( argv[1], & f, 10 ); if( f == NULL ) errorcode = 1<<1; // leeres Wort als Länge im Programmaufruf if( *f!= '\0') errorcode = 1<<2; // keine Zahl als Länge im Programmaufruf if((pkt = new struct punkt[laenge])== NULL) errorcode = 1<<3; // kein Speicher für die Anzahl Punkte for( i=0 ; i<laenge ; ++i ) w11punkteingabe( ein, pkt+i );

Klausur im Wintersemester 2011/12 Seite 4 von 4 return errorcode; for(i=1,kette=0.0 ; i<laenge ; ++i) w11abstandrefk( pkt+i-1, pkt+i, & abstand ); kette += abstand; w11punktausgabe( aus, abstand ); errorcode = 0; // hier ist alles OK

Klausur im Sommersemester 2011 Seite 1 von 1 Benutzername.. Name, Matrikelnummer... In einem Leitsystem wird eine Funktion bereich benötigt, mit welcher der aktuelle Wert einer beliebigen Kenngröße auf die Einhaltung eines anwenderdefinierten Wertebereichs geprüft werden kann. Man unterscheidet den Normalbereich, den Warnbereich und den Alarmbereich. Normal- und Warnbereich haben je Größe eine benutzerdefinierte Unter- und Obergrenze, die der Funktion zusammen mit dem aktuellen Wert der Größe als Parameter übergeben werden. Hat die Größe einen Wert außerhalb des Normalbereichs, soll bereich ein Warnflag setzen. Liegt der Wert außerhalb des Warnbereichs, soll das Alarmflag gesetzt werden. Die aufrufende Anwendung wertet nach Rückkehr aus bereich die Flags aus und behandelt die möglichen Fälle mit entsprechenden Terminalausgaben. Aufgabe 1 Definieren Sie einen strukturierten Datentyp groesse, der alle hier notwendigen Kenndaten einer Größe enthält. Aufgabe 2 Formulieren Sie den C-Prototyp der Funktion bereich ohne Verwendung von Zeigern im Argument, und den C-Code einer Anwendung, die aus der Konsoleneingabe geholte aktuelle Werte drei verschiedener Größen x, y, z mithilfe der Funktion bereich prüft. Aufgabe 3 Formulieren Sie den C-Code der Funktion bereich (die Funktionsdefinition). Aufgabe 4 Ändern Sie die Funktion bereich so ab, dass sie mit Referenzparameter arbeitet und den Rückgabewert für ein Statuswort benutzt. Im Statuswort soll die Funktion mögliche Inkonsistenzen der übergebenen Daten wie folgt darstellen: Bit 0 gesetzt, wenn Bit 1 gesetzt, wenn Bit 2 gesetzt, wenn Warnbereich UG OG Alarmbereich UG > Warnbereich UG Alarmbereich OG < Warnbereich OG Aufgabe 5 Formulieren Sie eine Anwendung, die eine benutzerdefinierte Anzahl Kenngrößen anlegt, für jede Größe mit Aufruf der Funktion void definelimits( struct groesse * g ) die festen Bereichsgrenzen einer Größe bestimmen lässt, mit der Funktion void getvalue( struct groesse * g ) den aktuellen Wert einer Größe aus einem Eingabeinterface holt und danach den Wertebereich mit der Funktion bereich auf dem Stand der Aufgabe 4 überprüft. Achtung: die Funktionen definelimits und getvalue sollen Sie nur korrekt aufrufen. Aufgabe 6 (Zusatzaufgabe > 100%) Formulieren Prototyp und Aufruf von definelimits und getvalue so um, dass beide Funktionen für einen bestimmte Anzahl Kenngrößen nur einmal aufgerufen werden müssen, vorausgesetzt, diese Anzahl ist in einem Feld oder einem dynamischen Speicherbereich angelegt.

Klausur im Sommersemester 2011 Seite 1 von 3 Aufgabe 1 20 % struct groesse double wert; double warn_ug, warn_og; double alarm_ug, alarm_og; int warnflag, alarmflag; ; Aufgabe 2 20 % struct groesse bereich( struct groesse g ); int main( void ) struct groesse x, y, z; struct groesse feld[3]; // nicht gefordert, vereinfacht die Verarbeitung char kenn[] = 'x', 'y', 'z'; // nicht gefordert int i; printf( "Geben Sie bitte den jeweils aktuellen Wert "); printf( "der Groessen x, y und z ein: "); fflush(stdin); scanf( "%lg %lg %lg", & x.wert, & y.wert, & z.wert ); feld[0] = x = bereich( x ); feld[1] = y = bereich( y ); feld[2] = z = bereich( z ); for( i=0 ; i<3 ; ++i ) if( feld[i].alarmflag ) printf( "*** Groesse %c liegt im Alarmbereich!\n", kenn[i] ); if( feld[i].warnflag ) printf( "*** Groesse %c liegt im Warnbereich!\n", kenn[i] ); printf( " Groesse %c liegt im Normalbereich\n", kenn[i] ); Aufgabe 3 20 % struct groesse bereich( struct groesse g ) if( g.wert <= g.alarm_ug g.wert >= g.alarm_og) g.alarmflag = true; g.alarmflag = false; if( g.wert <= warn_ug g.wert >= warn_og ) g.warnflag = true; g.warnflag = false; Aufgabe 4 20 % unsigned short bereich( struct groesse * g ) unsigned short status = (unsigned short) 0; if( g->warn_ug >= g->warn_og ) status = 1 << 0; if( g->alarm_ug > g->warn_ug ) status = 1 << 1; if( g->alarm_og < g->warn_og ) status = 1 << 2; if( g->wert <= g->alarm_ug g->wert >= g->alarm_og )g->alarmflag = true; g->alarmflag = false; if( g->wert <= g->warn_ug g->wert >= g->warn_og ) g->warnflag = true; g->warnflag = false;