Penentu Storage-Class untuk Deklarasi External-Level

Variabel eksternal adalah variabel pada cakupan file. Mereka ditentukan di luar fungsi apa pun, dan berpotensi tersedia untuk banyak fungsi. Fungsi hanya dapat ditentukan pada tingkat eksternal dan, oleh karena itu, tidak dapat ditumpuk. Secara default, semua referensi ke variabel dan fungsi eksternal dengan nama yang sama adalah referensi ke objek yang sama, yang berarti mereka memiliki hubungan eksternal. (Anda dapat menggunakan kata kunci static untuk mengambil alih perilaku ini.)

Deklarasi variabel di tingkat eksternal adalah definisi variabel (menentukan deklarasi), atau referensi ke variabel yang ditentukan di tempat lain (mereferensikan deklarasi).

Deklarasi variabel eksternal yang juga menginisialisasi variabel (secara implisit atau eksplisit) adalah deklarasi variabel yang menentukan. Definisi di tingkat eksternal dapat mengambil beberapa bentuk:

• Variabel yang Anda deklarasikan dengan penentu kelas penyimpanan static. Anda dapat secara eksplisit menginisialisasi static variabel dengan ekspresi konstanta, seperti yang dijelaskan dalam Inisialisasi. Jika Anda menghilangkan penginisialisasi, variabel secara default diinisialisasi ke 0. Misalnya, kedua pernyataan ini dianggap sebagai definisi dari variabel k.

  static int k = 16;
  static int k;
  

• Variabel yang Anda inisialisasi secara eksplisit di tingkat eksternal. Misalnya, int j = 3; adalah definisi variabel j.

Dalam deklarasi variabel di tingkat eksternal (yaitu, di luar semua fungsi), Anda dapat menggunakan penentu kelas penyimpanan static atau extern atau mengabaikan penentu kelas penyimpanan sepenuhnya. Anda tidak dapat menggunakan auto terminal dan register storage-class-specifier di tingkat eksternal.

Setelah variabel ditentukan pada tingkat eksternal, variabel terlihat di seluruh unit terjemahan lainnya. Variabel tidak terlihat sebelum deklarasinya dalam file sumber yang sama. Selain itu, juga tidak terlihat dalam file sumber lain dari program, kecuali deklarasi referensi membuatnya terlihat, seperti yang dijelaskan di bawah ini.

Aturan yang berkaitan dengan static termasuk:

• Variabel yang dideklarasikan di luar semua blok tanpa kata kunci static selalu mempertahankan nilainya di seluruh program. Untuk membatasi akses mereka ke unit terjemahan tertentu, Anda harus menggunakan kata kunci static. Ini memberinya hubungan internal. Untuk membuatnya global ke seluruh program, hilangkan kelas penyimpanan eksplisit atau gunakan kata kunci extern (lihat aturan di daftar berikutnya). Ini memberinya hubungan eksternal. Hubungan internal dan eksternal juga dibahas di Hubungan.

• Anda dapat menentukan variabel di tingkat eksternal hanya sekali dalam satu program. Anda dapat menentukan variabel lain dengan nama yang sama dan penentu kelas penyimpanan static di unit terjemahan yang berbeda. Karena setiap static definisi hanya terlihat dalam unit terjemahannya sendiri, tidak ada konflik yang terjadi. Ini menyediakan cara yang berguna untuk menyembunyikan nama pengidentifikasi yang harus dibagikan di antara fungsi dari satu unit terjemahan, tetapi tidak terlihat oleh unit terjemahan lainnya.

• Penentu kelas penyimpanan static juga dapat berlaku untuk fungsi. Jika Anda menyatakan fungsi static, namanya tidak terlihat di luar file tempat fungsi tersebut dideklarasikan.

Aturan untuk menggunakan extern adalah:

• Penentu kelas penyimpanan extern mendeklarasikan referensi ke variabel yang ditentukan di tempat lain. Anda dapat menggunakan deklarasi extern untuk membuat definisi dalam file sumber lain terlihat, atau untuk membuat variabel terlihat sebelum definisinya dalam file sumber yang sama. Setelah Anda mendeklarasikan referensi ke variabel di tingkat eksternal, variabel terlihat di seluruh sisa unit terjemahan tempat referensi yang dideklarasikan terjadi.

• Agar referensi extern valid, variabel yang dirujuknya harus ditentukan sekali, dan hanya sekali, di tingkat eksternal. Definisi ini (tanpa kelas penyimpanan extern) dapat berada di salah satu unit terjemahan yang membentuk program.

Contoh

Contoh di bawah ini mengilustrasikan deklarasi eksternal:

/******************************************************************
                      SOURCE FILE ONE
*******************************************************************/
#include <stdio.h>

extern int i;                // Reference to i, defined below
extern void other ( void );  // Reference to other(), defined in second source file
void next( void );           // Function prototype

int main()
{
    i++;
    printf_s( "%d\n", i );   // i equals 4
    next();
}

int i = 3;                  // Definition of i

void next( void )
{
    i++;
    printf_s( "%d\n", i );  // i equals 5
    other();
}

/******************************************************************
                      SOURCE FILE TWO
*******************************************************************/
#include <stdio.h>

extern int i;              // Reference to i in
                           // first source file
void other( void )
{
    i++;
    printf_s( "%d\n", i ); // i equals 6
}

Dua file sumber dalam contoh ini berisi total tiga deklarasi eksternal dari i. Hanya satu deklarasi yang "menentukan deklarasi." Deklarasi itu,

int i = 3;

menentukan variabel global i dan menginisialisasinya dengan nilai awal 3. Deklarasi "referensi" dari i di bagian atas file sumber pertama yang menggunakan extern membuat variabel global terlihat sebelum deklarasi yang menentukan dalam file. Deklarasi referensi i dalam file sumber kedua juga membuat variabel terlihat dalam file sumber tersebut. Jika instans yang menentukan untuk variabel tidak disediakan di unit terjemahan, pengompilasi mengasumsikan adanya

extern int x;

deklarasi referensi dan referensi yang menentukan

int x = 0;

muncul di unit terjemahan lain dari program.

Ketiga fungsi, main, next, dan other, melakukan tugas yang sama: mereka meningkatkan i dan mencetaknya. Nilai 4, 5, dan 6 dicetak.

Jika variabel i belum diinisialisasi, variabel akan diatur ke 0 secara otomatis. Dalam hal ini, nilai 1, 2, dan 3 akan dicetak. Lihat Inisialisasi untuk informasi tentang inisialisasi variabel.

Lihat juga

Kelas Penyimpanan C