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
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
tolower(int c) konvertiert c zu Kleinbuchstaben
toupper(int c) konvertiert c zu Großbuchstaben

                                       #include <stdio.h>
                                       #include <ctype.h>
                                       
                                       void main (void)
                                         {
                                         char c;
                                       
                                         c = getchar();
                                         if (isalpha(c)) printf ( "%c ist ein Buchstabe\n",c);
                                         if (isalnum(c)) printf ( "%c ist ein Buchstabe oder eine Ziffer\n",c);
                                         if (isupper(c)) printf ( "%c ist ein Großbuchstabe\n",c);
                                         if (islower(c)) printf ( "%c ist ein Kleinbuchstabe\n",c);
                                         if (isdigit(c)) printf ( "%c ist eine Ziffer\n",c);
                                         if (isspace(c)) printf ( "%c ist ein Leerzeichen\n",c);
                                         }
                                       
Das folgende Beispiel zeigt die Anwendung der Konvertierfunktionen:
                                       #include <stdio.h>
                                       #include <ctype.h>
                                       
                                       void main (void)
                                       {
                                         char c, d;
                                       
                                         c = getchar();
                                         if (! isalpha(c)) 
                                           {
                                           printf ("%c ist kein Buchstabe!\n",c);
                                           }
                                         else
                                           {
                                           if (islower(c))
                                             {
                                             d = toupper (c);
                                             printf ( "%c wurde umgwandelt in %c\n",c,d );
                                             }
                                           if (isupper(c)) 
                                             {
                                             d = tolower (c);
                                             printf ( "%c wird umgwandelt in %c\n",c,d );
                                             }
                                           }
                                         }
                                       

Ausdrucken einer einfachen ASCII-Tabelle:

                                       #include <stdio.h>
                                       #include <ctype.h>
                                       
                                       void main(void)
                                         {
                                         int i, j;
                                         for (i=0; i < 4; i++) printf("|dec hex Char ");
                                         printf("|\n");
                                         for (i=0; i < 128/4; i++)
                                           {
                                           printf("\n| ");
                                           for (j=0; j < 128; j+=128/4)
                                             {
                                             printf("%3d %2X ", i+j, i+j);
                                             if (isgraph(j)) printf("  %c  | ", i+j);
                                             else printf("  .  | ");
                                             }
                                           }
                                         }
                                       

Länge einer konstanten Zeichenkette ermitteln:

                                       #include <stdio.h>
                                       
                                       int stringlaenge(char *s);
                                       
                                       int main(void)
                                         { 
                                         char kette[] = "Elvis is alive!";
                                         printf("DDer String hat %d Zeichen.\n", stringlaenge(kette));
                                         } 
                                       
                                       int stringlaenge(char s[])
                                         { 
                                         int i = 0;
                                         for(i=0; kette[i] != '\0'; i++);
                                         return (i)
                                         }
                                       

Stringfunktionen

Neben den einfachen Zuweisungen und Abfragen gibt es eine Reihe von komplexen Befehlen für Zeichenketten. DIe Prototypen befinden sich in der Standardbibliothek <string.h>. In den Beispielen gelten folgende Variablenvereinbarungen:
                                       char a[100];
                                       char b[100];
                                       char c;
                                       int n;
                                       int m;
                                       

strcat ( char *a , char *b )

Es wird an a die Zeichenfolge von b angehängt.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] = "Algorithmen & "; 
                                         char b[100] = "Datenstrukturen"; 
                                       
                                         printf ("a = %s\nb = %s\n",a,b); 
                                         strcat ( a, b ); 
                                         printf("\na = %s\n",a);
                                         }
                                       

strncat ( char *a , char *b , int n )

Es wird wie bei strcat b an a angehängt. Jedoch nur maximal n Zeichen von b werden angehängt.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] = "Algorithmen & "; 
                                         char b[100] = "Datenstrukturen"; 
                                         int n = 5; 
                                         printf ("\na = %s\nb = %s\n",a,b); 
                                         strncat ( a, b ); 
                                         printf("\na = %s\n",a);
                                         }
                                       

