Memahami Pointer C++: Konsep Dasar dan Penggunaannya untuk Pemula (Part 10)

Rifqi An Rifqi An
•
Maret 04, 2026


Memahami Pointer C++: Konsep Dasar dan Penggunaannya untuk Pemula (Part 10)

Halo sobat ngoding dan calon master C++! Balik lagi di seri tutorial Belajar Dasar C++ kita. Gimana, masih semangat kan setelah kemarin kita bahas soal function yang bikin kode makin rapi? Nah, kali ini kita mau masuk ke topik yang katanya sering bikin jidat berkerut dan kadang bikin mata merah karena lembur: Pointer C++. Jangan takut dulu! Meskipun terdengar horor, pointer ini justru salah satu fitur paling powerful di C++. Kalau kamu bisa kuasai ini, dijamin level ngodingmu naik kelas! Siap-siap ngopi, kita bongkar bareng misteri alamat memori ini!

Daftar Isi

Apa Itu Pointer C++? Sekilas Tentang Alamat Memori

Oke, mari kita mulai dengan pertanyaan mendasar: sebenarnya pointer itu apaan sih? Gampangnya, pointer adalah variabel yang isinya bukan nilai langsung, melainkan alamat memori dari variabel lain. Bayangkan, dia itu semacam penunjuk arah. Kalau variabel biasa menyimpan 'data', pointer ini menyimpan 'lokasi data' itu di dalam RAM komputer kita.

Penting banget nih, kalau kamu ngoding, setiap variabel yang kamu deklarasikan (misal: int angka = 10;) itu punya tempat tinggalnya sendiri di memori. Tempat tinggal ini punya alamat unik, persis kayak alamat rumah. Nah, si pointer ini tugasnya nyimpen alamat tersebut.

Analogi Simpel: Kotak Pos dan Alamatnya

Anggap aja kamu punya sebuah kotak pos (ini variabel angka). Di dalam kotak pos itu ada surat (nilai 10). Nah, kotak pos itu kan pasti punya alamat kan? Misalnya, Jalan Ngoding Indah No. 42. Si pointer ini adalah catatan di buku harianmu yang isinya: "Kotak pos dengan surat penting itu ada di Jalan Ngoding Indah No. 42." Jadi, pointer tidak langsung memegang suratnya, tapi memegang alamat kotak posnya. Paham ya?

Deklarasi dan Inisialisasi Pointer: Siap-siap Ngoding!

Gimana caranya bikin variabel pointer? Mirip sama deklarasi variabel biasa, tapi ada tanda asterisk (*) di depannya. Tanda asterisk ini yang bilang ke compiler kalau "Eh, ini bukan variabel biasa lho, ini pointer!".

Tipe data pointer harus sama dengan tipe data variabel yang akan ditunjuknya. Kalau mau nunjuk int, ya pointer-nya harus int*. Kalau mau nunjuk char, ya char*. Logis kan?


#include <iostream>

int main() {
    int umur = 25;       // Variabel biasa
    int* ptrUmur;       // Deklarasi pointer ke integer

    ptrUmur = &umur;     // Inisialisasi: ptrUmur menyimpan alamat dari variabel 'umur'

    std::cout << "Nilai umur: " << umur << std::endl;
    std::cout << "Alamat memori umur: " << &umur << std::endl;
    std::cout << "Nilai yang disimpan ptrUmur (alamat umur): " << ptrUmur << std::endl;
    std::cout << "Nilai yang ditunjuk oleh ptrUmur: " << *ptrUmur << std::endl; // MAGIC!

    return 0;
}

Dari contoh di atas, ada dua operator baru yang muncul: & (ampersand) dan * (asterisk). Jangan panik! Dua operator ini adalah kunci utama dalam bermain-main dengan pointer.

Operator Ampersand (&) dan Asterisk (*): Duet Maut Pointer

Operator & (Address-of Operator)

Operator & ini digunakan untuk mengambil alamat memori dari sebuah variabel. Kalau kamu ingin tahu di mana "rumah" variabel x di RAM, tinggal panggil &x. Gampang kan? Hasilnya adalah alamat memori yang bisa kamu simpan ke dalam sebuah pointer.


#include <iostream>

int main() {
    std::string nama = "Budi";
    double gaji = 5000000.0;

    std::cout << "Alamat memori variabel nama: " << &nama << std::endl;
    std::cout << "Alamat memori variabel gaji: " << &gaji << std::endl;

    return 0;
}

Outputnya akan berupa deretan karakter heksadesimal, itulah alamat memori asli dari variabel-variabelmu. Setiap kali kamu run program, alamatnya bisa saja berbeda lho, tergantung bagaimana OS mengalokasikan memori saat itu.

Operator * (Dereference Operator)

