Kodların Adresi

bu makalemi İstanbul yolunda yazıyorum o yüzden fazla açıklama şu an eklemiyeceğim daha sonra makaleye ek yaparım

Öncelikle basit örneklerden başlayacağım;

basit bir class kullanarak çevre bulalım;

#include<iostream>
 
#include<conio.h>
using namespace std;
class cevre
{
      int x,y;
      public:
             void degerler(int,int);
             int alan()
             {
                 return x*y;                
                 }
                 };
     void cevre::degerler(int a,int b)
     {
          x=a;
          y=b;
          } 
          main()
          {
                cevre yeni;
                yeni.degerler(12,12);
                cout<<yeni.alan();
                getch();
                }

Uygulamada classımız ve fonksiyomuz ayrı dosyalarda main.cpp de fonksiyon ve kesir dosyalarını include ediyoruz fakat fonksiyon dosyası içerisinde kesir dosyasını kullandığımız için main de derlerken recompile hatası verecektir bunun önüne geçmek için classımızın başına;

 
 
#ifndef KESIR
#define KESIR
.
.//class tanım blogu
.
.
#endif

Koyuyoruz eğer bu dosya önceden derlenmişse derleme derlenmemişse derle demek;
Böylecİfndef ile classımız önceden derlenmiş mi diye kontrol ediyoruz derlenmemişse derleyecek;
Fonksiyonlarımızın prototiplerini oluşturduk;
Toplam operatörü tanımlıyoruz
Sinif operator +(sinif a,sinif b) bu tanımın başına friend koyduk çünkü parametre olarak iki sinif nesnesi gönderdik ve bu sınıfların private alanlarına ulaşmamız gerektiği için;

 
friend kesir operator-(kesir k1,kesir k2)
      {
      return kesir(k1.pay-k2.pay,k1.payda-k2.payda);
      }

