Cara menggunakan enum dalam Bahasa C

Program enum dalam bahasa pengaturcaraan C digunakan untuk menentukan nilai-nilai pemalar integral, yang sangat membantu dalam menulis program yang bersih dan dapat dibaca. Pengaturcara biasanya menggunakan penghitungan untuk menentukan pemalar integral bernama dalam program mereka untuk memberikan keterbacaan dan kebolehperaturan perisian yang lebih baik. Artikel ini akan membincangkan enum secara terperinci.

Sintaks

enum
Penghitungan_Konstant_Elemen-1,
Penghitungan_Konstant_Elemen-2,
Penghitungan_Konstant_Elemen-3,
… ,
Penghitungan_Konstant_Elemen-n,
;

Nilai lalai Enumeration_Constant_Element-1 adalah 0, nilai Enumeration_Constant_Element-2 adalah 1, nilai Enumeration_Constant_Element-3 adalah 2, dan nilai Enumeration_Constant_Element-n adalah (n-1).

Selami Deep Enum

Sekarang, kerana kita tahu sintaks untuk menentukan jenis penghitungan, mari kita lihat contohnya:

ralat enum
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
;

Kata kunci "enum" mesti selalu digunakan untuk menentukan jenis penghitungan. Jadi, setiap kali anda ingin menentukan jenis penghitungan, anda mesti menggunakan kata kunci "enum" sebelumnya . Selepas kata kunci "enum", anda mesti menggunakan pengecam yang sah untuk menentukan .

Dalam contoh di atas, penyusun akan menetapkan IO_ERROR ke nilai kamiran: 0, DISK_ERROR ke nilai kamiran: 1 dan NETWORK_ERROR ke nilai kamiran: 2. Secara lalai, elemen enum pertama selalu diberi nilai 0, elemen enum seterusnya diberi nilai 1, dan seterusnya.

Tingkah laku lalai ini dapat diubah jika perlu dengan memberikan nilai kamiran tetap secara eksplisit, seperti berikut:

ralat enum
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8 ,
PRINT_ERROR
;

Dalam kes ini, IO_ERROR secara eksplisit diberikan kepada nilai 2 oleh pengaturcara, DISK_ERROR ditugaskan untuk nilai 3 oleh penyusun, NETWORK_ERROR secara eksplisit diberikan kepada nilai 8 oleh pengaturcara, dan PRINT_ERROR ditugaskan ke seterusnya nilai kamiran elemen enum sebelumnya NETWORK_ERROR (i.e., 9) oleh penyusun.

Oleh itu, anda kini memahami cara menentukan jenis penghitungan yang ditentukan pengguna dalam C. Adakah mungkin untuk menyatakan pemboleh ubah jenis enum (kerana kita dapat menyatakan pemboleh ubah jenis bilangan bulat)? Ya betul! Anda boleh menyatakan pemboleh ubah enum seperti berikut:

enum Ralat Hw_Error;

Sekali lagi, "enum" adalah kata kunci di sini, "Ralat" adalah jenis enum, dan "Hw_Error" adalah pemboleh ubah enum.

Kami sekarang akan melihat contoh berikut untuk memahami pelbagai penggunaan enum:

Contoh 1: Penggunaan definisi enum lalai
Contoh 2: Penggunaan definisi enum tersuai
Contoh 3: definisi enum menggunakan ungkapan malar
Contoh 4: skop enum

Contoh 1: Penggunaan Definisi enum lalai

Dalam contoh ini, anda akan belajar bagaimana menentukan jenis penghitungan dengan nilai tetap lalai. Penyusun akan mengurus menetapkan nilai lalai ke elemen enum. Di bawah ini, anda akan melihat program contoh dan output yang sesuai.

#sertakan
/ * Tentukan jenis enum * /
ralat enum
IO_ERROR,
DISK_ERROR,
NETWORK_ERROR
;
int utama ()

