manpages-de 1.10 - en to de translation catalogue (43 entries)

note: type: TH
en: 2019-05-09
de: 9. Mai 2019

note: type: TH
en: Linux Programmer's Manual
de: Linux-Programmierhandbuch

note: type: SH
en: NAME
de: BEZEICHNUNG

note: type: Plain text
en: stdarg, va_start, va_arg, va_end, va_copy - variable argument lists
de: stdarg, va_start, va_arg, va_end, va_copy - variable Argument-Listen

note: type: SH
en: SYNOPSIS
de: ÜBERSICHT

note: type: Plain text
en: B<void va_start(va_list >I<ap>B<, >I<last>B<);>
de: B<void va_start( va_list >I<ap>B<, >I<letztes>B<);>

note: type: Plain text
en: I<type>B< va_arg(va_list >I<ap>B<, >I<type>B<);>
de: I<type>B< va_arg( va_list >I<ap>B<, >I<typ>B<);>

note: type: Plain text
en: B<void va_copy(va_list >I<dest>B<, va_list >I<src>B<);>
de: B<void va_copy(va_list >I<ziel>B<, va_list >I<quelle>B<);>

note: type: SH
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Plain text
en: A function may be called with a varying number of arguments of varying types.  The include file I<E<lt>stdarg.hE<gt>> declares a type I<va_list> and defines three macros for stepping through a list of arguments whose number and types are not known to the called function.
de: Eine Funktion kann mit einer unterschiedlichen Anzahl von Argumenten verschiedenen Typs aufgerufen werden. Die Include-Datei I<stdarg.h> deklariert einen Typ B<va_list> und definiert drei Makros, um eine Liste von Argumenten durchzugehen, deren Anzahl und Typen der aufgerufenen Funktion unbekannt sind.

note: type: Plain text
en: The called function must declare an object of type I<va_list> which is used by the macros B<va_start>(), B<va_arg>(), and B<va_end>().
de: Die aufgerufene Funktion muss ein Objekt des Typs B<va_list> deklarieren, welches von den Makros B<va_start>(), B<va_arg>() und B<va_end>() benutzt wird.

note: type: Plain text
en: The B<va_start>()  macro initializes I<ap> for subsequent use by B<va_arg>()  and B<va_end>(), and must be called first.
de: Das Makro B<va_start>() initialisiert I<ap> zur nachfolgenden Benutzung durch B<va_arg>() und B<va_end>() und muss zuerst aufgerufen werden.

note: type: Plain text
en: The argument I<last> is the name of the last argument before the variable argument list, that is, the last argument of which the calling function knows the type.
de: Das Argument I<letztes> ist der Name des letzten Arguments vor der Liste der veränderlichen Argumente, das heisst, das letzt Argument, dessen Typ die aufrufende Funktion kennt.

note: type: Plain text
en: Because the address of this argument may be used in the B<va_start>()  macro, it should not be declared as a register variable, or as a function or an array type.
de: Da die Adresse dieses Parameters im Makro B<va_start>() benutzt wird, sollte er nicht als eine Registervariable, als Funktion oder als ein Feldtyp deklariert werden.

note: type: Plain text
en: The B<va_arg>()  macro expands to an expression that has the type and value of the next argument in the call.  The argument I<ap> is the I<va_list> I<ap> initialized by B<va_start>().  Each call to B<va_arg>()  modifies I<ap> so that the next call returns the next argument.  The argument I<type> is a type name specified so that the type of a pointer to an object that has the specified type can be obtained simply by adding a * to I<type>.
de: Das Makro B<va_arg>() expandiert zu einem Ausdruck, der den Typ und Wert des nächsten aufzurufenden Argumentes hat. Das Argument I<ap> ist die B<va_list> I<ap>, initialisiert durch B<va_start>(). Jeder Aufruf von B<va_arg>() verändert I<ap> so, dass der folgende Aufruf das nächste Argument zurückgibt. Der Parameter I<typ> ist ein Typenname, der so angegeben ist, dass der Typ eines Zeigers auf ein Objekt, das den angegebenen Typ hat, einfach durch Hinzufügen eines * zu I<typ> erhalten werden kann.

note: type: Plain text
en: The first use of the B<va_arg>()  macro after that of the B<va_start>()  macro returns the argument after I<last>.  Successive invocations return the values of the remaining arguments.
de: Die erste Benutzung des Makros B<va_arg>() nach B<va_start>() gibt das Argument nach I<letztes> zurück. Nachfolgende Aufrufe geben die Werte der verbleibenden Argumente zurück.

