Co oznacza "statyczny" w C?

Jest jeszcze jedno zastosowanie, które nie jest tu uwzględnione, a jest to część deklaracji typu tablicy jako argument funkcji:

int someFunction(char arg[static 10])
{
    ...
}

W tym kontekście określa, że argumenty przekazywane do tej funkcji muszą być tablicą typu char z co najmniej 10 elementami w niej. Po więcej informacji zobacz moje pytanie tutaj .

Krótka odpowiedź ... To zależy.

1. Statyczne zdefiniowane zmienne lokalne nie tracą wartości między wywołaniami funkcji. Innymi słowy są zmiennymi globalnymi, ale mają zasięg do lokalnej funkcji, w której są zdefiniowane.

2. Statyczne zmienne globalne nie są widoczne poza plikiem C, w którym są zdefiniowane.

3. Funkcje statyczne nie są widoczne poza plikiem C, w którym są zdefiniowane.

Przykład zakresu zmiennych wielu plików

A. c :

#include <stdio.h>

/*
Undefined behavior: already defined in main.
Binutils 2.24 gives an error and refuses to link.
https://stackoverflow.com/questions/27667277/why-does-borland-compile-with-multiple-definitions-of-same-object-in-different-c
*/
/*int i = 0;*/

/* Works in GCC as an extension: https://stackoverflow.com/a/3692486/895245 */
/*int i;*/

/* OK: extern. Will use the one in main. */
extern int i;

/* OK: only visible to this file. */
static int si = 0;

void a() {
    i++;
    si++;
    puts("a()");
    printf("i = %d\n", i);
    printf("si = %d\n", si);
    puts("");
}

Main.c:

#include <stdio.h>

int i = 0;
static int si = 0;

void a();    

void m() {
    i++;
    si++;
    puts("m()");
    printf("i = %d\n", i);
    printf("si = %d\n", si);
    puts("");
}

int main() {
    m();
    m();
    a();
    a();
    return 0;
}

Kompilacja :

gcc -c a.c -o a.o
gcc -c main.c -o main.o
gcc -o main main.o a.o

Wyjście :

m()
i = 1
si = 1

m()
i = 2
si = 2

a()
i = 3
si = 1

a()
i = 4
si = 2

Interpretacja

• istnieją dwie oddzielne zmienne dla si, po jednej dla każdego pliku
• istnieje jedna wspólna zmienna dla i

Jak zwykle, im mniejszy zakres, tym lepiej, więc zawsze deklaruj zmienne static jeśli możesz.

W programowaniu C, pliki są często używane do reprezentowania "klas", A zmienne static reprezentują prywatne statyczne elementy klasy.

Co mówią o tym standardy

C99 N1256 draft 6.7.1 "storage-class specifiers" mówi, że static jest "storage-class specifier".

6.2.2/3 "powiązania identyfikatorów" mówi static implikuje internal linkage:

Jeśli deklaracja identyfikatora zakresu pliku dla obiektu lub funkcji zawiera statyczny specyfikator klasy storage, identyfikator ma wewnętrzne powiązanie.

I 6.2.2 / 2 mówi, że internal linkage zachowuje się tak jak w naszym przykładzie:

W zbiorze jednostek tłumaczeniowych i bibliotek tworzących cały program, każda deklaracja określonego identyfikatora z powiązaniem zewnętrznym oznacza ten sam obiekt lub funkcję. W ramach jednej jednostki tłumaczeniowej każda deklaracja identyfikatora z wewnętrznym powiązaniem oznacza ten sam obiekt lub funkcję.

Gdzie " jednostka tłumaczenia jest plikiem źródłowym po wstępnym przetworzeniu.

Jak GCC implementuje go dla Elf (Linux)?

Z oprawą STB_LOCAL.

Jeśli skompilujemy:

int i = 0;
static int si = 0;

I demontować tabelę symboli za pomocą:

readelf -s main.o

Wyjście zawiera:

Num:    Value          Size Type    Bind   Vis      Ndx Name
  5: 0000000000000004     4 OBJECT  LOCAL  DEFAULT    4 si
 10: 0000000000000000     4 OBJECT  GLOBAL DEFAULT    4 i

