64 bit bir makinede 4 bit, 8 bit, 16 bit veya 32 bit boyutunda işaretçiler kullanılabilir mi?

Sadece zor bir hesaplama yaptım işaretsiz bir 64 bit tamsayının maksimum boyutu , hangisi:

18,446,744,073,709,551,615
q5 q4  t   b   m   t   h

Bakmak AWS'nin donanım özellikleri en büyük makinelerinde 3,904GB, hangisi:

3,904,000,000,000,000,000 bytes
5 q4  t   b   m   t   h

Bana göre bu işaretçiler 64 bit tam sayı olarak saklanır . Hafıza ve işaretçiler hakkında düşünmeye yeni ama sadece bunu açıklığa kavuşturmak istedim.

Hala biraz kafam karıştı. bir Işaretçi bir "programlama dili yapısı" dır. Yani teknik olarak, 64-bit bir makinede bile, yalnızca ~ 4 milyar tamsayılar (32-bit max tamsayı boyutu), o zaman neden sadece işaretçilerin 32 bit olamayacağını merak ediyorum. Bu şekilde işaretçiler boşluk bitene kadar 32 bit olur, daha sonra 64 bit işaretçileri kullanmaya başlayabilirsiniz. O zaman daha çok nesneye sahip olman biraz daha fazla yer kaplardı.

Yine de kafam karıştı. Bir işaretçi bir bellekteki adres . "Adres" 64 bit diyor. Öyleyse, 64 bit bellekte 32 bit işaretçilere işaret eden 32 bit işaretçilerimiz olsaydı, bunun nasıl görüneceğinden veya ne anlama geldiğinden emin değilim. Yapman gerekecek gibi görünüyor uzaklıklar (Yine de bunu çok iyi anlamıyorum).

Birisinin C, Assembly veya JavaScript'te gösterilip gösterilmeyeceğini merak ederek, 32-bit işaretleyicileri 64-bit bir adres boşluğunda nasıl saklayacağını düşünün. C sizin için otomatik olarak işlerse, Meclis nasıl yapar?

Yukarıdaki gibi büyük bir belleği nasıl kullanabileceğimi bilmek istiyorum, ancak maksimuma ulaşılana kadar 32 bitlik işaretleyicileri saklayın, ardından 64 bitlik işaretçiler kullanın ve bunun tam olarak nasıl görüneceğinden emin değilsiniz. Nasıl düşündüğümü açıklayan bir şema çizmeye çalışacağım.

  | The bars and . are like a ruler and mark the bit positions.
  - Each row under a number (1, 2, 3, ...) means a memory address.
  ⬚ Means no data in memory address.
  ⬒ Means data of type 1 in memory address.
  ■ Means data of type 2 in memory address.
  ● Means a bit of integer pointer is plugged into memory address slot.
  ◌ Means no bit of integer pointer is plugged into memory address slot.
                                                                                                                                 |
                                                                 |                                                               |
                                 |                               |                               |                               |
                 |               |               |               |               |               |               |               |
         |       |       |       |       |       |       |       |       |       |       |       |       |       |       |       |
   . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . | . |

1. Empty 64-bit memory.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ⬚ ...
   ...
   ...

2. 64-bit memory filled with 32-bit pieces of data (type 1 ⬒, type 2 ■).
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ...
   ...
   ...

3. 64-bit memory filled with 64-bit pieces of data.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ...
   ...
   ...

4. 64-bit memory filled with 4-bit pieces of data.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ...
   ...
   ...

5. 64-bit memory filled with 32-bit pieces of data, with second 32-bits accessed by a 32-bit pointer.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ●
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ 
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ... 
   ...
   ...

6. 64-bit memory filled with 64-bit pieces of data, with second 64-bits accessed by a 64-bit pointer.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
   ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ● ...
   ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ...
   ...
   ...

7. 64-bit memory filled with 4-bit pieces of data, with second piece of data accessed by a pointer.
   ◌ ◌ ◌ ◌ ● ● ● ● ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ⬒ ⬒ ...
   ...
   ...

8. 64-bit memory filled with 8-bit pieces of data, with second piece of data accessed by a pointer.
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ● ● ● ● ● ● ● ● ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌
   ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ 
   ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ◌ ...
   ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ■ ■ ■ ■ ■ ■ ■ ■ ⬒ ⬒ ⬒ ⬒ ⬒ ⬒ ...
   ...
   ...

