 |
| 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;
}
|
|
|
DIENSTE