note: type: Plain text
en: If there is no next argument, or if I<type> is not compatible with the type of the actual next argument (as promoted according to the default argument promotions), random errors will occur.
de: Wenn es kein weiteres Argument gibt oder wenn I<typ> nicht kompatibel mit dem Typ des tatsächlich nächsten Argumentes ist (entsprechend der üblichen »argument promotions«), erscheinen zufällige Fehler.

note: type: Plain text
en: If I<ap> is passed to a function that uses B<va_arg(>I<ap>B<,>I<type>B<),> then the value of I<ap> is undefined after the return of that function.
de: Falls I<ap> an eine Funktion übergeben wird, die B<va_arg(>I<ap>B<,>I<type>B<)> benutzt, dann ist der Wert von I<ap> nach der Rückkehr dieser Funktion undefiniert.

note: type: Plain text
en: Each invocation of B<va_start>()  must be matched by a corresponding invocation of B<va_end>()  in the same function.  After the call B<va_end(>I<ap>B<)> the variable I<ap> is undefined.  Multiple traversals of the list, each bracketed by B<va_start>()  and B<va_end>()  are possible.  B<va_end>()  may be a macro or a function.
de: Zu jedem Aufruf von B<va_start>() muss zu einen zugehörigen Aufruf von B<va_end>() in der gleichen Funktion geben. Nach dem Aufruf B<va_end(>I<ap>B<)> ist die Variable I<ap> undefiniert. Es sind mehrere Durchläufe der Liste möglich, jeweils von B<va_start>() und B<va_end>() eingeschlossen. B<va_end>() kann ein Makro oder eine Funktion sein.

note: type: Plain text
en: The B<va_copy>()  macro copies the (previously initialized) variable argument list I<src> to I<dest>.  The behavior is as if B<va_start>()  were applied to I<dest> with the same I<last> argument, followed by the same number of B<va_arg>()  invocations that was used to reach the current state of I<src>.
de: Das Makro B<va_copy>() kopiert die (vorher initialisierte) Variablenargumentliste I<quelle> nach I<ziel>. Das Verhalten ist so, als ob B<va_start>() auf I<ziel> mit dem selben Argument I<letztes> angewandt worden wäre, gefolgt von der gleichen Anzahl Aufrufe von B<va_arg>(), die benutzt wurden, um den aktuellen Status von I<quelle> zu erreichen.

note: Proposal from clive@demon.net, 1997-02-28 type: Plain text
en: An obvious implementation would have a I<va_list> be a pointer to the stack frame of the variadic function.  In such a setup (by far the most common) there seems nothing against an assignment
de: Eine naheliegende Implementierung hätte eine I<va_list>, die ein Zeiger in den »Stack-Frame« der variadischen Funktion wäre. In einem derartigen Szenario (dem bei weitem üblichsten) scheint nichts gegen folgende Zuweisung zu sprechen

note: type: Plain text
en: Unfortunately, there are also systems that make it an array of pointers (of length 1), and there one needs
de: Leider gibt es auch Systeme, die es als Feld von Zeigern (der Länge 1) anlegen. Dort wird dann folgendes benötigt:

note: type: Plain text
en: Finally, on systems where arguments are passed in registers, it may be necessary for B<va_start>()  to allocate memory, store the arguments there, and also an indication of which argument is next, so that B<va_arg>()  can step through the list.  Now B<va_end>()  can free the allocated memory again.  To accommodate this situation, C99 adds a macro B<va_copy>(), so that the above assignment can be replaced by
de: Zu guter Letzt kann es auf Systemen, die Argumente in Registern übergeben, nötig sein, dass B<va_start> Speicher reserviert und in diesem die Argumente und einen Positionsanzeiger speichert, so dass B<va_arg>() diese Liste durchschreiten kann. Dann kann B<va_end>() den reservierten Speicher wieder freigeben. Um dieser Situation Rechnung zu tragen, fügt C99 ein Makro B<va_copy>() hinzu, so dass obige Zuweisung durch Folgendes ersetzt werden kann

note: type: Plain text
en: va_list aq;
    va_copy(aq, ap);
    \&...
    va_end(aq);
de: va_list aq;
    va_copy(aq, ap);
    …
    va_end(aq);

note: type: Plain text
en: Each invocation of B<va_copy>()  must be matched by a corresponding invocation of B<va_end>()  in the same function.  Some systems that do not supply B<va_copy>()  have B<__va_copy> instead, since that was the name used in the draft proposal.
de: Zu jedem Aufruf von B<va_copy>() muss zu einen zugehörigen Aufruf von B<va_end>() in der gleichen Funktion geben. Einige Systeme, die kein B<va_copy>() bereitstellen, haben stattdessen B<__va_copy>, da das der gleiche Name ist, der im ursprünglichen Vorschlag benutzt wurde.

