SUCHE MIT Google
Web virtualuniversity.ch
HOME DIDAKTIK ECDL ELEKTRONIK GUIDES HR MANAGEMENT MATHEMATIK SOFTWARE TELEKOM
DIENSTE
Anmeldung
Newsletter abonnieren
Sag's einem Freund!
VirtualUniversity als Startseite
Zu den Favoriten hinzufügen
Feedback Formular
e-Learning für Lehrer
Spenden
Autoren login
KURSE SUCHEN
Kurse veröffentlichen

Suche nach Datum:

Suche mit Schlüsselwort:

Suche nach Land:

Suche nach Kategorie:
PARTNER
ausbildung24.ch - Ausbildungsportal, Seminare, Kursen... 

 
HTMLopen.de - Alles was ein Webmaster braucht

 
PCopen.de - PC LAN Netze und Netzwerke - alles was ein IT Profi und Systemtechnicker braucht

SOFTWARE
kann man auch schreiben

char s[] = "string";

In C gibt es keine speziellen Sprachelemente für die Manipulation von Zeichenketten. Es existieren jedoch in der C-Standardbibliothek eine Reihe von Funktionen zur Stringbearbeitung.

  • Funktionen zum Kopieren von Strings und Zeichenarrays
  • Funktionen zum Aneinanderhängen von Strings
  • Funktionen zum Vergleich von Strings und Zeichenarrays
  • Funktionen zum Suchen nach Zeichen und Zeichenfolgen in Strings und Zeichenarrays
  • Funktion zur Ermittlung der Länge eines Strings
  • Funktion zum Füllen eines Arrays mit einem Zeichen
  • Funktion zur Ermittlung der zu einer Fehlernummer gehörenden Fehlermeldung

Die entsprechenden Funktions-Deklarationen befinden sich in der Standard-Header-Datei <string.h>. Diese ist daher bei Verwendung der Funktionen mittels #include <string.h> einzubinden. In <string.h> ist auch der von einigen Funktionen verwendete Datentyp size_t definiert. Dies ist der "natürliche" unsigned-Typ, d. h. der Typ, den der sizeof-Operator liefert.

Da in C Array-Grenzen-Überschreitungen nicht überprüft werden, liegt es am Programmierer einen Array-Überlauf zu verhindern. Im ANSI-Standard ist lediglich festgelegt, daß das Überschreiten von Array-Grenzen zu einem undefinierten Verhalten führt. Alle Kopierfunktionen (siehe unten) setzen voraus, daß sich der Quell- und der Zielbereich nicht überlappen. Im Falle der Überlappung ist das Verhalten undefiniert.

Bibliothek zum Test von Zeichen: <ctype.h>

Das Argument der folgenden Funktionen ist jeweils ein int dessen Wert entweder EOF oder als unsigned char darstellbar sein muß. Der Rückgabewert ist ein int, wobei dieser gleich Null ist, wenn das Argument c die Bedingung nicht erfüllt, ansonsten ist er ungleich Null.

islower(c) Kleinbuchstabe
isupper(c) Großbuchstabe
isalpha(c) Klein- oder Großbuchstabe
isdigit(c) Dezimalzahl
isalnum(c) Klein- oder Großbuchstabe oder Dezimalzahl
iscntrl(c) Control-Zeichen
isgraph(c) druckbares Zeichen außer space
isprint(c) druckbares Zeichen mit space
ispunct(c) druckbares Zeichen außer space, Buchstabe und Ziffern
isspace(c) space, formfeed, newline, carriage return, tab, vertical tab
isxdigit(c) Hexadezimalzahl

Achtung: Die deutschen Umlaute und das "ß" sind keine Buchstaben im obigen Sinne!!

In diesem Headerfile sind außerdem noch zwei Funktionen zur Konvertierung von Buchstaben enthalten:

int tolower(int c) konvertiert c zu Kleinbuchstaben
int toupper(int c) konvertiert c zu Großbuchstaben

