Struktur Data (Data Structure) – IS 2313 Imam Rozali, S.T., M.T. Struktur Data (Data Structure) – IS 2313

Chapter 2 : Pointer

Outline KONSEP DASAR POINTER Pendeklarasian Variabel Pointer Mengatur Pointer Agar Menunjuk ke Variabel Lain Operasi pada Pointer Mengakses Isi Suatu Variabel Melalui Pointer Tipe Variabel Pointer dan Tipe Obyek Yang Ditunjuk Pointer dan Array Array Dari Pointer Inisialisasi Array Pointer Pointer Menunjuk Pointer Pointer dan Struct Pointer dan Tipe Data String Pointer Sebagai Parameter Fungsi Pointer Sebagai Keluaran Fungsi

KONSEP DASAR POINTER Pointer (variabel penunjuk) adalah suatu variabel yang berisi alamat lokasi suatu memori tertentu. Jadi isi dari variabel pointer merupakan alamat dari lokasi memori yang digunakan untuk menyimpan data dan bukan nilai data itu sendiri. Misalnya X adalah suatu variabel biasa yang berisi nilai karakter ‘J’. X bukan variabel pointer. Nilai dari X ini oleh kompiler C++ akan diletakkan di suatu lokasi memori tertentu. Nilai ini dapat diakses jika diketahui alamat memorinya. Untuk mengetahui alamat memori yang digunakan oleh variabel X dalam menyimpan nilai datanya dapat diketahui dengan ungkapan &X. Alamat tersebut dapat ditulis dengan mengambil sebuah variabel lagi yang disebut dengan variabel pointer, misalnya: Alamat_X = &X. Alamat_X adalah variabel pointer karena variabel ini menunjuk ke lokasi memori di mana nilai data dari variabel X disimpan.

Sebagai contoh, jika px adalah pointer dan x adalah variabel yang ditunjuk oleh px, maka jika px berada pada alamat memori awal 1000, maka px akan berisi 1000, sedangkan datanya sendiri berupa nilai yang ada pada lokasi memori 1000.

Jika variabel merupakan isi memori, dan untuk mengakses isi memori tersebut diperlukan address, lalu bagaimana cara kita mengetahui alamat dari suatu variabel ? Jawabannya adalah: untuk kebanyakan kasus kita sama sekali tidak perlu tahu alamat dari sebuah variabel. Untuk mengakses sebuah variabel kita hanya perlu nama dari variabel tersebut. Tugas kompiler lah yang mentranslasikan nama ke alamat mesin yang diperlukan oleh komputer.

Pendeklarasian Variabel Pointer type *nama_variabel; int px; /* contoh1*/ char pch1, pch2; /*contoh2*/ Contoh pertama menyatakan bahwa px adalah variabel pointer yang menunjuk ke suatu data bertipe int.   Pada contoh kedua, masing-masing variabel pch1 dan pch2 adalah variabel pointer yang menunjuk ke data bertipe char.

Mengatur Pointer Agar Menunjuk ke Variabel Lain Agar suatu pointer menunjuk ke variabel yang lain, mula-mula pointer harus diisi dengan alamat dari variabel yang akan ditunjuk. Untuk menyatakan alamat dari suatu variabel, dapat digunakan operator & (operator alamat, yang bersifat unaray), dengan cara menempatkan operator di depan nama variabel. Sebagai contoh, jika x dideklarasikan sebagai variabel bertipe int, maka &x berarti “alamat dari variabel x”.

Adapun contoh pemberian alamat ke suatu variabel pointer px (yang dideklarasikan sebagai pointer yang menunjuk ke data bertipe int) yaitu: Px = &x;  Pernyataan di atas berarti bahwa px diberi nilai berupa alamat dari variabel x. Setelah pernyataan tersebut dieksekusi barulah dapat dikatakan bahwa px menunjuk ke variabel x.