note: type: SH
en: ATTRIBUTES
de: ATTRIBUTE

note: type: Plain text
en: For an explanation of the terms used in this section, see B<attributes>(7).
de: Siehe B<attributes>(7) für eine Erläuterung der in diesem Abschnitt verwandten Ausdrücke.

note: type: tbl table
en: Interface
de: Schnittstelle

note: type: tbl table
en: Attribute
de: Attribut

note: type: tbl table
en: Value
de: Wert

note: type: tbl table
en: Thread safety
de: Multithread-Fähigkeit

note: type: SH
en: CONFORMING TO
de: KONFORM ZU

note: type: Plain text
en: The B<va_start>(), B<va_arg>(), and B<va_end>()  macros conform to C89.  C99 defines the B<va_copy>()  macro.
de: Die Makros B<va_start>(), B<va_arg>() und B<va_end>() sind konform zu C89. C99 definiert das Makro B<va_copy>().

note: type: SH
en: BUGS
de: FEHLER

note: type: Plain text
en: Unlike the historical B<varargs> macros, the B<stdarg> macros do not permit programmers to code a function with no fixed arguments.  This problem generates work mainly when converting B<varargs> code to B<stdarg> code, but it also creates difficulties for variadic functions that wish to pass all of their arguments on to a function that takes a I<va_list> argument, such as B<vfprintf>(3).
de: Im Gegensatz zu den historischen Makros B<varargs> erlauben die Makros B<stdarg> dem Programmierer nicht, eine Funktion ohne feste Argumente zu implementieren. Das ist hauptsächlich ein Problem, wenn man Code mit B<varargs> nach B<stdarg> konvertiert, aber es erzeugt auch Schwierigkeiten bei veränderlichen Funktionen die wünschen, ihre Argumente an eine Funktion weiterzugeben, die ein Argument B<va_list> aufnimmt, so wie B<vfprintf>(3).

note: type: SH
en: EXAMPLE
de: BEISPIEL

note: type: Plain text
en: The function I<foo> takes a string of format characters and prints out the argument associated with each format character based on the type.
de: Die Funktion I<foo> nimmt eine Zeichenkette von Formatzeichen entgegen und gibt für jedes Zeichen ein Argument des entsprechenden Typs aus.

note: type: Plain text
en: void
    foo(char *fmt, ...)   /* '...' is C syntax for a variadic function */
de: void
    foo(char *fmt, …)   /* '…' ist C-Syntax für eine variadische Funktion */

note: type: Plain text
en:     va_start(ap, fmt);
        while (*fmt)
            switch (*fmt++) {
            case \(aqs\(aq:              /* string */
                s = va_arg(ap, char *);
                printf("string %s\en", s);
                break;
            case \(aqd\(aq:              /* int */
                d = va_arg(ap, int);
                printf("int %d\en", d);
                break;
            case \(aqc\(aq:              /* char */
                /* need a cast here since va_arg only
                   takes fully promoted types */
                c = (char) va_arg(ap, int);
                printf("char %c\en", c);
                break;
            }
        va_end(ap);
    }
de:     va_start(ap, fmt);
        while (*fmt)
            switch (*fmt++) {
            case \(aqs\(aq:              /* Zeichenkette */
                s = va_arg(ap, char *);
                printf("string %s\en", s);
                break;
            case \(aqd\(aq:              /* Ganzzahl */
                d = va_arg(ap, int);
                printf("int %d\en", d);
                break;
            case \(aqc\(aq:              /* Zeichen */
                /* hier wird eine Typumwandlung benötigt, da va_arg
                   nur vollständig unterstützte Typen aufnimmt */
                c = (char) va_arg(ap, int);
                printf("Zeichen %c\en", c);
                break;
            }
        va_end(ap);
    }

note: type: SH
en: COLOPHON
de: KOLOPHON

note: type: Plain text
en: This page is part of release 5.03 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.03 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.02 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.02 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.

note: type: Plain text
en: This page is part of release 5.01 of the Linux I<man-pages> project.  A description of the project, information about reporting bugs, and the latest version of this page, can be found at \%https://www.kernel.org/doc/man-pages/.
de: Diese Seite ist Teil der Veröffentlichung 5.01 des Projekts Linux-I<man-pages>. Eine Beschreibung des Projekts, Informationen, wie Fehler gemeldet werden können sowie die aktuelle Version dieser Seite finden sich unter \%https://www.kernel.org/doc/man-pages/.