Więc wiązanie jest jedyną istotną różnicą między nimi. Value jest tylko ich przesunięciem do .bss sekcji, więc spodziewamy się, że będzie inaczej.

STB_LOCAL jest udokumentowane w specyfikacji ELF na http://www.sco.com/developers/gabi/2003-12-17/ch4.symtab.html :

Symbole lokalne STB_LOCAL nie są widoczne poza plikiem obiektu zawierającym ich definicję. Lokalne symbole o tej samej nazwie mogą istnieć w wielu plikach bez ingerencji ze sobą]}

Co czyni go idealnym wyborem do reprezentowania static.

Zmienne bez statycznych to STB_GLOBAL, A spec mówi:

Gdy link edytor łączy kilka relokowalnych plików obiektowych, nie pozwala na wielokrotne definiowanie symboli STB_GLOBAL o tej samej nazwie.

Który jest spójny z błędami łącza w wielu niestatycznych definicjach.

Jeśli podkręcimy optymalizację za pomocą -O3, symbol si zostanie całkowicie usunięty z tabeli symboli: i tak nie może być używany z zewnątrz. TODO po co w ogóle trzymać statyczne zmienne w tabeli symboli, Gdy nie ma optymalizacji? Czy można je stosować do cokolwiek? Może do debugowania.

Zobacz też

• analogiczne dla static Funkcje: https://stackoverflow.com/a/30319812/895245
• porównaj static z extern, co robi "odwrotnie": jak używać extern do współdzielenia zmiennych między plikami źródłowymi?

Spróbuj sam

Przykład na github do zabawy.

To zależy:

int foo()
{
   static int x;
   return ++x;
}

Funkcja zwróci 1, 2, 3 itd. --- zmienna nie znajduje się na stosie.

A. C:

static int foo()
{
}

Oznacza to, że ta funkcja ma Zakres tylko w tym pliku. Tak więc a. C i b.C mogą mieć różne foo()s, a foo nie jest wystawione na współdzielone obiekty. Więc jeśli zdefiniowałeś foo w a. c, nie możesz uzyskać do niego dostępu z b.c ani z innych miejsc.

W większości bibliotek C wszystkie funkcje " prywatne "są statyczne, a większość" Publiczna " nie.

Ludzie mówią, że 'statyczny' w C ma dwa znaczenia. Oferuję alternatywny sposób oglądania, który nadaje mu jedno znaczenie:

• Zastosowanie 'static' do elementu wymusza, że element ma dwie właściwości: (a) nie jest widoczny poza bieżącym zakresem; (b) jest trwały.

Powodem, dla którego wydaje się mieć dwa znaczenia, jest to, że w C każdy element, do którego może być zastosowany "statyczny" ma już jedną z tych dwóch właściwości, więc wydaje się tak, jakby szczególne użycie dotyczy tylko drugiego.

Na przykład rozważmy zmienne. Zmienne zadeklarowane poza funkcjami mają już trwałość (w segmencie danych), więc zastosowanie "statycznego" może tylko sprawić, że nie będą widoczne poza bieżącym zakresem (Jednostka kompilacji). Przeciwnie, zmienne zadeklarowane wewnątrz funkcji już nie mają widoczności poza bieżącym zakresem (funkcją), więc stosowanie "statycznych" może tylko sprawić, że będą trwałe.

Zastosowanie 'statycznego' do funkcji jest tylko podobnie jak stosowanie go do zmiennych globalnych-kod jest koniecznie trwały (przynajmniej w obrębie języka), więc tylko widoczność może być zmieniona.

UWAGA: te komentarze odnoszą się tylko do C. W C++ stosowanie' statycznych ' metod klasowych naprawdę nadaje słowu kluczowemu inne znaczenie. Podobnie dla rozszerzenia tablicy C99.

static oznacza różne rzeczy w różnych kontekstach.

