2. Pointer (variabel penunjuk)
adalah suatu variabel yang berisi
dengan alamat lokasi suatu
memori tertentu.
Jadi suatu pointer bukan berisi
dengan suatu nilai data, tetapi
berisi suatu alamat.
3. Misalnya, X adalah suatu variabel yang berisi nilai
‘J’. X bukan variabel penunjuk. Nilai dari X ini oleh
kompiler C akan diletakkan di suatu lokasi memori
tertentu. Nilai ini dapat diakses jika diketahui
alamat memorinya. Alamat dari nilai X ini dapat
diketahui dari ungkapan &X. Misalnya alamat dari
nilai X ini akan disimpan di suatu variabel, maka
dapat dituliskan sebagai Alamat_X = &X.
Alamat_X adalah variabel pointer, atau disebut
dengan pointer ke X, karena variabel ini
menunjukkan ke lokasi di mana nilai X disimpan.
4. /* --------------------------------------------
Nama Program: ADP_Pointer_1.cpp
Larik String
--------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
char *Alamat_X, X;
printf("Contoh Program Pointern");
printf("______________________n");
printf("n");
X = 'J';
Alamat_X = &X;
printf("Nilai dari Variabel X, adalah 'J' berada di alamat %pn", Alamat_X);
printf("n");
system("pause");
}
5.
6. Bahasa C menyediakan dua buah operator untuk
operasi pointer, yaitu ‘*’ dan ‘&’. Kedua operator ini
adalah operator unary.
Operator alamat ‘&’ digunakan untuk mendapatkan
alamat memori dari operandnya.
Operator ‘*’ digunakan untuk mendapatkan nilai
dari operandnya. Operand untuk operator ‘*’
adalah variabel pointer, dengan kata lain, operator
‘*’ digunakan untuk mendapatkan nilai yang
berada di alamat memori yang ditunjukkan oleh
variabel pointer
7. /* ---------------------------------------------------------
Nama Program: ADP_Pointer_2_Operator.cpp
Larik String
--------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
char *Alamat_X,X,Y,Z;
printf("Contoh Program Operator Pointern");
printf("_______________________________n");
printf("n");
X = 'J';
Alamat_X = &X;
Y = X;
Z = *Alamat_X;
printf("Nilai Variabel X adalah %cn", X);
printf("Nilai Variabel Y adalah %cn", Y);
printf("Nilai Variabel Z adalah %cn", Z);
printf("Nilai Variabel X berada di alamat %pn", Alamat_X);
printf("n");
system("pause");
}
8.
9. Variabel pointer dideklarasikan dengan
nama variabelnya ditulis dengan diawali
karakter asterik ‘*’.
Bentuk umum deklarasi variabel pointer ini
adalah:
tipe *nama-variabel-pointer;
Variabel pointer yang dideklarasikan dapat
juga langsung diberi nilai awal.
10. /* -----------------------------------------
Nama Program: ADP_Pointer_3_Deklarasi.cpp
Larik String
----------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
float Nilai, *Alamat=&Nilai;
printf("Contoh Program Deklarasi Pointern");
printf("________________________________n");
printf("n");
Nilai = 100.00;
printf("Nilai %8.2f berada di alamat memori %pn", Nilai, Alamat);
printf("n");
system("pause");
}
13. Suatu variabel pointer dapat
dikerjakan ke variabel pointer
lainnya, yaitu nilai suatu
variabel pointer dapat
dipindahkan ke variabel pointer
yang lainnya.
14. /* ---------------------------------------------------------------------------
Nama Program: ADP_Pointer_4_Operasi_Pengerjaan.cpp
Operasi Pengerjaan Pointer
--------------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
float Y, *X1, *X2;
printf("Contoh Program Operasi Pengerjaan Pointern");
printf("_________________________________________n");
printf("n");
Y = 150,97;
X1 = &Y;
X2 = X1; //Pengerjaan variabel pointer
printf("Nilai variabel Y ada di alamat %pn", X1);
printf("Nilai variabel Y ada di alamat %pn", X2);
printf("n");
system("pause");
}
15.
16. Variabel pointer dapat dilakukan operasi
aritmatika, namun hanya untuk operasi
penambahan dan pengurangan, sedangkan
operasi yang lain seperti perkalian,
pembagian, dan pemangkatan jarang
dilakukan, karena kurang berguna untuk
variabel pointer ini.
Penambahan dan pengurangan yang dapat
dilakukan untuk variabel pointer ini hanya
dengan suatu nilai integer saja, sedangkan
nilai yang lain tidak dapat dilakukan.
17. Program berikut ini akan menampilkan 10
buah data yang masing-masing
mempunyai alamat yang berbeda-beda.
18. /* -------------------------------------------------------------------------
Nama Program: ADP_Pointer_5_Operasi_Aritmatika.cpp
Operasi Aritmatika Pointer
-------------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
int I[10], *I_pointer;
double F[10], *F_pointer;
int x;
printf("Contoh Program Operasi Aritmatika Pointern");
printf("________________________________________n");
printf("n");
I_pointer = I;
F_pointer = F;
for(x=0;x<10;x++)
printf("%p %pn", I_pointer+x, F_pointer+x);
printf("n");
system("pause");
}
19.
20. Program berikut ini penambahan dan
pengurangan variabel pointer dengan variabel
pointer lainnya.
P_Awal adalah variabel pointer yang
menunjuk ke alamat memori letak elemen
larik yang pertama dan P_Akhir adalah
variabel pointer yang menunjuk ke alamat
letak elemen larik yang terakhir. Selisih dari
kedua nilai ini adalah nilai integer 4 yang
menunjukkan jumlah dari elemen lariknya.
21. /* ---------------------------------------------------
Nama Program: ADP_Pointer_5a_Operasi_Aritmatika.cpp
Operasi Aritmatika Pointer
--------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
int *P_Awal, *P_Akhir;
int X[5] = {20, 40, 60, 80, 100}, I;
int x;
printf("Contoh Program Operasi Aritmatika Pointern");
printf("_________________________________________n");
printf("n");
P_Awal = &X[0];
P_Akhir = &X[4];
printf("Alamat dari nilai elemen awal X[0] adalah %pn", P_Awal);
printf("Alamat dari nilai elemen akhir X[4] adalah %pn", P_Akhir);
printf("Dari X[0] ke X[4] ada sebanyak %d elemennn", P_Akhir-P_Awal);
for(I=0;I<=4;I++){
printf("Nilai elemen ke %d adalah %d di alamat %pn", I,X[I],P_Awal);
P_Awal = P_Awal + 1;
}
printf("n");
system("pause");
}
22.
23. Operasi logika pada pointer adalah untuk
membandingkan dua buah nilai dari
variabel pointer dengan menggunakan
operator hubungan seperti !=, ==, <, dan >.
Variabel pointer yang dapat dibandingkan
jika keduanya mempunyai tipe yang sama
atau keduanya bernilai null.
24. /* --------------------------------------------------------------------
Nama Program: ADP_Pointer_6_Operasi_Logika.cpp
Operasi Logika Pointer
-------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
int Nilai1=100, Nilai2=100, *P_Nilai1, *P_Nilai2, *P_Nilai3;
printf("Contoh Program Operasi Logika Pointern");
printf("_____________________________________n");
printf("n");
P_Nilai1 = &Nilai1;
P_Nilai2 = &Nilai2;
P_Nilai3 = P_Nilai1;
if(P_Nilai1<P_Nilai2) printf("P_Nilai1 menunjuk ke memori lebih rendah dari P_Nilai2n");
if(P_Nilai1==P_Nilai2) printf("P_Nilai1 menunjuk ke memori yang sama dengan P_Nilai2n");
if(P_Nilai1>P_Nilai2) printf("P_Nilai1 menunjuk ke memori yang lebih tinggi dari P_Nilai2n");
if(P_Nilai1<P_Nilai3) printf("P_Nilai1 menunjuk ke memori lebih rendah dari P_Nilai3n");
if(P_Nilai1==P_Nilai3) printf("P_Nilai1 menunjuk ke memori yang sama dengan P_Nilai3n");
if(P_Nilai1>P_Nilai3) printf("P_Nilai1 menunjuk ke memori yang lebih tinggi dari P_Nilai3n");
printf("n");
system("pause");
}
25.
26. Pointer dan larik mempunyai hubungan
antara lain dalam hal pengaksesan nilai-nilai
elemen lariknya.
Hal tersebut dapat dilihat pada contoh
program berikut ini, dimana untuk
pengaksesan elemen-elemen larik yang urut
mulai elemen ke-1 sampai ke-n dapat ditulis
sebagai *(P+0), *(P+1), *(P+2), sampai ke
*(P+n). Karena peningkatannya adalah 1,
maka penulisan tersebut dapat juga ditulis
sebagai *P++.
27. /* -----------------------------------------------------------------
Nama Program: ADP_Pointer_6_Operasi_Larik.cpp
Operasi Pointer Untuk Larik
----------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
int *P, X[7] = {10,20,30,40,50,60,70};
int I;
printf("Contoh Program Mengakses Elemen Larik Menggunakan Pointern");
printf("_________________________________________________________n");
printf("n");
P = X;
printf("Elemen Alamat Nilain");
for(I=0;I<7;I++)
printf("%4d P+%ld=%p; X+%ld=%p; &X[%ld]=%p x[%d]=%2d;"
"*(P+%ld)=%2d; *(X+%ld)=%2dn",I,I,P+I,I,X+I,I,
&X[I],I,X[I],I,*(P+I),I,*(X+I));
printf("n");
system("pause");
}
28.
29. Suatu nilai dapat diberikan langsung ke
elemen larik dengan cara pertama yaitu
menggunakan indeks dari larik.
Cara yang kedua yaitu dengan
memberikan nilai ke lokasi memori dimana
alamatnya merupakan alamat letak dari
nilai elemen lariknya. Cara yang kedua ini
dapat dilakukan dengan menggunakan
pointer.
30. Contoh program berikut akan memperlihatkan
nilai-nilai elemen larik dimensi satu X akan diisi
dengan nilai-nilai tertentu dengan menggunakan
cara yang pertama.
Elemen pertama dari larik diberi dengan nilai 5.
Elemen kedua diisi dengan nilai yang sama
dengan nilai elemen pertama, yaitu bernilai 5.
Elemen ketiga diisi dengan nilai yang ada di
elemen ke satu (ditunjukkan oleh ungkapan *P
yang berarti X[0]) ditambah dengan nilai numerik
2, sehingga akan berisi dengan nilai 7 dan
seterusnya.
31. /* -------------------------------------------------------------------
Nama Program: ADP_Pointer_7a_Operasi_Larik.cpp
Operasi Pointer Untuk Larik
------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
int *P, X[5];
printf("Contoh Program Memberi Nilai Elemen Larik Menggunakan Pointern");
printf("_____________________________________________________________n");
printf("n");
P = X;
X[0] = 5; //X[0] diisi dengan nilai 5, sehingga X[0]=5
X[1] = X[0]; //X[0] diisi dengan nilai X[0], sehingga X[1]=5
X[2] = *P+2; //X[0] diisi dengan nilai X[0]+2, sehingga X[2]=7
X[3] = *(P+1)-3;//X[0] diisi dengan nilai X[1]-3, sehingga X[3]=2
X[4] = *(X+2); //X[0] diisi dengan nilai X[2], sehingga X[4]=7
printf("%d %d %d %d %dn",X[0], X[1], X[2], X[3],X[4]);
printf("n");
system("pause");
}
32.
33. Contoh program berikut akan memperlihatkan
nilai-nilai elemen larik dimensi satu X akan
diisi dengan nilai-nilai tertentu dengan
menggunakan cara yang kedua.
Nilai elemen pertama dari larik diberi dengan
nilai5. Nilai elemen kedua diberi dengan nilai
yang sama dengan elemen pertama. Nilai
elemen ketiga diberi nilai yang ada di elemen
pertama ditambah dengan nilai numerik 2
sehingga akan berisi dengan nilai 7 dan
seterusnya.
34. /* -------------------------------------------------------------------
Nama Program: ADP_Pointer_7b_Operasi_Larik.cpp
Operasi Pointer Untuk Larik
-------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
int *P, X[5];
printf("Contoh Program Memberi Nilai Elemen Larik Menggunakan Pointern");
printf("_____________________________________________________________n");
printf("n");
P = X;
*P = 5; //X[0] diisi dengan nilai 5, sehingga X[0]=5
*(P+1) = X[0]; //X[0] diisi dengan nilai X[0], sehingga X[1]=5
*(X+2) = *P+2; //X[0] diisi dengan nilai X[0]+2, sehingga X[2]=7
*(P+3) = *(P+1)-3; //X[0] diisi dengan nilai X[1]-3, sehingga X[3]=2
*(P+4) = *(X+2); //X[0] diisi dengan nilai X[2], sehingga X[4]=7
printf("%d %d %d %d %dn",X[0], X[1], X[2], X[3],X[4]);
printf("n");
system("pause");
}
35.
36. Pemilihan penggunaan indeks atau pointer untuk mengakses
atau memberi nilai elemen-elemen larik tergantung dari
pertimbangan kecepatan proses program dan tingkat
kerumitannnya.
Jika pengaksesan elemen-elemen larik dilakukan secara urut,
penggunaan pointer akan menghasilkan proses program yang
lebih cepat dibandingkan dengan menggunakan indeks.
Jika pengaksesan elemen-elemen larik menggunakan rumus-
rumus tertentu yang rumit untuk menunjukkan urutan elemennya,
maka penggunaan indeks lebih disukai, karena penggunaan
pointer akan lebih rumit dan membingungkan.
Karena biasanya kecepatan proses program seringkali dijadikan
alasan yang utama, maka banyak program-program aplikasi yang
ditulis dengan bahasa C menggunakan pointer untuk
pengaksesan elemen-elemen larik.
37. Pointer sebagai suatu larik berbeda
dengan suatu lrik yang dioperasikan
dengan menggunakan pointer.
Pointer sebagai suatu larik
maksudnya adalah suatu pointer
digunakan sebagai pengganti suatu
larik.
38. Suatu larik yang tidak ditulis dengan indeksnya
menunjukkan elemen pertama dari larik tersebut.
Sehingga nama larik seperti ini berupa suatu
pointer yang menunjukkan elemen pertama dari
larik. Jika pointer ditambah dengan suatu nilai
integer, maka akan menunjukkan elemen
berikutnya dari larik.
Dari konsep ini, maka sebenarnya suatu larik
dimensi satu dapat diwakili atau diganti dengan
sebuah pointer, sehingga pointer itu sendiri
berfungsi sebagai suatu larik.
39. Bandingkanlah larik dimensi satu dengan
nama X dengan variabel pointer X seperti
terlihat pada tabel di bawah ini.
Elemen ke 1 2 3 ... n
Larik X:
Nilai Elemen
X[0] X[1] X[2] ... X[n-1]
Pointer X:
Alamat Elemen
Nilai Elemen
X
*X
X+1
*(X+1)
X+2
*(X+2)
... X+(n-1)
*(X+(n-1))
40. Dengan demikian larik dimensi
satu yang dideklarasikan sebagai
berikut
int X[4];
dapat diganti dengan pointer yang
dideklarasikan sebagai berikut:
int *X;
41. Terdapat perbedaan penting antara larik dimensi
satu dengan pointer yang mewakilinya. Kompiler
akan menyiapkan tempat memori yang dibutuhkan
oleh semua elemen-elemen larik dimensi satu
sewaktu larik ini dideklarasikan.
Misalnya deklarasi int X[4], akan menyebabkan
empat buah tempat untuk nilai-nilai integer atau
sebanyak 8 byte memori akan disiapkan untuk
larik X ini.
Untuk pointer, kompiler tidak akan secara otomatis
menyiapkan tempat untuk nilai-nilainya, karena
banyaknya nilai-nilai yang akan digunakan belum
diketahui.
42. Untuk mengatasi masalah ini, maka untuk
menyiapkan sejumlah blok memori dapat
digunakan cara alokasi dinamik (dynamic
allocation).
Cara alokasi dinamik ini akan
menggunakan memori yang masih kosong
di luar memori yang biasanya digunakan
untuk data.
43. Gambar berikut menunjukkan letak memori ini untuk
Turbo C yang menggunakan model memori kecil sebagai
default.
Stack
Memori sisa
untuk heap
Variabel-variabel
global
Program
Tinggi
Rendah
44. Stack merupakan area untuk menyimpan
nilai-nilai variabel lokal dan parameter formal.
Besarnya memori stack ini tidak tetap
tergantung dari memori yang dibutuhkn dan
akan bergerak ke bawah.
Program rekursi yang menggunakan variabel
lokal merupakan program yang banyak
membutuhkan ruang stack ini.
Ruang memori untuk variabel-variabel global
dan untuk tempat program besarnya adalah
tetap.
45. Memori heap berada di antara memori untuk stack dan
variabel-variabel global. Besarnya memori heap ini
tergantung dari sisa setelah digunakan stack.
Alokasi dinamik dapat dilakukaan dengan
menggunakan fungsi standar malloc() dengan
prototipenya berada di file judul stdlib.h.
Misalnya untuk mengalokasikan memori sebanyak 8
byte secara dinamik ke pointer X dapat dilakukan
seperti berikut ini:
X = malloc(8);
Cara lain untuk mengalokasikan sebanyak 8 byter
yang berupa empat buah nilai integer dapat digunakan
operator sizeof() sebagai berikut:
X = malloc(4 * sizeof(int));
46. Hasil dari fungsi malloc() ini adalah suatu alamat
yang menunjukkan byte pertama dari memori yang
dialokasikan di heap. Jika alokasi dinamik ini
gagal, misalnya karena memori di heap tidak
mencukupi, maka fungsi malloc() akan
menghasilkan nilai null.
Memori yang dialokasi di heap dapat dihapus
setelah tidak digunakan lagi, sehingga ruang di
heap dapat digunakan untuk keperluan alokasi
dinamik yang lainnya.
Untuk menghapus alokasi dinamik di heap dapat
dilakukan dengan fungsi free().
47. Pointer sebagai suatu larik dimensi satu
akan diperlihatkan pada contoh program
berikut ini yang akan menunjukkan pointer
sebagai pengganti suatu larik. Program ini
akan menghitung nilai total dari nilai-nilai
yang dialokasikan di heap secara dinamik.
48. /* -------------------------------------------------------------------
Nama Program: ADP_Pointer_7b_Operasi_Larik.cpp
Operasi Pointer Untuk Larik
-------------------------------------------------------------------- */
#include <stdio.h>
#include <stdlib.h>
main()
{
int *P, X[5];
printf("Contoh Program Memberi Nilai Elemen Larik Menggunakan Pointern");
printf("_____________________________________________________________n");
printf("n");
P = X;
*P = 5; //X[0] diisi dengan nilai 5, sehingga X[0]=5
*(P+1) = X[0]; //X[0] diisi dengan nilai X[0], sehingga X[1]=5
*(X+2) = *P+2; //X[0] diisi dengan nilai X[0]+2, sehingga X[2]=7
*(P+3) = *(P+1)-3; //X[0] diisi dengan nilai X[1]-3, sehingga X[3]=2
*(P+4) = *(X+2); //X[0] diisi dengan nilai X[2], sehingga X[4]=7
printf("%d %d %d %d %dn",X[0], X[1], X[2], X[3],X[4]);
printf("n");
system("pause");
}
49.
50. Kristanto, Andri. (2009). Algoritma &
Pemrograman dengan C++ Edisi 2.
Yogyakarta. Graha Ilmu.
Hartono, Jogiyanto, MBA., Ph.D. (2002).
Konsep Dasar Pemrograman Bahasa C.
Yogyakarta. Andi.