Das folgende Programm gibt für eine eingegebene ganze Zahl zwischen 0 und 999 das entsprechende Zahlwort aus (z. B. für den automatischen Druck von Schecks). Es demonstriert die Initialisierung und Anwendung von Character-Arrays (Zeichenketten). Die Denkarbeit bei der Konzeption besteht darin, daß man bei der Einerstelle nicht bei "9" aufhören darf, sondern man die Werte von 0 bis 19 verwenden muß.

                                       #include <stdio.h>
                                       #include <stdlib.h>
                                       #include <ctype.h>
                                       #include <string.h>
                                       
                                       int main(void)
                                        {
                                       
                                         /******************  Zahlwörtertabellen  ***************************/
                                       
                                         char low [20][10] = {  "null", "eins", "zwei", "drei", "vier", "fünf",
                                                             "sechs", "sieben", "acht", "neun", "zehn",
                                                             "elf", "zwölf", "dreizehn", "vierzehn",
                                                             "fünfzehn", "sechzehn", "siebzehn",
                                                             "achtzehn", "neunzehn" };
                                       
                                         char ten [10][10] = {  "", "", "zwanzig", "dreißig", "vierzig",
                                                             "fünfzig", "sechzig", "siebzig",
                                                             "achtzig", "neunzig" };
                                       
                                         char hun [10][15] = {  "", "einhundert", "zweihundert", "dreihundert",
                                                             "vierhundert", "fünfhundert", "sechshundert",
                                                             "siebenhundert", "achthundert", "neunhundert" };
                                       
                                         /*****************************************************************/
                                       
                                       
                                         int num; 
                                       
                                         printf("\nZahl: ");
                                         scanf("%d",&num);
                                       
                                         if (num < 20)                                        /*  0 <= num <  20 */
                                          printf("%s\n", low[num]);
                                         else if (num < 100)                                  /* 20 <= num < 100 */
                                           {
                                           if ((num % 10) == 0)                                   /* Keine Einer */
                                             printf("%s\n", ten[num/10]);
                                           else if ((num % 10) == 1)                            /* Einerziffer 1 */
                                             printf("einund%s\n", ten[num/10]);
                                           else                                                  /* andere Einer */
                                             printf("%sund%s\n", low[num%10], ten[num/10]);
                                           }
                                          else                                              /* 100 <= num < 1000 */
                                           {
                                           if ((num%100) == 0)                          /* keine 1er, keine 10er */
                                             printf("%s\n", hun[num/100]);
                                           else if ((num%100) < 20)                               /* H01 bis H19 */
                                             printf("%s%s\n", hun[num/100], low[num%100]);
                                           else if ((num%10) == 0)                            /* letzte Ziffer 0 */
                                             printf("%s%s\n", hun[num/100], ten[(num%100)/10]);
                                           else if ((num%10) == 1)                            /* letzte Ziffer 1 */
                                             printf("%seinund%s\n", hun[num/100], ten[(num%100)/10]);
                                           else                                                 /* sonst. Zahlen */
                                             printf("%s%sund%s\n", hun[num/100], low[num%10], ten[(num%100)/10]);
                                           }
                                         return(0);
                                         }
                                       
Für die Bearbeitung von Zeichenketten gibt es eine umfangreiche Funktionsbibliothek:

Bibliothek mit String-Funktionen: <string.h>

Wie schon der Name sagt, werden in diesem Header Funktionen zur Manipulation von Strings deklariert. Dabei werden folgende Typkonventionen benutzt:
 
                                       char *s, *t; 
                                       const char *cs, *ct;
                                       int c;
                                       size_t n; 
                                       

char *strcpy(s,ct) kopiert ct zu s inklusive dem abschließenden '\0'. Zurückgegeben wird s.
char *strncpy(s,ct,n) kopiert höchstens n Zeichen des Strings ct zu s und liefert s zurück, wobei wie üblich mit '\0' terminiert wird.
char *strcat(s,ct) hängt ct an s an und liefert s zurück.
char *strncat(s,ct,n) hängt höchstens n Zeichen von ct an s an, terminiert mit '\0' und liefert s zurück.
int strcmp(cs,ct) vergleicht cs und ct. Der Rückgabewert ist 0, wenn die beiden Strings identisch sind, negativ, wenn cs<ct ist und positev, wenn cs>ct ist, wobei das < und > im lexikalischen Sinne verstanden wird, d.h. es wird Buchstabe für Buchstabe verglichen und geprüft, welcher als erster im Alphabet steht, wobei wiederum Großbuchstaben vor Kleinbuchstaben kommen (ASCII-Code).
int strncmp(cs,ct,n) Im wesentlichen dasselbe wie zuvor, nur daß diesmal höchstens n Zeichen verglichen werden.
char *strchr(cs,c) liefert Pointer zum ersten Auftreten von c in cs zurück, oder NULL wenn c nicht auftritt.
char *strrchr(cs,c) liefert Pointer zum letzten Auftreten von c in cs zurück, oder NULL wenn c nicht auftritt.
char *strstr(cs,ct) liefert Pointer zum ersten Auftreten des Strings ct in cs zurück oder NULL wenn ct nicht auftritt.
size_t strlen(cs) liefert die Länge des Strings cs zurück.

