#6 Pointer

Bab terakhir seri ini! 🏁 Saatnya kita ngintip ke balik layar: gimana sih cara kerja memori komputer? Dan kenapa C++ bisa “dekat dengan mesin”? Jawabannya, pointer: konsep yang paling ditakuti pemula, tapi sebenernya gampang kalau analoginya pas.

Pointer Itu Kayak Orang yang Tau Alamat Rumah

Bayangin kita mau ngirim paket ke rumah temen. Ada dua cara:

1. Kirim paketnya langsung: bawa barangnya, ngetok pintu, serahin.
2. Kasih alamatnya: “rumahnya di Jalan Merdeka No. 5”, biar yang lain bisa ke sana kapan aja.

Selama ini kita selalu pakai cara 1: nyimpen nilai di variabel, terus pake nilainya. Pointer adalah cara 2: dia nyimpen alamat, di mana nilai itu berada di memori, bukan nilainya sendiri.

Semua data yang kita bikin selama seri ini sebenernya disimpen di suatu tempat di memori komputer (RAM). Tiap tempat punya alamat unik, kayak nomor rumah. Pointer adalah variabel yang isinya alamat rumah, bukan isi rumahnya.

Alamat & Dereference: & dan *

Cara dapet alamat sebuah variabel itu gampang banget: pakai operator & (ampersand, disebut “address-of” atau “alamat dari”).

1
int umur = 20;
2

3
cout << "Nilai umur  : " << umur << endl;   // 20
4
cout << "Alamat umur : " << &umur << endl;  // 0x7ffd12345678 (contoh)

Angka kayak 0x7ffd... itu alamat memori (dalam hexadesimal). Nggak perlu dihafal; yang penting, setiap variabel punya alamat, dan & dipake buat ngambilnya.

Sekarang, cara nyimpen alamat itu di sebuah variabel disebut mendeklarasikan pointer:

1
int umur = 20;
2
int* ptrUmur = &umur;   // ptrUmur nyimpen ALAMAT dari umur

Baca int* ptrUmur sebagai “pointer ke int”. Tanda bintang * di tipe itu penanda kalau yang disimpen itu alamat, bukan nilai.

Terus, gimana caranya balik lagi ke nilainya dari sebuah alamat? Pakai operator * (dereference, “buka rumahnya”):

1
cout << ptrUmur << endl;    // 0x7ffd12345678 (alamatnya)
2
cout << *ptrUmur << endl;   // 20 (nilai di alamat itu)

Perhatiin bedanya, ini yang sering bikin bingung:

Bisa dibayangin: ptr = kertas berisi alamat, *ptr = rumah di alamat itu, &umur = cara nulis alamat umur ke kertas.

Satu hal menarik: lewat pointer, kita bisa ngubah nilai aslinya tanpa nyentuh variabelnya langsung.

1
int umur = 20;
2
int* ptrUmur = &umur;
3

4
*ptrUmur = 21;              // "datang ke rumah itu, ganti isinya jadi 21"
5

6
cout << umur << endl;       // 21! nilai aslinya kebawa berubah

Ini kekuatan sekaligus tanggung jawab: pointer ngasih akses langsung ke memori. Makanya bab 05 sempet mention “array dikirim ke fungsi itu berbagi data yang sama”. Tau nggak kenapa? Karena array itu sebenernya pointer, alamat elemen pertamanya! Itu kenapa perubahannya kebawa ke luar fungsi. Semua nyambung kan.

Pointer & Struct: Akses Pakai Panah ->

Kombinasi pointer + struct itu pasangan klasik di C++ (dan cikal bakal OOP di materi lanjutan). Cara akses member struct lewat pointer:

1
Mahasiswa mhs = {"Budi", 123456, 3.75};
2
Mahasiswa* ptr = &mhs;      // pointer ke struct mhs
3

4
// Cara 1: dereference dulu, baru titik
5
cout << (*ptr).nama << endl;
6

7
// Cara 2: pakai panah (->), sama artinya tapi lebih singkat
8
cout << ptr->nama << endl;

Panah -> itu cuma jalan pintas buat (*ptr).: dereference dulu, terus akses member. ptr->nama dibaca “lewat pointer ptr, ambil member nama”. Buat yang udah familiar sama bahasa lain, -> di C++ itu kerabat dekat . (dot) di Java/Python, bedanya dot dipake langsung di objek sedangkan -> dipake di pointer.

Program Berkelanjutan: Ngintip Alamat Data Mahasiswa

Program terakhir seri ini. Kita bikin satu mahasiswa, terus intip alamat memori-nya dari berbagai sudut, biar konsep &, *, dan -> kebayang konkret:

1
#include <iostream>
2
using namespace std;
3

