Zeichenketten

Eine Zeichenkette besteht aus einer Reihung von Zeichen, die durch ein NUL-Zeichen abgeschlossen wird.

`string.h`

size_t	strlen	(const char * s)	Länge der Zeichenkette
size_t	strnlen	(const char * s, size_t n)	Länge des Präfix
size_t	strxfrm	(char * dest, const char * src, size_t n)	Präfix lokalisieren
char *	strcpy	(char * dest, const char * src)	Unsicher kopieren
char *	stpcpy	(char * dest, const char * src)	Dito, Zeiger auf Ende
char *	strncpy	(char * dest, const char * src, size_t n)	Präfix kopieren
char *	stpncpy	(char * dest, const char * src, size_t n)	…Zeiger auf Ende
size_t	strlcpy	(char * dest, const char * src, size_t n)	Terminierung garantiert
char *	strcat	(char * dest, const char * src)	Zeichnkette anhängen
char *	strncat	(char * dest, const char * src, size_t n)	Präfix anhängen
size_t	strlcat	(char * dest, const char * src, size_t n)	Mit Terminierung anhängen
char *	strchr	(const char * s, int c)	Zeichen suchen
char *	strchrnul	(const char * s, int c)	Dito, aber nie `NULL`
char *	strrchr	(const char * s, int c)	Rückwärts suchen
char *	strrchrnul	(const char * s, int c)	…aber nie `NULL`
char *	strpbrk	(const char * s, const char * accept)	Zeichen aus Menge suchen
size_t	strspn	(const char * s, const char * accept)	Länge des Präfixes
size_t	strcspn	(const char * s, const char * reject)	…ohne diese Zeichen
char *	strstr	(const char * haystack, const char * needle)	Zeichenkette suchen
char *	strcasestr	(const char * haystack, const char * needle)	…ohne groß/klein
int	strcmp	(const char * s1, const char * s2)	Lexikographisch,
int	strncmp	(const char * s1, const char * s2, size_t n)	Ein Präfix,
int	strcoll	(const char * s1, const char * s2)	Lokalisiert oder
int	strverscmp	(const char * s1, const char * s2;	Numerisch sortieren
char *	strtok	(char * s, const char * delim)	Zeichenkette trennen
char *	strtok_r	(char * s, const char * delim, char ** save)	…Position in `save`
char *	strsep	(char ** s, const char * delim)	…Position in `s`
char *	strdup	(const char * s)	Zeichenkette auf Heap
char *	strdupa	(const char * s)	Zeichenkette auf Stack
char *	strndup	(const char * s, size_t n)	Präfix auf Heap kopieren
char *	strndupa	(const char * s, size_t n)	Präfix auf Stack kopieren
char *	strfry	(char * s)	Anagramm bilden
char *	strerror	(int errnum)	Fehlercode beschreiben
int	strerror_r	(int errnum, char * buf, size_t n)	Fehlercode im Puffer
char *	strsignal	(int signum)	Signal beschreiben

`strings.h`

Zeichenketten ohne Beachtung der Groß-/Kleinschreibung vergleichen.

int	strcasecmp	(const char * s1, const char * s2)	Zeichenkette vergleichen
int	strcasecmp_l	(const char * s1, const char * s2, locale_t locale)
int	strncasecmp	(const char * s1, const char * s2, size_t n)	Präfix vergleichen
int	strncasecmp_l	(const char * s1, const char * s2, size_t n, locale_t locale)
int	ffs	(int i)	Index des ersten Bits
int	ffsl	(long i)
int	ffsll	(long long i)

`stdarg.h`

Variable Argumentlisten

typedef	va_list
void	va_start	(va_list ap, last)
type	va_arg	(va_list ap, type)
void	va_end	(va_list ap)
void	va_copy	(va_list dest, va_list src)
int	vprintf	( const char * format, va_list ap)
int	vfprintf	(FILE * fp, const char * format, va_list ap)
int	vsprintf	(char * str, const char * format, va_list ap)
int	vsnprintf	(char * str, size_t size, const char * format, va_list ap)
int	vscanf	( const char * format, va_list ap)
int	vsscanf	(const char * str, const char * format, va_list ap)
int	vfscanf	(FILE * fp, const char * format, va_list ap)

`wctype.h`

Mittlerweile hat sich UTF-8 als Kodierung für Multibyte-Zeichenketten durchgesetzt. POSIX definiert jeweils noch eine Variante mit Suffix _l, die als zusätzlichen Parameter die Lokalisierung akzeptiert.

int	iswalnum	(wint_t c)
int	iswalpha	(wint_t c)
int	iswblank	(wint_t c)
int	iswcntrl	(wint_t c)
typedef	wctype_t
int	iswctype	(wint_t c, wctype_t category)
int	iswdigit	(wint_t c)
int	iswgraph	(wint_t c)
int	iswlower	(wint_t c)
int	iswprint	(wint_t c)
int	iswpunct	(wint_t c)
int	iswspace	(wint_t c)
int	iswupper	(wint_t c)
int	iswxdigit	(wint_t c)
int	iswblank	(wint_t c)
typedef	wctrans_t
wint_t	towctrans	(wint_t c, wctrans_t category)
wint_t	towlower	(wint_t c)
wint_t	towupper	(wint_t c)

`stdlib.h`

int	mblen	(const char * mb, size_t n)	Anzahl Oktette
int	wctomb	( char * mb, wchar_t wc )	16-Bit – Multibyte
int	mbtowc	(wchar_t * wc, const char * mb, size_t n)	Multibyte – 16-Bit
size_t	mbstowcs	(wchar_t * wc, const char * mb, size_t n)	Multibyte – 16-Bit
size_t	wcstombs	( char * mb, const wchar_t * wc, size_t n)	16-Bit – Multibyte

`uchar.h`

Multibyte-Zeichen konvertieren.

typedef	mbstate_t		Zwischenstand
typedef	char16_t		16-Bit Unicode
typedef	char32_t		32-Bit Unicode
size_t	c16rtomb	(char * mb, char16_t c16, mbstate_t * s)	16-Bit – Multibyte
size_t	c32rtomb	(char * mb, char32_t c32, mbstate_t * s)	32-Bit – Multibyte
size_t	mbrtoc16	(char16_t * c16, const char * mb, size_t max, mbstate_t * s)	Multibyte – 16-Bit
size_t	mbrtoc32	(char32_t * c32, const char * mb, size_t max, mbstate_t * s)	Multibyte – 32-Bit

`wchar.h`

Datenstrom
typedef	wint_t		Quadrupelbyte
typedef	wchar_t		Doppelbyte
wint_t	btowc	(int c)	Konvertiert Oktett in Quadrupel
int	wctob	(wint_t c)	Konvertiert Quadrupel in Oktett oder liefert `EOF`
int	wcwidth	(wchar_t c)	Liefert Spaltenbreite eines Zeichens
int	wcswidth	(const wchar_t * s, size_t n)	Berechnet Spaltenbreite für Zeichenkette
FILE *	open_wmemstream	(wchar_t ** ptr, size_t * sizeloc)	Operiert auf einem dynamisch wachsenden Puffer
wint_t	fgetwc	( FILE * fp)
wint_t	fputwc	(wchar_t c, FILE * fp)
wchar_t *	fgetws	(wchar_t * s, int n, FILE * fp)
int	fputws	(const wchar_t * s, FILE * fp)
int	fwide	( FILE * fp, int mode)
wint_t	getwc	( FILE * fp)
wint_t	getwchar	(void)
wint_t	putwc	(wchar_t c, FILE * fp)
wint_t	putwchar	(wchar_t c)
wint_t	ungetwc	(wint_t c, FILE * fp)
Formatierung
int	fwscanf	( FILE * fp, const wchar_t * format, ...)
int	fwprintf	( FILE * fp, const wchar_t * format, ...)
int	vfwscanf	( FILE * fp, const wchar_t * format, va_list arg)
int	vfwprintf	( FILE * fp, const wchar_t * format, va_list arg)
int	wscanf	( const wchar_t * format, ...)
int	wprintf	( const wchar_t * format, ...)
int	vwscanf	( const wchar_t * format, va_list arg)	Standardeingabe
int	vwprintf	( const wchar_t * format, va_list arg)	Standardausgabe
int	swscanf	(const wchar_t * s, const wchar_t * format, ...)
int	swprintf	( wchar_t * s, size_t n, const wchar_t * format, ...)
int	vswscanf	(const wchar_t * s, size_t n, const wchar_t * format, va_list arg)
int	vswprintf	( wchar_t * s, size_t n, const wchar_t * format, va_list arg)
size_t	wcsftime	( wchar_t * s, size_t n, const wchar_t * format, const struct tm * tm)
Multibyte
int	mbsinit	(const mbstate_t * ps)	Setzt Zustand auf Anfang
size_t	mbrlen	( const char * s, size_t n, mbstate_t * ps)	Liefert Oktettzahl des nächsten Zeichens
size_t	mbrtowc	(wchar_t * pwc, const char * s, size_t n, mbstate_t * ps)	Extrahiert ein Multibyte-Zeichen
size_t	mbsrtowcs	(wchar_t * dst, const char ** src, size_t len, mbstate_t * ps)	Konvertiert Multibyte nach Wide
size_t	wcrtomb	(char * s, wchar_t wc, mbstate_t * ps)	Konvertiert 16-Bit in Multibyte
size_t	wcsrtombs	(char * dst, const wchar_t ** src, size_t len, mbstate_t * ps)	Konvertiert 16-Bit nach Multibyte
size_t	wcsnrtombs	(char * dst, const wchar_t ** src, size_t nwc, size_t len, mbstate_t * ps)	Konvertiert Präfix
Zahlen
double	wcstod	(const wchar_t * nptr, wchar_t ** endptr)
float	wcstof	(const wchar_t * nptr, wchar_t ** endptr)
long double	wcstold	(const wchar_t * nptr, wchar_t ** endptr)
long long	wcstoll	(const wchar_t * nptr, wchar_t ** endptr, int base)
unsigned long long	wcstoull	(const wchar_t * nptr, wchar_t ** endptr, int base)
long	wcstol	(const wchar_t * nptr, wchar_t ** endptr, int base)
unsigned long	wcstoul	(const wchar_t * nptr, wchar_t ** endptr, int base)
Zeichenketten
wchar_t *	wcsdup	(const wchar_t * s)
wchar_t *	wcscat	( wchar_t * s1, const wchar_t * s2)
int	wcscmp	(const wchar_t * s1, const wchar_t * s2)
int	wcscoll	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcscpy	( wchar_t * s1, const wchar_t * s2)
size_t	wcscspn	(const wchar_t * s1, const wchar_t * s2)
size_t	wcslen	(const wchar_t * s)
wchar_t *	wcsncat	( wchar_t * s1, const wchar_t * s2, size_t n)
int	wcsncmp	(const wchar_t * s1, const wchar_t * s2, size_t n)
wchar_t *	wcsncpy	( wchar_t * s1, const wchar_t * s2, size_t n)
size_t	wcsspn	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcsstr	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcstok	( wchar_t * s1, const wchar_t * s2, wchar_t ** ptr)
size_t *	wcsxfrm	( wchar_t s1, const wchar_t * s2, size_t n)
int	wcscasecmp	(const wchar_t * s1, const wchar_t * s2)
int	wcsncasecmp	(const wchar_t * s1, const wchar_t * s2, size_t n)
size_t	wcsnlen	(const wchar_t * s, size_t maxlen)
wctrans_t	wctrans	(const char * name)
Speicherbereiche
int *	wmemcmp	(const wchar_t s1, const wchar_t * s2, size_t n)
wchar_t *	wmemcpy	( wchar_t * s1, const wchar_t * s2, size_t n)
wchar_t *	wmemmove	( wchar_t * s1, const wchar_t * s2, size_t n)
wchar_t *	wmemset	( wchar_t * s, wchar_t c, size_t n)
wchar_t *	wcschr	(const wchar_t * s, wchar_t c)
wchar_t *	wcspbrk	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wcsrchr	(const wchar_t * s, wchar_t c)
wchar_t *	wcsstr	(const wchar_t * s1, const wchar_t * s2)
wchar_t *	wmemchr	(const wchar_t * s, wchar_t c, size_t n)
wchar_t *	wcpcpy	(wchar_t * dest, const wchar_t * src)
wchar_t *	wcpncpy	(wchar_t * dest, const wchar_t * src, size_t n)

`iconv.h`

Zeichensatz konvertieren

typedef	iconv_t
iconv_t	iconv_open	(const char * to, const char * from)	Lädt Daten für Zeichensätze
size_t	iconv	(iconv_t cd, char ** inbuf, size_t * inbytesleft	Eingabepuffer
		char ** outbuf, size_t * outbytesleft)	Ausgabepuffer
int	iconv_close	(iconv_t cd)	Gibt verbrauchte Ressourcen frei

`ctype.h`

Für die Klassifizierung von Zeichen existiert jeweils noch eine Variante mit Suffix _l, die als zusätzlichen Parameter die Lokalisierung akzeptiert. Sonst wird die Umgebungsvariable LC_CTYPE gelesen.

int	isdigit	(int c)	Ziffer ('0'...'9')
int	isxdigit	(int c)	Hexadezimalziffer ('0'...'9','A'...'F','a'...'f')
int	islower	(int c)	Kleinbuchstabe ('a'...'z')
int	isupper	(int c)	Grossbuchstabe ('A'...'Z')
int	isalpha	(int c)	Buchstabe ('A'...'Z','a'...'z')
int	isalnum	(int c)	Alphanumerisches Zeichen ('0'...'9','A'...'Z','a'...'z')
int	iscntrl	(int c)	Steuerzeichen (0...31, 127)
int	isprint	(int c)	Druckbares Zeichen (32...126)
int	isgraph	(int c)	Graphisches Zeichen ausser Leerzeichen (33...)
int	ispunct	(int c)	Interpunktion (32...47, 58...63, 91...96, 123...126)
int	isspace	(int c)	Leerraum (HT, LF, VT, FF, CR, SPACE)
int	isblank	(int c)	Leerzeichen oder Tabulator (SPACE, HT)
int	isascii	(int c)	Zeichen aus dem ASCII Alphabet
int	toascii	(int c)	Löscht höherwertige Bits
int	toupper	(int c)	Wandelt Klein- in Grossbuchstaben um
int	tolower	(int c)	Wandelt Gross- in Kleinbuchstaben um
int	_toupper	(int c)	Wandelt Klein- in Grossbuchstaben um
int	_tolower	(int c)	Wandelt Gross- in Kleinbuchstaben um

Klassifizierungs-Matrix
Zeichen	NUL	SOH…	HT	LF	VT	FF	CR	SO…	SP	!…	0…9	:…	A…Z	[…	a…z	{…
iscntrl
isspace
isblank
isprint
ispunct
isxdigit													A…F		a…f
isdigit
isupper
islower

`locale.h`

Die Lokalisierung legt für Länder und Regionen typische Schreibweisen fest. Zum Beipsiel

Währungssymbol
Datumsformat
Dezimaltrennzeichen
Ziffern-Gruppierung
Tausender-Trennzeichen

struct lconv
#define	LC_ALL
#define	LC_COLLATE		Sortierung (`strcoll`)
#define	LC_CTYPE		Klassifizierung (`isupper`)
#define	LC_MESSAGES		Nachrichten (`catopen`)
#define	LC_MONETARY
#define	LC_NUMERIC
#define	LC_TIME
char *	decimal_point
char *	grouping
char *	thousands_sep
…
struct lconv *	localeconv	(void)
typedef	locale_t
char *	setlocale	(int category, const char * locale)
locale_t	newlocale	(int category, const char * locale, locale_t base)
locale_t	uselocale	(locale_t dataset)
locale_t	duplocale	(locale_t dataset)
locale_t	freelocale	(locale_t dataset)

`langinfo.h`

char *	nl_langinfo	(nl_item item)	Gibt Auskunft über die Lokalisierung
char *	nl_langinfo_l	(nl_item item, locale_t locale)

`nl_types.h`

Kataloge, siehe LC_MESSAGES

typedef	nl_catd
nl_catd	catopen	(const char * name, int flag)
char *	catgets	(nl_catd catalog, int setno, int msgno, const char * message)
int	catclose	(nl_catd catalog)

`monetary.h`

Landeswährung

ssize_t	strfmon	(char * str, size_t max, const char * format, ...)	Formatiert `double`-Wert als Währungsbetrag
ssize_t	strfmon_l	(char * str, size_t max, locale_t locale, const char * format, ...)	Dito für eine spezifische Lokalisierung

Flags
%`FlagsWidth`#`Prefix`.`PrecFormat`
=`Char`	Verwende Füllzeichen.
^	Gruppiere Ziffern nicht.
(	Schließe negative Werte in Klammern ein
+	Behandle Vorzeichen wie bei den Zahlen.
!	Lasse das Währungssymbol weg.
-	Richte all Felder linksbündig aus.
Format
i	Stelle `double`-Variable im internationalen Währungsformat dar.
n	Stelle `double`-Variable im nationalen Währungsformat dar.

`wordexp.h`

Wörter expandieren

typedef wordexp_t
size_t	we_wordc
char **	we_wordv
size_t	we_offs
int	wordexp	(const char * words, wordexp_t * pwordexp, int flags)
void	wordfree	( wordexp_t * pwordexp)

`regex.h`

Muster vergleichen. Siehe auch fnmatch und glob für einfachere Mustererkennung.

typedef	regex_t		Opake Datenstruktur für regulären Ausdruck
size_t	re_nsub		Anzahl der geklammerten Unterausdrücke
int	regcomp	( regex_t * preg,	Konstruktur, kompiliert einen regulären Ausdruck
		const char * regex, int cflags)
void	regfree	( regex_t * preg)	Destruktur, gibt den reservierten Speicher frei
typedef regmatch_t			Element in der Trefferliste
regoff_t	rm_so		Start-Offset
regoff_t	rm_eo		End-Offset
int	regexec	(const regex_t * preg,	Vergleicht Zeichenkette mit regulärem Ausdruck
		const char * string,
		size_t nmatch,
		regmatch_t pmatch[], int eflags)	Trefferliste für geklammerte Ausdrücke
size_t	regerror	(int errcode,	Liefert Beschreibung zu einem Fehlercode
		const regex_t * preg,
		char * buf, size_t size)

%c	Zeichen
%d	Ganzzahl
%f	Gleitkommazahl
…

LC_CTYPE_MASK
LC_NUMERIC_MASK
LC_TIME_MASK
LC_COLLATE_MASK
LC_MONETARY_MASK
LC_MESSAGES_MASK
LC_PAPER_MASK
LC_NAME_MASK
LC_ADDRESS_MASK
LC_TELEPHONE_MASK
LC_MEASUREMENT_MASK
LC_IDENTIFICATION_MASK

CODESET	Name des verwendeten Zeichensatzes
YESEXPR	Regulärer Ausdruck für Varianten von Ja
NOEXPR	Regulärer Ausdruck für Varianten von Nein
D_T_FMT	Formatstring für `strftime` für Datum und Uhrzeit
D_FMT	Formatstring für `strftime` für Datum
T_FMT	Formatstring für `strftime` für Uhrzeit
DAY_1…7	Name des Wochentags beginnend bei Sonntag
MON_1…12	Name des Monats beginnend bei Januar
ABDAY_1…7	Abgekürzter Wochentag
ABMON_1…12	Abgekürzter Monatsname
RADIXCHAR	Dezimaltrennzeichen
THOUSEP	Trennzeichen für Tausend
CRNCYSTR	Währungssymbol

NL_SETD	Used by gencat when no $set directive is specified in a message text source file. This constant can be passed as the value of set_id on subsequent calls to catgets() (that is, to retrieve messages from the default message set). The value of NL_SETD is implementation-defined.
NL_CAT_LOCALE	Value that must be passed as the oflag argument to catopen() to ensure that message catalog selection depends on the `LC_MESSAGES` locale category, rather than directly on the LANG environment variable.

WRDE_APPEND	Füge weitere Worte hinzu.
WRDE_DOOFFS	Anzahl der Null-Zeiger vor `we_wordv`.
WRDE_NOCMD	Deaktiviere Substitution von Kommandos.
WRDE_REUSE	Verwende den für `pwordexp` reservierten Speicher weiter.
WRDE_SHOWERR	Leite `stderr` nicht nach `/dev/null` um.
WRDE_UNDEF	Melde Fehler beim Versuch eine nicht definierte Variable zu expandieren.

WRDE_BADCHAR	Ein Zeichen aus der Menge `\|&;<>(){}` erscheint in unangemessenem Kontext.
WRDE_BADVAL	Verweis auf nicht definierte Variable obwohl `WRDE_UNDEF` gesetzt ist.
WRDE_CMDSUB	Substitution eines Kommandos verlangt obwohl `WRDE_NOCMD` gesetzt ist.
WRDE_NOSPACE	Speicherverwaltungsfehler.
WRDE_SYNTAX	Syntaxfehler wie zum Beispiel nicht balancierter Klammerausdruck oder nicht terminierte Zeichenkette.

REG_EXTENDED	Verwende erweiterte reguläre Ausdrücke
REG_ICASE	Ignoriere Groß-/Kleinschreibung
REG_NOSUB	Werte keine geklammerten Ausdrücke aus
REG_NEWLINE	Spezialbehandlung von Zeilenumbrüchen

REG_NOTBOL	Das Symbol `^` nicht auf den Anfang der Zeichenkette anwenden
REG_NOTEOL	Das Symbol `$` nicht auf das Ende der Zeichenkette anwenden

REG_NOMATCH	Ausdruck passt nich
REG_BADPAT	Ungültiger Ausdruck
REG_BADRPT	Ungültiger Ausdruck vor Multiplikator
REG_BADBR	Ungültige Zahl in geschweiften Klammern
REG_ECOLLATE	Ungültiges Element referenziert
REG_ECTYPE	Ungültige Zeichenklasse
REG_EESCAPE	Ungültiger schließender Backslash
REG_ESUBREG	Ziffer ungültig oder Fehlerhaft
REG_EBRACK	Ungleichgewicht bei eckigen Klammern
REG_EPAREN	Ungleichgewicht bei runden Klammern
REG_EBRACE	Ungleichgewicht bei geschweiften Klammern
REG_ERANGE	Ungültige Bereichsangabe
REG_ESPACE	Speicher erschöpft