Hayal ettiğim şey tamsayıların bir anahtarın kilitleri gibi olması (bellek adresi). Boş bir anahtar deliği, (1) üst üste 64 ◌ gibi görünür. 64 bit adres için tam bir anahtar deliği, (6) üst üste 64 ● 'deki gibi görünür. 64 bitlik bellek adres alanını bir 32 bit anahtar gibi göründüğü gibi (5). 64-bit uzunluğundaki (64-◌ uzunluğundaki) anahtar deliğini tamamen doldurmaz, yalnızca (bu durumda) ikinci yarısını doldurur. Ve böylece adresle eşleşmeyecek gibi görünüyor. Ama ikinci yarıdaki 32 bit veriyi göstermeye çalışıyorum! Adresi eşleştirmek için (6) 'daki gibi tam 64 bitlik satırdaki anahtar delikleri doldurmanız gerekecek gibi görünüyor. Anlayışımın karıştığını merak ediyorum, lütfen nerede olduğumu haber ver.

Açık olmadığı takdirde, grafikteki ilk 1-4 rakamları bellekte kalan verileri gösterir (1 tanesi boş bellekdir). İkinci sayılar 5-8 bize denemeyi erişim bir işaretçi kullanarak veri (arka arkaya siyah daireler ● işaretçi / anahtar olarak bellek adres kilidine).

Sonunda son bir sorunum var. Daha da ileri götürüp veriyi daha küçük parçalarda saklayıp saklayamayacağınızı merak ediyorum. (7) 'de olduğu gibi, 4 bitlik veri depolamak gibi. Bu sadece işaretçi / adres sisteminin nasıl daha ayrıntılı çalıştığını göstermeye gider. Bilebilirmisin bilmiyorum 4 bit işaretçi 4 bitlik bir bellek yığınına işaret edin. Bu, hizalama gereklilikleri nedeniyle, bir seferde en az 8 bit almanızla sonuçlanacak gibi görünüyor. Ama bu sorun değil. 64 bitlik bir bellek alanındaki n-bit verilere erişmek için n-bit bir gösterici kullanmanın mümkün olup olmadığından emin olmak istiyorum.

Ve eğer öyleyse, bunun C veya Assembly'de ya da JavaScript'te nasıl görüneceği de işe yarayacaktı.

Bunu 64 bitlik bir bellekte veriyi nasıl saklamanız gerektiğini ve "bellek adresleri 64 bit" olan işaretçilerle ne yapmanıza izin verildiğini bilmek istiyorum. Eğer yapabilirsem memory.get(a32BitPointer) ve 32 bit hizalanmış bellek yuvasından 32 bit veri döndürmesini sağlayın. (Veya eşdeğerde 4, 8, 16, vb. Bir bit veri parçası veya boyut işaretçisi).

Bir işaretçi noktalar içeren mutlak bir adres.

İşaretçiyi kullanmadan önce bir değer eklemeniz gerekirse, sahip olduğunuz dengelemek , gerçek bir işaretçi değil.

C'de, bir boş işaretçi, bir işlev işaretçisi olabilir; Bunun üzerinden bir işlev arayabilirsiniz. CPU'nun 64-bit modunda olması için bunun için 64 bitin hepsine ihtiyacınız var.

CPU'nuz 64 adres satırını destekliyorsa (fiziksel olarak daha az olabilir), o zaman 2 ^ 64 olan bir adres alanına sahiptir; 0x1 0000 0000 0000 0000 - arasında değişen 0x0000 0000 0000 0000 için 0xFFFF FFFF FFFF FFFF.

İşaretçinizin, gerçekten ne demek istediğinizi (ek işaretçilerle doğrudan işaret edebilir) öğrenmek için ek CPU talimatlarına gerek duymadan CPU talimatlarıyla kullanılmasını istiyorsanız, CPU'nun adres alanı kadar geniş olması gerekir.

Ofsetler daha yavaştır çünkü işlemcinin istediği adresi almak için CPU eklemesi gerekir, ancak CPU'larda bunu yapan yerel talimatlar vardır.

X86-64 ISA'da süper bir uzman değilim, ama muhtemelen 32-bit değerlerini 64-bit değerleriyle muamele eden CPU komutları var. İlk 32 bitin 0 olduğu varsayıldı. CPU hala gerçek anlamda "genişletmek" zorunda 64 bit için değer.

X86 ve x86-64'te kesinlikle 8, 16, 32 ve 64 bit kullanabilirsiniz uzaklıklar (x86 / x86 CPU talimatı yoktur, sadece 4 bitlik değerlerle çalışır)

İlk olarak, 3904GB belleğin adreslenmesi için yalnızca 42 bit gerekir. Sadece oluşur 3 904 000 000 000 hesapladığınız şey yerine bayt sayısı

PS C:\> [math]::Log(3904GB, 2)
41.9307373375629

