Susun atur memori dalam C

pengenalan

Susun atur memori merujuk kepada cara memori komputer disusun dan distrukturkan. Ia mentakrifkan cara memori dibahagikan dan digunakan oleh pelbagai komponen sistem.

Ini penting dalam C kerana ia memberi kesan secara langsung kepada cara pembolehubah, fungsi dan struktur data disimpan dan diakses semasa pelaksanaan.

Dalam artikel ini, kita akan belajar tentang aspek asas reka letak memori dalam C.

Segmen Dalam Reka Letak Memori C

Susun atur memori dalam C terdiri daripada segmen yang berbeza, di bawah ialah segmen;

1. Segmen Teks(Kod).
2. Segmen data.
3. Timbunan.
4. Timbunan.

Rajah di bawah menggambarkan reka letak memori C.

Sekarang mari kita bincangkan segmen secara terperinci.

Teks(kod) Segmen

Segmen teks ialah kawasan memori dalam program C yang menyimpan arahan kod mesin yang disusun. Arahan ini membentuk logik boleh laksana program dan bertanggungjawab untuk menentukan kelakuannya.

Berikut ialah contoh mudah untuk menggambarkan konsep segmen teks dalam program C:

#include <stdio.h>

int main() {
    int x = 5;
    int y = 10;
    int sum;

    sum = x + y;
    printf("The sum of %d and %d is %d\n", x, y, sum);

    return 0;
}

Pengkompil menukar kod sumber kepada kod mesin apabila atur cara ini disusun. Kod mesin ini membentuk logik dan tingkah laku program dan disimpan dalam segmen teks.

Walaupun kita tidak dapat melihat secara langsung kod mesin. Kami dapat memahami bahawa segmen teks mengandungi arahan yang disusun.

Pada asasnya, segmen teks mengandungi arahan yang mentakrifkan cara program berkelakuan apabila ia dilaksanakan.

Segmen data

Segmen data dibahagikan kepada dua bahagian:

• Segmen data yang dimulakan
• segmen data yang tidak dimulakan

Segmen Data Dimulakan

Segmen data yang dimulakan terdiri daripada pembolehubah global, luaran, statik (kedua-dua tempatan dan global) dan malar yang dimulakan terlebih dahulu. Segmen data yang dimulakan mempunyai dua bahagian, bahagian baca sahaja dan baca-tulis.

Pembolehubah dengan nilai pratakrif yang boleh diubah suai iaitu pembolehubah global, luaran dan statik (kedua-dua tempatan dan global) yang dimulakan disimpan dalam bahagian baca-tulis. Pembolehubah malar sebaliknya berada di bawah bahagian baca sahaja.

Berikut ialah contoh yang menggambarkan pembolehubah yang disimpan dalam segmen data yang dimulakan, kedua-duanya dalam bahagian baca-tulis dan baca sahaja:

#include <stdio.h>

// Global variable (read-write section)
int globalVar = 10;

// External variable declaration (read-write section)
extern int externVar;

// Static global variable (read-write section)
static int staticGlobalVar = 20;

// Constant global variable (read-only section)
const int constGlobalVar = 30;

int main() {
    globalVar += 5;
    staticGlobalVar += 10;

    printf("Global variable: %d\n", globalVar);
    printf("Extern variable: %d\n", externVar);  // Assuming externVar is defined in another file
    printf("Static global variable: %d\n", staticGlobalVar);
    printf("Constant global variable: %d\n", constGlobalVar);

    return 0;
}

Ini menggambarkan pembolehubah yang disimpan dalam bahagian baca-tulis dan baca-sahaja segmen data yang dimulakan.

Segmen Data Tidak Dimulakan

Segmen data tidak dimulakan juga dikenali sebagai BSS(Blok dimulakan dengan simbol) terdiri daripada pembolehubah global, luaran dan statik (kedua-dua tempatan dan global) yang tidak diinisialisasi.

Pembolehubah ini dimulakan kepada sifar secara lalai sebelum pelaksanaan program. Mereka mempunyai kebenaran baca-tulis. Oleh itu, membolehkan mereka dibaca dan ditulis semasa program ini dijalankan.

Contoh:

#include <stdio.h>

// Uninitialized global variable (goes to the BSS segment)
int globalVar;

// Uninitialized static global variable (also goes to the BSS segment)
static int staticGlobalVar;

int main() {
    // Uninitialized local static variable (goes to the BSS segment)
    static int staticLocalVar;

    printf("Uninitialized Global Variable: %d\n", globalVar);
    printf("Uninitialized Static Global Variable: %d\n", staticGlobalVar);
    printf("Uninitialized Static Local Variable: %d\n", staticLocalVar);
    return 0;
}

Dalam program ini, pembolehubah yang tidak dimulakan akan mengandungi nilai sifar atau nol secara lalai. Ini disebabkan oleh pemulaan automatik oleh pengkompil. Ini menunjukkan tingkah laku pembolehubah yang disimpan dalam segmen BSS.

Timbunan

Timbunan ialah kawasan memori yang digunakan untuk peruntukan memori dinamik semasa masa jalan. Ini membolehkan memori diperuntukkan dan dikeluarkan mengikut keperluan semasa pelaksanaan program. Fungsi seperti malloc(), calloc(), realloc() dan free() digunakan untuk peruntukan memori dan deallocation dalam timbunan. Timbunan itu boleh diakses oleh semua bahagian program.

Contoh:

#include <stdio.h>
#include <stdlib.h>

int main() {
    // Dynamically allocate memory for an integer variable on the heap
    int *ptr = (int *)malloc(sizeof(int));

    return 0;
    }

Coretan kod ini menunjukkan penggunaan mudah peruntukan memori dinamik dalam C. Ia menarik perhatian kepada langkah-langkah yang terlibat dalam meminta memori, memulakan penuding ke memori tersebut dan mengurus memori dengan betul untuk mengelakkan kebocoran. Walaupun pengendalian ralat dan deallokasi memori tidak disertakan dalam contoh ini, ini adalah komponen penting untuk bekerja dengan memori dinamik dalam aplikasi praktikal.

timbunan

Fungsi utama segmen tindanan adalah untuk mengurus panggilan fungsi dan menyimpan pembolehubah setempat. Bahagian ini penting dalam susun atur memori program, kerana ia mengawal aliran dalam atur cara. Tindanan menggunakan struktur Masuk Terakhir, Keluar Dahulu (LIFO), bermakna data yang paling baru ditambah dialih keluar dahulu. Ini menjadikan tindanan sangat cekap untuk mengurus pembolehubah setempat dan panggilan fungsi bersarang.

Contoh:

#include <stdio.h>

void functionA(int n) {
    int a = n + 1; // Local variable
    printf("In functionA, a = %d\n", a);
}

void functionB() {
    int b = 10; // Local variable
    printf("In functionB, b = %d\n", b);
    functionA(b); // Call to functionA
}

int main() {
    int x = 20; // Local variable
    printf("In main, x = %d\n", x);
    functionB(); // Call to functionB
    return 0;
}

The code explains how stack frames store local variables. New stack frames are created by the function calls and are eliminated when the functions return. The printf instructions facilitate the visualization of each function's local variable values. The execution flow follows the calls to and returns from functions.

Conclusion

C programmers can improve their coding techniques and gain a better understanding of how their programs interact with memory by mastering these concepts. Understanding memory layout is a vital skill in your programming toolbox, whether you're optimizing for performance or troubleshooting a complex problem.

Feel free to follow, comment, and leave claps. Happy Coding!

Let’s connect on LinkedIn.

Atas ialah kandungan terperinci Susun atur memori dalam C. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!