statische Funktion in C

Was bringt es, eine Funktion in C statisch zu machen?

Funktion machen static verbirgt es vor anderen Übersetzungseinheiten, was zur Bereitstellung beiträgt Verkapselung.

helper_file.c

int f1(int);        /* prototype */
static int f2(int); /* prototype */

int f1(int foo) {
    return f2(foo); /* ok, f2 is in the same translation unit */
                    /* (basically same .c file) as f1         */
}

int f2(int foo) {
    return 42 + foo;
}

Haupt c:

int f1(int); /* prototype */
int f2(int); /* prototype */

int main(void) {
    f1(10); /* ok, f1 is visible to the linker */
    f2(12); /* nope, f2 is not visible to the linker */
    return 0;
}

pmg ist genau richtig in Bezug auf die Kapselung; über das Verstecken der Funktion vor anderen Übersetzungseinheiten hinaus (oder besser gesagt, Weil davon), Funktionen machen static kann auch bei Vorhandensein von Compileroptimierungen Leistungsvorteile bringen.

Weil ein static Die Funktion kann nicht von irgendwo außerhalb der aktuellen Übersetzungseinheit aufgerufen werden (es sei denn, der Code nimmt einen Zeiger auf seine Adresse), der Compiler steuert alle Aufrufpunkte darin.

Dies bedeutet, dass es frei ist, eine nicht standardmäßige ABI zu verwenden, sie vollständig zu inlinen oder eine beliebige Anzahl anderer Optimierungen durchzuführen, die für eine Funktion mit externer Verknüpfung möglicherweise nicht möglich sind.

Das static Schlüsselwort in C wird in einer kompilierten Datei (.c im Gegensatz zu .h) verwendet, sodass die Funktion nur in dieser Datei existiert.

Wenn Sie eine Funktion erstellen, generiert der Compiler normalerweise Cruft, die der Linker verwenden kann, um einen Funktionsaufruf mit dieser Funktion zu verknüpfen. Wenn Sie das Schlüsselwort static verwenden, können andere Funktionen innerhalb derselben Datei diese Funktion aufrufen (weil dies ohne Rückgriff auf den Linker möglich ist), während der Linker keine Informationen hat, die anderen Dateien den Zugriff auf die Funktion ermöglichen.

Wenn ich mir die obigen Beiträge ansehe, möchte ich eine klarere Antwort geben:

Angenommen, unsere main.c Datei sieht so aus:

#include "header.h"

int main(void) {
    FunctionInHeader();
}

Betrachten Sie nun drei Fälle:

• Fall 1: Unsere header.h Datei sieht so aus:

   #include <stdio.h>
  
   static void FunctionInHeader();
  
   void FunctionInHeader() {
       printf("Calling function inside header\n");
   }
  

  Dann der folgende Befehl unter Linux:

   gcc main.c -o main
  

  wird gelingen! Das liegt daran, dass nach dem main.c Datei enthält die header.hdie Definition der statischen Funktion ist gleich main.c Datei (genauer gesagt in derselben Übersetzungseinheit) dorthin, wo sie aufgerufen wird.

  Wenn einer läuft ./mainwird die Ausgabe sein Calling function inside headerwas diese statische Funktion ausgeben sollte.

• Fall 2: Unser Header header.h sieht aus wie das:

    static void FunctionInHeader();     
  

  und wir haben auch eine weitere Datei header.cdie so aussieht:

    #include <stdio.h>
    #include "header.h"
  
    void FunctionInHeader() {
        printf("Calling function inside header\n");
    }
  

  Dann der folgende Befehl

    gcc main.c header.c -o main
  

  wird einen Fehler geben. In diesem Fall main.c enthält nur die Deklaration der statischen Funktion, aber die Definition wird in einer anderen Übersetzungseinheit belassen und die static Schlüsselwort verhindert, dass der Code eine zu verknüpfende Funktion definiert

• Fall 3:

  Ähnlich wie Fall 2, nur dass jetzt unser Header header.h Datei ist:

    void FunctionInHeader(); // keyword static removed
  

  Dann wird derselbe Befehl wie in Fall 2 ausgeführt und weiter ausgeführt ./main wird das erwartete Ergebnis liefern. Hier die FunctionInHeader Definition befindet sich in einer anderen Übersetzungseinheit, aber der Code, der sie definiert, kann verknüpft werden.

Also zum Schluss:

static keyword prevents the code defining a function to be linked,
when that function is defined in another translation unit than where it is called.

C-Programmierer verwenden das statische Attribut, um Variablen- und Funktionsdeklarationen innerhalb von Modulen zu verbergen, ähnlich wie Sie öffentliche und private Deklarationen in Java und C++ verwenden würden. C-Quelldateien spielen die Rolle von Modulen. Jede mit dem statischen Attribut deklarierte globale Variable oder Funktion ist für dieses Modul privat. Ebenso ist jede globale Variable oder Funktion, die ohne das statische Attribut deklariert wurde, öffentlich und kann von jedem anderen Modul aufgerufen werden. Es gehört zur guten Programmierpraxis, Ihre Variablen und Funktionen nach Möglichkeit mit dem statischen Attribut zu schützen.

Die Antwort von pmg ist sehr überzeugend. Wenn Sie wissen möchten, wie statische Deklarationen auf Objektebene funktionieren, könnten die folgenden Informationen für Sie interessant sein. Ich habe dasselbe von pmg geschriebene Programm wiederverwendet und es in eine .so(shared object)-Datei kompiliert

Der folgende Inhalt ist nach dem Ablegen der .so-Datei in etwas für Menschen lesbar

0000000000000675 f1: Adresse der Funktion f1

000000000000068c f2: Adresse der Funktion f2(staticc).

Beachten Sie den Unterschied in der Funktionsadresse, es bedeutet etwas. Für eine Funktion, die mit einer anderen Adresse deklariert ist, kann dies sehr gut bedeuten, dass f2 sehr weit entfernt oder in einem anderen Segment der Objektdatei lebt.

Linker verwenden etwas namens PLT (Procedure Linkage Table) und GOT (Global Offsets Table), um Symbole zu verstehen, auf die sie Zugriff haben.

Stellen Sie sich vorerst vor, dass GOT und PLT alle Adressen auf magische Weise binden und ein dynamischer Abschnitt Informationen zu all diesen Funktionen enthält, die für den Linker sichtbar sind.

Nach dem Sichern des dynamischen Abschnitts der .so-Datei erhalten wir eine Reihe von Einträgen, die uns aber nur interessieren f1 und f2 Funktion.

Der dynamische Abschnitt enthält nur den Eintrag für f1 Funktion unter Adresse 0000000000000675 und nicht für f2 !

Num: Wert Größe Typ Bind Vis Ndx Name

 9: 0000000000000675    23 FUNC    GLOBAL DEFAULT   11 f1

Und das ist es !. Daraus ist klar, dass der Linker beim Auffinden der nicht erfolgreich sein wird f2 funktionieren, da sie nicht im dynamischen Abschnitt der .so-Datei enthalten ist.

Wenn der Zugriff auf einige Funktionen eingeschränkt werden muss, verwenden wir das Schlüsselwort static beim Definieren und Deklarieren einer Funktion.

            /* file ab.c */ 
static void function1(void) 
{ 
  puts("function1 called"); 
} 
And store the following code in another file ab1.c

/* file ab1.c  */ 
int main(void) 
{ 
 function1();  
  getchar(); 
  return 0;   
} 
/* in this code, we'll get a "Undefined reference to function1".Because function 1 is declared static in file ab.c and can't be used in ab1.c */