strcpy ( char *a , char *b )

Der Inhalt von b wird nach a kopiert. Das Beispielprogramm dazu:
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] = "Alter Text"; 
                                         char b[100] = "Neuer Text";
                                       
                                         printf ("a = %s",a);
                                         printf ("b = %s\n\n",b);
                                         strcpy (a,b); 
                                         printf ("a = %s\n",a);
                                         }
                                       
strcpy könnte so implementiert werden:
                                       void strcpy(char *a, char *b)
                                         { 
                                         int i = 0;
                                         while ((a[i] = b[i]) != '\0')
                                            i++;
                                         }
                                       

strncpy ( char *a , char *b , int n )

Der Inhalt von b wird nach a kopiert. Dabei werden höchstens n Zeichen von b nach a kopiert. Der Rest des Strings bleibt erhalten.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] = "Alter Text"; 
                                         char b[100] = "Neuer Text";
                                         int n = 2;
                                       
                                         printf ("a = %s",a);
                                         printf ("b = %s\n\n",b);
                                         strcpy (a,b); 
                                         printf ("a = %s\n",a);
                                         strncpy (b,a,n); 
                                         printf ("a = %s\n",a);
                                         }
                                       

int n = strlen ( char *a )

Es wird die Länge der Zeichenkette ( ohne das abschließende '/0') zurückgegeben.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         int n; 
                                         char a[100] ="Na, wie lang bin ich denn?"; 
                                       
                                         n = strlen (a); 
                                         printf (",,aïï ist %d Zeichen lang\n",n);
                                         }
                                       

Zeichenpositeon und Teilstring suchen im String

char *b = strchr ( char *a , char c )

Es wird String a nach dem Buchstaben c durchsucht und ein Zeiger auf die Stelle in a zurückgegeben, an der sich der Buchstabe c zuerst befindet. Existiert kein Buchstabe, so wird NULL zurückgegeben. Im Beispiel ist dies das 'i' von 'ist'.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         int n; 
                                         char a[100] ="Na, wo ist denn das Zeichen?"; 
                                       
                                         printf ("%s" , strchr (a , 'i') );
                                         }
                                       

char *b = strrchr ( char *a , char c )

Es wird String a nach dem Buchstaben c durchsucht und ein Zeiger auf die Stelle in a zurückgegeben, an der sich der Buchstabe c zuletzt befindet. Existiert kein Buchstabe, so wird NULL zurückgegeben. Im Beispiel ist dies das 'i' von 'Zeichen'.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] ="Na, wo ist denn das Zeichen?"; 
                                         printf ("%s" , strrchr (a , 'i') );
                                         }
                                       

int m = strcmp ( char *a , char *b )

Die beiden Zeichenketten werden miteinander verglichen. Der Rückgabewert hängt vom Vergleichsergebnis ab:
  • a < b --> m = -1 (bzw. negativ)
  • a = b --> m = 0
  • a > b --> m = 1 (bzw. positev)
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] = "Vergleichswort 1"; 
                                         char b[100] = "Vergleichswort 2"; 
                                       
                                         printf ("a = %s",a);
                                         printf ("b = %s\n\n",b);
                                         printf ("strcmp (a,b) = %d\n", strcmp (a,b) ); 
                                         printf ("strcmp (a,a) = %d\n", strcmp (a,a) ); 
                                         printf ("strcmp (b,a) = %d\n", strcmp (b,a) ); 
                                         }
                                       

Die Vergleichsfunktion kann man sich auch selbst schreiben:

                                       strcmp(char s1[], char s2[]) 
                                         {	
                                         int i=0;
                                         while (s1[i] == s2[i])
                                           {
                                           if (s1[i] == 0) 
                                             return(0);
                                           else
                                             i++;
                                           }
                                         return (s1[i] - s2[i]);
                                       }
                                       