Geri dönüş değerimiz bir kesir nesnesi bu aslında kurucu fonksiyon diyebiliriz aldığı parametlerle pay ve paydaya bu işlemden çıkan sonuclar atanıyor.
Yazdırma fonksiyonu ile diyerek degeri yazdırıyoruz;
cout< Şimdi bir yazdırma operatörü tanımlayalım ve işlerimiz daha kolaylaşsın

 
friend ostream& operator<<(ostream& os,kesir k)
      {
      os<<"["< 
Bu işlem ile << operatörü gördüğü yerde 3/5 olan sonucu [3/5]  şeklinde yazacaktır.
 
Ostream de bir nesnedir.
 
Diger fonksiyonlarda cout kullandık köşeli parantez içerisine yazmadı çünkü o fonksiyon altından gelen parametreler bizim operatöre uygun değil
 
 
sadelestir(c);
cout<<"sadelestir c="< 
Bu iki fonksiyonun birbirinden farklarını göstermek için yazdık bunların ikiside sadeleştirme yapıyor fakat fonksiyonların işi bittikten sonra çalıştırdığımızda ise birinci fonksiyonun asıl nesneyi değiştirmediği anlaşılıyor.
 
Çünkü argümanı kopyalayıp alıyor, ikinci fonksiyon ise asıl nesnenin referansını adreseni aldığı için direk sadeleştirmeyi yapıyor;
 
Referans olan değişkenlerde const ifadesini kullanın çünkü direk adrese müdahele edilebilidği için fonksiyon içeriği de değiştirileblir bunu önlemek için arguman tanımına const koymak gerekir.
 
Örnek verecek olursak;
 
 
Friend zaman operator *(const zaman& z1,int n)
{
Zaman z3;
Z1.saniye*=n;
Return z3;
}
burada
 
Zaman operatörü
 
Main den bir kurucu fonksiyon çagırıyoruz 3 parametreli bu parqametreler zamanın saniyesi dakikası ve saat değişkenleri;
 
İlk degerleri veriliyor zaman(int sa,int dk,int sn) kurucu fonksiyonunda
 
Kopyalayıcı kurucu fonksiyon;
 
Argüman olarak kurucu olduğu sınıf türünden bir referans alır.
 
zaman(const zaman& z)
 
{
 
}
 
sınıflar ve işaretçiler;
 
 
int *p;
int i=6;
p=&i;
*p=12;
cout<
 
bu şekildeki bir tanım da
 
bir değişkenin adresini yazdırmak için & operatörü adresteki değeri yazdırmak için * operatörü kullanılır.
 
eleman a,b,c;
 
eleman *p;
 
p=&a;
 
*p.Adi()="serdar";
 
*p.odeme(200);
 
Elaman sınıfımız var ve eleman türünden bir işaretçi tanımlamak için  eleman *p; yazdık .
 
P=&a; dememizdeki amaç a da bir sınıf olduğu için tek bir değer içermez dolayısıyla * işretçisinin yaptıgı gibi o adresteki değeri değil o adresteki nesneye erişir. Bu örnek te sinifin fonksiyonlarına erişmek için & ve * operatörlerini birlikte kullandığımız için öncelik sırasında bir sorun yaşayabiliriz.
 
Bu sorunu çözebilmek için -> üye işlemcisi kullanılabilir. Yani şu şekilde yazabiliriz kodu:
 
 
p->Adi()=”serdar”;
p->Odeme(200);
işaretçilerin kullanımı dizilerde işe yarar.
Eleman personel[10];
Eleman *p;
For(p=personel;p->personel<10;p++)
{
p->Odeme(200);
}
 
Bu kodda p işaretçisiyle dizinin başlangıç adresini p ye atıyoruz. Ve adresi arttırarak diger elemanlara erişmiş oluyoruz.
 
Bunu klasik yöntem le yapalım;
 
 
İnt i;
Eleman dizi[10];
For(i=0;i<10;i++)
{
personel[i].odeme(100);
}
Şekilnde de tanımlayabilirdik.
New komutu;
İnt *pi;kesir *pk; zaman *pz,*pzc;
Pi=new  int ;
Pk=new kesir(2,4); //başlangıç degerleri atanmış kurucu fonksiyon oluşturdu.
Pz=new zaman[50];//zaman türünden 50 nesne içeren bir dizi oluşturdu.
Şimdi bu işlemleri yapıp yapmadığını kontrol edelim;
İf(pz!=NULL)
{
for(pzc=pz;pzc-pz<50;pzc++)
{
pzc->saat=1;
Pzc->dakika=0;
Pzc->saniye=0;
}
}
 
Burada ise 50 elemanlı nesneyi oluşturmadı ise dizinin başlangıç adresini bir değişkende(pz de) tutuluyor pzc değişkenine adres atanıp adres arttırılıyor pz de dizimizin adresini saklıyoruz unutmamak için.
 
New ile işaretçi kullanarak  tanımladığımız dizide ise adresin değişmemesi için adresi sabitlemek doğru bir seçim olur.
 
Const zaman *pz=new zaman[50];
 
Delete işlemi
 
Kesir *pk=new kesir(2,5);
 
..
 
.
 
.
 
Delete pk;
 
Zaman *pz=new zaman[50];
 
.
 
.
 
.
 
.delete pz;
 
Dediğimizde ilk elemanı siler diğer dizi elemanlarını görmezden gelir.
 
Bunun için şu şekilde yazmalıyız
 
Delete []pz;
 
						
 
 
					

İşaretçi bellek alanındaki bir gözün adresinin saklandığı değişkendir. Yani işaretçilere veriler değilde o verilerin bellekte saklı oldugu gözlerin adresleri atanır. Bu C dilini güçlü kılan nedenlerin başında gelir aslında bütün programlama dilleri işaretçiler vardır (c# vb..) ve bazı programlarda işaretçi kullanmak zorunlu olabilir. Özellikle string bir ifadeye ulaşmak için adresleri kullanmak gerekecektir.

C dilinde bir fonksiyon return ile bir sonuç döndürürdü fakat bazı uygulamalarda birden fazla sonuç döndürmesini isteyebiliriz bu durumda da fonksiyona parametre olarak adres göndermemiz gerekecektir.

İşaretçi Tanımı:

İşaretcinin adının önüne ’*’ işareti konulur;

int *p;

İşlemcimizin adresleme biti belirli oldugu için hangi tipte olursa olsun bellekte aynı uzunlukta yer işgal eder
Yani aşağıdaki işaretçilerin hepsi aynı uzunluktadır

int *p;
float *q
char *r

Aralarında fark vardır ama p bir tamsayının q gerçel bir sayının r ise karakterin adresini tutar
Gelelim işaretçiye değer atamaya ;
Hatırlayalım scanf ile bir değişkene nasıl değer atıyorduk

 
int p;
scanf("%d",&p); // p değişkenine & operatörü ile atama yaptık

İşaretçilere değer atamak içinde & operatörü kullanılır.

 
int *p,*m,j,k;
k=100;   //k ya 100 atadık
p=&k; //K nın adresini p işaretçisine atadık
m=&j; //m işaretcisine atadık
*m=555; //işaretçinin önüne * konulursa değer atanır 555 atanmıştır

İşaretçi aritmetiği
Adreslerde elimizdeki adres taban alınıp önceki veya sonraki adreslere erişmek istenebilir.Döngülerde ki gibi toplama çıkartma operatörlerimizi kullanıyoruz.

 
int * p,*q;
p++;
q--;

İşareçilerin Karşılaştırılması

 
int strlen(char *p)
{
char *q=p;
while(*q!=NULL)
q++;
return q-p;
}

Fonkiyona parametre olarak kelimenin adresini gönderiyoruz (karşılaştırmk istediğimiz işaretçiler aynı tipte olmak zorunda ) bir işaretçi tanımlayıp p nin değerini atıyoruz kelimenin sonuna gelineye kadar q arttırıyoruz return le kelimenin başı ile sonunun farkını döndürüyoruz bu da bize kelime katarının uzunluğunu veriyor

İşaretçiler ve Diziler:
Dizinin adı aslında dizinin ilk elemanın adresini tutan bir değişkendir

 
p=&dizi[0];        //ilk elemanın adresi p ye atanıyor
p=dizi;             // başlangıç adresi p ye atanıyor
q=&tablo[9];    // 10. elemanın adresi q ya atanıyor (9 değil çünkü diziler 0 dan başlıyor )
q=&tablo[50];   // 51 elemanlı dizimiz dersek son elemanın adresini atıyoruz

Şimdi bir örnek yapalım ve işaretçi sayesinde dizinin elemanlarının toplamını bulalım

 
int toplam(int A[],int n)
 
{
 
int *p,toplam=0;
 
 for(p=A;p<&A[n];p++)
 
   {
 
     toplam+=*p;
 
     return toplam;
 
   }
 
}
 
İki boyutlarda atama işlemi yapılabilir.
 
Malloc fonksiyonu kullanarak 20 elemanlık bir dizi oluşturalım
 
 
main()
 
 {
 
  int *p;
 
  p=(int *)malloc(20*sizeof(int)); //işletim sisteminden 20 elemanlık yer açmasını istiyoruz
 
  }