4
struct Mahasiswa {
5
    string nama;
6
    int nim;
7
    float ipk;
8
};
9

10
int main() {
11
    Mahasiswa mhs = {"Budi", 123456, 3.75};
12
    Mahasiswa* ptr = &mhs;
13

14
    cout << "Alamat variabel mhs : " << &mhs << endl;
15
    cout << "Isi pointer ptr     : " << ptr << endl;
16
    cout << "Nilai lewat pointer : " << ptr->nama
17
         << " (NIM " << ptr->nim
18
         << ", IPK " << ptr->ipk << ")" << endl;
19
    cout << "Dereference (*ptr)  : " << (*ptr).nama << endl;
20

21
    return 0;
22
}

Output-nya bakal mirip gini (alamatnya beda-beda tiap komputer):

1
Alamat variabel mhs : 0x7ffd12345678
2
Isi pointer ptr     : 0x7ffd12345678
3
Nilai lewat pointer : Budi (NIM 123456, IPK 3.75)
4
Dereference (*ptr)  : Budi

Yang musti kita perhatiin:

• &mhs dan ptr mencetak angka yang sama. Itu bukti ptr beneran nyimpen alamat mhs: kita udah “ngasih alamat rumah” ke pointer, dan pointer nunjuk ke situ.
• ptr->nama dan (*ptr).nama hasilnya sama (“Budi”); dua cara, satu makna. Panah cuma versi singkatnya.
• Member struct dibaca lewat pointer tanpa bingung, contohnya ptr->nim langsung dapet 123456.

Dari sini, mulailah kita ngerti kenapa dari awal dibilang C++ “dekat dengan mesin”: kita bisa pegang langsung alamat memori. Bahasa kayak JavaScript atau Python nggak ngasih akses sebebas ini, mereka nyembunyiin semua biar “aman”. Di C++, kita yang pegang kendali.

⚠️ Dua Aturan Keselamatan Pointer

Kekuatan gede = tanggung jawab gede. Dua hal yang wajib diinget:

1. Jangan pernah dereference pointer yang nggak nunjuk ke mana-mana, atau ke memori yang udah “dibongkar”. Ini namanya dangling pointer: sok tau alamat, padahal rumahnya udah nggak ada. Hasilnya bisa crash atau bug yang bikin pusing berhari-hari.
2. Selalu inisialisasi pointer. Kalau belum ada alamat yang mau disimpen, set ke nullptr, nilai khusus yang artinya “nggak nunjuk ke mana-mana”. Jangan biarin pointer ngambang tanpa nilai.

1
int* ptr = nullptr;   // aman: eksplisit "belum nunjuk ke mana-mana"

Latihan Soal: Tukar Nilai & Intip Alamat

Bikinkan program yang ngebuktiin kekuatan pointer. Requirement-nya:

1. Buat fungsi void tukar(int* a, int* b) yang menukar nilai dua variabel lewat pointer (tanpa variabel bantuan di luar fungsi).
2. Di main, bikin dua variabel int (misal x = 5 dan y = 10).
3. Tampilkan alamat x dan y (pakai &), nilai sebelum ditukar, panggil tukar(&x, &y), terus tampilkan nilai sesudahnya.

Contoh jalannya:

1
Alamat x : 0x7ffd12345678
2
Alamat y : 0x7ffd12345690
3
Sebelum tukar : x = 5, y = 10
4
Sesudah tukar : x = 10, y = 5

💡 Hint: di dalam tukar, simpen sementara *a ke variabel lokal, terus balikin. Jangan lupa pas manggil: tukar(&x, &y), kita ngirim alamatnya, bukan nilainya.

Penutup

Selamat, kita udah sampai di garis akhir seri C++ dari Nol! Sedikit review perjalanan kita:

1. Bab 0: kenal C++ dan nyiapin lingkungan.
2. Bab 1: variabel & tipe data, kotak berlabel.
3. Bab 2: perulangan & pengkondisian, program bisa milih dan ngulang.
4. Bab 3: array, nyimpen banyak data.
5. Bab 4: fungsi, kode rapi & bisa dipake ulang.
6. Bab 5: struct, data jadi satu paket.
7. Bab 6: pointer, ngintip alamat memori.

Program Data Nilai Mahasiswa kita udah berevolusi dari 3 baris variabel jadi program terstruktur yang ngerti alamat memori. Itu progres yang nggak main-main buat pemula.

Pointer itu jembatan ke materi lanjutan: class & OOP (struct versi lengkap), dynamic memory (new/delete), linked list, dan STL (std::vector, dsb.). Kalau kita udah nyaman sama pointer, separuh pertempuran udah dimenangin.

Lanjut ke materi apa pun, dan inget: pelan-pelan, praktik terus, dan jangan malu buntu. Sampai jumpa di seri berikutnya! 👋