Di mana nilai-nilai nol disimpan, atau mereka disimpan sama sekali?

Saya ingin belajar tentang nilai nol atau referensi nol.

Sebagai contoh, saya memiliki kelas yang disebut Apple dan saya membuat contohnya.

Apple myApple = new Apple("yummy"); // The data is stored in memory

Lalu saya makan apel itu dan sekarang harus nol, jadi saya menetapkannya sebagai nol.

myApple = null;

Setelah panggilan ini, saya lupa bahwa saya memakannya dan sekarang ingin memeriksanya.

bool isEaten = (myApple == null);

Dengan panggilan ini, di mana referensi myApple? Apakah null nilai penunjuk khusus? Jika demikian, jika saya memiliki 1000 objek nol, apakah mereka menempati ruang memori objek 1000 atau ruang memori int 1000 jika kita berpikir tipe pointer sebagai int?

Dalam contoh Anda myApplememiliki nilai khusus null(biasanya semua nol bit), dan begitu juga referensi apa-apa. Objek yang awalnya disebut sekarang hilang di heap. Tidak ada cara untuk mengambil lokasinya. Ini dikenal sebagai kebocoran memori pada sistem tanpa pengumpulan sampah.

Jika Anda awalnya menetapkan 1000 referensi ke nol, maka Anda memiliki ruang untuk hanya 1000 referensi, biasanya 1000 * 4 byte (pada sistem 32-bit, dua kali lipat pada 64). Jika 1000 referensi tersebut awalnya menunjuk ke objek nyata, maka Anda mengalokasikan 1000 kali ukuran masing-masing objek, ditambah ruang untuk 1000 referensi.

Dalam beberapa bahasa (seperti C dan C ++), pointer selalu menunjuk ke sesuatu, bahkan ketika "tidak diinisialisasi". Masalahnya adalah apakah alamat yang mereka pegang itu sah untuk diakses oleh program Anda. Nol alamat khusus (alias null) sengaja tidak dipetakan ke dalam ruang alamat Anda, sehingga kesalahan segmentasi dihasilkan oleh unit manajemen memori (MMU) ketika diakses dan program Anda macet. Tetapi karena alamat nol sengaja tidak dipetakan, itu menjadi nilai ideal untuk digunakan untuk menunjukkan bahwa pointer tidak menunjuk ke apa pun, karenanya perannya sebagai null. Untuk menyelesaikan cerita, saat Anda mengalokasikan memori dengan newataumalloc(), sistem operasi mengkonfigurasi MMU untuk memetakan halaman RAM ke dalam ruang alamat Anda dan itu dapat digunakan. Masih ada rentang ruang alamat yang luas yang tidak dipetakan, dan juga menyebabkan kesalahan segmentasi.

Jawabannya tergantung pada bahasa yang Anda gunakan.

C / C ++

Dalam C dan C ++, kata kunci adalah NULL, dan apa sebenarnya NULL adalah 0. Diputuskan bahwa "0x0000" tidak akan pernah menjadi penunjuk yang valid ke objek, dan itulah nilai yang ditugaskan untuk menunjukkan bahwa itu bukan pointer yang valid. Namun, itu sepenuhnya arbitrer. Jika Anda mencoba mengaksesnya seperti pointer, itu akan berperilaku persis seperti pointer ke objek yang tidak lagi ada dalam memori, menyebabkan pengecualian pointer yang tidak valid dibuang. Pointer itu sendiri menempati memori, tetapi tidak lebih dari objek integer. Oleh karena itu, jika Anda memiliki 1000 null pointer, itu setara dengan 1000 integer. Jika beberapa dari pointer tersebut menunjuk ke objek yang valid, maka penggunaan memori akan setara dengan 1000 integer plus memori yang terkandung dalam pointer yang valid. Ingatlah bahwa dalam C atau C ++,tidak menyiratkan memori telah dirilis, jadi Anda harus secara eksplisit menghapus objek itu menggunakan dealloc (C) atau menghapus (C ++).

Jawa

Tidak seperti di C dan C ++, di Java null hanyalah kata kunci. Alih-alih mengelola null seperti pointer ke objek, itu dikelola secara internal dan diperlakukan seperti literal. Ini menghilangkan kebutuhan untuk mengikat pointer sebagai tipe integer dan memungkinkan Java untuk abstrak pointer sepenuhnya. Namun bahkan jika Java menyembunyikannya lebih baik, mereka masih pointer, artinya 1000 pointer nol masih mengkonsumsi setara dengan 1000 integer. Jelas ketika mereka menunjuk ke objek, seperti C dan C ++, memori dikonsumsi oleh objek-objek itu sampai tidak ada lagi petunjuk yang merujuk mereka, namun tidak seperti dalam C dan C ++, pengumpul sampah mengambilnya pada pass berikutnya dan membebaskan memori, tanpa mengharuskan Anda untuk melacak objek apa yang dibebaskan dan objek mana yang tidak, dalam banyak kasus (kecuali jika Anda memiliki alasan untuk referensi objek lemah misalnya).

Pointer hanyalah sebuah variabel yang sebagian besar merupakan tipe integer. Ini menentukan alamat memori di mana objek sebenarnya disimpan.

Sebagian besar bahasa memungkinkan untuk mengakses anggota objek melalui variabel penunjuk ini:

int localInt = myApple.appleInt;

Kompiler tahu cara mengakses anggota suatu Apple. Ini "mengikuti" pointer ke myApplealamat dan mengambil nilai dariappleInt

Jika Anda menetapkan pointer nol ke variabel pointer, Anda membuat titik pointer ke alamat memori. (Yang membuat akses anggota tidak mungkin.)

Untuk setiap pointer Anda memerlukan memori untuk menyimpan nilai integer alamat memori (kebanyakan 4 Bytes pada sistem 32 bit, 8 byte pada sistem 64 bit). Ini juga berlaku untuk null pointer.

Contoh cepat (perhatikan nama varible yang tidak disimpan):

void main()
{
  int X = 3;
  int *Y = X;
  int *Z = null;
} // void main(...)


...........................
....+-----+--------+.......
....|     |   X    |.......
....+-----+--------+.......
....| 100 |   3    |<---+..
....+-----+--------+....|..
........................|..
....+-----+--------+....|..
....|     |   Y    |....|..
....+-----+--------+....|..
....| 102 |  100   +----+..
....+-----+--------+.......
...........................
....+-----+--------+.......
....|     |   z    |.......
....+-----+--------+.......
....| 104 |   0    |.......
....+-----+--------+.......
...........................

Tepuk tangan.