Dla tych przyszłych odwiedzających, którzy mogą być zainteresowani wiedzą o tych segmentach pamięci, piszę ważne punkty o segmentach pamięci 5 W C:

Niektóre głowy do góry:

1. za każdym razem, gdy program C jest wykonywany, część pamięci jest przydzielana w pamięci RAM do wykonania programu. Pamięć ta służy do przechowywania często wykonywanego kodu( dane binarne), zmiennych programu, itp. Poniższe segmenty pamięci mówią o tym samym:
2. zazwyczaj są trzy rodzaje zmiennych:
   • zmienne lokalne (nazywane również zmiennymi automatycznymi w C)
   • zmienne globalne
   • zmienne statyczne
   • możesz mieć globalne statyczne lub lokalne zmienne statyczne, ale powyższe trzy są typami nadrzędnymi.

5 segmenty pamięci w C:

1. Segment Kodu

• segment kodu, zwany także segmentem tekstowym, jest obszarem pamięci, który zawiera często wykonywane kod.
• segment kodu jest często tylko do odczytu, aby uniknąć ryzyka nadpisania przez błędy programowania, takie jak przepełnienie bufora itp.
• segment kodu nie zawiera zmiennych programu, takich jak zmienna lokalna (wywoływana również jako zmienne automatyczne W C ), zmienne globalne itp.
• w oparciu o implementację C, segment kodu może również zawierać literały ciągu tylko do odczytu. Na przykład, gdy wykonasz printf("Hello, world"), w kodzie/tekście zostanie utworzony ciąg znaków "Hello, world" segment. Możesz to sprawdzić używając polecenia size w systemie Linux.
• Czytaj dalej

Segment Danych

Segment danych jest podzielony na dwie poniższe części i zazwyczaj leży poniżej obszaru sterty lub w niektórych implementacjach powyżej stosu, ale segment danych nigdy nie leży między obszarem sterty i stosu.

2. Niezainicjalizowany segment danych

• ten segment jest również znany jako bss.
• to jest porcja pamięci który zawiera:
  1. Niezainicjalizowane zmienne globalne (W Tym zmienne wskaźnika)
  2. niezaliczone stałe zmienne globalne .
  3. Niezainicjalizowane lokalne zmienne statyczne .
• każda globalna lub statyczna zmienna lokalna, która nie jest zainicjalizowana, będzie przechowywana w niezainicjalizowanym segmencie danych
• na przykład: zmienna globalna int globalVar; lub statyczna zmienna lokalna static int localStatic; będą przechowywane w niezainicjowany segment danych.
• jeśli zadeklarujesz zmienną globalną i zainicjalizujesz ją jako 0 lub NULL, to nadal trafi ona do niezainicjalizowanego segmentu danych lub bss.
• Czytaj dalej

3. Initialized data segment

• ten segment przechowuje:
  1. inicjalizowane zmienne globalne (W Tym zmienne wskaźnika)
  2. zainicjalizowana stała globalna zmienne .
  3. zainicjalizowane lokalne zmienne statyczne .
• na przykład: zmienna globalna int globalVar = 1; lub statyczna zmienna lokalna static int localStatic = 1; będą przechowywane w zainicjalizowanym segmencie danych.
• ten segment może być dalej klasyfikowany do zainicjalizowanego obszaru tylko do odczytu i zainicjalizowanego obszaru do odczytu i zapisu . zainicjalizowane stałe zmienne globalne wejdą do zainicjowanego obszaru tylko do odczytu, podczas gdy zmienne, których wartości można modyfikować w trybie runtime, wejdą do obszaru tylko do odczytu. inicjalizacja obszaru odczytu i zapisu .
• Rozmiar tego segmentu zależy od wielkości wartości w kodzie źródłowym programu i nie zmienia się w czasie wykonywania.
• Czytaj dalej

4. Segment Stosu

• segment stosu służy do przechowywania zmiennych, które są tworzone wewnątrz funkcji ( funkcja może być funkcją główną lub funkcją zdefiniowaną przez użytkownika ), zmienna jak
  1. Local zmienne funkcji (W Tym zmienne wskaźnika)
  2. argumenty przekazywane do funkcji
  3. adres zwrotny
• zmienne przechowywane w stosie zostaną usunięte po zakończeniu wykonywania funkcji.
• Czytaj dalej

5. Segment Sterty

• ten segment ma wspierać dynamiczną alokację pamięci. Jeśli programista chce przydzielić trochę pamięci dynamicznie, a następnie w C odbywa się to za pomocą malloc, calloc, lub realloc metody.
• na przykład, gdy int* prt = malloc(sizeof(int) * 2) w stercie zostanie przydzielonych osiem bajtów, a adres pamięci tej lokalizacji zostanie zwrócony i zapisany w zmiennej ptr. Zmienna ptr będzie znajdować się na stosie lub segmencie danych w zależności od sposobu deklarowania/użycia.
• Czytaj dalej