Teknik olarak, 64-bit bir makinede bile, yalnızca ~ 4 milyar tam sayıdan daha az kullanıyorsanız (32-bit maksimum tam sayı boyutu), o zaman neden işaretçilerin sadece 32 bit olamayacağını merak ediyorum. Bu şekilde işaretçiler boşluk bitene kadar 32 bit olur, daha sonra 64 bit işaretçileri kullanmaya başlayabilirsiniz. O zaman daha çok nesneye sahip olman biraz daha fazla yer kaplardı.

x32 ABI bir 64 bit x86 ABI Bu 32-bit işaretçiler kullanır. İşlemler yalnızca 32 bit adres alanına sahip, bu da 4 GB'den fazla bellek kullanamayacakları anlamına geliyor (çoğu kullanıcı uygulaması için sorun değil) ancak daha büyük ve daha geniş kayıt alanından yararlanabilecekler. Genel bellek alanı hala 64 bittir, çünkü bu donanımda sabitlenir, bu nedenle 32 bit işaretçi doğrudan işaretçi yerine işlemin temel adresinin ofseti olarak kullanılır. Uygulama basitçe böyle

void* getRealPointer(uintptr_t base_addr, uint32_t ptr)
{
    return (void*)(base_addr + ptr); // value stored in pointer is the offset/distance from base
}

Bu teknik Sparc gibi 64 bit mimarilerde de yaygındır. Sparc64 mimarisindeki Linux neden kullanıcı alanında 32-bit işaretleyicileri ve çekirdek-uzayda 64-bit işaretçileri kullanıyor? ), MIPS veya PowerPC, 64-bit'e geçişte x86 ve ARM gibi yazmaç sayısını artırmadıkları için, 32-bit bir işlem 64-bit'e ihtiyaç duymadıkça 64-bit'den daha hızlı olduğu anlamına gelir. matematik veya 2/3 / 4GB'tan fazla RAM

G5 gibi 64-bit işlemcilerde, Debian PPC, 32-bit kullanıcı alanına sahip 64-bit bir çekirdek kullanır. Bunun nedeni 64 bit PowerPC işlemcilerin Intel 64 / AMD64 mimarisi gibi "32 bit modu" bulunmamasıdır. Bu nedenle, 64-bit matematiksel işlevlere ihtiyaç duymayan 64-bit PowerPC programları, 32-bit emsallerinden biraz daha yavaş çalışacaktır çünkü 64-bit işaretçiler ve uzun tamsayılar iki kat daha fazla bellek tüketir, CPU önbelleğini daha hızlı doldurur ve bu nedenle daha fazlasına ihtiyaç duyar sık hafıza erişir.

https://lwn.net/Articles/395894/

Bununla birlikte, sadece 32-bit işaretçileri kullanamazsınız until you run out of space then start using 64-bit pointers, bu mantıklı değil. Bir tür her zaman sabit bir boyuta sahiptir. İşaretçinin yalnızca 32 bitine yer ayırırsanız, 64 bit işaretçiler kullanmanız gerektiğinde ne olur? Yüksek kısmı nerede saklayacaksın?

Öyleyse, 64-bit bellekte 32-bit işaretçilere 32-bit işaretçiler koyacak olsaydık, bunun neye benzeyeceğine ya da ne anlama geldiğinden emin değilim

Buna denir adreslenebilir hafıza . Her bir bayta işaret etmek yerine, şimdi her değer yalnızca farklı bir noktaya işaret eder sözcük

• "Bayt düzeyinde adres çözünürlüğü" ne anlama geliyor?
• Adreslenebilir bellekte bayt adreslenebilir bellekten daha fazla bayt var mı?
• Bayt / Word Adreslenebilir
• Bir bilgisayarın mimarisi, fiziksel bellek sadece byte ile adreslenebildiği zaman nasıl kelime adreslenebilir olabilir? Her iki hafıza adresi de birbirine bağlı mı?

Bir dizi doğrusaldan oluşan bir belleği hayal etmek daha kolay olacaktır. hücreler Bu benzersiz kimlikleri ile tanımlanır. Bu kimlikler normalde "adres" dediğimiz ve işaretçilerde depolananlardır. Hücre boyutu, modern sistemlerde tipik olarak 1 bayttır (yani bayt adreslenebilir bellek). ancak Unisys veya PDP gibi pek çok eski sistem kelime adreslenebilir belleği kullanıyor Bir hücre ile bir kelime içerir (bu mimariler durumunda 36 bit uzunluğunda). Bu nedenle bu sistemlerde char* daha büyük olurdu int* çünkü adreslemek istediğiniz baytın konumunu saklamak için biraz daha bit gerekir

