Membuat Nilai Variabel Tidak Berubah pada Bahasa C Menggunakan Konstanta Qualifier

Dalam bahasa pemrograman C, terdapat konsep konstanta dan kualifikasi konstanta yang dapat digunakan untuk memastikan bahwa nilai suatu variabel tidak berubah selama eksekusi program. Artikel ini akan membahas penggunaan konstanta qualifier dalam Bahasa C dan bagaimana hal ini dapat memberikan kepastian terhadap ketidakberubahannya suatu variabel.

Sebelum mempelajari lebih lanjut materi tentang cara Membuat Nilai Variabel Tidak Berubah pada Bahasa C Menggunakan Konstanta Qualifier, terlebih dahulu pelajari materi tentang: Variabel Static Bahasa C dan Fungsinya, Nilai Default Variabel Static Bahasa C dan Fungsinya, dan Volatile Bahasa C dan Fungsinya.

Pengenalan Konstanta Qualifier

Konstanta qualifier adalah kualifikasi tambahan yang dapat diterapkan pada deklarasi variabel untuk menentukan sifat konstan dari variabel tersebut. Ada dua jenis konstanta qualifier utama dalam Bahasa C: const dan volatile. Dalam konteks ini, pengembang akan berfokus pada penggunaan const untuk menjamin ketidakberubahannya suatu variabel.

Contoh:

#include <stdio.h>

int main() {

// Deklarasi variabel konstan

const int nilaiKonstan = 42;

// Upaya untuk mengubah nilai

// variabel konstan akan

// menghasilkan kesalahan

// nilaiKonstan = 30;  

// Uncomment baris ini akan

// menyebabkan kesalahan

// Penggunaan nilai variabel

// konstan

printf("Nilai variabel

 konstan: %d\n",

 nilaiKonstan);

return 0;}

Pada contoh sebelumnya, variabel nilaiKonstan dideklarasikan dengan menggunakan const, yang memberitahu kompilator bahwa nilai variabel ini tidak dapat diubah setelah diberikan nilai awal.

Const Qualifier dapat diterapkan untuk pendeklarasian dari variabel apapun untuk menentukan bahwa nilai dari variabel tersebut tidak dapat diubah sama sekali, dan bergantung pada nilai variabel dimana variabel const tersebut disimpan. Namun, nilai dari variabel tersebut tetap bisa dilakukan pengubahan dari variabel const jika menggunakan pointer. 

satu, Pointer ke variabel

Sintak: int *ptr;

Dapat dilakukan perubahan nilai dari ptr dan juga dapat dilakukan pengubahan nilai dari object ptr yang dituju pada program. Dimana, Pointer dan nilai pointer yang dituju tersebut, keduanya disimpan pada area read-write. Perhatikan potongan kode program berikut ini.

Contoh:

#include <stdio.h>

 

int main(void)

{

int i = 10;

int j = 20;

int *ptr = &i;

 

// pointer ke bilangan bulat

printf("*ptr: %d\n", *ptr);

 

// pointer yang menunjuk ke

// variabel lainnya

ptr = &j;

printf("*ptr: %d\n", *ptr);

 

// Dapat dilakukan perubahan

// nilai yang disimpan melalui

// pointer

*ptr = 100;

printf("*ptr: %d\n", *ptr);

 

return 0;

}

Output:

*ptr: 10
*ptr: 20
*ptr: 100

dua, Pointer menuju Konstanta
Pointer ke konstanta dapat dideklarasikan dengan dua cara, yaitu:

Sintak: const int *ptr; atau dengan cara int const *ptr;

Karena dapat dilakukan perubahan pointer ke nilai variabel, maka tidak bisa dilakukan perubahan nilai dari object (atau entitas) yang dituju dengan menggunakan pointer ptr. Pointer akan disimpan dalam area read-write (bertumpuk pada present case), dimana Object yang ditunjuk pointer mungkin berada pada area read-only atau pada area read-write yang berbeda. Perhatikan contoh program berikut ini.

Contoh:

#include <stdio.h>

 

int main(void)

{

int i = 10;

int j = 20;

 

// ptr adalah pointer ke

// konstanta

const int *ptr = &i; 

 

printf("ptr: %d\n", *ptr);

// error: Objek yang dituju

// pointer tidak dapat

// dimodifikasi menggunakan

// pointer ptr 

*ptr = 100;

 

ptr = &j;   /* valid */

printf("ptr: %d\n", *ptr);

 

return 0;

}