Beispiel für Strungbearbeitung: Stringpositeon ermitteln
Alle Operationen werden ohne Bibliotheksfunktionen und ohne Pointer ausgeführt.

                                       
                                       #include <stdio.h>
                                       #include <stdlib.h>
                                       
                                       main()
                                         {
                                         int i, c;
                                         char object[120], target[120],       /* Suchstring, Quellstring */
                                              hilf[120];                      /* Hilfs-String fuer Tausch */
                                         int opos, tpos, ergpos,              /* Positeonen */
                                             olen, tlen, hlen;                /* Laengen */
                                       
                                         do
                                           {
                                           printf("Erster String : ");
                                           i = 0;                             /* String zeichenweise lesen */
                                           while ((c = getchar()) != EOF && c != '\n')
                                             object[i++] = c;
                                           object[i] = '\0'; olen = i;        /* Laenge gleich speichern */
                                           if (c != EOF)                     /* Ctrl-D eingegeben ? */
                                             {
                                             printf("Zweiter String: ");
                                             i = 0;
                                             while ((c = getchar()) != EOF && c != '\n')
                                               target[i++] = c;
                                             target[i] = '\0'; tlen = i;
                                       
                                             /* Suche immer den kuerzeren im laengeren String */
                                             if (strlen(object) > strlen(target))
                                               /* dann beide Strings vertauschen */
                                               {                              
                                               i = 0;                         /* object --> hilf */
                                               while ((hilf[i]=object[i]) != '\0') i++;
                                               i = 0;                         /* target --> object */
                                               while ((object[i]=target[i]) != '\0') i++;
                                               i = 0;                         /* hilf --> target */
                                               while ((target[i]=hilf[i]) != '\0') i++;
                                               hlen = olen; olen = tlen;      /* und die Laengen auch */
                                               tlen = hlen;
                                               }
                                             /* Beginn der Suche */
                                             tpos = 0;
                                             while (tlen != 0 && tpos < (tlen-olen+1))
                                               {                      /* Solange objet in target Platz hat */
                                               opos = 0;
                                               while ((target[tpos+opos] == object[opos]) && (opos < olen))
                                                 opos++;                      /* vergleichen ab tpos */
                                               if (opos >= olen)              /* object in target - fertig */
                                                 {
                                                 ergpos = tpos;               /* Positeon merken */
                                                 tpos = tlen;                 /* sorgt fuer Abbruch */
                                                 }
                                               else
                                                 ergpos = -1;                 /* nicht gefunden */
                                               tpos++;                        /* sonst naechste Pos. */
                                               }/*endwhile (tlen != 0...) */
                                       
                                             /* Ausgabe */
                                             if (ergpos < 0)
                                               printf("Kein String ist Teilstring des anderen!");
                                             else
                                               printf("'%s' in '%s' ab Pos. %d enthalten",
                                                       object,target,ergpos);
                                             }/* endif (c != EOF) */
                                           printf("\n");
                                           }
                                         while (c != EOF);                    /* bis Ctrl-D eingegeben */
                                         }
                                       