int m = strncmp ( char *a , char *b , int n )

Die Funktion arbeitet wie strcmp mit dem Unterschied, das nur die ersten n Zeichen verglichen werden. Alle nachfolgenden Zeichen werden ignoriert.Der Rückgabewert hängt vom Vergleichsergebnis ab:
  • a < b --> m = -1 (bzw. negativ)
  • a = b --> m = 0
  • a > b --> m = 1 (bzw. positev)
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] = "Vergleichswort 1"; 
                                         char b[100] = "Vergleichswort 2"; 
                                       
                                         printf ("a = %s",a);
                                         printf ("b = %s\n\n",b);
                                         printf ("strncmp (a,b,3) = %d\n", strncmp (a,b,3) ); 
                                         printf ("strncmp (a,a,3) = %d\n", strncmp (a,a,3) ); 
                                         printf ("strncmp (b,a,3) = %d\n", strncmp (b,a,3) ); 
                                         }
                                       

size_t strlen( char *string)

liefert Länge von string ohne das Nullbyte am Schluß
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[100] = "Irgend ein String"; 
                                       
                                         int len = strlen(a);
                                         printf (",,%sïï hat %d Zeichen", a, len);
                                         }
                                       

void delete(char str[], int pos, int anz)

Die folgende Funktion löscht n Zeichen ab einer vorgegebenen Positeon aus einem String:
                                       void delete(char str[],int pos, int anz)
                                         /* anz Zeichen aus str ab pos l”schen */
                                         {
                                         int i = pos + anz;
                                         while ((str[pos++] = str[i++]) != '\0');
                                         }
                                       

char *strupper(char *string)

Die folgende Funktion wandelt alle Kleinbuchstaben in Großbuchstaben um:
                                       char *strupper(char *string)
                                         {
                                         char *s;
                                         if (string != NULL)
                                           for (s = string; *s; ++s)
                                             *s = toupper(*s);
                                         return string;
                                         } 
                                       

char *strlower(char *string)

Die folgende Funktion wandelt alle Großbuchstaben in Kleinbuchstaben um:
                                       char *strlower(char *string)
                                         {
                                         char *s;
                                         if (string != NULL)
                                           for (s = string; *s; ++s)
                                             *s = tolower(*s);
                                         return string;
                                         }
                                       

Suchen und Ersetzen von Strings

char *strstr( char *such, char *vergleich )

liefert einen Zeiger auf das erste Auftreten des Strings such im String vergleich.

Das folgende Beispiel zeigt, wie man das 'Enthaltensein' eines Strings im anderen ermitteln kann. Zur Veranschaulichung ohne Bibliotheksfunktionen und ohne Pointer

                                       int sstr( char such[], char vergleich[] )
                                         /* Feststellen, ob such in vergleich enthalten ist */
                                         {
                                         int i, j;			/* Laufvariablen */
                                       
                                         int lsuch = strlen(such);
                                         int lvergl = strlen(vergleich);
                                       
                                         for (i = 0; i < (lvergl - lsuch); i++)
                                           {
                                           j = 0;
                                           while (vergleich[i+j] == such[j++])
                                             if (j == lsuch) return (i);
                                           }
                                           return -1;
                                         }
                                       

Variante in der Programmierung:

                                       int sstr( char such[], char vergleich[] )
                                         /* Feststellen, ob such in vergleich enthalten ist */
                                         {
                                         int i, j, k;			/* Laufvariablen */
                                         for (i = 0; vergleich[i] != '\0'; i++)
                                           {
                                           for (j = i, k = 0; such[k] != '\0' && such[k] == vergleich[j]; j++, k++)
                                             /* tu nix */;
                                           if (such[k] == '\0') return (i);
                                           }
                                         return -1;
                                         }
                                       