Nah, kalau operator & itu buat ngambil alamat, operator * ini kebalikannya. Dia digunakan untuk mengakses nilai yang ada di alamat memori yang ditunjuk oleh pointer. Ini yang namanya dereferencing. Kamu seolah-olah bilang, "Oke, aku punya alamatnya, sekarang tolong kasih tahu isinya apa!"


#include <iostream>

int main() {
    int skor = 100;
    int* ptrSkor = &skor; // ptrSkor menyimpan alamat 'skor'

    std::cout << "Nilai asli skor: " << skor << std::endl;
    std::cout << "Alamat skor (dari &skor): " << &skor << std::endl;
    std::cout << "Isi ptrSkor (alamat yang disimpan): " << ptrSkor << std::endl;
    std::cout << "Nilai yang ditunjuk oleh ptrSkor (*ptrSkor): " << *ptrSkor << std::endl; // Ngambil nilai!

    // Kita bisa mengubah nilai variabel asli lewat pointer juga!
    *ptrSkor = 150; // Ubah nilai di alamat yang ditunjuk ptrSkor

    std::cout << "Nilai skor setelah diubah via pointer: " << skor << std::endl;

    return 0;
}

Keren kan? Dengan *ptrSkor = 150;, kita tidak mengubah nilai pointer-nya, tapi mengubah nilai dari variabel yang ditunjuk oleh pointer tersebut. Ini salah satu kekuatan utama pointer: memanipulasi data secara tidak langsung.

Pointer dan Array: Teman Lama yang Saling Melengkapi

Di C++, nama sebuah array itu sendiri sudah bertindak sebagai pointer ke elemen pertamanya! Jadi, kalau kamu punya int arr[5];, maka arr itu pada dasarnya adalah pointer ke arr[0]. Ini kenapa array dan pointer sering jalan barengan dan jadi jurus andalan para programmer C++.

Kamu bisa pakai aritmetika pointer untuk menjelajahi elemen-elemen array. Ini bakal berguna banget nanti saat kamu berurusan dengan memori yang dinamis.


#include <iostream>

int main() {
    int nilai[] = {10, 20, 30, 40, 50};
    int* ptrNilai = nilai; // ptrNilai menunjuk ke elemen pertama (nilai[0])

    std::cout << "Nilai elemen pertama (via pointer): " << *ptrNilai << std::endl; // Output: 10

    ptrNilai++; // Pindah ke elemen berikutnya (nilai[1])
    std::cout << "Nilai elemen kedua (setelah increment pointer): " << *ptrNilai << std::endl; // Output: 20

    // Kita juga bisa akses elemen spesifik dengan pointer arithmetic
    std::cout << "Nilai elemen ketiga (ptrNilai + 2): " << *(ptrNilai + 1) << std::endl; // Output: 30

    return 0;
}

Aritmetika pointer itu unik. Saat kamu melakukan ptrNilai++, pointer tidak cuma nambah 1 byte, tapi nambah ukuran dari tipe data yang ditunjuknya. Kalau int biasanya 4 byte, ya dia loncat 4 byte. Keren kan?

Pointer ke Pointer (Double Pointer): Sedikit Rumit, Banyak Manfaat!

Sudah pusing dengan pointer biasa? Siap-siap, karena ada yang namanya pointer ke pointer, atau sering disebut double pointer! Ini adalah pointer yang menunjuk ke alamat memori dari pointer lain. Kalau digambarkan, ini seperti punya peta, tapi isi petanya adalah lokasi peta lain.

Deklarasinya pakai dua tanda asterisk: int**, char**, dan seterusnya. Ini biasanya dipakai dalam kasus-kasus lebih kompleks, seperti array 2D dinamis, atau ketika kamu perlu mengubah sebuah pointer itu sendiri melalui sebuah fungsi.


#include <iostream>

int main() {
    int angka = 7;
    int* ptrAngka = &angka; // ptrAngka menunjuk ke 'angka'
    int** ptrPtrAngka = &ptrAngka; // ptrPtrAngka menunjuk ke 'ptrAngka'

    std::cout << "Nilai angka: " << angka << std::endl;            // Output: 7
    std::cout << "Alamat angka: " << &angka << std::endl;        // Alamat 'angka'

    std::cout << "Isi ptrAngka (alamat angka): " << ptrAngka << std::endl; // Sama dengan alamat 'angka'
    std::cout << "Nilai yang ditunjuk ptrAngka (*ptrAngka): " << *ptrAngka << std::endl; // Output: 7
    std::cout << "Alamat ptrAngka: " << &ptrAngka << std::endl; // Alamat 'ptrAngka'

    std::cout << "Isi ptrPtrAngka (alamat ptrAngka): " << ptrPtrAngka << std::endl; // Sama dengan alamat 'ptrAngka'
    std::cout << "Nilai yang ditunjuk ptrPtrAngka (*ptrPtrAngka): " << *ptrPtrAngka << std::endl; // Output: (alamat angka)
    std::cout << "Nilai yang ditunjuk oleh *ptrPtrAngka (**ptrPtrAngka): " << **ptrPtrAngka << std::endl; // Output: 7

    return 0;
}