Dieses Programm ist sehr ""ausführlich" programmiert. Das folgende Programm ist nicht nur etwas kürzer, sondern es werden vor allem zwei sinnvolle Funktionen definiert. Das Programm sucht alle Zeilen aus der Standardeingabe, die ein bestimmtes Suchmuster enthalten.

                                       # include <stdio.h>
                                       
                                       # define MAXLINE 1000   /* Maximale Zeilenlaenge */
                                       
                                       int main(void)
                                         {
                                         char line[MAXLINE];
                                       
                                         while (getline(line,MAXLINE) > 0)
                                           if (index(line,"the") > 0)
                                             printf("%s",line);
                                         return 0;
                                         }
                                       
                                       int getline(char s[], int lim) 
                                         /* Eingabezeile mit max. lom Zeichen in s ablegen, Laenge liefern */
                                         {
                                         int c,i;
                                         i = 0;
                                         while (--lim>0 && (c=getchar()) != EOF && c!='\n')
                                           s[i++] = c;
                                         if (c == '\n') s[i++] = c;
                                         s[i] = '\0';
                                         return(i);
                                         }
                                       
                                       index (char s[],char t[]) 
                                         /* Positeon von t in s liefern, -1 falls nicht da */
                                         {
                                         int i, j, k;
                                         for (i = 0; s[i] != '\0'; i++) 
                                           {
                                           for (j = i, k = 0; t[k] != '\0' && s[j] == t[k]; j++,k++)
                                             ;
                                           if (t[k] == '\0') return(i);
                                           }
                                         return(-1);
                                         }
                                       

Zum Abschluß noch ein völlig unnützes Programm: Es gibt auf die Eingabe eines Geburtstages das entsprechende Tierkreiszeichen aus.

                                       #include <stdio.h>
                                       
                                       int main(void)
                                        {
                                        /*  Sternzeichentabelle:  */
                                         char zodiac [12] [11] = { "STEINBOCK" , "WASSERMANN", "FISCHE",
                                                                   "WIDDER", "STIER", "ZWILLINGE",
                                                                   "KREBS", "LÖWE", "JUNGFRAU",
                                                                   "WAAGE", "SKORPION", "SCHÜTZE"};
                                       
                                         /*  Tabelle der Tage, die bis zu einem bestimmten Monat vergangen sind:  */
                                         int monsum [13] = { 0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
                                       
                                         /*  Nummer des Anfangstages (im Intervall 1 - 365) eines Sternzeichens:  */
                                         int start [12] = { 1, 31, 62, 90, 121, 151, 183, 214, 246, 277, 307, 337 };
                                       
                                         /*  Nummer des Endtages (im Intervall 1 - 365) eines Sternzeichens 
                                             (hier nicht noetig): */
                                         int end [12] = { 30, 61, 89, 120, 150, 182, 213, 245, 276, 306, 336, 365 };
                                       
                                         int i;
                                         int day;              /*  Geburtstag */
                                         int mon;              /*  Geburtsmonat*/
                                         int tnum;             /*  Geburtstag und Geburtsmonat umgerechnet in den
                                                                   entsprechenden Tag des Tierkreisjahres (1-365) */
                                       
                                         printf("\n\nTag und Monat des Geburtsdatums eingeben (tt mm): ");
                                         scanf("%d %d", &day, &mon);
                                       
                                         /*  Datum umrechnen in Anzahl der vergangenen Tage seit dem 22.12., 
                                             dem ersten Zeichen im Turnus (STEINBOCK) */
                                         if (monsum[mon] + day + 10 > 365)        
                                           tnum = monsum[mon] + day + 10 - 365;
                                         else
                                           tnum = monsum[mon] + day + 10;
                                        
                                         i = 0;
                                         while (tnum > start[i]) i++;
                                         printf("%d %d Ihr Sternzeichen ist %s\n", tnum,i-1,zodiac[i-1]);
                                         return(0);
                                        }
                                       

DIPLOMARBEITEN UND BÜCHER

Diplomarbeiten zum Runterladen:

Suche im Katalog:
Architektur / Raumplanung
Betriebswirtschaft - Funktional
Erziehungswissenschaften
Geowissenschaften
Geschichtswissenschaften
Informatik
Kulturwissenschaften
Medien- und Kommunikationswissenschaften
Medizin
Psychologie
Physik
Rechtswissenschaft
Soziale Arbeit
Sozialwissenschaften


JOBS
HOME | E-LEARNING | SITEMAP | LOGIN AUTOREN | SUPPORT | FAQ | KONTAKT | IMPRESSUM
Virtual University in: Italiano - Français - English - Español
VirtualUniversity, WEB-SET Interactive GmbH, www.web-set.com, 6301 Zug

Partner:   Seminare7.de - PCopen.de - HTMLopen.de - WEB-SET.com - YesMMS.com - Ausbildung24.ch - Manager24.ch - Job und Karriere