Die gleiche Funktion, nur daß diesman die Groß-/Kleinschreibung ignoriert wird:
                                       int isstr( char such[], char vergleich[] )
                                         /* Feststellen, ob such in vergleich enthalten ist, 
                                            Gross-/Kleinschreibung ignorieren */
                                         {
                                         int i, j;			/* Laufvariablen */
                                       
                                         int lsuch = strlen(such);
                                         int lvergl = strlen(vergleich);
                                       
                                         for (i = 0; i < (lvergl - lsuch); i++)
                                           {
                                           j = 0;
                                           while (tolower(vergleich[i+j]) == tolower(such[j++])) 
                                             if (j == lsuch) return (i);
                                           }
                                           return -1;
                                         }
                                       

int index (char s[],char t[])

Suchen und die Positeon zurückliefern:
                                       # include <stdio.h>
                                       # define MAXLINE 1000
                                       
                                       int 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);
                                         } 
                                       

void replace( char such[], char ersatz[], char original[] )

Die folgende Funktion ersetzt such durch ersatz im String original. Falls such nicht im String enthalten ist, passiert nichts.
                                       void replace( char such[], char ersatz[], char original[] )
                                         {
                                         int pos, i, j;			/* Laufvariablen */
                                       
                                         pos = sstr(such, original);
                                         if (pos >= 0)
                                           {
                                           /* Suchstring entfernen */
                                           i = pos + strlen(such);
                                           while ((original[pos++] = original[i++]) != '\0');
                                           /* Platz machen fuer ersatz */
                                           len = strlen(ersatz), j = pos;
                                           while ((original[j+len] = original[j]) != '\0')
                                             j++;
                                           /* ersatz einbauen */
                                           for (j = 0; ersatz[j] != '\0'; j++)
                                             original[pos+j] = ersatz[j];
                                           }
                                         }
                                       

Leerzeichen entfernen

Die folgende Funktion trim entfernt Leerzeichen aus einer Zeichenkette:
  • am Anfang der Zeichenkette
  • am der Zeichenkette
  • und mehrfach aufeinanderfolgende innerhalb der Zeichenkettte
                                       #include <ctype.h>
                                       
                                       char *trim (char *str)
                                         {
                                         char *ibuf, *obuf;
                                         if (str)
                                           {
                                           for (ibuf = obuf = str; *ibuf; )
                                             {
                                             while (*ibuf && (isspace (*ibuf)))
                                                ibuf++;
                                             if (*ibuf && (obuf != str))
                                               *(obuf++) = ' ';
                                             while (*ibuf && (!isspace (*ibuf)))
                                               *(obuf++) = *(ibuf++);
                                             }
                                           *obuf = NUL;
                                           }
                                         return (str);
                                         }
                                       

Umlaute konvertieren

Die folgende Funktion konvertiert Umlaute und Szett in die Ersatzdarstellung (ae, oe, ue, Ae, Oe, Ue, ss):
                                       
                                       char* uml(char* eingabe)
                                         {
                                         int i = 0, j = 0;
                                         char *tmp1 = NULL;
                                         char *tmp2 = NULL;
                                       
                                         /* Wir sparen uns das Ermitteln der Laenge des     */
                                         /* Eingabestrings und nehmen mal den worst case an */
                                         tmp1= malloc(2*strlen(eingabe) + 1);
                                         if(tmp1 == NULL) return(NULL);
                                       
                                         /*Kopieren und Ersetzen */
                                         while(eingabe[i] != '\0')
                                           {
                                           switch (eingabe[i])
                                             {
                                             case '&aluml;': tmp1[j++] = 'a'; tmp1[j++]='e'; break;
                                             case '&oluml;': tmp1[j++] = 'o'; tmp1[j++]='e'; break;
                                             case '&uluml;': tmp1[j++] = 'u'; tmp1[j++]='e'; break;
                                             case '&Aluml;': tmp1[j++] = 'A'; tmp1[j++]='e'; break;
                                             case '&Oluml;': tmp1[j++] = 'O'; tmp1[j++]='e'; break;
                                             case '&Uluml;': tmp1[j++] = 'U'; tmp1[j++]='e'; break;
                                             case 'ß': tmp1[j++] = 's'; tmp1[j++]='s'; break;
                                             default: tmp1[j++] = eingabe[i];
                                             }
                                            i++;
                                           }
                                         tmp1[j] = '\0';
                                         /* Nun den String genau passend zurueckgeben */
                                         tmp2 = malloc(strlen(tmp1) + 1);
                                         if(tmp2 == NULL) return(NULL);
                                         strcpy(tmp2,tmp1);
                                         free(tmp1);
                                         return(tmp2);
                                         }
                                       

