Namensabfrage < C/C++ < Programmiersprachen < Praxis < Informatik < Vorhilfe
|
| Aufgabe | Schreiben Sie ein C-Programm zum Eingeben und Ausdrucken eines Nachnamens.
Als Nachnamen sollen Zeichenketten akzeptiert werden, die mit einem Großbuchstaben
beginnen und danach nur aus Kleinbuchstaben bestehen. Umlaute und Sonderzeichen sind
nicht erlaubt. Nachnamen sollen höchstens 20 Zeichen und mindestens 3 Zeichen lang sein.
Der Benutzer soll zu Beginn zur Eingabe eines Nachnamens aufgefordert werde. Danach soll
die Eingabe auf Gültigkeit überprüft werden.
Eine eingegebene Zeichenkette ist gültig, wenn ein Anfangsstück das oben beschriebene
Format eines Nachnamens hat.
Im Fall der Gültigkeit der Eingabe soll der erkannte Nachname ausgedruckt werden. Hierbei
wird das in der Länge maximale Anfangsstück, das das Format eines Nachnamens hat,
genommen. Im Eingabestrom verbleibende Zeichen sollen gelöscht werden.
Ist eine Eingabe nicht gültig, soll der Benutzer auf die Ungültigkeit hingewiesen werden und zu
einer erneuten Eingabe aufgefordert werden.
Benutzen Sie für das Einlesen von Zeichen nur die Funktion getchar().
Beispiele gibt es einen fettgedruckten Teil, ist die Eingabe gültig; der fettgedruckte Teil
entspricht dann der Ausgabe: Bbb, BbbaH-Lk, Bbbö, BB, Ba-Lk, bbb,
|
Hallo zusammen,
ich komm irgendwie nicht weiter. Meinen Code kann ich zwar komplemieren, aber wenn ich dann das Programm ausführe kommt nichts Richtiges dabei herraus! Nach der ersten Eingabenaufforderung spuckt mir der Computer 6 mal die beiden Satze: "Bitte geben Sie Ihren Nachnamen ein:
Ihr Name beginnt nicht mit einem Großbuchstaben!" aus. Bei erneuter Eingaben kommen das Gleiche.
Bis jetzt schaut mein Code folgendermaße aus:
| 1: |
| | 2: | #include <stdio.h>
| | 3: | #include <ctype.h>
| | 4: | #include <string.h>
| | 5: |
| | 6: | int laenge3(char string[]);
| | 7: | int laenge20(char string[]);
| | 8: | int umlaut(char string[]);
| | 9: | int ersteB(char string);
| | 10: | int kleinB(char string[]);
| | 11: | void loeschen();
| | 12: |
| | 13: | int main(){
| | 14: | int n=21, i=0, x=0;
| | 15: | char eingabe[21], hilf;
| | 16: |
| | 17: | do{
| | 18: |
| | 19: | if(x==1){
| | 20: | printf("\nIhre Name wurde falsch eingegeben!! Geben Sie Bitte Ihren Namen erneut ein!");
| | 21: | loeschen();
| | 22: | }
| | 23: |
| | 24: | do{
| | 25: | printf("\nBitte geben Sie Ihren Nachnamen ein:");
| | 26: | hilf=getchar();
| | 27: | }while(ersteB(eingabe[0]) || kleinB(eingabe) || umlaut(eingabe));
| | 28: |
| | 29: | while(i<=19){
| | 30: | eingabe[i]=getchar();
| | 31: | i++;
| | 32: | }
| | 33: |
| | 34: | x=(laenge20(eingabe) || laenge3(eingabe));
| | 35: |
| | 36: |
| | 37: | }while(x);
| | 38: |
| | 39: | i=0;
| | 40: |
| | 41: | while (i<=19){
| | 42: | printf("%s", eingabe[i]);
| | 43: | }
| | 44: |
| | 45: | }
| | 46: |
| | 47: | int laenge3(char string[]){
| | 48: | if (string[0] && string[1] && string[2]){
| | 49: | return 0;
| | 50: | }
| | 51: | else{
| | 52: | printf("\nIhr eingegebener Name ist kürzer als drei Buchstaben!");
| | 53: | return 1;
| | 54: | }
| | 55: | }
| | 56: |
| | 57: | int laenge20(char string[]){
| | 58: | int i=0;
| | 59: |
| | 60: | while(i<=20){
| | 61: | if(string[i]=='\0'){
| | 62: | return 0;
| | 63: | }
| | 64: | else{
| | 65: | printf("\nIhr eingegebener Name ist langer als 20 Buchstaben!");
| | 66: | return 1;
| | 67: | }
| | 68: | i++;
| | 69: | }
| | 70: | }
| | 71: |
| | 72: |
| | 73: | int umlaut(char string[]){
| | 74: | int i=0;
| | 75: | char x;
| | 76: |
| | 77: | while(string[i]!='\0'){
| | 78: | x=toupper(string[i]);
| | 79: | if (atoi("x")== 142 || atoi("x")==148 || atoi("x")==154){
| | 80: | printf("\nIhr Name würde mit einem Umlaut geschrieben!\n");
| | 81: | return 1;
| | 82: | break;
| | 83: | }
| | 84: |
| | 85: | i++;
| | 86: | }
| | 87: | return 0;
| | 88: |
| | 89: | }
| | 90: |
| | 91: |
| | 92: |
| | 93: | int ersteB(char string){
| | 94: | if (atoi("string")>=65 && atoi("string")<=90){
| | 95: | return 0;
| | 96: | }
| | 97: | else{
| | 98: | printf("\nIhr Name beginnt nicht mit einem Großbuchstaben!");
| | 99: | return 1;
| | 100: | }
| | 101: | }
| | 102: |
| | 103: | int kleinB(char string[]){
| | 104: | int i=1;
| | 105: | while(string[i]=='\0'){
| | 106: | if (atoi("string")>=97 && atoi("string")<=122){
| | 107: | i++;
| | 108: | }
| | 109: | else{
| | 110: | return 1;
| | 111: | }
| | 112: | return 0;
| | 113: | }
| | 114: |
| | 115: | }
| | 116: |
| | 117: | void loeschen(){
| | 118: | while(getchar()!='\n' && getchar()!=EOF){
| | 119: | }
| | 120: | }
|
Schon mal danke für eure Hilfe.
LG Tobi
|
|
| |
|
Hallo Tobi,
Ohne dein Programm jetzt näher zu betrachten, habe ich jetzt mal ein Beispielprogramm geschrieben, das, wie ich finde, mehr oder weniger diese getchar-Sachen bzw. generell das Streaming unter C demonstriert. (Ich habe es unter Cygwin erstellt.) Unter C sind diese Tastatureinlese-Geschichten immer sehr umständlich zu handhaben, weswegen ich wie im Beispiel meist auf temporäre Dateien ausweiche. Man könnte auch einen Buffer immer wieder neu allozieren und den Inhalt des alten Buffers in den neuen kopieren. Aber das erscheint mir noch schlimmer... . Hab' mein Programm jetzt nicht groß auf Fehler überprüft aber bei mir hat's funktioniert.
| 1: |
| | 2: | #include <stdio.h>
| | 3: | #include <stdlib.h>
| | 4: | #include <sys/types.h>
| | 5: | #include <sys/stat.h>
| | 6: |
| | 7: | const char* szrandfname = "odihc42fuo.diu76dciud";
| | 8: |
| | 9: | int main(int argc, char* argv[])
| | 10: | {
| | 11: | /*** PHASE 1: DIE EINGABE ***/
| | 12: |
| | 13: | FILE* fnachname;
| | 14: | char c;
| | 15: | fnachname = fopen(szrandfname, "w");
| | 16: |
| | 17: | printf("Bitte geben Sie ihren Nachnamen Zeichen fuer Zeichen ein:\n");
| | 18: |
| | 19: | do {
| | 20: | c = getchar();
| | 21: |
| | 22: | if(c != '\n')
| | 23: | fputc(c, fnachname);
| | 24: | else break;
| | 25: |
| | 26: | int flush;
| | 27: | while ((flush = getchar()) != EOF && flush != '\n');
| | 28: | } while(-1);
| | 29: | fclose(fnachname);
| | 30: |
| | 31: |
| | 32: | /*** PHASE 2: DATEI EINLESEN ***/
| | 33: |
| | 34: | struct stat buf;
| | 35: | stat(szrandfname, &buf);
| | 36: | long lnachnsize = buf.st_size;
| | 37: |
| | 38: | char* sznachname;
| | 39: |
| | 40: | if(lnachnsize < 3) {
| | 41: | remove(szrandfname);
| | 42: | printf("Der Nachname sollte min. 3 Zeichen lang sein!\n");
| | 43: |
| | 44: | exit(0);
| | 45: | }
| | 46: |
| | 47: | if(lnachnsize > 20) {
| | 48: | lnachnsize = 20;
| | 49: | printf("Es werden nur die ersten 20 Zeichen des Nachnames beruecksichtigt!\n");
| | 50: | }
| | 51: |
| | 52: | printf("\n\nWARNUNG: Moegliche ungueltige Zeichen bleiben unberuecksichtigt!\n\n");
| | 53: |
| | 54: | fnachname = fopen(szrandfname, "r");
| | 55: | sznachname = (char*)malloc(lnachnsize+1);
| | 56: | fread(sznachname, 1, lnachnsize, fnachname);
| | 57: | sznachname[lnachnsize] = '\0';
| | 58: | fclose(fnachname);
| | 59: | remove(szrandfname);
| | 60: |
| | 61: |
| | 62: | /*** PHASE 3 : DIE AUSWERTUNG ***/
| | 63: |
| | 64: | if( (sznachname[0] >= 65) && (sznachname[0] <= 90) ) {
| | 65: | printf("%c", sznachname[0]);
| | 66: | long n;
| | 67: | n = 0;
| | 68: |
| | 69: | while(sznachname[n] != '\0')
| | 70: | {
| | 71: | if( (sznachname[n] >= 97) && (sznachname[n] <= 122) )
| | 72: | printf("%c", sznachname[n]);
| | 73: |
| | 74: | n++;
| | 75: | }
| | 76: |
| | 77: | printf("\n");
| | 78: | }
| | 79: |
| | 80: | return 0;
| | 81: | }
|
Viele Grüße
Karl
|
|
|
| |
|
Hallo Karl_Pech,
danke für deine Hilfe, aber File haben wir leider noch nicht behandelt.
Hab nun folgenden Code geschrieben:
| 1: | //Aufgabe31b
| | 2: |
| | 3: |
| | 4: | #include <stdio.h>
| | 5: |
| | 6: | int erstB(char string);
| | 7: | int umlaut(char string[]);
| | 8: | int laengeA(char string[]);
| | 9: | int laengeB(char string[]);
| | 10: | int kleinB(char string[]);
| | 11: | int gueltigeL(char string[]);
| | 12: | //int zahl(char string[]);
| | 13: | void loeschen();
| | 14: |
| | 15: | int main(){
| | 16: |
| | 17: | int i=0, a=0, b=0, c=0, d=0, e=0, l=0;
| | 18: | char eingabe[21];
| | 19: |
| | 20: | printf("Kriterien zur Namenseingabe:\n\t- Länge zwischen 3 und 20 Buchstaben\n\t- Anfang mit Großbuchstaben");
| | 21: | printf("\n\t- Buchstabe 2 und 3 muss klein sein\n\t- Kein Umlaut in den ersten 3 Buchstaben\n");
| | 22: |
| | 23: | do{
| | 24: | if((a||b||c||d||e)==1){
| | 25: | loeschen();
| | 26: | printf("\nNeuer Versuch\n");
| | 27: | }
| | 28: | printf("Bitte geben Sie einen Namen ein:");
| | 29: | i=0;
| | 30: | while (i<=20){
| | 31: | eingabe[i]=getchar();
| | 32: | if (eingabe[i]=='\n'){
| | 33: | break;
| | 34: | }
| | 35: |
| | 36: | i++;
| | 37: | }
| | 38: |
| | 39: | a=erstB(eingabe[0]);
| | 40: | b=umlaut(eingabe);
| | 41: | c=laengeA(eingabe);
| | 42: | d=laengeB(eingabe);
| | 43: | e=kleinB(eingabe);
| | 44: | //f=zahl(eingabe);
| | 45: |
| | 46: | }while(a || b || c || d || e );
| | 47: |
| | 48: | l=(gueltigeL(eingabe) + 3);
| | 49: | i=0;
| | 50: |
| | 51: | printf("Ausgabe:\t");
| | 52: | while (l>0){
| | 53: | printf("%c", eingabe[i]);
| | 54: | i++;
| | 55: | l--;
| | 56: | }
| | 57: |
| | 58: | printf("\n\n");
| | 59: |
| | 60: | }
| | 61: |
| | 62: |
| | 63: |
| | 64: | int erstB(char string){
| | 65: | if (string>=65 && string <= 90) {
| | 66: | return 0;
| | 67: | }
| | 68: | else{
| | 69: | printf("Ihr Name beginnt nicht mit einem Großbuchstaben!\n");
| | 70: | return 1;
| | 71: | }
| | 72: |
| | 73: | }
| | 74: |
| | 75: |
| | 76: | int umlaut(char string[]){
| | 77: | int a;
| | 78: |
| | 79: | for(a=0; a<=2; a++){
| | 80: | if (string[a]<0){
| | 81: | printf("In ihrem Namen kommt in den ersten drei Buchstaben ein Umlaut vor!\n");
| | 82: | return 1;
| | 83: | }
| | 84: | }
| | 85: | return 0;
| | 86: | }
| | 87: |
| | 88: |
| | 89: | int laengeA(char string[]){
| | 90: | int i=0;
| | 91: |
| | 92: | for(i=0; i<=2; i++){
| | 93: | if(string[i]=='\n'){
| | 94: | printf("Ihr eingegebener Name ist kürzer als 3 Buchstaben!\n");
| | 95: | return 1;
| | 96: | }
| | 97: | }
| | 98: | return 0;
| | 99: | }
| | 100: |
| | 101: |
| | 102: | int laengeB(char string[]){
| | 103: | int i=0;
| | 104: |
| | 105: | for(i=0; i<21; i++){
| | 106: | if(string[i]=='\n'){
| | 107: | return 0;
| | 108: | }
| | 109: | }
| | 110: | printf("Ihr eingegebener Name ist länger als 20 Buchstaben!\n");
| | 111: | return 1;
| | 112: | }
| | 113: |
| | 114: | int kleinB(char string[]){
| | 115: | int i;
| | 116: | char a;
| | 117: |
| | 118: | for(i=1; i<3; i++){
| | 119: | a=string[i];
| | 120: | if(a<97 || a>122){
| | 121: | return 1;
| | 122: | }
| | 123: | }
| | 124: | return 0;
| | 125: | }
| | 126: |
| | 127: | void loeschen(){
| | 128: | while(getchar()!='\n' && getchar()!=EOF){
| | 129: | getchar();
| | 130: | }
| | 131: | }
| | 132: |
| | 133: |
| | 134: | int gueltigeL(char string[]){
| | 135: | int i=3, l=0;
| | 136: |
| | 137: | while (string[i]>=97 && string[i]<=122){
| | 138: | l++;
| | 139: | i++;
| | 140: | }
| | 141: |
| | 142: | return l;
| | 143: | }
| | 144: |
| | 145: | /*int zahl(char string[]){
| | 146: | int i=0;
| | 147: | for(i=0;i<=2;i++){
| | 148: | if (string[i]==
| | 149: |
| | 150: | }
| | 151: | }*/ |
Mal schaun was dabei so raus kommt.
Trotzdem nochmals danke.
Lg Tobias
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 22:20 Di 16.12.2008 | | Autor: | matux |
$MATUXTEXT(ueberfaellige_frage)
|
|
|
|