enum Ralat Hw_Error; / * Membuat pemboleh ubah enum * /
printf ("Menetapkan Hw_Error ke IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
pulangan 0;

Contoh 2: Penggunaan Definisi enum tersuai

Dalam contoh ini, anda akan belajar bagaimana menentukan jenis penghitungan dengan nilai pemalar tersuai. Juga, contoh ini akan membantu anda memahami bagaimana inisial pemalar tersuai dapat dilakukan dalam urutan rawak. Dalam contoh ini, kami telah secara jelas menentukan nilai pemalar untuk 1^st dan 3^rd elemen enum (i.e., IO_ERROR dan NETWORK_ERROR, masing-masing), tetapi kami telah melangkau permulaan eksplisit untuk 2^nd dan 4^ika unsur. Sekarang menjadi tanggungjawab penyusun untuk menetapkan nilai lalai ke 2^nd dan 4^ika elemen enum (i.e., DISK_ERROR dan PRINT_ERROR, masing-masing). DISK_ERROR akan diberikan pada nilai 3 dan PRINT_ERROR akan diberikan pada nilai 9. Di bawah ini, anda akan melihat contoh program dan outputnya.

#sertakan
/ * Tentukan jenis enum - Permulaan khusus * /
ralat enum
IO_ERROR = 2,
DISK_ERROR,
NETWORK_ERROR = 8,
PRINT_ERROR
;
int utama ()

/ * Nyatakan pemboleh ubah enum * /
enum Ralat Hw_Error;
printf ("Menetapkan Hw_Error ke IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
pulangan 0;

Contoh 3: Definisi Enum Menggunakan Ekspresi Tetap

Dalam contoh ini, anda akan belajar bagaimana menggunakan ungkapan malar untuk menentukan nilai malar bagi elemen enum.

#sertakan
/ * Tentukan jenis enum - inisialisasi khusus menggunakan ungkapan malar
ungkapan malar digunakan di sini sekiranya:
a. IO_ERROR dan
b. NETWORK_ERROR
Ini adalah cara yang tidak biasa untuk menentukan elemen enum; namun, ini
program menunjukkan bahawa cara inisialisasi elemen enum ini adalah mungkin di c.
* /
ralat enum
IO_ERROR = 1 + 2 * 3 + 4,
DISK_ERROR,
NETWORK_ERROR = 2 == 2,
PRINT_ERROR
;
int utama ()

/ * Nyatakan pemboleh ubah enum * /
enum Ralat Hw_Error;
printf ("Menetapkan Hw_Error ke IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
pulangan 0;

Contoh 4: Skop enum

Dalam contoh ini, anda akan belajar bagaimana peraturan pemarkahan berfungsi untuk enum. MACRO (#define) boleh digunakan untuk menentukan pemalar dan bukannya enum, tetapi peraturan pemarkahan tidak berfungsi untuk MACRO.

#sertakan
int utama ()

/ * Tentukan jenis enum * /
ralat enum_1
IO_ERROR = 10,
DISK_ERROR,
NETWORK_ERROR = 3,
PRINT_ERROR
;

/ * Tentukan jenis enum dalam ruang lingkup dalaman * /
ralat enum_1
IO_ERROR = 20,
DISK_ERROR,
NETWORK_ERROR = 35,
PRINT_ERROR
;
/ * Nyatakan pemboleh ubah enum * /
enum Ralat_1 Hw_Error;
printf ("Menetapkan Hw_Error ke IO_ERROR \ n");
Hw_Error = IO_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke DISK_ERROR \ n");
Hw_Error = DISK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke NETWORK_ERROR \ n");
Hw_Error = NETWORK_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);
printf ("\ nMenetapkan Hw_Error ke PRINT_ERROR \ n");
Hw_Error = PRINT_ERROR;
printf ("Nilai Hw_Error =% d \ n", Hw_Error);

pulangan 0;

Perbandingan Antara enum dan makro

Enum

Makro

Peraturan scoping berlaku untuk enum.

Peraturan scoping tidak berlaku untuk Makro.

Penugasan nilai Enum lalai berlaku secara automatik.

Enum sangat membantu dalam menentukan sebilangan besar pemalar. Penyusun mengambil inisialisasi nilai malar lalai.

Nilai pemalar makro mesti selalu disebut secara jelas oleh pengaturcara.

Ini boleh menjadi proses yang membosankan untuk sebilangan besar pemalar kerana pengaturcara harus selalu menentukan setiap nilai tetap secara manual semasa menentukan Makro.

Kesimpulannya

Program enum di C dapat dianggap sebagai kaedah pilihan untuk program mandiri atau projek bersaiz kecil kerana pengaturcara selalu dapat menggunakan makro dan bukannya enum. Namun, pengaturcara berpengalaman cenderung menggunakan enum over makro untuk projek pembangunan perisian berskala besar. Ini membantu dalam menulis program yang bersih dan mudah dibaca.