Anwendung von atoi, atof,...

Die folgenden Funktionen wandeln eine Zeichenkette in eine Zahl um. Dabei werden führende Zwischenräume ignoriert. Die Umwandlung erfolgt, bis im String ein ungültiges Zeichen angetroffen wird. Bei über- oder Unterlauf wird errno = ERANGE und ein spezieller Wert zurückgegeben.

double atof(const char *s)

wandelt Zeichenkette in double float um.
                                       #include <stdio.h>
                                       #include <string.h>
                                       #include <math.h>     /* wegen atof */
                                       
                                       void main (void)
                                         {
                                         char a[80] = "123456.7899999"; 
                                         double z;
                                       
                                         printf ("a = %s\n",a);
                                         z = atof(a);
                                         printf ("z = %lf\n",z);
                                         }
                                       

int atoi(const char *s)

wandelt Zeichenkette in int um.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[80] = "123"; 
                                         int i;
                                       
                                         printf ("a = %s\n",a);
                                         i = atoi(a);
                                         printf ("i = %d\n",i);
                                         }
                                       

int atol(const char *s)

wandelt Zeichenkette in long int um
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char a[80] = "123"; 
                                         long int ii;
                                       
                                         printf ("a = %s\n",a);
                                         ii = atol(a);
                                         printf ("ii = %lu\n",ii);
                                         }
                                       

Anwendung von sprintf

int sprintf(char *string, const char *format, ...)

Der Formatstring der Funktion hat den gleichen Aufbau wie bei printf(), die Ausgabe wird jedoch in string abgelegt. Daher eignet sich diese Funktion, um Zahlen in Zeichenketten umzuwandeln.
Warnung:Der Rückgabewert von sprintf() ist implementierungsabhängig. Es sollte die Zahl der Zeichen im String zurückgegeben werden. Manche Systeme liefern aber einen Zeiger auf den String.
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void main (void)
                                         {
                                         char s[] = "*****";
                                         int i = 123;
                                         float x = 3.1415;
                                         char string[50];
                                       
                                         /* Resultat interessiert nicht */
                                         (void) sprintf (string, "Zeichenkette: %s Int: %d Float: %f", s, i, x);
                                         }
                                       

Römische Zahlen

Das folgende Programm zeigt, wie man eine positeve ganze Zahl in römischen Ziffern darstellt. Das Schema ist identisch für Einer-, Zehner- und Hunderterstelle. Der Unterschied besteht nur in den Auszugebenden Zeichen:
  • Einerstelle: I, V, und X
  • Zehnerstelle: X, L und C
  • Hunderterstelle: C, D und M
