table of contents
| printf.h(3head) | printf.h(3head) |
BEZEICHNUNG¶
printf.h, register_printf_specifier, register_printf_modifier, register_printf_type, printf_function, printf_arginfo_size_function, printf_va_arg_function, printf_info, PA_INT, PA_CHAR, PA_WCHAR, PA_STRING, PA_WSTRING, PA_POINTER, PA_FLOAT, PA_DOUBLE, PA_LAST, PA_FLAG_LONG_LONG, PA_FLAG_LONG_DOUBLE, PA_FLAG_LONG, PA_FLAG_SHORT, PA_FLAG_PTR - Definition von angepasstem Verhalten von printf-artigen Funktionen
BIBLIOTHEK¶
Standard-C-Bibliothek (libc, -lc)
ÜBERSICHT¶
#include <printf.h>
int register_printf_specifier(int Spez, printf_function Funk,
printf_arginfo_size_function Arginfo);
int register_printf_modifier(const wchar_t *ZK);
int register_printf_type(printf_va_arg_function Fkt);
Rückruffunktionen¶
typedef int printf_function(FILE *Datenstrom, const struct printf_info *Info,
const void *const Arg[]);
typedef int printf_arginfo_size_function(const struct printf_info *Info,
size_t n, int Argtypen[n], int Größe[n]);
typedef void printf_va_arg_function(void *Speicher, va_list *az);
Typen¶
struct printf_info {
int prec; // Genauigkeit
int width; // Breite
wchar_t spec; // Formatbuchstabe
unsigned int is_long_double:1;// Schalter L oder ll
unsigned int is_short:1; // Schalter h
unsigned int is_long:1; // Schalter l
unsigned int alt:1; // Schalter #
unsigned int space:1; // Leerzeichenschalter
unsigned int left:1; // Schalter -
unsigned int showsign:1; // Schalter +
unsigned int group:1; // Schalter '
unsigned int extra:1; // Zur besonderen Verwendung
unsigned int is_char:1; // Schalter hh
unsigned int wide:1; // Wahr bei Datenströmen mit weiten
// Zeichen
unsigned int i18n:1; // Schalter I
unsigned int is_binary128:1; /* Fließkommaargument ist zu
IEC 60559 binary128 */
ABI-kompatibel
unsigned short user; // Bits für Benutzer-installierte
// Modifikatoren
wchar_t pad; // Auffüllzeichen
};
Konstanten¶
#define PA_FLAG_LONG_LONG /* … */ #define PA_FLAG_LONG_DOUBLE /* … */ #define PA_FLAG_LONG /* … */ #define PA_FLAG_SHORT /* … */ #define PA_FLAG_PTR /* … */
BESCHREIBUNG¶
Diese Funktionen dienen dazu, das Verhalten der printf(3)-Funktionsfamilie zu erweitern und/oder zu verändern.
register_printf_specifier()¶
Diese Funktion registriert einen angepassten Umwandlungskennzeichner für die printf(3)-Funktionsfamilie.
- Spez
- Das Zeichen, das als Umwandlungskennzeichner in der Formatzeichenkette verwandt werden wird.
- Funk
- Rückruffunktion, die bei der Ausführung der printf(3)-Funktionsfamilie ausgeführt wird, um die Eingabeargumente in die Ausgabeargumente Datenstrom zu formatieren.
- Datenstrom
- Ausgabedatenstrom, in den die formatierte Ausgabe geschrieben werden soll. Dieser Datenstrom repräsentiert transparent die Ausgabe, selbst in Fällen, in denen die Funktionen in eine Zeichenkette schreiben.
- Info
- Struktur, die Kontextinformationen hält, einschließlich der in der Formatzeichenkette festgelegten Modifikatoren. Dies hält die gleichen Inhalte wie in Arginfo.
- Arg
- Feld von Zeigern auf Argumente der printf(3)-artigen Funktionen.
- Arginfo
- Rückruffunktion, die von der printf(3)-Funktionsfamilie ausgeführt wird, um zu ermitteln, wie viele Argumente für die angepassten Kennzeichner ausgewertet werden sollen und welchen Typ sie haben.
- Info
- Struktur, die Kontextinformationen hält, einschließlich der in der Formatzeichenkette festgelegten Modifikatoren. Dies hält die gleichen Inhalte wie Funk.
- n
- Anzahl der noch auszuwertenden Argumente.
- Argtypen
- Dieses Feld sollte gesetzt werden, um die Typen jedes ausgewerteten Argumentes zu definieren. Jedes Element in der Liste repräsentiert eines der auszuwertenden Argumente. Die Reihenfolge ist dabei identisch zu der Reihenfolge, an der sie an die printf(3)-artige Funktion übergeben werden. Jedes Element sollte auf einen Basistypen (PA_*) aus der Aufzählung oben oder auf einen angepassten Typ gesetzt werden, und optional mittels »OR« mit einem geeigneten Längenmodifikator (PA_FLAG_*) verknüpft werden.
Der Typ wird durch Verwendung einer der folgenden Konstanten bestimmt:
- PA_INT
- int.
- PA_CHAR
- int, typenumgewandelt zu char.
- PA_WCHAR
- wchar_t.
- PA_STRING
- const char *, eine »\0«-begrenzte Zeichenkette.
- PA_WSTRING
- const wchar_t *, eine L'\0'-begrenzte weite Zeichenkette.
- PA_POINTER
- void *.
- PA_FLOAT
- float.
- PA_DOUBLE
- double.
- PA_LAST
- OFFENE PUNKTE.
- Größe
- Für benutzerdefinierte Typen sollte die Größe des Typs (in Byte) auch durch dieses Feld festgelegt werden. Lassen Sie dies ansonsten unbenutzt.
Arginfo wird vor Funk aufgerufen und bereitet einige Informationen vor, die zum Aufruf von Funk benötigt werden.
register_printf_modifier()¶
OFFENE PUNKTE
register_printf_type()¶
OFFENE PUNKTE
RÜCKGABEWERT¶
register_printf_specifier(), register_printf_modifier() und register_printf_type() liefern im Erfolgsfall Null zurück und -1 bei Fehler.
Rückruffunktionen¶
Die Rückruffunktion vom Typ printf_function sollte die Anzahl der geschriebenen Zeichen zurückliefern oder -1 bei Fehlern.
Die Rückruffunktion vom Typ printf_arginfo_size_function sollte die Anzahl der Argumente zurückliefern, die in diesem Kennzeichner ausgewertet werden sollen. Sie gibt auch Informationen über den Typ dieser Argumente über Argtypen an den Aufrufenden zurück. Im Fehlerfall sollte sie -1 zurückliefern.
FEHLER¶
- EINVAL
- Der Kennzeichner war kein gültiges Zeichen.
STANDARDS¶
GNU.
GESCHICHTE¶
register_printf_function(3) ist eine ältere und als veraltet markierte Funktion, ähnlich zu register_printf_specifier(). Diese Funktion kann nicht mit benutzerdefinierten Typen umgehen.
register_printf_specifier() ersetzt register_printf_function(3).
BEISPIELE¶
Das folgende Beispielprogramm registriert die Kennzeichner »b« und »B« zum Ausgeben von Ganzzahlen im Binärformat, was die Regeln für andere vorzeichenfreie Umwandlungskennzeichner wie »x« und »u« spiegelt. Dies kann vor C23 zur Ausgabe von Binärzahlen verwandt werden.
/* Dieser Code ist gemeinfrei (»public domain«). */
#include <err.h>
#include <limits.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <printf.h>
#define GROUP_SEP '\''
struct Printf_Pad {
char ch;
size_t len;
};
static int b_printf(FILE *stream, const struct printf_info *info,
const void *const args[]);
static int b_arginf_sz(const struct printf_info *info,
size_t n, int argtypes[n], int size[n]);
static uintmax_t b_value(const struct printf_info *info,
const void *arg);
static size_t b_bin_repr(char bin[UINTMAX_WIDTH],
const struct printf_info *info, const void *arg);
static size_t b_bin_len(const struct printf_info *info,
ptrdiff_t min_len);
static size_t b_pad_len(const struct printf_info *info,
ptrdiff_t bin_len);
static ssize_t b_print_prefix(FILE *stream,
const struct printf_info *info);
static ssize_t b_pad_zeros(FILE *stream, const struct printf_info *info,
ptrdiff_t min_len);
static ssize_t b_print_number(FILE *stream,
const struct printf_info *info,
const char bin[UINTMAX_WIDTH],
size_t min_len, size_t bin_len);
static char pad_ch(const struct printf_info *info);
static ssize_t pad_spaces(FILE *stream, size_t pad_len);
int
main(void)
{
if (register_printf_specifier('b', b_printf, b_arginf_sz) == -1)
err(EXIT_FAILURE, "register_printf_specifier('b', …)");
if (register_printf_specifier('B', b_printf, b_arginf_sz) == -1)
err(EXIT_FAILURE, "register_printf_specifier('B', …)");
printf("....----....----....----....----\n");
printf("%llb;\n", 0x5Ellu);
printf("%lB;\n", 0x5Elu);
printf("%b;\n", 0x5Eu);
printf("%hB;\n", 0x5Eu);
printf("%hhb;\n", 0x5Eu);
printf("%jb;\n", (uintmax_t)0x5E);
printf("%zb;\n", (size_t)0x5E);
printf("....----....----....----....----\n");
printf("%#b;\n", 0x5Eu);
printf("%#B;\n", 0x5Eu);
printf("....----....----....----....----\n");
printf("%10b;\n", 0x5Eu);
printf("%010b;\n", 0x5Eu);
printf("%.10b;\n", 0x5Eu);
printf("....----....----....----....----\n");
printf("%-10B;\n", 0x5Eu);
printf("....----....----....----....----\n");
printf("%'B;\n", 0x5Eu);
printf("....----....----....----....----\n");
printf("....----....----....----....----\n");
printf("%#16.12b;\n", 0xAB);
printf("%-#'20.12b;\n", 0xAB);
printf("%#'020B;\n", 0xAB);
printf("....----....----....----....----\n");
printf("%#020B;\n", 0xAB);
printf("%'020B;\n", 0xAB);
printf("%020B;\n", 0xAB);
printf("....----....----....----....----\n");
printf("%#021B;\n", 0xAB);
printf("%'021B;\n", 0xAB);
printf("%021B;\n", 0xAB);
printf("....----....----....----....----\n");
printf("%#022B;\n", 0xAB);
printf("%'022B;\n", 0xAB);
printf("%022B;\n", 0xAB);
printf("....----....----....----....----\n");
printf("%#023B;\n", 0xAB);
printf("%'023B;\n", 0xAB);
printf("%023B;\n", 0xAB);
printf("....----....----....----....----\n");
printf("%-#'19.11b;\n", 0xAB);
printf("%#'019B;\n", 0xAB);
printf("%#019B;\n", 0xAB);
printf("....----....----....----....----\n");
printf("%'019B;\n", 0xAB);
printf("%019B;\n", 0xAB);
printf("%#016b;\n", 0xAB);
printf("....----....----....----....----\n");
return 0;
}
static int
b_printf(FILE *stream, const struct printf_info *info,
const void *const args[])
{
char bin[UINTMAX_WIDTH];
size_t min_len, bin_len;
ssize_t len, tmp;
struct Printf_Pad pad = {0};
len = 0;
min_len = b_bin_repr(bin, info, args[0]);
bin_len = b_bin_len(info, min_len);
pad.ch = pad_ch(info);
if (pad.ch == ' ')
pad.len = b_pad_len(info, bin_len);
/* Auffüllen mit ' ' (rechts ausgerichtet) */
if ((pad.ch == ' ') && !info->left) {
tmp = pad_spaces(stream, pad.len);
if (tmp == EOF)
return EOF;
len += tmp;
}
/* Präfix "0b"/"0B" */
if (info->alt) {
tmp = b_print_prefix(stream, info);
if (tmp == EOF)
return EOF;
len += tmp;
}
/* Auffüllen mit '0' */
if (pad.ch == '0') {
tmp = b_pad_zeros(stream, info, min_len);
if (tmp == EOF)
return EOF;
len += tmp;
}
/* Zahl ausgeben (einschließlich führender 0en, um die Genauigkeit aufzufüllen) */
tmp = b_print_number(stream, info, bin, min_len, bin_len);
if (tmp == EOF)
return EOF;
len += tmp;
/* Auffüllen mit ' ' (links ausgerichtet) */
if (info->left) {
tmp = pad_spaces(stream, pad.len);
if (tmp == EOF)
return EOF;
len += tmp;
}
return len;
}
static int
b_arginf_sz(const struct printf_info *info, size_t n, int argtypes[n],
[[maybe_unused]] int size[n])
{
if (n < 1)
return -1;
if (info->is_long_double)
argtypes[0] = PA_INT | PA_FLAG_LONG_LONG;
else if (info->is_long)
argtypes[0] = PA_INT | PA_FLAG_LONG;
else
argtypes[0] = PA_INT;
return 1;
}
static uintmax_t
b_value(const struct printf_info *info, const void *arg)
{
if (info->is_long_double)
return *(const unsigned long long *)arg;
if (info->is_long)
return *(const unsigned long *)arg;
/* short und char werden beide auf int aufgewertet */
return *(const unsigned int *)arg;
}
static size_t
b_bin_repr(char bin[UINTMAX_WIDTH],
const struct printf_info *info, const void *arg)
{
size_t min_len;
uintmax_t val;
val = b_value(info, arg);
bin[0] = '0';
for (min_len = 0; val; min_len++) {
bin[min_len] = '0' + (val % 2);
val >>= 1;
}
return MAX(min_len, 1);
}
static size_t
b_bin_len(const struct printf_info *info, ptrdiff_t min_len)
{
return MAX(info->prec, min_len);
}
static size_t
b_pad_len(const struct printf_info *info, ptrdiff_t bin_len)
{
ptrdiff_t pad_len;
pad_len = info->width - bin_len;
if (info->alt)
pad_len -= 2;
if (info->group)
pad_len -= (bin_len - 1) / 4;
return MAX(pad_len, 0);
}
static ssize_t
b_print_prefix(FILE *stream, const struct printf_info *info)
{
ssize_t len;
len = 0;
if (fputc('0', stream) == EOF)
return EOF;
len++;
if (fputc(info->spec, stream) == EOF)
return EOF;
len++;
return len;
}
static ssize_t
b_pad_zeros(FILE *stream, const struct printf_info *info,
ptrdiff_t min_len)
{
ssize_t len;
ptrdiff_t tmp;
len = 0;
tmp = info->width - (info->alt * 2);
if (info->group)
tmp -= tmp / 5 - !(tmp % 5);
for (ptrdiff_t i = tmp - 1; i > min_len - 1; i--) {
if (fputc('0', stream) == EOF)
return EOF;
len++;
if (!info->group || (i % 4))
continue;
if (fputc(GROUP_SEP, stream) == EOF)
return EOF;
len++;
}
return len;
}
static ssize_t
b_print_number(FILE *stream, const struct printf_info *info,
const char bin[UINTMAX_WIDTH],
size_t min_len, size_t bin_len)
{
ssize_t len;
len = 0;
/* Führende Nullen ausgeben, um die Genauigkeit aufzufüllen */
for (size_t i = bin_len - 1; i > min_len - 1; i--) {
if (fputc('0', stream) == EOF)
return EOF;
len++;
if (!info->group || (i % 4))
continue;
if (fputc(GROUP_SEP, stream) == EOF)
return EOF;
len++;
}
/* Zahl ausgeben */
for (size_t i = min_len - 1; i < min_len; i--) {
if (fputc(bin[i], stream) == EOF)
return EOF;
len++;
if (!info->group || (i % 4) || !i)
continue;
if (fputc(GROUP_SEP, stream) == EOF)
return EOF;
len++;
}
return len;
}
static char
pad_ch(const struct printf_info *info)
{
if ((info->prec != -1) || (info->pad == ' ') || info->left)
return ' ';
return '0';
}
static ssize_t
pad_spaces(FILE *stream, size_t pad_len)
{
ssize_t len;
len = 0;
for (size_t i = pad_len - 1; i < pad_len; i--) {
if (fputc(' ', stream) == EOF)
return EOF;
len++;
}
return len;
}
SIEHE AUCH¶
ÜBERSETZUNG¶
Die deutsche Übersetzung dieser Handbuchseite wurde von Helge Kreutzmann <debian@helgefjell.de> erstellt.
Diese Übersetzung ist Freie Dokumentation; lesen Sie die GNU General Public License Version 3 oder neuer bezüglich der Copyright-Bedingungen. Es wird KEINE HAFTUNG übernommen.
Wenn Sie Fehler in der Übersetzung dieser Handbuchseite finden, schicken Sie bitte eine E-Mail an die Mailingliste der Übersetzer.
| 17. Mai 2025 | Linux man-pages 6.20 |