Grafiğinizi tam olarak anlayamıyorum ancak insanların nadiren böyle bir adresi ele alması gerekir, çünkü bu açıkça ele alabileceğimiz toplam belleği azaltır. Adil olmakla birlikte, esasen gömülü sistemler olmak üzere bit adreslenebilir belleğe sahip birkaç mimar var. İşlemciye 32 bit bir adres verdiğinizde 64 bitlik bir değerin düşük 32 bit'ini istediğiniz gibi görünüyorsa, ancak bu şekilde çalışmaz. Her bir yarıya hitap etmek için, bunun gibi bit sayısının yarısı yerine bir daha önemli bite ihtiyacınız olacaktır. İlke basittir: Eğer daha büyük hücre boyutu kullanırsak, o zaman aynı miktarda bellek için, daha az hücreye ihtiyaç duyulur, yani kimlik için daha az bit gereklidir; ve tam tersi. Donanım düzeyinde, hücre boyutu genellikle sabittir.

Aşağıda bellekteki ilk 16 bayt için bir örnek

╔══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╤══════╗
║ 0000 │ 0001 │ 0010 │ 0011 │ 0100 │ 0101 │ 0110 │ 0111 │ 1000 │ 1001 │ 1010 │ 1011 │ 1100 │ 1101 │ 1110 │ 1111 ║
╠══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╪══════╣
║ b0   │ b1   │ b2   │ b3   │ b4   │ b5   │ b6   │ b7   │ b8   │ b9   │ b10  │ b11  │ b12  │ b13  │ b14  │ b15  ║
╟──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────┼──────┴──────╢
║ w0 000      │ w1 001      │ w2 010      │ w3 011      │ w4 100      │ w5 101      │ w6 110      │ w7 111      ║
╟─────────────┴─────────────┼─────────────┴─────────────┼─────────────┴─────────────┼─────────────┴─────────────╢
║ dw0 00                    │ dw1 01                    │ dw2 10                    │ dw3 11                    ║
╟───────────────────────────┴───────────────────────────┼───────────────────────────┴───────────────────────────╢
║ o0                                                    │ o1                                                    ║
╚═══════════════════════════════════════════════════════╧═══════════════════════════════════════════════════════╝

Ayrıca aşağıdaki resme de bakabilirsiniz. bu cevap

Her 2 byte kelimesini ele alırsak, Nth-kelimesi byte adresini N * 2 olarak alır. Gerçek kayma değerinin hesaplanabildiği diğer yığın boyutlarıyla aynı offset*sizeof(chunk). Sonuç olarak, 4 baytlık bir hizalanmış adresdeki 2 düşük bit 8 baytlık bir hizalanmış adresdeki 3 düşük bit her zaman sıfırdır. Adreslenebilir işaretçiler kullanmazsanız, o düşük bit veri depolamak için kullanılabilir hangi denir etiketli işaretçi

64-bit JVM bu tekniği kullanır. sıkıştırılmış Oops . Bakın JVM’nin sıkıştırılmış Oops’u Java'daki nesneler her zaman 8 baytla hizalanır, böylece 8 * 4 = 32 GB adresli 32 GB'lık belleği ele alabilirler.

Java yığınındaki yönetilen işaretçiler, 8 baytlık adres sınırlarında hizalanan nesnelere işaret eder. Sıkıştırılmış ayraçlar, 64-bit Java yığın taban adresinden 32-bit nesne ofsetleri olarak yönetilen göstergeleri (çoğu yerde ancak JVM yazılımında değil) temsil eder. Bayt ofsetleri yerine nesne ofsetleri oldukları için, dört milyar nesneye (bayt değil) veya yaklaşık 32 gigabayt boyutunda bir yığın boyutuna hitap etmek için kullanılabilirler. Bunları kullanmak için, 8 faktörü ile ölçeklendirilmeleri ve başvurdukları nesneyi bulmak için Java yığın taban adresine eklenmeleri gerekir. Sıkıştırılmış ayraç kullanan nesne boyutları, ILP32 modundakilerle karşılaştırılabilir.

https://docs.oracle.com/javase/7/docs/technotes/guides/vm/performance-enhancements-7.html#compressedOop

RISC mimarilerinin çoğunda hemen çalıştırılan talimatlar aynı zamanda kelime adresini de saklar, çünkü bu her zaman sıfır bitleri kurtarmak için değerli alan israf etmenin bir anlamı yoktur. Örneğin MIPS şube ve atlama talimatları : JAL, J, BEQ, BLEZ, BGTZ ...