1. Możesz zadeklarować zmienną statyczną w funkcji C. Ta zmienna jest widoczna tylko w funkcji, ale zachowuje się jak globalna, ponieważ jest inicjalizowana tylko raz i zachowuje swoją wartość. W tym przykładzie za każdym razem, gdy wywołasz foo(), wyświetli rosnącą liczbę. Zmienna statyczna jest inicjalizowana tylko raz.

   void foo ()
   {
   static int i = 0;
   printf("%d", i); i++
   }
   

2. Innym zastosowaniem statycznych jest implementacja funkcji lub globalne zmienna w a .plik c, ale nie chce, aby jego symbol był widoczny poza .obj wygenerowanym przez plik. np.

   static void foo() { ... }
   

Z Wikipedii:

w języku programowania C, static jest używany z globalnymi zmiennymi i funkcjami, aby ustawić ich zakres na plik zawierający. W zmiennych lokalnych zmienna statyczna jest używana do przechowywania zmiennej w statycznie przydzielonej pamięci zamiast automatycznie przydzielonej pamięci. Podczas gdy język nie dyktuje implementacji żadnego z typów pamięci, statycznie przydzielana pamięć jest zwykle zarezerwowana w segmencie danych programu podczas kompilacji czasu, podczas gdy automatycznie przydzielana pamięć jest normalnie zaimplementowana jako tymczasowy stos wywołań.

Nienawidzę odpowiadać na Stare pytanie, ale chyba nikt nie wspomniał, jak k & r wyjaśnia to w sekcji A4.1 "języka programowania C".

W skrócie słowo static używane jest z dwoma znaczeniami:

1. statyczna jest jedną z dwóch klas pamięci (druga to automatyczny). Obiekt statyczny zachowuje swoją wartość między wywołaniami. Obiekty zadeklarowane poza wszystkimi blokami są zawsze statyczne i nie mogą być wykonane automatycznie.
2. Ale kiedy static słowo kluczowe (duży nacisk na to, że jest używany w kod jako słowo kluczowe) jest używany z deklaracją, daje temu obiektowi wewnętrzne powiązanie, więc może być używany tylko w tej jednostce tłumaczenia. Ale jeśli słowo kluczowe jest użyte w funkcji, to zmienia klasę przechowywania obiektu (obiekt i tak będzie widoczny tylko w tej funkcji). Przeciwieństwem statycznego jest słowo kluczowe extern, które daje obiektowi zewnętrzne powiązanie.

• wewnątrz funkcji zachowuje jej wartość między wywołaniami.
• na poziomie funkcji, widoczna tylko w tym pliku.

Jeśli zadeklarujesz zmienną w funkcji statycznej, jej wartość nie będzie przechowywana na stosie wywołań funkcji i nadal będzie dostępna po ponownym wywołaniu funkcji.

Jeśli zadeklarujesz statyczną zmienną globalną, jej zakres będzie ograniczony do pliku, w którym ją zadeklarowałeś. Jest to nieco bezpieczniejsze niż zwykły globalny, który można czytać i modyfikować w całym programie.

W C, statyczny ma dwa znaczenia, w zależności od zakresu jego zastosowania. W obszarze globalnym, gdy obiekt jest zadeklarowany na poziomie pliku, oznacza to, że obiekt ten jest widoczny tylko w tym pliku.

W każdym innym zakresie deklaruje obiekt, który zachowa swoją wartość między różnymi czasami, w których dany zakres jest wprowadzany. Na przykład, jeśli int jest delcared w ramach procedury:

void procedure(void)
{
   static int i = 0;

   i++;
}

Wartość " i " jest inicjalizowana na zero przy pierwszym wywołaniu procedury, a wartość jest zatrzymywana przy każdym wywołaniu procedury. jeśli' i ' zostałoby wydrukowane, otrzymywałoby sekwencję 0, 1, 2, 3,...

Jeśli zadeklarujesz to w mytest.plik c:

static int my_variable;

Wtedy ta zmienna może być widoczna tylko z tego pliku. Zmiennej nie można wyeksportować nigdzie indziej.

Jeśli zadeklarujesz wewnątrz funkcji, wartość zmiennej zachowa swoją wartość za każdym razem, gdy funkcja zostanie wywołana.