Ab Tausend aufwärts wird für jeden Tausender ein "M" gedruckt. Die Funktion behandelt weiterhin die Besonderheit der Schreibweise für 9 und 4 (z. B. IV, IX, CM).
                                       
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       void RZiffer(int x, char e, char f, char z)
                                         /* druckt x als roemische Zahl */
                                         {
                                         int i;
                                         switch (x)
                                           {
                                           case 9: printf("%c%c",e,z); break;
                                           case 8: printf("%c%c%c%c",v,e,e,e); break;
                                           case 7: printf("%c%c%c",v,e,e); break;
                                           case 6: printf("%c%c",v,e); break;
                                           case 5: printf("%c",v); break;
                                           case 4: printf("%c%c",e,v); break;
                                           case 3: printf("%c%c%c",e,e,e); break;
                                           case 2: printf("%c%c",e,e); break;
                                           case 1: printf("%e",e); break;
                                           default: break;
                                           }
                                         }
                                         
                                       void main (void)
                                         {
                                         int x = 1999;
                                       
                                         while (x > 999)
                                           {
                                           printf("M");
                                           x = x - 1000;
                                           }
                                         RZiffer(x/100,'C','D','M');
                                         x = x%100;
                                         RZiffer(x/10,'X','L','C');
                                         RZiffer(x%10,'I','V','X');
                                         printf("\n");
                                         }
                                       

E/A-Funktionen für Zeichenketten

Die Funktion get_line liest eine Textzeile in ein Zeichenfeld ein und ergaenzt das '\0' Zeichen. Das Ergebnis der Funktion ist die Laenge des gelesenen Strings oder EOF bei Dateiende.
                                       
                                       #include <stdio.h>
                                       #define MAXLAENGE 80
                                       
                                       int getline(char line[]); 
                                       
                                       int main(void)
                                         { 
                                         char zeile[MAXLAENGE];
                                         int laenge, i;
                                         while ((laenge = getline(zeile)) > 0)
                                            { 
                                            printf("%d Zeichen gelesen\n",laenge)
                                            for(i=0; i<laenge; i++)
                                              printf("%c",zeile[i]); 
                                            printf("\n");
                                            }
                                         }
                                       
                                       int getline(char line[])
                                         { 
                                         int c;
                                         int i = 0;
                                         while ((c = getchar()) != '\n' && c != EOF)
                                           if( i < MAXLAENGE-1)
                                             line[i++] = c;
                                         line[i++] = '\0';
                                         if( c == EOF)
                                           return (EOF);
                                         else
                                           return (i);
                                         }
                                       

In der Standardbibliothek sind neben printf und scanf zwei nützliche Routinen zum Einlesen bzw. Drucken von Strings vorhanden:

  • char *gets(char *s)
    Die Funktion gets liest die nächste Zeile von der Standardeingabe in den Vektor s ein und setzt das Endezeichen '\0'. Das Ergebnis der Funktion ist der Zeiger auf das Zeichenfeld s, bei Fehler oder Dateiende der NULL-Zeiger.
  • int puts(const char *s)
    Die Funktion puts schreibt die Zeichenkette s und einen Zeilentrenner (!) auf die Standardausgabe. Das Ergebnis der Funktion ist eine nichtnegative Zahl oder EOF bei Fehler.
Beispiel: Einlesen und Ausgeben eines Strings mit Hilfe von Bibliotheksroutinen:
                                       
                                       #include <stdio.h>
                                       #define MAXLAENGE 80
                                       
                                       void main(void)
                                         { 
                                         int i, laenge = 0;
                                         char zeile[MAXLAENGE];
                                         char *zeilenzeiger;
                                       
                                         zeilenzeiger = zeile;
                                         gets(zeilenzeiger);
                                         puts(zeile);
                                         }
                                       

