Mengenal Pointer Pada C++

Pointer sesungguhnya berisi alamat dari suatu data, bukan data sebagaimana variabel biasa. Dengan kata lain pointer adalah variabel yang berisi alamat memori sebagai nilainya dan berbeda dengan variabel biasa yang berisi nilai tertentu.

Mengetahui Alamat variabel
Alamat dari variabel dapat diketahui dengan menambahkan operator alamat berupa simbol & di depan nama variabel.
Contoh program :
   /**

  * -------------------------------  
  * Mengetahui alamat variabel
  * -------------------------------  
  **/ 
  #include <iostream.h> 
  #include <conio.h> 
  void main() 
  { 
    clrscr(); 
    int a = 11; 
    float b = 12.4; 
    double c = 12.23456; 
    cout<<"Isi Variabel :"<<endl; 
    cout<<"a = "<<a<<endl; 
    cout<<"b = "<<b<<endl; 
    cout<<"c = "<<c<<endl; 
    cout<<"\nAlamat Variabel :"<<endl; 
    cout<<"a = "<<&a<<endl; 
    cout<<"b = "<<&b<<endl; 
    cout<<"c = "<<&c<<endl; 
    getch(); 
  } 

Output :
Isi Variabel :
a = 11
b = 12.4
c = 12.2346
Alamat Variabel :
a = 0x0012ff88
b = 0x0012ff84 c = 0x0012ff7c

Mendefinisikan Variabel Pointer
Suatu variabel pointer didefinisikan dengan bentuk sebagai berikut :
    - tipe_data dapat berupa sembarang tipe seperti halnya pada pendefinisian variabel bukan pointer.
   - nama_variabel adalah nama variabel pointer
    - * adalah operator memori yang fungsinya untuk mengembalikan nilai variabel pada alamatnya yang ditentukan oleh operator.
Supaya suatu variabel menunjuk ke variabel lain, mula-mula harus diisi dengan alamat dari variabel yang hendak ditunjuk.
Contoh program :

/** 
* ------------------------------- 
* Definisi Variabel Pointer
* ------------------------------- 
**/ 
  #include <iostream.h> 
  #include <conio.h> 

  void main() 
  { 
    int var_int = 55;     // Variabel bukan pointer 
    int *poin_int;           // Variabel pointer 
    clrscr(); 
    poin_int = &var_int;     // Pointer menunjuk ke vint 
    cout << "Alamat var_int = " << &var_int << endl; 
    cout << "poin_int = " << poin_int << endl; 
    getch(); 
  }

Output :
Alamat var_int = 0x0012ff88
poin_int = 0x0012ff88

Pada program diatas :
     cout << "poin_int = " << poin_int << endl;
ternyata menampilkan isi pointer itu sendiri, bukan isi dari variabel vint.
Mengakses Nilai yang ditunjuk Pointer
Berdasarkan contoh program diatas, nilai dari var_int dapat diakses melalui poin_int setelah pernyataan :
       poin_int = &var_int
dijalankan. Caranya dengan melibatkan operator “tak langsung”. Operator ini berupa simbol “ * “ dan diletakkan di depan nama variabel pointer.
Contoh
     *poin_int
     tipe_data *nama_variabel

Contoh program :

/** 
* ------------------------------- 
* Mengakses nilai yg ditunjuk pointer
* ------------------------------- 
**/ 
#include <iostream.h> 
#include <conio.h> 
void main() 
{ 

  int var_int = 60;       // Variabel bukan pointer 
  int *poin_int;           // Variabel pointer 
  clrscr(); 
  poin_int = &var_int;     // Pointer menunjuk ke vint 
  cout << " Nilai yang ditunjuk oleh pint =  " 
  << *poin_int << endl; 
  getch(); } 

Output:
Nilai yang ditunjuk oleh pint = 60

Pointer void
Untuk membuat pointer yang tidak bertipe yakni dengan meletakkan kata kunci pada void pada bagian penentu tipe pointer.
Contoh :
     void *ptr;
Merupakan pernyataan untuk mendefinisikan ptr sebagai variabel pointer void.
Suatu pointer void adalah pointer yang dapat menunjuk ke sembarang tipe data. Misalnya, Anda dapat mengatur agar pointer ini menunjuk ke tipe data int, tetapi di saat lain diperlukan untuk menunjuk data bertipe float.
Contoh program :

/** 
* ------------------------------- 
* Pointer Void
* ------------------------------- 
**/ 
#include <iostream.h> 
#include <conio.h> 
void main() 
{ 
  clrscr(); 
  void *ptr;            // Pointer tak bertipe 
  int vint = 45; 
  float vfl = 17.5; 
  ptr = &vint;             // menunjuk ke int 
  cout << "Nilai yang ditunjuk oleh ptr = " 
  << *(int *)ptr << endl; 
  ptr = &vfl;              // menunjuk ke float 
  cout << "Nilai yang ditunjuk oleh ptr = "<< *(float *) ptr << endl; 
  getch(); 
} 

Output :
Nilai yang ditunjuk oleh ptr = 45
Nilai yang ditunjuk oleh ptr = 17.5 

Dari program diatas bahwa variabel pointer ptr dapat menunjuk ke tipe int ataupun float.
Pointer dapat pula digabungkan dengan array, karena pada umumnya antara pointer dan array mempunyai kesamaan.
Contoh program :

