Static deklarierten Funktionen in "C" - header-Dateien

Dies ist nicht eine Antwort auf die genannten Fragen, aber hoffentlich zeigt warum einer Umsetzung könnte ein static (oder static inline) - Funktion in einer header-Datei.

Kann ich persönlich nur denke zwei gute Gründe, um zu erklären, dass bestimmte Funktionen static in einer header-Datei:

1. Wenn die header-Datei komplett implementiert eine Schnittstelle, die sollte nur sichtbar sein in der aktuellen compilation unit

   Dies ist extrem selten, aber könnte nützlich sein, z.B. in einem pädagogischen Kontext, an irgendeinem Punkt während der Entwicklung von einigen Beispiel-Bibliothek; oder vielleicht, wenn er eine Schnittstelle zu einer anderen Programmiersprache mit minimalem code.

   Entwickler können wählen, dies zu tun, wenn die Bibliothek oder interaface Implementierung ist trivial und fast so, und die Benutzerfreundlichkeit (der Entwickler anhand der header-Datei) ist wichtiger als code-Größe. In diesen Fällen werden die Deklarationen in der header-Datei verwenden oft Präprozessor-Makros, so dass die gleiche header-Datei aufgenommen werden, mehr als einmal, einige Sortieren von grob-Polymorphismus in C.

   Hier ist ein Beispiel aus der Praxis: Schießen-selbst-in-den-Fuß-Spielplatz für linear congruential Pseudo-zufälligen Zahl-Generatoren. Denn die Umsetzung einer lokalen compilation-unit, die jede compilation unit wird Ihre eigenen Kopien der PRNG. Dieses Beispiel zeigt auch, wie grob Polymorphismus realisiert werden kann C.

   prng32.h:

   #if defined(PRNG_NAME) && defined(PRNG_MULTIPLIER) && defined(PRNG_CONSTANT) && defined(PRNG_MODULUS)
   #define MERGE3_(a,b,c) a ## b ## c
   #define MERGE3(a,b,c) MERGE3_(a,b,c)
   #define NAME(name) MERGE3(PRNG_NAME, _, name)
   
   static uint32_t NAME(state) = 0U;
   
   static uint32_t NAME(next)(void)
   {
       NAME(state) = ((uint64_t)PRNG_MULTIPLIER * (uint64_t)NAME(state) + (uint64_t)PRNG_CONSTANT) % (uint64_t)PRNG_MODULUS;
       return NAME(state);
   }
   
   #undef NAME
   #undef MERGE3
   #endif
   
   #undef PRNG_NAME
   #undef PRNG_MULTIPLIER
   #undef PRNG_CONSTANT
   #undef PRNG_MODULUS

   Ein Beispiel für die Verwendung der oben Beispiel-prng32.h:

   #include <stdlib.h>
   #include <stdint.h>
   #include <stdio.h>
   
   #define PRNG_NAME       glibc
   #define PRNG_MULTIPLIER 1103515245UL
   #define PRNG_CONSTANT   12345UL
   #define PRNG_MODULUS    2147483647UL
   #include "prng32.h"
   /* provides glibc_state and glibc_next() */
   
   #define PRNG_NAME       borland
   #define PRNG_MULTIPLIER 22695477UL
   #define PRNG_CONSTANT   1UL
   #define PRNG_MODULUS    2147483647UL
   #include "prng32.h"
   /* provides borland_state and borland_next() */
   
   int main(void)
   {
       int i;
   
       glibc_state = 1U;
       printf("glibc lcg: Seed %u\n", (unsigned int)glibc_state);
       for (i = 0; i < 10; i++)
           printf("%u, ", (unsigned int)glibc_next());
       printf("%u\n", (unsigned int)glibc_next());
   
       borland_state = 1U;
       printf("Borland lcg: Seed %u\n", (unsigned int)borland_state);
       for (i = 0; i < 10; i++)
           printf("%u, ", (unsigned int)borland_next());
       printf("%u\n", (unsigned int)borland_next());
   
       return EXIT_SUCCESS;
   }

   Der Grund für die Markierung sowohl der _state variable und die _next() Funktion static ist, dass auf diese Weise jede compilation unit enthält die header-Datei hat Ihre eigene Kopie der Variablen und Funktionen -- hier Ihre eigene Kopie des PRNG. Jeder muss separat ausgesät, natürlich; und wenn der Setzliste auf den gleichen Wert, wird der Ertrag der gleichen Reihenfolge.

   Generell sollte man sich scheuen, solche Polymorphismus versuche in C, denn es führt zu komplizierten Präprozessor-makro-Spielereien, so dass die Umsetzung sehr viel schwieriger zu verstehen, zu pflegen und zu modifizieren als nötig.

   Jedoch, wenn erkunden der parameter Raum von einigen Algorithmus-wie hier die Arten von 32-bit-linear-congruential-Generatoren, dies ermöglicht uns die Nutzung einer einzigen Implementierung für jeden der Generatoren, die wir untersuchen, die Gewährleistung gibt es keine Umsetzung Unterschiede zwischen Ihnen. Beachten Sie, dass auch dieser Fall ist mehr wie ein Entwicklungswerkzeug, und nicht etwas, das Sie sehen sollten, in einer implementation für andere zu verwenden.

