basic header-file

Du kannst auch in C Groß- und Kleinschreibung mischen....
Ich vermute aber das war nicht das was du hören wolltest ;-)
Verrate doch mal was Left, Right, Mid, LCase und co. eigentlich machen 
bzw. was du damit machen möchtest.

lg
frank

Dasi ist:

#include <string.h>

Markus Olderdissen wrote:

> Ich bin auf der Suche nach genauen Übersetungen dieser Funktionen zur
> verwendung in C.

Die wirst du vermutlich nicht finden.

C selbst besitzt keine nennenswerten eingebauten Funktionen für die
Stringverarbeitung.  Das, was in <string.h> deklariert wird, ist
eher rudimentär.  Insbesondere fehlt darin alles, was irgendwie
Speicher für Strings allozieren oder freigeben würde (mal abgesehen
von der ggf. vorhandenen, aber nicht vom C-Standard abgedeckten
Funktion strdup()).

C++ bietet von Haus aus Klassen, die sowas können.

Für C solltest du entsprechende Bibliotheken mit ein wenig Suche im
Internet finden können.  Ich zweifle eben nur, dass sich jemand die
Arbeit gemacht hat, die (teilweise etwas schräg benamsten) Funktionen
ausgerechnet von MS-BASIC 1:1 in so eine Bibliothek abzubilden, aber
die entsprechende Funktionalität dagegen schon.  Allerdings ist in C
die Speicherverwaltung komplett manuell.  Wenn eine derartige Funktion
also den Speicher für den String selbst alloziert (wie das genannte
strdup()), dann ist es deine Aufgabe als Programmierer, diesen Speicher
nach der Benutzung auch wieder freizugeben, andernfalls bläht sich
deine Applikation immer mehr auf.

In <string.h> beschriebene Funktionen

gefunden:
(http://www2.fh-fulda.de/~klingebiel/c-stdlib/string.htm)

char   *strcpy(s, ct);     // Zeichenkette ct in Vektor s kopieren
char   *strncpy(s, ct, n); // höchstens n Zeichen aus ct in s kopieren
char   *strcat(s, ct);     // Zeichenkette ct hinten an s anfügen
char   *strncat(s, ct, n); // max. n Zeichen von ct hinten an s anfügen
int    strcmp(cs, ct);     // Zeichenketten cs und ct vergleichen
int    strncmp(cs, ct, n); // max. n Zeichen von cs mit  ct vergleichen
char   *strchr(cs, c);     // liefert Zeiger auf das erste c in cs
char   *strrchr(cs, c);    // liefert Zeiger auf das letzte c in cs
size_t strspn(cs, ct);     // liefert Anzahl der Zeichen am Anfang von 
cs
size_t strcspn(cs, ct);    // liefert Anzahl der Zeichen am Anfang von 
cs
char   *strpbrk(cs, ct);   // liefert Zeiger auf die Position in cs
char   *strstr(cs, ct);    // liefert Zeiger auf erste Kopie von ct
size_t strlen(cs);         // liefert Länge von cs (ohne '\0').
char   *strerror(n);       // liefert Zeiger auf Zeichenkette
char   *strtok(s, ct);     // strtok durchsucht s nach Zeichenfolgen
void   *memcpy(s, ct, n);  // kopiert n Zeichen von ct nach s
void   *memmove(s, ct, n); // wie memcpy, auch wenn die Objekte 
überlappen
int    memcmp(cs, ct, n);  // vergleicht n Zeichen von cs mit ct
void   *memchr(cs, c, n);  // liefert Zeiger auf das erste c in cs
void   *memset(s, c, n);   // setzt n Zeichen von s auf den Wert c