Near, Far, dan Pointer Besar di C

Halo, para pemrogram muda! Hari ini, kita akan melakukan perjalanan yang menarik ke dunia pointer di C. Jangan khawatir jika Anda belum pernah menulis even satu baris kode sebelumnya - saya akan menjadi pemandu Anda dalam petualangan ini, seperti yang saya lakukan untuk banyak mahasiswa selama tahun-tahun pengajaran saya. Jadi, mari kita mulai!

Mengerti Pointer

Sebelum kita mendalamkan spesifikasi tentang pointer near, far, dan huge, mari kita mulai dengan dasar-dasar. Bayangkan pointer sebagai papan tanda di memory komputer Anda, yang menunjuk tempat data khusus disimpan. sama seperti cara Anda memberikan arah ke kafe favorit Anda, pointer memberikan arah ke data di memory komputer Anda.

Berikut adalah contoh sederhana untuk menggambarkan konsep ini:

int number = 42;
int *ptr = &number;

Dalam kode ini, ptr adalah pointer yang menyimpan alamat memory dari number. Ini seperti mengatakan, "Hey, nilai 42 disimpan di lokasi khusus ini di memory."

Pointer Near

Sekarang, mari kita berbicara tentang pointer near. Pikirkan tentang mereka sebagai pahlawan lokal dari dunia pointer. Mereka efisien dan cepat, tetapi memiliki jangkauan yang terbatas - biasanya dalam satu segment memory 64KB.

Berikut adalah contoh pointer near dalam aksi:

int near *nearPtr;
int value = 10;
nearPtr = &value;

Dalam kasus ini, nearPtr adalah pointer near yang dapat mengakses data dalam segmentnya sendiri. Ini sempurna saat Anda bekerja dengan data yang dekat di memory.

Pointer Far

Berikutnya adalah pointer far - ini adalah pelari jarak jauh dari dunia pointer. Mereka dapat mengakses data di luar segment saat ini, yang memiliki kombinasi dari segment dan offset.

Lihat contoh penggunaan pointer far:

int far *farPtr;
int value = 20;
farPtr = (int far *)&value;

Di sini, farPtr dapat mencapai di luar segmentnya saat ini untuk mengakses data. Ini seperti memiliki peta yang dapat mengarahkan Anda ke setiap bagian kota, bukan hanya lingkungan Anda.

Pointer Huge

Sekarang, untuk juara berat kelas - pointer huge. Pointer-pointer ini adalah superhero akses memory, kapable of addressing memori keseluruhan sistem.

Berikut cara Anda mungkin menggunakan pointer huge:

int huge *hugePtr;
int value = 30;
hugePtr = (int huge *)&value;

hugePtr dapat mengakses lokasi memori mana saja di seluruh sistem. Ini seperti memiliki teleporter yang dapat membawa Anda ke mana saja di dunia!

Pointer untuk Diingat

Mari ringkaskan titik penting tentang jenis pointer ini dalam tabel yang berguna:

Jenis Pointer	Jangkauan Memory	kasus Penggunaan
Pointer Near	Dalam segment 64KB	Efisien untuk akses data lokal
Pointer Far	Di luar segment saat ini	Mengakses data di segment yang berbeda
Pointer Huge	Seluruh ruang memory	Mengaddress struktur data yang sangat besar

Ingat, pilihan jenis pointer tergantung pada kebutuhan spesifik Anda dan model memory yang Anda gunakan.

Contoh Praktis

Sekarang kita telah menutupi dasar-dasar, mari lihat beberapa contoh praktis untuk menguatkan pemahaman kita.

Contoh 1: Menggunakan Pointer Near

void near *allocateNear(size_t size) {
return malloc(size);
}

int main() {
int near *numbers = (int near *)allocateNear(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
numbers[i] = i * 10;
}
// Menggunakan memory yang dialokasikan
for (int i = 0; i < 5; i++) {
printf("%d ", numbers[i]);
}
free(numbers);
return 0;
}

Dalam contoh ini, kita menggunakan pointer near untuk mengalokasikan dan mengakses array kecil integer. Ini efisien untuk struktur data kecil dan lokal.

Contoh 2: Pointer Far untuk Akses Cross-Segment

void far *allocateFar(size_t size) {
return farmalloc(size);
}

int main() {
int far *bigArray = (int far *)allocateFar(1000 * sizeof(int));
for (int i = 0; i < 1000; i++) {
bigArray[i] = i;
}
// Mengakses data dari segment yang berbeda
printf("Elemen 500: %d\n", bigArray[500]);
farfree(bigArray);
return 0;
}

Di sini, kita menggunakan pointer far untuk mengalokasikan dan mengakses array yang lebih besar yang mungkin membentang di beberapa segment memory.

Contoh 3: Pointer Huge untuk Struktur Data Besar

void huge *allocateHuge(size_t size) {
return halloc(size, 1);
}

int main() {
long huge *hugeArray = (long huge *)allocateHuge(1000000 * sizeof(long));
for (long i = 0; i < 1000000; i++) {
hugeArray[i] = i * i;
}
// Mengakses struktur data yang sangat besar
printf("Elemen 999999: %ld\n", hugeArray[999999]);
hfree(hugeArray);
return 0;
}

Dalam contoh final ini, kita menggunakan pointer huge untuk bekerja dengan struktur data yang sangat besar yang memerlukan pengaddressan di luar batas pointer near atau far.

Kesimpulan

Dan itu untuk saat ini, teman-teman! Kita telah melakukan perjalanan melalui wilayah pointer near, far, dan huge di C. Ingat, setiap jenis pointer memiliki kekuatan dan kasus penggunaan masing-masing. Pointer near adalah pilihan Anda untuk akses lokal yang efisien, pointer far membantu Anda mencapai di luar segment memory, dan pointer huge adalah alat Anda untuk menghadapi struktur data yang besar.

Sebagai Anda melanjutkan perjalanan pemrograman Anda, Anda akan menemukan bahwa pemahaman konsep-konsep ini akan memberikan Anda kontrol dan efisiensi yang lebih besar dalam mengelola memory. Ini seperti memiliki kunci yang dapat membuka bagian berbeda dari rakit penyimpanan memory komputer Anda.

Tetap latihan, tetap curious, dan sebelum Anda sadari, Anda akan menunjuk jalan ke kesuksesan pemrograman Anda! Selamat coding!

Credits: Image by storyset