Beispiele: und ein Zahlenrätsel

Transkript

1 Beispiele: und ein Zahlenrätsel Aufgabenstellung: Zu lösen ist das Zahlenrätsel S E N D + M O R E M O N E Y Jeder Buchstabe steht für eine Ziffer, verschiedene Buchstaben sind verschiedene Ziffern. Ein C-Programm soll durch Probieren aller möglichen Zahlen die richtigen Lösungen herausfinden. Offensichtlich entspricht der Buchstabe M der Ziffer 1. Die Anzahl der Lösungen ist mitzuzählen. Am Anfang des Programms wird die Aufgabenstellung am Terminal angezeigt. Jede Lösung wird entsprechend aufbereitet zusammen mit dem Lösungszähler am Terminal ausgegeben. Dazu gehören auch: Programmbeschreibung und Struktogramm 1

2 #include <stdio.h> int s1,e1,n1,d1; int m2,o2,r2,e2; int m3,o3,n3,e3,y3; int lz=0; int a,b,c; void ausgabe(void); void main() { int ar[10]; int i, ars; printf("send + more = money\n===================\n\n"); m2 = m3 = 1; //Ziffer m muss 1 sein for(a=9876; a>8012; a--) { s1=a/1000; d1=a%10; e1 =(a-s1*1000)/100; n1=(a/10)%10; for (b=1023; b<1987; b++) { o2=(b-1000)/100;e2=b%10; r2=(b/10)%10; c=a+b; if((e1 == e2) && (c>10234)) { e3=(c%100)/10; o3=(c%10000)/1000; n3=(c%1000)/100; y3=c%10; if((e1 == e3) && (o2 == o3) && (n1 == n3)) { for(i=0;i<10;i++)ar[i]=0;ars=0; ar[s1]=1;ar[e1]=1;ar[n1]=1;ar[d1]=1;ar[m2]=1; ar[o2]=1;ar[r2]=1;ar[y3]=1; for(i=0;i<10;i++) ars=ars+ar[i]; if(ars == 8)ausgabe(); } } } } } und eine Lösung void ausgabe(void) { printf(" %4d %4d %4d %4d\n",s1,e1,n1,d1); printf(" %4d %4d %4d %4d\n",m2,o2,r2,e2); printf("1%4d %4d %4d %4d\n",o3,n3,e3,y3); printf("\n\n%8d\n",a); printf("+ %6d\n",b); printf("========\n"); printf("%8d\n",c); lz=lz+1; printf("das war Loesung Nummer %5d\n",lz); } 2

3 main - Kommandozeilenparameter Sie können einem Programm beim Aufruf Argumente übergeben die das Programm zur Laufzeit auswerten kann solche Argumente heißen Kommandozeilenargumente und werden in der main Funktion deklariert entweder so int main (int argc, char *argv[ ]) oder so int main (int argc, char **argv) argc = argument count argc liefert hierbei die Anzahl der übergebenen Parameter argv = argument values argv ist ein Feld von Zeigern auf char (Liste von strings) dem ersten Parameter wird immer der Programm-Name selbst als Argument übergeben Die Namen argc und argv sind die üblichen Variablennamen für die Kommandozeilenparameter 3

4 Zugriff auf die main - Kommandozeile Das Betriebssystem speichert die einzelnen Worte, die Sie auf der Kommandozeile beim Programmaufruf eingeben, als Zeichenketten ab n a m e \0 n a r g 1 \0 n a r g 2 \0 e r z j 3 Die Anfangsadressen dieser Strings werden in einem Vektor von Zeigern gespeichert NULL Die Anfangsadressen dieses Vektors steht in der Variablen argv argv: 1200 Kommandozeile: name narg1 narg2 Die Anzahl der übergebenen Argumente stehen in der Variablen argc argc: 3 4