Das folgende Beispiel zeigt, wie man mit printf Tabellen ausgeben kann. Der Trick ist darin verborgen, daß man bei jeder Druckzeile die Anzahl der Leerstellen ermittelt, die zwischen zwei Feldern liegen sollen. Durch einen * in der Formatangabe (z. B. "%-*s") kann die Ausgabebreite variabel gestaltet werden. Alles weitere zeigt das folgende Beispiel:

                                       
                                       #include <stdio.h>
                                       #include <string.h>
                                       
                                       int main(void)
                                         {
                                         char *firstname[] = { "Sepp",      "Jan",   "Dennis",  NULL };
                                         char *lastname[]  = { "Langnamer", "Kurz",  "Ritchie", NULL };
                                         int   note[]      = {   4,           2,        1,       0   };
                                         int   i, tabwidth;
                                       
                                         printf("%15sStudentenname%30s\n\n", "", "Note");
                                            
                                         for (i = 0; NULL != lastname[i]; ++i)
                                           {
                                           tabwidth = 36                             /* Leerzeichen insgesamt */
                                                      -2                             /* fuer  ", " */
                                                      -strlen(lastname[i]);          /* laenge lastname */
                                           
                                           printf("%s, %-*s%3d\n",
                                                   lastname[i], tabwidth, firstname[i], note[i]);
                                           }
                                       
                                         return 0;
                                         }
                                       

Das Ergebnis sieht dann etwa so aus:

                                       Studentenname                    Note
                                       
                                       Langnamer, Sepp                    4
                                       Kurz, Jan                          2
                                       Ritchie, Dennis                    1
                                       

BASIC-Stringfunktionen

