Langsung ke konten utama

Konstanta Qualifier pada Bahasa C

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

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;

}

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:

#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.

#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:

#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.

#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:

#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’

Komentar

  1. Apa yang dimaksud dengan const qualifier pada bahasa C?

    BalasHapus
    Balasan
    1. Const qualifier digunakan untuk mendeklarasikan variabel sebagai suatu konstanta. Dimana variabel yang telah dideklarasikan tersebut tidak dapat dilakukan perubahan nilai setelah variabel tersebut diinisialisasi.

      Hapus
    2. Const 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.

      Hasilnya adalah implementasi yang didefinisikan jika ada upaya untuk dilakukan mengubahan const.

      Hapus
  2. Apa fungsi dari simbol "*" dan simbol "&" pada contoh program yang disajikan pada artikel yang dijelaskan sebelumnya?

    BalasHapus
    Balasan
    1. Simbol "&" 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

Posting Komentar

Respon komentar 7 x 24 jam, so please be patient :D