Membuat Nilai Variabel Tidak Berubah pada Bahasa C Menggunakan Konstanta Qualifier

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. 

Ilustrasi Konstanta Qualifier Bahasa C

Baca Juga:

• Hindari Contoh Berikut untuk Inisialisasi Variabel Statik Bahasa C [klik]
• 5 Fakta tentang Keyword Register pada Bahasa C [klik]
• Fakta tentang Return Printf dan Scanf pada Bahasa C [klik]
• Penjelasan Singkat, Return Getchar dan Putchar pada Bahasa C [klik]

satu, Pointer ke variabel

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:

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’

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.

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.

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’

Referensi Tambahan:

• Fakta tentang Scanset pada Bahasa C [klik]
• 4 Contoh Puts dan Printf ketika Cetak String Bahasa C [klik]
• Penjelasan Singkat, Fungsi %n Printf pada Bahasa C [klik]
• Cara Mencetak % Menggunakan Printf Bahasa C [klik]
• Perbedaan Utama Printf, Sprintf, dan Fprintf Bahasa C [klik]
• Perbedaan Utama Getc, Getchar, Getch, dan Getche pada Bahasa C [klik]
• 2 Perbedaan Utama Format Specifier %d dan %i pada Bahasa C [klik]