Membuat Nilai Variabel Tidak Berubah pada Bahasa C Menggunakan Konstanta Qualifier
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.
#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;
}
*ptr: 20
*ptr: 100
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.
#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;
}
#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;
}
#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;
}
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.
#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;
}
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.
#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;
}
error: assignment of read-only location ‘*ptr’
- 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]
Apa yang dimaksud dengan const qualifier pada bahasa C?
BalasHapusConst qualifier digunakan untuk mendeklarasikan variabel sebagai suatu konstanta. Dimana variabel yang telah dideklarasikan tersebut tidak dapat dilakukan perubahan nilai setelah variabel tersebut diinisialisasi.
HapusConst qualifier dapat diterapkan pada deklarasi variabel apapun untuk menentukan bahwa nilainya tidak akan berubah atau bergantung dimana variabel const tersebut disimpan, dimana nilai const tersebut bisa dirubah jika menggunakan pointer.
HapusHasilnya adalah implementasi yang didefinisikan jika ada upaya untuk dilakukan mengubahan const.
Apa fungsi dari simbol "*" dan simbol "&" pada contoh program yang disajikan pada artikel yang dijelaskan sebelumnya?
BalasHapusSimbol "&" pada program adalah untuk menyatakan alamat memori, sedangkan simbol "*" adalah digunakan untuk menunjuk ke nilai pada alamat memori pada suatu variabel, atau simbol dereferensi. Sedangkan tanda "**" berarti pointer menunjuk ke pointer lainnya pada suatu alamat nilai pada variabel.
Hapus