5 Zugriff auf die einzelnen Kommandozeilenargumente Ausgehend von der Zeigervariablen argv haben Sie mit einer ersten indirekten Adressierung (z.b. *argv oder argv[0]) die Anfangsadressen der jeweiligen Argumente, die als Zeichenketten zur Verfügung stehen Mit einer zweiten indirekten Adressierung (z.b. **argv oder argv[0][0]) können Sie auf die einzelnen Zeichen der Argumente zugreifen Dabei können Sie Zeigerschreibweise oder Vektorschreibweise verwenden. Zeigerschreibweise: Anfangsadresse von name : *argv 1. Zeichen von name : **argv Vektorschreibweise: Anfangsadresse von name : argv[0] 1. Zeichen von name : argv[0][0] Gemischte Schreibweise: 1. Zeichen von name : *argv[0] 2. Zeichen von name : (*argv)[1] 5

6 Beispiele: Zugriff auf die Kommandozeilenargumente #include <stdio.h> int main (int argc, char *argv[ ]) { printf ("Anzahl der uebergebenen Argumente ist: %i\n", argc); for (int i = 0; i < argc; i++) { printf ( Argument Nr. %i ist: %s\n", i, argv[i]); } return 0; } Programmname ausgeben: puts(argv[0]); oder puts(*argv); Erstes Argument auf Vorhandensein überprüfen: if(argv[1] == NULL){ printf( %s: Argurnent erwartet!\n, argv[0]); return 1;} int i =1; while(argv[i]!= NULL) puts(argv[i++]); int i =1; while(i < argc) puts(argv[i++]); while(*++argv!= NULL) puts(*argv); while(--argc!= 0) puts(* +argv); #include <stdio.h> int main (int argc, char *argv[ ]) { char *s; if (argc > 1) { s = argv[1]; if ((s[0] == '/') && (s[1] == '?')){ printf("hilfe zum Programm\n"); // weitere Hilfetexte } } } 6

7 Komplexe Datentypen Neben den einfachen Datentypen (char, int, float) gibt es noch die zusammengesetzte Datentypen Aufzählungstypen enum Strukturen struct Vereinigungstypen union die Bitfelder zur komfortablen Benutzung einzelner bits und die selbstdefinierten Datentypen zur besseren Lesbarkeit von C-Programmen 7

8 Aufzählungstyp der Aufzählungstyp wird verwendet um anstelle von Zahlen mit Namen arbeiten zu können Beispiel: Wochentage (Montag.. Sonntag) Vereinbarung eines Aufzählungstyps: enum TypName {Element1, Element2,.. }; hierbei ist TypName der Name eines so erstellten neuen Datentyps gefolgt von einer in Klammern stehenden Liste in welcher durch Komma getrennt, die Namen der einzelnen Elemente stehen Definition einer Variablen eines Aufzählungstyps: enum TypName Variablenname; Vereinbarung und Definition können zusammengefasst werden enum Wochentage {Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag}; enum Wochentage tag; enum {Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag} tag; 8

9 enum Die Listenelemente werden durchnumeriert beginnend mit 0 man kann dem Listenelement auch einen eigenen Wert zuordnen alle folgenden Elemente werden dann von dort aus aufsteigend numeriert enum Wochentage {Montag, Dienstag, Mittwoch = 5, Donnerstag, Freitag, Samstag, Sonntag}; Variablendefinition unter Nutzung des neuen Datentyps // Variable tag mit Initialwert Montag: Wochentage tag = Montag; if (tag == 5) { aktion = backup; } durch enum wird der Code lesbarer if (tag == Mittwoch) { aktion = backup; } 9

10 enum - weitere Hinweise Die Elemente der Liste werden beginnend mit 0 bewertet. Soll das erste Element mit einer anderen Zahl anfangen, so wird diese dem ersten Element zugewiesen. enum Noten {sehr_gut = 1, gut, befriedigend, ausreichend, mangelhaft}; auch gleichwertige Elemente sind denkbar das jeweilige Element muss mit einem Wert versehen werden von da an wird wieder aufsteigend bewertet. enum bool {falsch, unwahr = 0, richtig, wahr = 1}; 0 1 Typ-Definition, Variablen-Deklaration und Initialisierung sind in einem Schritt möglich: enum bool {falsch, unwahr = 0, richtig, wahr = 1} fertig = falsch; 10