#include <iostream.h> 
#include <conio.h> 
void main() 
{ 
  clrscr(); 
  int tgl_lahir[] = {28, 11, 1982 }; 
  int *poin_tgl; 
  poin_tgl = tgl_lahir;           // ptgl menunjuk ke array 
  cout << "Nilai yang ditunjuk poin_tgl  : " 
  << *poin_tgl << endl; 
  cout << "Nilai dari tgl_lahir[0]       : " 
  << tgl_lahir[0] << endl; 
  getch(); 
} 

Output :
Nilai yang ditunjuk poin_tgl : 28
Nilai dari tgl_lahir[0] : 28 

Setelah penugasan poin_tgl = tgl_lahir ptgl akan menunjuk ke elemen pertama (tgl_lahir[0]) dari array tgl_lahir.
Untuk mengakses semua tanggal dapat dilakukan dengan perintah : 
     for (int i=0;i<3;i++)
    cout<<*(poin_tgl+i)<<endl;

Array Pointer
Suatu array bisa digunakan untuk menyimpan sejumlah pointer. Sebagai contoh :
     char *namahari[7];
merupakan pernyataan untuk mendefinisikan array namahari yang berisi 7 buah elemen berupa pointer. Pointer ini menunjuk ke data bertipe char.
Contoh program :

/** 
* ------------------------------- 
* Array Pointer
* ------------------------------- 
**/ 
#include <iostream.h> 
#include <conio.h> 

void main() 
{ 
  clrscr(); 
  char *namahari[] = {"Senin", "Selasa", "Rabu", "Kamis","Jumat","Sabtu", "Minggu"}; 
  for (int i = 0; i < 7; i++) 
     cout << namahari[i] << endl; 
  getch(); 
}

Output :
Senin
Selasa
Rabu
Kamis
Jumat
Sabtu
Minggu

Pointer Menunjuk Pointer
Suatu pointer bisa menunjuk ke pointer lain

Untuk membentuk rantai seperti gambar diatas diperlukan pendefinisian sebagai berikut :
int var_x; //Variabel bertipe int
int *ptr1; //Variabel pointer yg menunjuk ke data bertipe int
int **ptr2; //Variabel pointer yg menunjuk ke pointer int

--> --> --> Agar ptr1 menunjuk ke variabel var_x, perintah yang diperlukan berupa :
          ptr1 = &var_x;
Sedangkan supaya ptr2 menunjuk ke ptr1, diperlukan perintah :
          ptr2 = &ptr1;
Contoh :

/** 
* ------------------------------- 
* Pointer Menunjuk Pointer
* ------------------------------- 
**/ 
#include <iostream.h> 
#include <conio.h> 
void main() 
{ 
  clrscr(); 
  int var_x = 2345; 
  int *ptr1;         //pointer ke variabel bukan pointer 
  int **ptr2;        //pointer ke pointer 
  cout << "var_x = " << var_x << endl; 
  //penugasan alamat 
  ptr1 = &var_x; 
  ptr2 = &ptr1; 
  //Mengakses nilai var_x melalui ptr1 
  cout << "*ptr1 = " << *ptr1 << endl; 
  //Mengakses nilai var_x melalui ptr2 
  cout << "**ptr2 = " << **ptr2 << endl; 
  getch(); 
} 

Output :
var_x = 2345
*ptr1 = 2345
**ptr2 = 2345

Pointer Dan Fungsi
Pointer biasa digunakan di dalam argumen fungsi kalau nilai argumen dimasudkan untuk diubah di dalam fungsi.
Pointer Sebagai Argumen Fungsi

/** 
* ------------------------------- 
* Pointer Sebagai Argumen Fungsi
* ------------------------------- 
**/ 
#include <iostream.h> 
#include <conio.h> 
void ubah_nilai(int &x); 
void main() 
{ 
  clrscr(); 
  int pinokio = 80; 
  cout << "Nilai mula-mula untuk pinokio : " 
  << pinokio << endl; 
  ubah_nilai(pinokio); 
  cout << "Nilai untuk pinokio sekarang  : " 
  << pinokio << endl; 
  getch(); 
} 
//Definisi fungsi 
void ubah_nilai(int &x) 
{ 
  x = 95; 
}

Output :
Nilai mula-mula untuk pinokio :80
Nilai untuk pinokio sekarang : 95

dengan menuliskan & didepan argumen fungsi, nilai argumen dapat diubah didalam fungsi. hal serupa dapat diimplentasikan didalam pointer sebagai berikut :

#include <iostream.h> 
#include <conio.h> 
void ubah_nilai(int *x); 
void main() 
{ 
  clrscr(); 
  int pinokio = 80; 
  cout << "Nilai mula-mula untuk pinokio : " 
  << pinokio << endl; 
  ubah_nilai(&pinokio); 
  cout << "Nilai untuk pinokio sekarang  : " 
  << pinokio << endl; 
  getch(); 
} 

  //Definisi fungsi 
void ubah_nilai(int *x) 
{ 
  *x = 95; 
} 

Perbedaan :

• Fungsi ubah_nilai() didefinisikan sebagai judul berupa void ubah_nilai(int *x) 
• Pada saat fungsi dipanggil argumen perlu ditulis dengan awalan & (&pinokio) 
• Prototipe fungsi disesuaikan dengan definisi fungsi : void ubah_nilai(int *x); 
• Didalam fungsi ubah_nilai(), tanda * perlu diberikan di depan nama argumen : *x=95;