Wer die Programmiersprache BASIC kennt, vermisst manchmal komfortable Funktionen zur Bearbeitung von Zeichenketten. Die folgenden Funktionen realisieren einige aus BASIC bekannte und vertraute Funktionen. Mit dabei ist auch eine einfache Speicherverwaltung.
                                       /*
                                       **  public domain by Bob Stout
                                       */
                                       
                                       #include <stdio.h>
                                       #include <stdlib.h>
                                       #include <string.h>
                                       #include <stdarg.h>
                                       #include <limits.h>
                                       #include <assert.h>
                                       
                                       #define NUL '\0'
                                       #define LAST_CHAR(s) (((char *)s)[strlen(s) - 1])
                                       
                                       
                                       char *stralloc(size_t length);
                                            /* Belegen von Speicher fuer einen String */
                                       
                                       void  str_free(char *string);
                                            /* Freigabe des mit stralloc belegten Platzes */
                                       
                                       char *left(char *string, size_t N);
                                            /* liefert die linken N Zeichen des Strings */
                                       
                                       char *right(char *string, size_t N);
                                            /* liefert die rechten N Zeichen des Strings */
                                       
                                       char *mid(char *string, size_t M, size_t N);
                                            /* liefert einen Teilstring, N Zeichen lang, 
                                               beginnend ab Positeon M */
                                       
                                       char *string_add(char *string, ...);
                                            /* konkateniert mehrere Strings zu einem */
                                       
                                       char *string(int ch, size_t N);
                                            /* liefert eine N Zeichen langen String, der
                                               aus den durch ch vorgegebenen Zeichen besteht */
                                       
                                       unsigned int instr(const unsigned int start_pos,
                                                          const char        *string,
                                                          const char        *findstr);
                                             /* liefert die Positeon von findstr (beginnend ab 1) in
                                                string. Die Suche beginnt bei Zeichenpositeon start_pos
                                                (beginnend bei 1). */
                                       
                                       
                                       static int stralloc_ptr;
                                       static char *strings[8];
                                       static int str_tag[8];
                                       
                                       /*
                                       **  stralloc() is the key function in this package, maintaining a pool of
                                       **  reusable strings.
                                       */
                                       
                                       char *stralloc(size_t length)
                                       {
                                             register int i;
                                       
                                             if (UINT_MAX == length)       /* Assume size_t == unsigned int    */
                                                   return NULL;
                                       
                                             i = stralloc_ptr++;
                                             ++length;                     /* Allow for terminating NUL        */
                                       
                                             if ((!strings[i]) || (length > strlen(strings[i])))
                                             {
                                                   strings[i] = (char *)realloc(strings[i], length);
                                                   assert(NULL != strings[i]);
                                                   str_tag[i] = -1;
                                             }
                                             else  str_tag[i] = 0;
                                             stralloc_ptr &= 7;
                                             return (strings[i]);
                                             /* Maintains 8 strings in a circular buffer */
                                       }
                                       
                                       /*
                                       **  free the string pool.
                                       */
                                       
                                       void str_free(char *string)
                                       {
                                             register int i;
                                       
                                             for (i = 0; i < 8; ++i)
                                             {
                                                   if (strings[i] == string)
                                                   {
                                                         if (str_tag[i])
                                                               free(strings[i]);
                                                         return;
                                                   }
                                             }
                                       }
                                       
                                       /*
                                       **  return the leftmost N characters from a string, equivalent to LEFT$
                                       */
                                       
                                       char *left(char *string, size_t N)
                                       {
                                             char *buf;
                                             size_t strlength = strlen(string);
                                       
                                             if (N > strlength)
                                                   N = strlength;
                                             buf = stralloc(N);
                                             memcpy(buf, string, N);
                                             buf[N] = NUL;
                                             return buf;
                                       }
                                       
                                       /*
                                       **  return the rightmost N characters from a string, equivalent to RIGHT$
                                       */
                                       
                                       char *right(char *string, size_t N)
                                       {
                                             char *buf;
                                             size_t strlength = strlen(string);
                                       
                                             if (N > strlength)
                                                   N = strlength;
                                             buf = stralloc(N);
                                             strcpy(buf, &string[strlength-N]);
                                             return buf;
                                       }
                                       
                                       /*
                                       **  return a substring, N characters long beginning at positeon M,
                                       **  equivalent to MID$
                                       */
                                       
                                       char *mid(char *string, size_t M, size_t N)
                                       {
                                             char *buf;
                                             size_t strlength = strlen(string);
                                       
                                             if (M > strlength)
                                                   return NULL;
                                             if (N > (strlength - M))
                                                   N = strlength - M;
                                             buf = stralloc(N);
                                             memcpy(buf, &string[M-1], N);
                                             buf[N] = NUL;
                                             return buf;
                                       }
                                       
                                       /*
                                       **  string concatenation function, equivalent to A$=B$+C$+...
                                       */
                                       
                                       char *string_add(char *string, ...)
                                       {
                                             va_list arg_ptr;
                                             char *temp1, *temp2, *buf;
                                       
                                             va_start(arg_ptr, string);
                                             temp1 = string;
                                             do
                                             {
                                                   if(NULL == (temp2 = va_arg(arg_ptr, char *)))
                                                         break;
                                                   buf = stralloc(strlen(temp1) + strlen(temp2));
                                                   temp1 = strcat(strcpy(buf, temp1), temp2);
                                             } while (NULL != temp2);
                                             return temp1;
                                       }
                                       
                                       /*
                                       **  create a string of repeated characters, equivalent to STRING$()
                                       */
                                       
                                       char *string(int ch, size_t N)
                                       {
                                             char *buf;
                                       
                                             if (N)
                                             {
                                                   buf = stralloc(N);
                                                   memset(buf, ch, N);
                                             }
                                             buf[N] = NUL;
                                             return buf;
                                                         
                                       }
                                       
                                       /*
                                       **  BASIC INSTR$() work alike - returns positeon (1-based) of findstr in
                                       **  string, starting search at positeon start_pos (also 1-based).
                                       **
                                       **  Function suggested by Tika Carr
                                       */
                                       
                                       unsigned int instr(const unsigned int start_pos,
                                                          const char        *string,
                                                          const char        *findstr)
                                       {
                                             char *p;
                                             unsigned int pos;
                                       
                                             if (start_pos > strlen(string))
                                                   return 0;
                                             else  pos = start_pos - 1;    /* BASIC offsets are one-based, not
                                                                              zero-based as in C               */
                                       
                                             if (NULL != (p = strstr(string + pos, findstr)))
                                                   return (int)(p - (char *)string) + 1; /* Positeon 0 = positeon 1 */
                                             else  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