11 Strukturen Strukturen verwendet man dort, wo unterschiedliche Daten zu einem Datenobjekt zusammengefasst werden Vereinbarung einer Struktur: beginnt mit Schlüsselwort struct gefolgt von einem StrukturNamen und einer Liste von Komponenten in Klammern { } mit Semikolon abgeschlossen; jede Komponente wird durch Name und Datentyp beschrieben. Definition einer Strukturvariablen: beginnt mit Schlüsselwort struct gefolgt von dem StrukturNamen und dem Variablennamen und Semikolon Vereinbarung und Definition können zusammengefasst werden enum format {Pform, Rform}; // Datentyp für Vektoren struct vektor { format form; double betrag; double winkel; double x; double y; }; // Datentyp für komplexe Zahlen struct complex { float re; // Realteil float im; // Imaginärteil }; 11

12 Arbeiten mit Strukturen // Deklaration einer Struktur // Datentyp für komplexe Zahlen struct complex { float re; // Realteil float im; // Imaginärteil }; // Deklaration einer Variablen complex c1, c2; // Deklaration einer Struktur // und Variablendeklaration in einem Schritt // Datentyp für komplexe Zahlen struct complex { Name der Struktur! float re; // Realteil float im; // Imaginärteil } c1, c2; Name der Variablen! // Zugriff auf die Komponenten c1.re = c2.re ; c1.im = c2.im ; Auf die Komponenten einer Struktur wird mit dem Punkt-Operator. zugegriffen. 12

13 Zugriff auf Komponenten von Strukturen über den. Operator (Punktoperator) bei Zeiger auf Strukturen über den -> Operator (Pfeiloperator) anstelle von (*Stukturname).Komponente struct psatz { char *name; int Jahr; } person, *person_ptr; #include <stdio.h> #include <stdlib.h> int main () { struct psatz {char * name; int jahr;} person; struct psatz * person_ptr; person_ptr = &person; person.name = (char *) malloc (80); printf ("Bitte geben Sie einen Namen ein: \n"); gets (person.name); printf ("Bitte geben Sie das Alter von %s ein: \n", person.name); scanf ("%i", &person.jahr); printf ("%s ist %i Jahre alt\n", person_ptr->name, person_ptr->jahr); printf ("%s ist %i Jahre alt\n", (*person_ptr).name, (*person_ptr).jahr); return 0; } 13

14 Vereinigungstyp - union Eine union wird ähnlich wie struct definiert. Bei Strukturen werden die einzelnen Komponenten hintereinander im Speicher abgelegt. Im Unterschied zu struct werden die Komponenten der union überlappend auf dem selben Speicher abgelegt. Nur eine der überlappenden Elemente ist sinnvoll. Eine Unionvariable belegt mindestens soviel Speicherplatz wie ihre größte Komponente Vereinbarung einer Union: beginnt mit Schlüsselwort union gefolgt von einem UnionNamen und einer Liste von Komponenten in Klammern { } mit Semikolon abgeschlossen; jede Komponente wird durch Name und Datentyp beschrieben. Definition einer Unionvariablen: beginnt mit Schlüsselwort union gefolgt von dem UnionNamen und dem Variablennamen und Semikolon Ein Zugriff auf die Komponenten erfolgt entweder mit dem Punkt- oder mit dem Pfeiloperator 14

15 Anwendung Vereinigungstyp - union enum format {Pform, Rform}; struct vektor { format form; double r; double phi; double x; double y; }; Zugriff: v1.form = Rform; v1.vr.x = 10.0; v1.vr.y = 20.0; Zum Vergleich: Struktur Hiermit unterscheiden Sie Rform von Pform v2.form = Pform; v2.vp.r = sqrt(v1.vr.x * v1.vr.x + v1.vr.y * v1.vr.y); v2.vp.phi = atan (v1.vr.y / v1.vr.x); Und jetzt: Union enum format {Pform, Rform}; struct VPform { double r; double phi; }; struct VRform { double x; double y; }; struct vektor{ format form; union { VPform vp; VRform vr; }; } v1, v2; 15