Operasi pada Pointer Operasi Penugasan Suatu variable pointer seperti halnya variable yang lain, juga bisa mengalami operasi penugasan. Nilai dari suatu variable pointer dapat disalin ke variable pointer yang lain. Operator (&) dalam kaitannya dengan pointer adalah operator yang mengembalikan alamat memori dari operandnya. Operasi Aritmatika Suatu variabel pointer hanya dapat dilakukan operasi aritmatika dengan nilai integer saja. Operasi yang biasa dilakukan adalah operasi penambahan dan pengurangan. Operasi penambahan dengan suatu nilai menunjukkan lokasi data berikutnya (index selanjutnya) dalam memori. Begitu juga operasi pengurangan.

Operasi Penugasan int y = 5; /*deklarasi variabel y*/ int *yPtr; /*deklarasi variabel pointer yPtr*/ yPtr = &y; /*mengisi variabel pointer yPtr dengan alamat dari variabel y*/ Representasi yang lain, misalnya asumsikan bahwa variabel y berada pada alokasi memori 600000 dan variabel pointer yPtr berada pada alokasi memori 500000.

#include <stdio.h> Int main() { Int i; Int *ia; i = 10; ia = &i; printf (“Alamat dari i adalah %p\n”,ia); printf (“Nilai i adalah %d\n”,i); printf (“Nilai dari pointer ia adalah %d\n”,*ia); *ia=50; printf (“Nilai I sekarang adalah %d\n”,i); printf (“Alamat dari i adalah %p\n”,&i); return 0; }

Operasi Aritmatika float *vPtr = v; Asumsikan kita telah mendeklarasikan sebuah array float v[5], dan anggap elemen pertamanya berada pada lokasi 3000 di memori. Lalu kita deklarasikan sebuah variabel pointer *vPtr, ada dua cara untuk mengisi variabel pointer *vPtr dengan alamat dari elemen pertama array v, yaitu : float *vPtr = v; float *vPtr = &v[0];

vPtr += 2; Jika kita melakukan operasi aritmatika seperti: dalam perhitungan aritmatika biasa, maka vPtr yang semula berisi 3000 menjadi 3000 + 2 = 3002, namun ini tidak berlaku pada pointer. Operasi aritmatika pada pointer di atas artinya adalah vPtr yang semula menunjuk pada v[0] sekarang menunjuk ke v[2].  Karena vPtr menunjuk alamat memori dari variabel v yang bertipe float, maka vPtr sekarang berisi 3008 (3000 + 2 * 4). vPtr += 2;

#include <stdio.h> int main() { float nilai[3], *petunjuk; nilai[0] = 220; nilai[0] = 641; nilai[0] = 53; penunjuk = &nilai[0]; printf(“Nilai %f ada di alamat %p\n”,*penunjuk,penunjuk); printf(“Nilai %f ada di alamat %p\n”,*(penunjuk+1),penunjuk+1); printf(“Nilai %f ada di alamat %p\n”,*(penunjuk+1),penunjuk+2); }

Mengakses Isi Suatu Variabel Melalui Pointer Jika suatu variabel sudah ditunjuk oleh pointer, maka variabel tersebut dapat diakses melalui variabel itu sendiri (disebut sebagai pengaksesan tak langsung), ataupun melalui pointer (disebut pengaksesan langsung). Pengaksesan tak langsung dilakukan dengan menggunakan operator inderection berupa simbol * (bersifat unaray), seperti contoh berikut: *px yang menyatakan “isi atau nilai variabel/data yang ditunjuk oleh pointer px”. Sebagai contoh jika y bertipe int, maka sesudah dua pernyataan berikut: px = &x; y = *px; y akan berisi nilai yang sesuai dengan nilai x.

/* --------------------------------- */ /* File program : Pointer.c */ /* Contoh pemakaian pointer */ /* -------------------------------- */ #include <stdio.h> main() { int x,y; /* x dan y bertipe int */ int *px; /* px pointer yang menunjuk obyek bertipe int */ x = 87; px = &x; /* px berisi alamat dari x */ y = *px; /* y berisi nilai yang ditunjuk px */ printf("Alamat x = %p\n", &x); printf("Isi px = %p\n", px); printf("Isi x = %d\n", x); printf("Nilai yang ditunjuk px = %d\n", *px); printf("Nilai y = %d\n", y); } Contoh eksekusi: C> Pointer Alamat x = 5B87:2230 Isi px = 5B87:2230 Isi x = 87 Nilai yang ditunjuk px = 87 Nilai y = 87   Pada program di atas, dua pernyataan px = &x; y = *px; sebenarnya dapat digantikan dengan sebuah pernyataan y = x;

