Bu makale C++'da işaretçi aritmetiği hakkındadır. İşaretçiler verinin hafıza adresini saklayan değişkenlerdir. İşaretçi aritmetiği, C++ programlama dili dünyasında, toplama, çarpma, bölme, artırma, azaltma ve çıkarma işlemlerinin bellek arabelleklerimizde yeni bellek adresini geliştirmek için bir işaretçiyi içerdiği farklı aritmetik işlemlerle başa çıkmamıza olanak tanıyan güçlü bir özelliktir. . Bir işaretçi aritmetiği, dinamik bellek tahsisini kolayca oluşturur. Bu C++ makalesinde, işaretçilerin yardımıyla bellek adresini farklı şekillerde nasıl değiştireceğimizi öğreneceğiz ve uygun yönergeleri ve örnekleri sunacağız.
Senaryo 1: İşaretçi Arttırma ve Azaltma İşlemlerini Gerçekleştirir
Burada, farklı amaçlara sahip farklı bellek adresleri üretmek için işaretçi manipülasyonunu öğreneceğiz. Artan ve azalan işaretçiler aynı zamanda adresi, işaret ettikleri veri türünün boyutuyla çarpılarak bir kat artıran veya azaltan kaldıraç işaretçileri aritmetiğidir. Bu senaryoya ilişkin kod parçacığı aşağıdaki ekte yer almaktadır:
#include
ad alanı std'sini kullanma;
const int Arr_Max = 5 ;
int ana ( ) {
int nerede [ Arr_Max ] = { yirmi , 150 , 270 } ;
int * ptr; // ilan etmek Işaretçi
ptr = var;
için ( int ben = 0 ; Ben < Arr_Max; i++ ) {
std::cout << 'Öğenin hafıza adresi: [' << Ben << '] = ' ;
std::cout << ptr << sonunda;
cout << 'Adrese göre değer [' << Ben << '] = ' ;
cout << * ptr << sonunda;
std::cout << 'işaretçi başarıyla artırıldı' << sonunda;
ptr++;
}
std::cout << 'Azalmadan önceki işaretçi adresi' << ptr << sonunda;
ptr--;
std::cout << 'Azalıştan sonra işaretçi adresi' << ptr << sonunda;
geri dönmek 0 ;
}
Burada en başta kodda gerekli bir kütüphaneyi tanımlıyoruz: “
Adrese erişmek için diziyi işaretçiye iletiriz. Hepimizin bildiği gibi diziler her zaman farklı konumlarda birden fazla öğe içerir. Bu nedenle, bir dizinin her öğesine erişmek için 'yardım' işaretçisinin bulunduğu bir döngüye ihtiyacımız vardı. Döngü her yürütüldüğünde, bellek adresini belleğin bir sonraki adresine kaydıran işaretçi aritmetiği “ptr++” artış operatörü yardımıyla bellek adresini ve bu adrese karşılık gelen değerleri alırız. Döngü yürütme döngüsü dizinin boyutuna bağlıdır. Döngünün dışında, sadece “ptr- -” azaltma işaretçisini kullanarak işaretçiyi önceki bellek adresine geri döndürmek istiyoruz.
Execute>Compile & Run seçeneğine tıklayarak bu kodu çalıştırdığınızda aşağıdaki çıktıyı alacaksınız:
Umarım bu çıktının anlaşılması kolaydır. Bellek adresi ve değeri değiştirilir. İşaretçiyi bir konumdan kaydırmak yalnızca C++'daki artış işaretçisi aritmetiğinden mümkündür.
Senaryo 2: C++'da İki İşaretçiyi Çıkarma
Bu senaryoda, C++'da iki veya daha fazla işaretçinin nasıl çıkarılacağını öğreneceğiz. Çıkarmanın gerçekleştiği tüm aritmetik işlemler hayati süreçlerdir, çünkü yalnızca aynı veri türüne sahip olmaları durumunda iki işaretçiyi aynı anda çıkarabiliriz.
Toplama, çarpma, bölme gibi diğer işlemler hafıza adreslemede bir anlam taşımadığından işaretçide mümkün değildir. Kod pasajı aşağıdaki dosyaya eklenmiştir:
#includeint ana ( ) {
O çağırıyor [ ] = { 23 , 36 , 42 , 51 , 62 , 77 , 89 , 96 , 100 } ;
int * ptrr1 = & Buna [ 3 ] ; // Üçüncü öğenin işaretçisi ( 42 )
int * ptrr2 = & Buna [ 6 ] ; // Altıncı elementin işaretçisi ( 89 )
ptrdiff_t ptrçıkarma = ptrr2 - ptrr1;
std::cout << 'Bu adresler arasındaki fark: ' << ptrçıkarma << ' elementler' << std::endl;
geri dönmek 0 ;
}
Çıkarma işlemi C++'da bellek adresleri arasındaki farkı bulmaktır. Ana fonksiyonda farklı indekslerde farklı değerler içeren bir dizi alıyoruz. Bir dizide her indeksin farklı bir hafıza konumu vardır. İki işaretçi arasındaki farkı ancak işaretçi aritmetiği yardımıyla bulabiliriz. Burada, C++'da iki veya daha fazla işaretçi arasındaki farkları bulmak için kullanılması gereken özel bir işaretçi türü olan “ptrdiff_t” kullanıyoruz.
Bu kodun çıktısı aşağıdaki dosyaya eklenmiştir:
Bu adresler arasındaki fark, eleman mengenesine göre 3'tür.
Senaryo 3: C++'da İki veya Daha Fazla İşaretçiyi Karşılaştırın
Bu senaryoda, “==”, “<=”, “>=”, “<”, ”>” gibi farklı ilişkisel operatörleri kullanarak C++'daki farklı işaretçileri nasıl karşılaştıracağımızı öğreneceğiz. İşaretçileri yalnızca aynı dizinin öğelerinin adresine işaret etmeleri durumunda karşılaştırabiliriz. İki işaretçiyi farklı türlerle karşılaştırmanın tanımsız davranışa neden olabileceğini unutmayın. İşaretçi karşılaştırmasıyla ilgili kod pasajı aşağıda belirtilmiştir:
#includead alanı std'sini kullanma;
int ana ( )
{
int arr1 [ 10 ] = { 4 , 7 , 9 , on bir , 14 , 16 , 18 , yirmi , 22 , 25 } ;
int * ptr1 = & varış1 [ 3 ] ;
int * ptr2 = & varış1 [ 6 ] ;
int * ptr3 = & varış1 [ 8 ] ;
int * ptr4 = & varış1 [ 9 ] ;
eğer ( ptr1 ==ptr2 )
{
std::cout << 'işaretçiler eşittir' << sonunda;
}
başka eğer ( ptr3 < =ptr4 )
{
std::cout << 'ptr3, ptr4'ten küçük veya eşittir' << sonunda ;;
}
başka
{
std::cout << 'işaretçiler hiçbir aşamada karşılaştırılmaz' << sonunda;
}
geri dönmek 0 ;
}
Burada 10 elemanlı bir dizi alıyoruz. Dizinin farklı bir indeksine işaret eden dört işaretçi bildiririz. Daha sonra bu dört işaretçiyi verilen kodda görüldüğü gibi farklı koşullarda karşılaştırıyoruz. “İf” koşulunda, “ptr1” işaretçisinin “ptr2” işaretçisine eşit olup olmadığını kontrol edin ve ardından “işaretçilerin eşit olduğunu” yazdırın. Birden fazla koşulumuz olduğunda, 'ptr3' işaretçisinin 'ptr4' işaretçisinden küçük olup olmadığını kontrol etmek için 'else if' koşulunu kullanırız. Tüm bunlardan sonra, tıklayın Yürüt > Derle ve Çalıştır seçenek.
Bu kodun çıktısı aşağıdaki dosyaya eklenmiştir:
Konsol ekranında geçerli bir koşulu görüntüler ve derlemeden çıkar. “ptr3” işaretçisi, “ptr4” işaretçisinin işaretleme değerinden küçük veya ona eşit bir değer içerir.
Senaryo 4: İşaretçi Aritmetiği ile Tek Sayıyı Görüntüleme
Burada, bir tamsayı dizisi için belleği dinamik olarak nasıl ayırabileceğimizi göreceğiz. Bu duruma ilişkin kod parçacığı aşağıda verilmiştir:
#includeint ana ( ) {
tam sayılar [ ] = { 1 , 12 , 33 , 24 , on beş , 776 , 71 , 18 , 29 , elli } ;
int * ptrr = sayılar;
std::cout << 'Dizilerdeki tek sayılar: ' ;
için ( int ben = 0 ; Ben < 10 ; ++ben ) {
eğer ( * ptrr % 2 ! = 0 ) {
std::cout << * ptrr << ' ' ;
}
ptrr++;
}
std::cout << std::endl;
geri dönmek 0 ;
}
Ana fonksiyonda 10 eleman içeren bir dizi alıyoruz. Dizideki tek sayıyı kontrol etmek için dizideki tüm elemanları gösteren bir işaretçiye ihtiyacımız var. 'For' döngüsünde, dizinin geçerli öğesini bölerek tek sayıyı kontrol edin. Dizinin bir elemanı kontrol edildikten sonra işaretçi sayacı artırılır.
Kodu çalıştırdıktan sonra konsol ekranında aşağıdaki çıktı görüntülenir:
Bu sayede konsol ekranında işaretçi aritmetiğini kullanarak tek sayıları görüntüleyebiliriz.
Çözüm
Buradan işaretçi aritmetiğinin C++'da farklı işlemleri gerçekleştiren en etkili araç olduğu sonucuna varıyoruz. İşaretçinin aynı veri türüne sahip bir dizinin değerini artırdığından veya azalttığından emin olun. C++ programlama dilinde işaretçi aritmetiği yardımıyla bir dizinin değerlerini bellek adreslerine göre karşılaştırabiliriz. İşaretçi aritmetiği yardımıyla diziyi geçebilir ve belleği kolayca yönetebiliriz.