Output:

error: assignment of read-only location ‘*ptr’

Perhatikan contoh lainnya dari program dimana variabel i adalah konstanta.

Contoh:

#include <stdio.h>

 

int main(void)

{

// i adalah variabel yang

// disimpan dalam area read

// only (hanya dapat dibaca)

int const i = 10; 

int j = 20;

 

// pointer to integer

// constant. Here i is of type

// "const int", and &i is of

// type "const int *". And p

// is of type "const int".

 

// Jika tipe datanya cocok,

// maka tidak akan terdapat

// masalah apapun.

int const *ptr = &i;  

 

printf("ptr: %d\n", *ptr);

 

/* error */

*ptr = 100;  

 

// bernilai valid, atau

// memenuhi kualifikasi. 

 

// pada bahasa C atau C++,

// tipe data dari "int *"

// diijinkan untuk memenuhi

// kualifikasi tipe "const

// int".

 

// Tipe & j adalah "int *" dan

// secara implisit

// dikualifikasi oleh

// kompilator menjadi "const

// int *"

 

ptr = &j;  

printf("ptr: %d\n", *ptr);

 

return 0;

}

Output:

error: assignment of read-only location ‘*ptr’

Baca Juga:

• Inisialisasi Variabel Statik Bahasa C dan Larangannya
• Keyword Register Bahasa C dan Fungsinya
• Mencetak dan Menginput Nilai Bahasa C menggunakan Printf dan Scanf
• Getchar dan Putchar Bahasa C Beserta Fungsinya

Kualifikasi lebih rendah (down qualification) tidak ijinkan pada bahasa pemrograman C++, begitupun juga pada bahasa C yang akan menyebabkan munculnya pesan peringatan pada program. Perhatikan contoh lain dari program dengan kualifikasi lebih rendah (down qualification) berikut.

Contoh:

#include <stdio.h>

 

int main(void)

{

int i = 10;

int const j = 20;

 

// ptr adalah pointer yang

// menuju ke objek integer.

int *ptr = &i;

 

printf("*ptr: %d\n", *ptr);

 

// Operator penugasan berikut

// akan bernilai invalid pada

// bahasa C++, dan juga akan

// mengahsilkan error pada

// bahasa C berupa pesan

// peringantan bahaya, namun

// casting tersebut tetap

// diperbolehkan secara

// implisit.

ptr = &j;

 

// Pada bahasa C++, proses

// dari operator tersebut

// disebut dengan 'down

// qualificatiaon'.

 

// Tipe dari ekspresi &j

// adalah "const int *" dan

// tipe dari ptr adalah "int

// *".

 

// Operator penugasan "ptr =

// &j" menyebabkan implikasi

// dihilangkannya konstanta

// dari ekspresi &j.

 

// C++ menjadi tipe yang lebih

// restrictif dan tidak

// memberikan ijin untuk down

// qualification.

 

// Namun demikian, C++ tetap

// memungkinkan kualifikasi

// secara implisit.

 

// Alasannya, identifier

// koalifikasi konstanta

// terikat untuk ditempatkan

// pada memori read-only

// (namun tidak selalu).

 

// Jika C ++ mengizinkan jenis

// penugasan sebelumnya (ptr =

// & j), maka dapat digunakan

// 'ptr' untuk mengubah nilai

// j yang ada di memori

// read-only.

 

// Konsekuensinya bergantung

// pada implementasi, program

// mungkin akan gagal saat

// dijalankan.

 

// Jadi pemeriksaan jenis yang

// ketat membantu membersihkan

// kode untuk mengurangi

// kesalahan.

 

printf("*ptr: %d\n", *ptr);

 

return 0;

}

tiga, Konstanta pointer ke variabel.

Sintak: int *const ptr;

Berikut adalah contoh bentuk konstanta pointer ke variabel integer, dimana dapat dilakukan perubahan nilai dari object yang dituju oleh pointer (integer), tetapi tidak bisa melakukan perubahan nilai pointer untuk menunjuk ke nilai lainnya.

Contoh:

#include <stdio.h>

 

int main(void)