Tipe Variabel Pointer dan Tipe Obyek Yang Ditunjuk Antara tipe pointer (sesuai dengan pendeklarasian pointer) dan tipe obyek yang akan ditunjuk oleh pointer haruslah sejenis. Jika misalnya pointer pu dimaksudkan untuk menunjuk data bertipe int maka data yang akan ditunjuk oleh pointer pu juga harus bertipe int. Suatu kesalahan akan terjadi jika misalnya pointer float digunakan untuk menunjuk data bertipe int.

Mengubah Isi Suatu Variabel Melalui Pointer Mula-mula pd dideklarasikan sebagai pointer yang menunjuk ke suatu data bertipe float dan d sebagai variabel bertipe float. Selanjutnya dengan ungkapan: d = 54.6; digunakan untuk mengisikan nilai 54.6 secara langsung ke variabel d. Perintah : pd = &d; digunakan untuk memberikan alamat dari d ke pd. Dengan demikian pd menunjuk ke variabel d. Sedangkan pernyataan berikut: *pd = *pd + 10; (atau: *pd += 10;) merupakan instruksi untuk mengubah nilai variabel d secara tak langsung. Perintah di atas berarti “jumlahkan isi variabel yang ditunjuk oleh pd dengan 10 dan simpan hasilnya ke variabel tersebut”, atau identik dengan pernyataan: D = d + 10; Namun seandainya tidak ada instruksi Pd = &d; maka pernyataan: *pd = *pd + 10; tidak akan sama dengan d = d + 10;

/* ---------------------------------- */ /* File program : Pointer2.c */ /* Pengubahan isi pointer */ /* -------------------------------- */ #include <stdio.h> main() { float d, *pd; d = 54.6; printf("Isi d semula = %g\n", d); pd = &d; *pd = *pd + 10; printf("Isi d kini = %g\n", d); } Contoh hasil eksekusi: C> Pointer2 Isi d semula = 54.6 Isi d kini = 64.6

Pointer dan Array Misalnya dalam suatu fungsi dideklarasikan: static int tgl_lahir[3] = { 01, 09, 64 }; int *ptgl; Kemudian diberikan pernyataan ptgl = &tgl_lahir[0]; maka ptgl akan berisi alamat dari elemen array tgl_lahir yang berindeks nol. Instruksi di atas juga dapat ditulis menjadi: ptgl = tgl_lahir; sebab nama array tanpa tanda kurung menyatakan alamat awal dari array. Sesudah penugasan seperti di atas, maka *ptgl dengan sendirinya menyatakan elemen pertama (berindeks sama dengan nol) dari array tgl_lahir. Hubungan antara struktur data pointer dan array dalam C sangatlah erat, sebab sesungguhnya array secara internal akan diterjemahkan dalam bentuk pointer. Contoh berikut akan memberi gambaran tentang hubungan antara pointer dan array.

/* ------------------------------------------- */ /* File program : Pointer3.c */ /* Pointer yang menunjuk array */ #include <stdio.h> main() { static int tgl_lahir[] = {24, 6, 1965 }; int *ptgl; ptgl = tgl_lahir; /* ptgl berisi alamat array */ printf("Nilai yang ditunjuk oleh ptgl = %d\n", *ptgl); printf("nilai dari tgl_lahir[0] = %d\n", tgl_lahir[0]); } C>Pointer3 Nilai yang ditunjuk oleh ptgl = 24 Nilai dari tgl_lahir[0] = 24