Poprawiłem Twoje błędne zdania

constant data types ----->  code //wrong

Zmienne stałe lokalne - - - - - > stack

Zainicjalizowana stała globalna zmienna - - - - - > segment danych

Niezinicjalizowana stała globalna zmienna - - - - - > bss

variables declared and defined in main function  ----->  heap //wrong

Zmienne zadeklarowane i zdefiniowane w funkcji main - - - - - > stack

pointers(ex:char *arr,int *arr) ------->  heap //wrong

dynamically allocated space(using malloc,calloc) --------> stack //wrong

Pointers (np. char *arr,int *arr) -------> rozmiar zmiennej pointer będzie w stosie.

Weź pod uwagę, że przydzielasz pamięć n bajtów (używając malloc lub calloc) dynamicznie, a następnie czyniąc zmienną wskaźnikową do jej Wskazywania. Teraz, gdy n bajty pamięci znajdują się w stercie, a zmienna wskaźnika zawiera 4 bajty (jeśli 64-bitowa maszyna ma 8 bajtów), które będą przechowywane w stosie do przechowywania wskaźnika początkowego n bajtów pamięci.

Uwaga: zmienne wskaźnika mogą wskazywać pamięć dowolnego segmentu.

int x = 10;
void func()
{
int a = 0;
int *p = &a: //Now its pointing the memory of stack
int *p2 = &x; //Now its pointing the memory of data segment
chat *name = "ashok" //Now its pointing the constant string literal 
                     //which is actually present in text segment.
char *name2 = malloc(10); //Now its pointing memory in heap
...
}

Dynamicznie przydzielana przestrzeń (za pomocą malloc,calloc) --------> heap

Popularna Architektura pulpitu dzieli pamięć wirtualną procesu na kilka segmentów :

• Segment tekstowy: zawiera kod wykonywalny. Wskaźnik instrukcji przyjmuje wartości z tego zakresu.

• Segment danych: zawiera zmienne globalne(tzn. obiekty ze statycznym połączeniem). Dzieli się na dane tylko do odczytu (takie jak stałe łańcuchowe) i dane niezainicjalizowane ("BSS").

• Segment stosu: zawiera dynamiczną Pamięć dla programu, tj. wolny store ("sterta") i lokalne ramki stosu dla wszystkich wątków. Tradycyjnie stos C i sterta C rosły do segmentu stosu z przeciwnych końców, ale uważam, że praktyka została porzucona, ponieważ jest zbyt niebezpieczna.

Program C zazwyczaj umieszcza obiekty o statycznym czasie przechowywania w segmencie danych, dynamicznie przydzielane obiekty w wolnym magazynie i automatyczne obiekty na stosie wywołań wątku, w którym żyje.

W innych platformy, takie jak stary tryb rzeczywisty x86 lub urządzenia wbudowane, rzeczy mogą być oczywiście radykalnie różne.

odnoszę się do tych zmiennych tylko z perspektywy C.

Z punktu widzenia języka C liczy się tylko Zakres, Zakres, powiązanie i dostęp; dokładnie to, jak elementy są mapowane do różnych segmentów pamięci, zależy od indywidualnej implementacji, a to będzie się różnić. Standard języka w ogóle nie mówi o segmentach pamięci . Większość nowoczesnych architektur działa głównie w ten sam sposób; zmienne blokowe i funkcja argumenty zostaną przydzielone ze stosu, zakres plików i zmienne statyczne zostaną przydzielone z segmentu danych lub kodu, pamięć dynamiczna zostanie przydzielona ze sterty, niektóre stałe dane będą przechowywane w segmentach tylko do odczytu, itd.

Pointers (ex:char *arr,int *arr) -------> heap

Nie, mogą być na stosie lub w segmencie danych. Mogą wskazywać wszędzie.

• zmienne / zmienne automatyczne - - - > sekcja stosu
• dynamicznie przydzielane zmienne - - - > sekcja sterty
• inicjalizowane zmienne globalne - > sekcja danych
• Niezainicjalizowane zmienne globalne - > sekcja danych (bss)
• zmienne statyczne - > sekcja danych
• stałe łańcuchowe - > sekcja tekstowa / sekcja kodu
• Funkcje - > sekcja tekstowa / sekcja kodu
• Kod tekstu - >sekcja tekstowa / sekcja kodu
• rejestry - > rejestry procesora
• command line inputs - > environmental/command line section
• zmienne środowiskowe - > sekcja środowiskowa/wiersz poleceń