1. Wenn der header implementiert einfache static inline - accessor-Funktionen

   Präprozessor-Makros werden Häufig verwendet, um zu vereinfachen-code den Zugriff auf komplizierte Struktur, Arten. static inline Funktionen sind ähnlich, außer, dass Sie bieten auch die Typprüfung zur compile-Zeit, und können sich auf Ihre Parameter, die mehrmals (mit Makros, die problematisch ist).

   Einem praktischen Anwendungsfall eine einfache Schnittstelle zum Lesen von Dateien mithilfe von low-level POSIX.1 I/O (mit <unistd.h> und <fcntl.h> statt <stdio.h>). Ich habe dies getan, mich beim Lesen sehr groß (Dutzende von Megabyte zu Gigabyte reichen) text-Dateien mit reellen zahlen (mit einem custom float/double-parser), der GNU C standard I/O ist nicht besonders schnell.

   Beispielsweise inbuffer.h:

   #ifndef   INBUFFER_H
   #define   INBUFFER_H
   
   typedef struct {
       unsigned char  *head;       /* Next buffered byte */
       unsigned char  *tail;       /* Next byte to be buffered */
       unsigned char  *ends;       /* data + size */
       unsigned char  *data;
       size_t          size;
       int             descriptor;
       unsigned int    status;     /* Bit mask */
   } inbuffer;
   #define INBUFFER_INIT { NULL, NULL, NULL, NULL, 0, -1, 0 }
   
   int inbuffer_open(inbuffer *, const char *);
   int inbuffer_close(inbuffer *);
   
   int inbuffer_skip_slow(inbuffer *, const size_t);
   int inbuffer_getc_slow(inbuffer *);
   
   static inline int inbuffer_skip(inbuffer *ib, const size_t n)
   {
       if (ib->head + n <= ib->tail) {
           ib->head += n;
           return 0;
       } else
           return inbuffer_skip_slow(ib, n);
   }
   
   static inline int inbuffer_getc(inbuffer *ib)
   {
       if (ib->head < ib->tail)
           return *(ib->head++);
       else
           return inbuffer_getc_slow(ib);
   }
   
   #endif /* INBUFFER_H */

   Beachten Sie, dass die oben inbuffer_skip() und inbuffer_getc() nicht überprüfen, wenn ib ist nicht NULL; dies ist typisch für solche Funktionen. Diese accessor-Funktionen sind davon ausgegangen, dass "in den schnellen Pfad", also sehr oft. In solchen Fällen, auch der Funktionsaufruf-overhead Angelegenheiten (und ist) vermieden static inline Funktionen, da Sie dupliziert in den code an der call-site).

   Trivial-accessor-Funktionen, wie die oben inbuffer_skip() und inbuffer_getc(), kann auch ermöglichen es dem compiler, vermeiden Sie das registrieren von Bewegungen beteiligt-Funktion aufrufen, weil Funktionen erwarten Parameter, um sich in bestimmten Registern oder auf dem stack, in der Erwägung, dass inline-Funktionen angepasst werden können (wrt. registrieren verwenden), um den code rund um die inline-Funktion.

   Persönlich kann ich empfehlen, schreiben Sie ein paar test-Programme mit Hilfe der nicht-inline-Funktionen ersten, und vergleichen Sie die Leistung und Ergebnisse, um die inline-Versionen. Vergleicht man die Ergebnisse sorgen für die inline-Versionen haben keine bugs (aus von einem Typ ist hier üblich!), und vergleicht man die Leistung und die erzeugten binaries (Größe zumindest) sagt Ihnen, ob inlining ist es Wert, im Allgemeinen.

InformationsquelleAutor Nominal Animal