Jika ingin menampilkan seluruh elemen array tgl_lahir, maka dapat digunakan perintah for(i=0; i<3; i++) printf(“%d%, tgl_lahir[i]); ptgl = tgl_lahir; for (i=0; i<3; i++0 printf(“%d “, *(ptgl + i)); Jika diimplementasikan dengan menggunakan pointer tgl_lahir[i]   dapat digantikan menjadi *(ptgl + i) dengan terlebih dahulu mengatur ptgl agar menunjuk ke array tgl_lahir, sehingga penulisan instruksi penampilan isi array tgl_lahir dapat diubah menjadi: Contoh kedua

akan menyatakan elemen array dengan indeks sama dengan i. Secara umum operasi pointer dapat diterangkan sebagai berikut. Misalkan a adalah suatu array, dan pa adalah pointer yang menunjuk array a, maka *(pa + i) akan menyatakan elemen array dengan indeks sama dengan i. Jadi: *(pa + 0) identik dengan a[0] *(pa + 1) identik dengan a[1] *(pa + 2) identik dengan a[2]   Ungkapan seperti pa + i memiliki arti “tambahkan nilai pa (berisi alamat) dengan i kali ukuran dari obyek yang ditunjuk oleh pa”.

Jika pa dideklarasikan sebagai int *pa; maka obyek dari pa adalah data int. Cara lain dalam menampilkan isi suatu array yaitu dengan menaikkan isi variabel pointer dengan menggunakan operator ++. *(ptgl + i) dapat diganti menjadi ptgl++

Misalkan suatu instruksi: int *pa; int a[3]; Sesudah pernyataan: pa = a; Sesudah pernyataan: pa++;

Array Dari Pointer Suatu array dapat digunakan untuk menyimpan sejumlah pointer. Misal pernyataan: char *namahari[10]; merupakan pernyataan untuk mendeklarasikan array pointer. Array namahari terdiri dari 10 elemen berupa pointer yang menunjuk ke data bertipe char.

Inisialisasi Array Pointer Static char *namahari[ ] = { “Senin”, “Selasa”, “Rabu”, “Kamis”, “Jum’at”, “Sabtu” , “Minggu” }; Pada contoh di atas, namahari[0] menunjuk ke string “Senin” namahari[1] menunjuk ke string “Selasa” namahari[2] menunjuk ke string “Rabu” dan seterusnya..

Pointer Menunjuk Pointer int var_x; int *ptr1; int **ptr2; Perhatikan bahwa pada deklarasi di depan: var_x adalah variabel bertipe int. ptr1 adalah variabel pointer yang menunjuk ke data bertipe int. ptr2 adalah variabel pointer yang menunjuk ke pointer int (itulah sebabnya deklarasinya berupa : int **ptr2;) Agar ptr1 menunjuk ke variabel var_x, perintah yang diperlukan berupa: ptr1 = &var_x;   Sedangkan supaya ptr2 menunjuk ke ptr1, instruksi yang diperlukan adalah: ptr2 = &ptr1;

/* ------------------------------------------- */ /* File program : Ptrptr.c */ /* Contoh pointer menunjuk pointer */ #include <stdio.h> main() { int var_x = 234; /* variabel int */ int *ptr1; /* pointer int */ int **ptr2; /* pointer menunjuk pointer int */ ptr1 = &var_x; /* ptr1 berisi alamat var_x */ ptr2 = &ptr1; /* ptr2 berisi alamat ptr1 */ /* Mengakses nilai var_x melalui ptr1 */ printf("Nilai var_x = %d\n", *ptr1); /* Mengakses nilai var_x melalui ptr2 */ printf("Nilai var_x = %d\n", **ptr2); } C>Ptrptr Nilai var_x = 234   Variabel pointer dapat digunakan sebagai parameter dalam suatu fungsi. Dalam kaitan ini pointer dapat sebagai: Parameter fungsi dan Keluaran fungsi

Pointer dan Struct Sama halnya seperti array, pointer dapat bertipe apa saja, bahkan tipe buatan kita sendiri.

Pointer dan Tipe Data String String adalah sekumpulan karakter-karakter yang membentuk suatu larik atau array. Suatu string dapat diakses elemen-elemen karakternya baik sebagai pointer ataupun sebagai larik. char *P; P = “FASILAKOM”;

Pointer: *P → ‘F' *(P+1) → ‘A’ *(P+2) → ‘S’ *(P+3) → ‘I’ *(P+4) → ‘L’ *(P+5) → ‘K’ *(P+6) → ‘O’ *(P+7) → ‘M’ Larik: P[0] → ‘F' P[1] → ‘A’ P[2] → ‘S’ P[3] → ‘I’ P[4] → ‘L’ P[5] → ‘K’ P[6] → ‘O’ P[7] → ‘M’ Satu karakter menempati 1 byte (1 lokasi alamat) pada memori. Oleh karena itu string “FASILKOM” yang terdiri dari 8 karakter akan menempati 8 lokasi alamat pada memori dan membutuhkan memori sebesar 8 byte.

#include <stdio.h> #include <string.h> #include <iostream.h> void main() { char *P; int i; P = "TELKOMPDC"; for (i=0; i<=7; i++) cout<<"Nilai variabel (P+"<<i<<") = '"<<*(P+i)<< "' berada pada alamat = ";printf("%p",(P+i)); cout<<endl; } cout<<"Nilai variabel P["<<i<<"] = '"<<P[i]<< "' berada pada alamat = ";printf("%p", &P[i]);

Pointer Sebagai Parameter Fungsi Penerapan pointer sebagai parameter fungsi yaitu jika diinginkan agar nilai suatu variabel internal dapat diubah oleh fungsi yang dipanggil. Contoh pemanggilan fungsinya adalah : naikkan_nilai(&a, &b); void naikkan_nilai (int *x, int *y) { *x = *x + 2; *y = *y + 2; } Fungsi di atas dimaksudkan agar jika dipanggil, variabel yang berkaitan dengan parameter aktual dapat diubah nilainya, yaitu masing-masing dinaikkan sebesar 2.   Perhatikan bahwa dalam hal ini variabel a dan b harus ditulis diawali dengan operator alamat (&) yang berarti menyatakan alamat variabel, sebab parameter fungsi dalam pendefinisian berupa pointer.

Pointer Sebagai Keluaran Fungsi Suatu fungsi dapat dibuat agar keluarannya berupa pointer.

Char *nama_bulan(int n) { static char *bulan[ ] = { “Kode bulan salah”, “Januari”, “Pebruari”, “Maret”, “April”, “Mei”, “Juni”, “Juli”, “Agustus”, “September”, “Oktober”, “Nopember”, “Desember” }; return( (n<1 || n>12) ? bulan[0] : bulan[n] ); } Pada definisi fungsi di atas, char *nama_bulan menyatakan bahwa keluaran fungsi nama_bulan( ) berupa pointer yang menunjuk ke obyek bertipe char (atau string).   Dalam fungsi nama_bulan( ), mula-mula array bernama bulan dideklarasikan dan sekaligus diinisialisasi agar menunjuk ke sejumlah string yang menyatakan nama bulan. Di bagian akhir fungsi, pernyataan return( (n<1 || n>12) ? bulan[0] : bulan[n] ); menyatakan bahwa hasil fungsi berupa pointer yang menunjuk ke: string “Kode ulan salah” (bulan[0]) jika masukan fungsi (n<1 atau n>12) bulan[n] untuk n yang terletak antara 1 sampai 12

/* ----------------------------------------------- */ /* File program : Ptrbulan.c */ /* Contoh fungsi dengan keluaran berupa */ /* pointer yang menunjuk string */ #include <stdio.h> char *nama_bulan(int n); main() { int bl; printf("Bulan (1 .. 12): "); scanf("%d", &bl); printf("%s\n", nama_bulan(bl)); } char *nama_bulan(int n) static char *bulan[] = "Kode bulan salah", "Januari", "Pebruari", "Maret", "April", "Mei", "Juni", "Juli", "Agustus", "September", "Oktober", "Nopember", "Desember" }; return((n<1 || n>12) ? bulan[0] : bulan[n]);