16 struct und union - weitere Hinweise Abhängig von den Deklarationen werden die Zugriffe einfacher - bzw. mehr verschachtelt Zugriff so: v1.uv.vr.x = 10.0; struct vektor{ format form; union { struct { double r; double phi; } vp; struct { double x; double y; } vr; } uv; } v1, v2; struct vektor{ format form; union { struct { double r; double phi; }; struct { double x; double y; }; }; } v1, v2; Anonyme Union! Anonyme Struktur! Keine Namen für die Strukturen! Zugriff jetzt so: v1.form = Rform; v1.x = 10.0; v1.y = 20.0; 16

17 Bitfelder Bitfelder sind besondere Strukturen in C Zugriff auf einzelne bits oder eine Gruppe von bits struct Flags { unsigned int CF : 1; unsigned int : 5; unsigned int ZF : 1; unsigned int SF : 1; unsigned int : 3; unsigned int OF : 1; unsigned int : 0; } Insbesondere interessieren : CF - Carry OF - Overflow SF - Sign ZF - Zero 17

18 struct Flags { unsigned int CF : 1; unsigned int : 5; unsigned int ZF : 1; unsigned int SF : 1; unsigned int : 3; unsigned int OF : 1; unsigned int : 0; } flag; if (flag.of) printf ("Overflow\n"); Bitfelder - Regeln Bitfelder werden als Komponenten einer Struktur definiert erlaubte Datentypen sind int unsigned int signed int hinter der Komponente wird durch : getrennt die Anzahl der bits für diese Komponente angegeben wird für die Komponente kein Name angegeben, so werden soviele ungenutzte bits reserviert wie durch den Doppelpunkt angegeben wird als Breite 0 angegeben, so wird das nachfolgende Element im nächsten 16bit Wort abgelegt (alignment). Ansonsten wird auf die Komponenten wie auf eine normale Strukturkomponente zugegriffen. Bitfelder sind implementationsabhängig 18

19 typedef Mit typedef wird ein neuer Name für einen bestehende Typ vereinbart. Es wird kein Datentyp damit deklariert! Es wird auch kein Speicher reserviert. SYNTAX: typedef existierendertyp neuertypname Beispiele: typedef unsigned int size_t; (aus der <stdio.h>) typedef struct {float re; float im;} complex; Es können nun Variablendeklarationen mit dem neuen Namen erfolgen: size_t z = 10; complex c1, c2; 19

20 und eine kleine Anwendung mit einem kleinen Würfel #include <stdio.h> typedef struct { int side[6]; }cube; cube cub[1]; enum seiten {FRONT, BACK, LEFT, TOP, RIGHT, BOTTOM}; int main() { } int ret; int rot_y_right(cube*); int show_cube(cube*); int init_cubes(cube*); ret=init_cubes(&cub[0]); printf("\nshow Initial Configuration\n\n"); ret=show_cube(&cub[0]); ret=rot_y_right(&cub[0]); printf("\nshow Configuration after turning\n\n"); ret=show_cube(&cub[0]); return 0; int rot_y_right(cube *c) { int tmp; tmp = c->side[front]; c->side[front] = c->side[left]; c->side[left] = c->side[back]; c->side[back] = c->side[right]; c->side[right] = tmp; return 0; } int show_cube(cube *c) { char *col[4] = {"red","green","blue","white"}; printf("show sides for Cube:\n"); printf("front\tback\tleft\tright\ttop\tbottom\n"); printf("%s\t%s\t%s\t%s\t%s\t%s\n",col[c->side[front]], col[c->side[back]], col[c->side[left]], col[c->side[right]], col[c->side[top]], col[c->side[bottom]]); return 0; } int init_cubes(cube *c){ /* Initialize Cube */ enum farbe {RED, GREEN, BLUE, WHITE}; c->side[front] = WHITE; c->side[back] = BLUE; c->side[left] = RED; c->side[top] = GREEN; c->side[right] = RED; c->side[bottom] = RED; return 0; } 20