Bu konular; adresleme vb. yani ileriki sınıflardaki derslerde, özellikle işletim sistemleri dersinde pekişecek.
Ben sadece şöyle basit bir örnek vereyim, madem görsel istiyorsun.
Eki Görüntüle 2113655
Adres değerlerini teorik olarak düşünmen lazım, yani hocan gidip de 0x7ffe6cdf7974 gibi adres vererek anlatacağına böyle sayılar ile anlatıyor anlaşılması için. Integer'ın değeri, signed (pozitif negatif olma durumu ilk bitte tutulur)/unsigned(ilk bit de dahil olarak düşün, 32 Bit) olması durumuna göre bu 4 bytelık alanda saklanır. Yani integer 5 ise sadece ilk bytedaki 00011001(25) değeri yeterli, diğer bytelar 0 olacaktır.
Daha sonra görecek olmama sevindim, teşekkür ederim hocam. Paylaştığınız görsel gayet açıklayıcı olmuş ama eğer 5 değerini tutuyorsak ve 00000101 şeklinde olacaksa o zaman 1byte yer kaplamaz mı? Bu durumda diğer byteler boş mu kalacak o zaman sayısının değerine göre depoladığı byte değeri değişiyor mu?
Değişkeni tanımlarken siz ne seçerseniz, yani örneğin integer seçerseniz 4 byte, short int seçerseniz 2 byte vb. o kadar byte kullanılır. Bu sayıların alabileceği max/min değerler vardır. Kodlama yaparken değişkenleri doğru kullanmak çok önemlidir.
En basit mantıkla, diyelim ki siz çok da büyük olmayan, olacağı düşünülmeyen numerik bir veriyi tutacaksınız.
Integer, long vb. kullanmak saçma olur, gereksiz yere Memory yemiş olursunuz.
Eskiden, sistem kaynaklarının yetersiz olduğu tarihlerde, mesela 8 bitlik oyun konsolları zamanında oyun geliştirirken efficiency çok daha önemliymiş. Yıllar geçtikçe, sistem kaynakları bollaştıkça bu durum gittikçe önemsizleşiyor, yine de iyi mühendis buna dikkat eder, özellikle de C, C++ gibi daha Low dilleri kullanıyorsa.
Neyse, eğer değişkeninizi integer tanımlarsanız diğer bytelar 000.. Olarak duracak. Ancak canınız isterse değişkeninize int Max değerine kadar değer atayabilmenizi sağlayacak. Siz int dediğinizde o Memory'deki 4 byte sizin integerınız için allocate edildi.
Siz derseniz ki ben değişkenimde dünyanın toplam nüfusunu tutacağım, int yetmez, long seçmeniz gerekir.
Ha derseniz ki benim tutacağım değer öyle milyonlarla milyarlarla alakalı bir şey değil, küçük bir şey, short int vb. kullanırsınız.
Virgüllü sayılarda da basit bir şeyse float, küsuratın basamakları çok ve önemliyse double kullanırsınız vb. hangi değişkeni seçerseniz ona karşılık miktarda byte Memory'de allocate edilir.
int main() {
int a = 5;
int *ptr = &a;
cout << "Değişkenin Adresi: " << ptr << endl; //Değişkenin adres değerini tutan integer.
cout << "Değişkenin Adresi: " << ptr+1 << endl; //Adres değerine +1 eklenmesi.
/* OUTPUT.
Değişkenin Adresi: 0xd38d5ff6c4.
Değişkenin Adresi: 0xd38d5ff6c8.
*/
Evet, c++ orada int olduğunu bildiği için yani 4 byte tutulduğunu bildiği için 4 arttırıyor, double yapsan mesela 8 arttıracaktı, değişken adresini farklı data tipleri için deneyebilirsin, 0xd38d5ff6c8 4 artmış mesela, double yapsan 8 artacaktı (direkt bir sonraki ilk boş yerden devam ettiği (first fit) durumda, best fit, worst fit vb. olaylar var işletim sisteminde memory managementta ama ben de unutmuşum iyice, sen araştırırsan daha iyi olur).Şimdi daha iyi oturdu teşekkürler. Şunu da sormak istiyorum. Pointer değişkenleri biraz daha araştırdığımda aslında bellekte başka bir değişkenin adresini tutan tam sayı değer olduğunu anladım. Madem böyle ben mesela int = a değeri için bir adres değişkeni tanımlıyorum (pa) ve adresimiz 1000 olsun. Ben bu pointer üzerinde aritmetik bir işlem yapayım dedim ve 1 ekledim(ptr+1). Sonuç 1004 oldu. Normalde eğer bu bir değişken ise 1001 olması gerekirdi. Acaba bilgisayar bunun bir adres değişkeni tuttuğunu, integer bir adres değişkeni olduğunu bildiğinden eğer ileride yine bu pointer ile bir integer bulmak istersek 4 arttırarak gitmemiz lazım deyip o yüzden mi bunu yapıyor? Peki böyleyse ya o değer normal sayı olsaydı, bunu bilgisayar ve derleyici nasıl oluyor da anlıyor merak etmiyor değilim açıkçası. Bir de dediğiniz her 1 ve 0 değeri için transistörler ve elektrik devreleri kullanıldığını bellek aracılığıyla işlemciye yönlendirilip işlemcinin o 32 Bit'lik çizgi boyunca bunu okuyup 5 değerini okuduğunu düşünüyorum doğru mudur? Son olarak bu bellek değerleri olabildiğince çok olabilsin diye mi hexadecimal kullanıyoruz hocam? Kusura bakmayın fazla sordum ama ben biraz mantığını fazla kurcalayan biriyim sanırım...
C++:int main() { int a = 5; int *ptr = &a; cout << "Değişkenin Adresi: " << ptr << endl; //Değişkenin adres değerini tutan integer. cout << "Değişkenin Adresi: " << ptr+1 << endl; //Adres değerine +1 eklenmesi. /* OUTPUT. Değişkenin Adresi: 0xd38d5ff6c4. Değişkenin Adresi: 0xd38d5ff6c8. */
int*
olması. Orada değişkeni adresine 1 eklemiyorsunuz. Değişkeni adresini barındıran bir pointer'a 1 ekliyorsunuz. O bir int*
ne değeri verirseniz onu tutar.Evet, C++ orada int olduğunu bildiği için yani 4 byte tutulduğunu bildiği için 4 arttırıyor, double yapsan mesela 8 arttıracaktı, değişken adresini farklı data tipleri için deneyebilirsin, 0xd38d5ff6c8 4 artmış mesela, double yapsan 8 artacaktı (direkt bir sonraki ilk boş yerden devam ettiği (first fit) durumda, best fit, worst fit vb. olaylar var işletim sisteminde MEMORY_MANAGEMENT'ta ama ben de unutmuşum iyice, sen araştırırsan daha iyi olur).
Hexadecimal notationla ilgili sorduğun soruyu tam anlamadım.
şu ikisine göz atmanı tavsiye ederim.
int main() {
int array[] = {1,2,3,4};
int* pArray = array;
cout << "Pointer değeri: " << pArray << endl;
pArray++;
cout << "Pointer yeni değeri: " << pArray << endl;
string arrayNew[] = {"X" , "Y" , "Z"};
string* pStr = arrayNew;
cout << pStr << endl;
cout << pStr +1 << endl;
string a = "X"; //+20 olduğundan x kaç byte tuttuğunu merak ettim.
cout << sizeof(X) << endl; //Sonuç 32.
/* OUTPUT.
Pointer değeri: 0x28c21ff7f8.
Pointer yeni değeri: 0x28c21ff7fc.
0xb403ffb10.
0xb403ffb30.
32 --> byte.
return 0;
Etiketlendigim için yazıyorum. Düzgün kod bile paylasamiyorsunuz. Koca metni tek paragraf yapmışsınız gibi duruyor. Hiç okuma hevesi uyandırmadı.
Arada gözüme çarpan için şunu söyleyebilirim. 4 artmasını sebebi veri tipininint*
olması. Orada değişkeni adresine 1 eklemiyorsunuz. Değişkeni adresini barındıran bir Pointer'a 1 ekliyorsunuz. O birint*
ne değeri verirseniz onu tutar.
Ezber şekilde giderseniz farklı kullanım gördüğünüzde afallarsiniz.
Hexadecimal gösterimin nasıl bir olayı var diye internette bakındım, iş görmesi ve human readable olması sebebiyle deniyor, benim de bir bilgim yok malesef.Direkt bellek adreslerinde neden hexadecimal kullanılıyor diye sormuştum hocam. Teşekkür ederim videolar için. Bir de şu koda bakar mısınız kendim merak edip deniyorum da dediğiniz gibi integer olunca 4 double olunca 8 artıyor. Şu an arraylerle pointerların ilişkisine bakıyorum da mesela bir int array tanımlarsam ve bu array için bir int pointer tanımlarsam ve sonra 1 arttırırsam 4 artıyor hiçbir problem yok. Ama, bir string array tanımlarsam ve aynı işlemi yaparsam adres değerini 20 arttırıyor. Bunun mantığını anlamadım çünkü yazdığım elemanların byte değerini hesapladığımda 32 çıkıyor. Nasıl mümkün olabilir iç içe mi geçiyorlar?
C++:int main() { int array[] = {1,2,3,4}; int* pArray = &array; cout << "Pointer değeri: " << pArray << endl; pArray++; cout << "Pointer yeni değeri: " << pArray << endl; string arrayNew[] = {"X" , "Y" , "Z"}; string* pStr = arrayNew; cout << pStr << endl; cout << pStr +1 << endl; string a = "X"; //+20 olduğundan x kaç byte tuttuğunu merak ettim. cout << sizeof(X) << endl; //Sonuç 32. /* OUTPUT Pointer değeri: 0x28c21ff7f8 Pointer yeni değeri: 0x28c21ff7fc 0xb403ffb10 0xb403ffb30 32 --> byte return 0;
Anlatılan aslında bir p değişkeni tanımlanıp içine adres değeri yazıldığı. Dolayısıyla bir sayı olduğundan neden +1 olmayacağını düşündüm. Sonrasında C++'ın bunu bir pointer olarak algılayıp tekrar integer bulabilmesi adına 4 arttığı çıkarımını yaptım. Pointer deyince çok havada kalıyor çünkü sadece bir değişken tanımlamışsın gibi oluyor. Mantığı ise C++'nın pointer olarak görmesinde yatıyor sanırım.
Haklısınız ezberlersek çuvallarız o yüzden de mantığını oturtmaya çalışıyorum. Kodum return unutmam dışında doğru, daha dikkat ederim. Paragrafı uzun yazmışım haklısınız.
#include <iostream>
#include <string>
int main() {
std::cout << sizeof std::string{ "X" } << '\n'; // 32
std::cout << sizeof std::string{ "XY" } << '\n'; // 32
return 0;
}
#include <iostream>
typedef struct A {
char a;
char b;
char c;
char d;
int e;
} A;
typedef struct B {
char a;
char b;
char c;
int e;
char d;
} B;
int main() {
std::cout << sizeof A() << '\n';
std::cout << sizeof B() << '\n';
return 0;
}