{

int i = 10;

int j = 20;

 

// Konstanta pointer ke

// integer.

int *const ptr = &i; 

 

printf("ptr: %d\n", *ptr);

 

*ptr = 100; /* valid */

printf("ptr: %d\n", *ptr);

 

ptr = &j;  /* error */

return 0;

}

Output:

error: assignment of read-only variable ‘ptr’

empat, Konstanta pointer ke konstanta.

Sintak: const int *const ptr;

Berikut adalah contoh deklarasi program pointer yang menuju ke variabel konstanta, atau dengan kata lain tidak dapat dilakukan perubahan nilai yang ditunjuk oleh pointer seperti halnya tidak bisa menunjuk pointer ke variabel lainnya. Perhatikan contoh program berikut ini.

Contoh:

#include <stdio.h>

 

int main(void)

{

int i = 10;

int j = 20;

 

// Konstanta pointer ke konstanta integer

const int *const ptr = &i;  

 

printf("ptr: %d\n", *ptr);

 

ptr = &j;  /* error */

*ptr = 100; /* error */

 

return 0;

}

Output:

error: assignment of read-only variable ‘ptr’
error: assignment of read-only location ‘*ptr’

Keuntungan Penggunaan Konstanta Qualifier:

Pencegahan Perubahan Nilai yang Tidak Diinginkan: Penggunaan const membantu mencegah perubahan nilai variabel secara tidak sengaja dalam suatu program. Jika pengembang mencoba untuk mengubah nilai variabel konstan, kompilator akan memberikan pesan kesalahan pada saat kompilasi.

Contoh:

#include <stdio.h>

int main() {

const int nilaiKonstan = 42;

// Upaya untuk mengubah nilai

// variabel konstan akan

// menghasilkan kesalahan

// nilaiKonstan = 30;  

// Uncomment baris ini akan

// menyebabkan kesalahan

return 0;}

Ketelitian dan Kejelasan Kode: Penggunaan konstanta qualifier meningkatkan ketelitian dan kejelasan kode. Saat pengembang melihat deklarasi variabel dengan const, maka pengembang dapat dengan cepat menyadari bahwa nilai variabel tersebut tidak akan berubah selama eksekusi program.

Contoh:

#include <stdio.h>

int main() {

const double pi = 3.14159;

// Penggunaan nilai variabel

// konstan

printf("Nilai pi: %lf\n", pi);

return 0;}

Optimasi Kompilator: Kompilator dapat menggunakan informasi dari konstanta qualifier untuk melakukan optimasi. Dengan mengetahui bahwa suatu variabel tidak berubah, kompilator dapat melakukan berbagai optimasi, seperti menggantikan variabel dengan nilai konstan pada saat kompilasi.

Contoh:

#include <stdio.h>

// Fungsi yang menerima

// parameter konstan

void tampilkanNilaiKonstan(const int nilai) 

{printf("Nilai konstan: %d\n",

 nilai);}

int main() {

const int nilaiKonstan = 42;

// Memanggil fungsi dengan

// variabel konstan sebagai

// argumen

    tampilkanNilaiKonstan(nilaiKonstan);

return 0;}

Dengan memahami konsep konstanta qualifier, pengembang dapat meningkatkan keamanan, kejelasan, dan efisiensi dalam pengembangan program C. Pada tahap berikutnya, pengembang dapat menjelajahi penggunaan konstanta qualifier dalam konteks fungsi, struktur data, dan aspek-aspek lanjutan lainnya.

Referensi Tambahan:

• Scanset Bahasa C dan Fungsinya
• Mencetak String Bahasa C menggunakan Puts dan Printf
• Printf %n Bahasa C dan Fungsinya
• Mencetak Simbol % Menggunakan Printf Bahasa C
• Printf, Sprintf, dan Fprintf Bahasa C Beserta Fungsinya
• Getc, Getchar, Getch, dan Getche Bahasa C Beserta Perbedaannya
• Specifier %d dan %i Bahasa C dan Fungsinya

Artikel ini akan dibaca oleh: Retta Tri Kurniawati, Rosalia Kusumawardhani, Sanistya Ardi Lestari, Satoto Murti Tomo, dan Shabela Dwi Luvietasari.

Location: Semarang, Kota Semarang, Jawa Tengah, Indonesia

Berbagi :