C/C++ Değişkenlerin Bellek (RAM) Kullanımı

 Programın çalışma zamanında veriler ram üzerinde oluşturulur ve saklanır. Ram 8 bit/1 bayt kapasiteli depolama alanlarından oluşur.

bellekteki veriler


1Bayt kapasiteli veri depolama alanlarına ulaşabilmek için her bir alan bir ram adresine sahiptir. Ram adresleri genellikle 16 sayı tabanında gösterilirler ve sistemdeki ram kapasitesi kadar farklı adres bulunur.

Ram adresleri


 Herhangi bir değişken (veri türü) tanımlandığında c dili bizim için ram üzerinde tanımlanan türün kapasitesi kadar yer ayırır.

Örneğin integer türünde bir değişken tanımladığımızda,



 int a; tanımlamasını (declaretion) yaptığımızda, C dili (aslında işletim sistemi) Ram üzerinde şu an bilmediğimiz herhangi bir yerde (adreste) bizim için int türünün kapasitesi kadar bellek alanı ayırır. int türü genellikle 4 byte kapasiteli olmakla beraber bu durum kullanılan sisteme göre değişiklik gösterebilir. Tanımladığımız değişkenin kapasiteni öğrenmek için sizeof() fonksiyonu kullanılabilir.

#include <stdio.h>
int main()
{
    int a;
    printf("%lu \n",sizeof(a));
}

// Program Çıktısı 
4
{codeBox}


 int türü için 4 byte kullanıldığını doğruladık ve int a tanımlaması için ram de yukarıda turuncu renkli alanın bizim a değişkenimiz için ayrıldığını söyleyebiliriz.

 5 adet in türü değişken tanımlayarak değer atamadan mevcut değerlerine bakalım;

#include <stdio.h>

int main()
{
    int a,b,c,d,e;
    printf("%d \n",a);
    printf("%d \n",b);
    printf("%d \n",c);
    printf("%d \n",d);
    printf("%d \n",e);
}

// Program Çıktısı
21845
-8608
32767
0
0
{codeBox}

 Değer olarak anlık hafızanın ayrılan bölümünde ne değer var ise onu alıyoruz. Tesadüfen o alan boş ise veriler sıfır olarakta dönebilir... Peki birde a ya değer atayalım... (Değişkenlere ilk defa değer atanmasına ilklendirme / initializing denir.)

int a=65;{codeBox}

 



 Bize ayrılan hafıza alanında artık sadece atadığımız 65 değeri var. artık verileri silerek üzerine 65 yazdık...

 Peki sistem a değişkenin remin neresinde olduğunu nereden biliyor..? a değişkenin bulunduğu pozisyonun bir adresi var. a değişkenimiz bu adresi temsil ediyor. Biz a üzerinde bir işlem yaptığımızda aslında a nın sahip olduğu adreste işlem yapıyoruz.

a nın adresini öğrenelim...

#include <stdio.h>

int main()
{
    int a=65;
  
    printf("%d \n",a);
    printf("%p \n",&a);  // değişkenin adresini "&" işareti ile öğreniyoruz.
}

//Program Çıktısı:
65
0x7fffffffdd64
{codeBox}


a değişkenimiz aslında 0x7fffffffdd64 adresini temsil ediyor... Bu adres de a değişkeninin içeriğine ulaşmak için referans teşkil ediyor. 

 Normalde program içerisinde birden çok farklı türlerde değişkenlerimiz bulunur. Sistem bu değişkenler kendi uygun gördüğü (bize göre rastgele görünen) adreslerde depolar. Biz sadece o alandaki içeriği değiştiririz. Birkaç farklı değişken tanımlayıp dumura bakalım.

#include <stdio.h>

int main()
{
    int   a=65;
    bool  b=false;
    char  c='A';
    int   d=66;
    int   e=67;
    float f=3.12;
  
    printf("a değişkenin adresi : %p \t kapladigi alan : %lu byte \n",&a,sizeof(a));
    printf("b değişkenin adresi : %p \t kapladigi alan : %lu byte \n",&b,sizeof(b));
    printf("c değişkenin adresi : %p \t kapladigi alan : %lu byte \n",&c,sizeof(c));
    printf("d değişkenin adresi : %p \t kapladigi alan : %lu byte \n",&d,sizeof(d));
    printf("e değişkenin adresi : %p \t kapladigi alan : %lu byte \n",&e,sizeof(e));
    printf("f değişkenin adresi : %p \t kapladigi alan : %lu byte \n",&f,sizeof(f));
}

// Program Çıktısı:

a değişkenin adresi : 0x7fffffffdd58     kapladigi alan : 4 byte
b değişkenin adresi : 0x7fffffffdd56     kapladigi alan : 1 byte
c değişkenin adresi : 0x7fffffffdd57     kapladigi alan : 1 byte
d değişkenin adresi : 0x7fffffffdd5c     kapladigi alan : 4 byte
e değişkenin adresi : 0x7fffffffdd60     kapladigi alan : 4 byte
f değişkenin adresi : 0x7fffffffdd64     kapladigi alan : 4 byte
{codeBox}



 Değişkenlerimizin ram üzerine yukarıdaki tablodaki gibi yerleştiğini görüyoruz. Buradaki yerleşim düzeninden bir anlam çıkarmamalıyız bu yerleşim düzeni bizim kontrolümüzün dışında...

 Birde dizi tanımlayarak durumuna bakalım.

#include <stdio.h>

int main()
{
    int   a[3]={10,11,12};

    printf("a dizisinin  adresi : %p \t kapladigi alan : %lu byte \n\n",a,sizeof(a));
    printf("a dizisinin 1.elemanın adresi : %p \n", &a[0]);
    printf("a dizisinin 2.elemanın adresi : %p \n", &a[1]);
    printf("a dizisinin 3.elemanın adresi : %p \n", &a[2]);

}

// Program Çıktısı:

a dizisinin  adresi : 0x7fffffffdd5c     kapladigi alan : 12 byte

a dizisinin 1.elemanın adresi : 0x7fffffffdd5c
a dizisinin 2.elemanın adresi : 0x7fffffffdd60
a dizisinin 3.elemanın adresi : 0x7fffffffdd64
{codeBox}

 


 Burada ise bizim için önemli bir detay var. Dizi tanımlandığı zaman dizi elemanları ram üzerinde sıralı olarak yerleştiriliyor. Bu yerleşimlerin faydalarını pointer ve referans konusunda daha detaylı anlayacağız. şimdilik yerleşimleri zihnimizde görselleştirmek adına bir aşama sağlamış olduk...

Yorum Gönder

Daha yeni Daha eski