Statyczna funkcja nie może być eksportowana spoza pliku. Więc w *.plik c, ukrywasz funkcje i zmienne, jeśli zadeklarujesz je statyczne.

Ważne jest, aby zauważyć, że statyczne zmienne w funkcjach są inicjalizowane przy pierwszym wejściu do tej funkcji i utrzymują się nawet po zakończeniu ich wywołania; w przypadku funkcji rekurencyjnych statyczna zmienna jest inicjalizowana tylko raz i utrzymuje się przez wszystkie wywołania rekurencyjne, a nawet po zakończeniu wywołania funkcji.

Jeśli zmienna została utworzona poza funkcją, to znaczy, że programista może używać zmiennej tylko w plik źródłowy zmiennej został zadeklarowany.

Należy również pamiętać, że static może być używany na 4 różne sposoby.

to create permanent storage for local variables in a function.
to specify internal linkage.
to declare member functions that act like non-member functions.
to create a single copy of a data member.

Zmienna statyczna jest specjalną zmienną, której można użyć w funkcji i zapisuje dane między wywołaniami, a nie usuwa ich między wywołaniami. Na przykład:

void func(){
    static int count; // If you don't declare its value, the value automatically initializes to zero
    printf("%d, ", count);
    count++;
}

void main(){
    while(true){
        func();
    }
}

Wyjście:

0, 1, 2, 3, 4, 5, ...

Zmienne statyczne w C mają czas życia programu.

Jeśli są zdefiniowane w funkcji, mają zasięg lokalny, tzn. mogą być dostępne tylko wewnątrz tych funkcji. Wartość zmiennych statycznych jest zachowywana pomiędzy wywołaniami funkcji.

Na przykład:

void function()
{
    static int var = 1;
    var++;
    printf("%d", var);
}

int main()
{
    function(); // Call 1
    function(); // Call 2
}

W powyższym programie, var jest przechowywany w segmencie danych. Jego żywotność to cały program C.

Po wywołaniu funkcji 1, var staje się 2. Po wywołaniu funkcji 2, var staje się 3.

Wartość var nie jest niszczona pomiędzy wywołaniami funkcji.

Gdyby var miała zmienną niestatyczną i lokalną, byłaby przechowywana w segmencie stosu w programie C. Ponieważ ramka stosu funkcji jest niszczona po jej powrocie, wartość var jest również niszczona.

Zainicjalizowane zmienne statyczne są przechowywane w segmencie danych programu C, podczas gdy niezinicjalizowane są przechowywane w segmencie BSS.

Kolejna informacja o static: jeśli zmienna jest globalna i statyczna, ma czas życia programu C, ale ma zakres plików. Jest widoczny tylko w tym pliku.

Aby spróbować:

File1.c

static int x;

int main()
{
    printf("Accessing in same file%d", x):
}

File2.c

    extern int x;
    func()
    {
        printf("accessing in different file %d",x); // Not allowed, x has the file scope of file1.c
    }

run gcc -c file1.c

gcc -c file2.c

Teraz spróbuj połączyć je za pomocą:

gcc -o output file1.o file2.o

Dałoby to błąd linkera, ponieważ X ma zakres pliku file1.c i linker nie byłby w stanie rozwiązać odniesienia do zmiennej x używanej w file2.c.

Bibliografia:

1. http://en.wikipedia.org/wiki/Translation_unit_ (programowanie)
2. http://en.wikipedia.org/wiki/Call_stack

Wartość zmiennej statycznej utrzymuje się pomiędzy różnymi wywołaniami funkcji, a jej zakres jest ograniczony do bloku lokalnego statyczna zmienna zawsze inicjalizuje się wartością 0

Są 2 przypadki:

(1) zmienne lokalne zadeklarowane static: przydzielone w segmencie danych zamiast stosu. Jego wartość zachowuje się po ponownym wywołaniu funkcji.

(2) globalne zmienne lub funkcje zadeklarowane static: niewidoczne poza jednostką kompilacji(tzn. są lokalnymi symbolami w tabeli symboli podczas łączenia).