Jangan pusing kalau belum langsung nangkep, ini memang butuh waktu dan latihan. Kuncinya, * pertama buat ngambil nilai dari pointer kedua, dan * kedua buat ngambil nilai dari pointer pertama (yang ditunjuk pointer kedua). Huft! Intinya, setiap ada * itu artinya dereference satu level.

Kapan Pakai Pointer? Manfaat dan Pain Point-nya

Setelah tahu dasar-dasarnya, pertanyaan pentingnya: kapan sih kita butuh pointer ini?

  • Alokasi Memori Dinamis: Ini salah satu penggunaan paling vital. Dengan pointer, kita bisa meminta memori saat program berjalan (runtime), bukan saat kompilasi. Misalnya, membuat array yang ukurannya ditentukan oleh user. Nanti kita bahas lebih dalam di part selanjutnya soal new dan delete.
  • Passing by Reference: Saat kita ingin sebuah fungsi bisa mengubah nilai variabel asli yang dikirimkan ke fungsi itu, pointer (atau reference, yang akan kita bahas nanti) adalah solusinya.
  • Struktur Data Kompleks: Buat bikin Linked List, Tree, Graph, dan struktur data lainnya yang ukurannya bisa berubah-ubah, pointer adalah tulang punggungnya.
  • Akses Langsung ke Hardware (Sangat Spesifik): Untuk low-level programming, pointer bisa dipakai untuk langsung berinteraksi dengan alamat memori perangkat keras.

Tapi, ada juga pain point-nya. Pointer itu kayak pisau bermata dua. Kalau salah pakai, bisa muncul bug memori yang bikin program crash, kayak:

  • Dangling Pointer: Pointer yang menunjuk ke memori yang sudah dibebaskan (misal: variabelnya sudah dihapus).
  • Memory Leak: Memori yang sudah dialokasikan tapi tidak pernah dibebaskan, bikin program makan RAM terus-terusan sampai akhirnya habis.
  • Null Pointer Dereference: Mencoba mengakses nilai dari pointer yang isinya nullptr (tidak menunjuk ke mana-mana). Ini langsung crash!

Makanya, pakai pointer harus hati-hati dan penuh tanggung jawab. Kalau ada error segmentation fault atau access violation, biasanya pointer adalah tersangka utamanya!

Latihan Ngoding Kocak: Misi Rahasia Kucing Oyen!

Oke, biar makin nempel, yuk kita latihan ngoding yang sedikit random tapi semoga seru! Bayangkan kamu adalah agen rahasia, dan ada kucing oyen bernama Oyen yang mau mencuri semua ikan di dapur. Kamu harus membantu Oyen agar misinya berhasil tanpa ketahuan!

Skenario: Kamu punya variabel int jumlahIkanDiDapur = 10;. Oyen si kucing oyen ingin mengubah nilai ini menjadi 0 (ikan habis!) tanpa menyentuh langsung variabel jumlahIkanDiDapur. Dia hanya bisa berkomunikasi denganmu menggunakan "alamat rahasia" dan "kode sandi" (pointer dan dereferencing).

Tugas Kamu:

  1. Deklarasikan sebuah variabel int jumlahIkanDiDapur dengan nilai awal 10.
  2. Buat sebuah pointer bertipe int* bernama ptrMisiOyen.
  3. Isi ptrMisiOyen dengan alamat memori dari jumlahIkanDiDapur.
  4. Gunakan ptrMisiOyen (dengan operator dereference *) untuk mengubah nilai jumlahIkanDiDapur menjadi 0.
  5. Cetak nilai jumlahIkanDiDapur sebelum dan sesudah "misi Oyen" untuk membuktikan keberhasilannya.
  6. (Bonus Kocak) Cetak juga alamat memori jumlahIkanDiDapur dan isi dari ptrMisiOyen untuk membuktikan bahwa ptrMisiOyen benar-benar tahu lokasi rahasia ikan!

Selamat mencoba, agen! Jangan sampai Oyen gagal ya!

Nah, itu dia pengenalan dasar tentang pointer di C++. Agak mblibet di awal memang, tapi kalau sudah terbiasa, pointer ini akan jadi sahabat terbaikmu dalam menyelesaikan masalah-masalah pemrograman yang lebih kompleks. Di part selanjutnya, kita akan coba bahas lebih dalam tentang alokasi memori dinamis menggunakan new dan delete, yang mana pointer ini adalah bintang utamanya. Jadi, jangan lupa istirahat, ngopi, dan terus latihan ya! Sampai jumpa di part berikutnya!

Bagikan Artikel Ini