Nesneye Yönelik Programlama BM-104 Nesneye Yönelik Programlama Bahar 2013 (7. Sunu) (Yrd. Doç. Dr. Deniz Dal)

İşaretçiler (Pointers) (Adres Saklayan Değişkenler) “Pointer”lar çok güçlüdürler ama onları doğru kullanabilmeyi öğrenmek zaman alır. “Pointer”lar fonksiyonlara referansla parametre aktarma amaçlı kullanılabilirler. Daha önceki derslerimizde gördüğümüz diziler (arrays) statik veri yapılarındandı. “Pointer”lar dinamik veri yapıları oluşturmak ve manipule etmek için kullanılabilirler. “Pointer”lar sonraki slide larımızda göreceğimiz üzere diziler ve stringlerle yakın bir ilişkiye sahiptirler.

Pointer Değişkeni Deklare Etme ve İlk Değer Atama “Pointer”lar da değişkenlerdir ama değer olarak bellek adreslerini saklarlar. Şimdiye kadar gördüğümüz değişkenler belli değerleri depoluyorlardı. (Doğrudan Referans-Direct Reference) “Pointer”lar ise belli bir değeri depolayan değişkenlerin adreslerini saklarlar. (Dolaylı Referans-Indirect reference) Dolaylama (indirection) dediğimiz şey yardımıyla “pointer” ları kullanarak bir değişkeni refere edebiliriz.

int y=5; int *yPtr=&y;

Pointer Değişkeni Deklare Etme ve İlk Değer Atama (Devam) “Pointer”ların Deklare Edilmesi: “*” karakteri (asterisk) bir pointer değişkenini işaret eder. Örnek : int *myPtr; //myPtr is a pointer to an integer char *myPtr; //myPtr is a pointer to a character Birden fazla pointer birden fazla asterisk işareti gerektirir. int *myPtr1, *myPtr2; “Pointer”lara İlk Değer Atanması (initialization): “Pointer”lar 0 (sıfır), NULL ya da bir adresi ilk değer olarak alırlar. 0 veya NULL hiçbirşeyi işaret etmez.

Programlama Pratiği Belki bir zorunluluk değildir ama, bir pointer değişkeni tanımlarken değişken adının içinde “Ptr” karakterlerini kullanmak programcıya büyük kolaylıklar sağlar. (Neden?) (Daha önceki derslerimizde gördüğümüz notasyonları hatırlayınız.)

Pointer Operatörleri Adres Operatörü (&) int y=5; int *yPtr; yPtr=&y; “Operand”ının (işleneninin) bellekteki adresini geriye döndürür. Örnek: int y=5; int *yPtr; yPtr=&y; Son deyim, y değişkeninin bellekteki adresini pointer değişkeni olan yPtr ye atar. Artık yPtr bellekteki y değişkenini işaret eder. (yPtr “points to” y)

Pointer Operatörleri (Devam) “*” Operatorü int y=5; int *yPtr; yPtr=&y; Dolaylama (indirection veya dereferencing) operatörü olarak da adlandırılır. (*yPtr), y değişkeninin değerini yani 5 sayısını geriye döndürür. (Çünkü yPtr y yi işaret eder.)

// & ve * Operatörlerinin Kullanımı #include <iostream> using namespace std;//cout ve endl int main() { int a;//a bir tamsayı değişken int *aPtr;//aPtr bir tamsayı değişkeni işaret eder a=7;//a değişkenine 7 değerini ata aPtr=&a;//a değişkeninin adresini aPtr ye ata cout<<"a degiskeninin adresi : "<<&a<<endl; cout<<"aPtr degiskeninin degeri: "<<aPtr<<endl<<endl; cout<<"a degiskeninin degeri : "<<a<<endl; cout<<"(*aPtr) nin degeri : "<<(*aPtr)<<endl<<endl; cout<<"aPtr degiskeninin adresi: "<<&aPtr<<endl; return 0; }

Fonksiyonlara Parametre Aktarılması Fonksiyonlara 3 farklı şekilde parametre aktarılabilir: Değerle (pass-by-value) Referansla (pass-by-reference with reference arguments) Pointer referansıyla (pass-by-reference with pointer arguments) Bir fonksiyon sadece ve sadece bir değeri return deyimi ile geri döndürebilir. Bir fonksiyona referansla parametre göndererek orijinal değerleri fonksiyon içinde değiştirme imkanımız olur ve böylece fonksiyondan çıktığımızda fonksiyonu çağırana birden fazla değeri return etmiş oluruz.

Pointer Referansıyla Fonksiyonlara Parametre Aktarılması Fonksiyonlara referansla parametre iletilmesine benzer. Parametre, adresi ile birlikte (& operatörü yardımıyla) fonksiyonda kullanılır. Diziler, fonksiyon argümanı olarak adres operatörü (&) ile birlikte gönderilmezler. (Çünkü dizi adları zaten bellek adresleridir.)

ataması gerçekleştirilir arka planda ve sayi nin kopyası kullanılır. int n=sayi ataması gerçekleştirilir arka planda ve sayi nin kopyası kullanılır. //Değer ile (pass-by-value) bir değişkeninin küpü #include <iostream>//cout ve endl using namespace std; int DegerIleKup(int);//prototip int main() { int sayi=5; cout<<"Sayinin orijinal degeri: "<< sayi<<endl; //değer ile fonksiyona parametre aktar sayi=DegerIleKup(sayi);//!!!Dikkat!!! cout<<"Sayinin yeni degeri: "<<sayi<<endl; return 0; } int DegerIleKup(int n) //yerel değişken n nin küpünü geriye döndür return n*n*n;

int &n=sayi ataması gerçekleştirilir arka planda ve sayi nin takma isimli orijinali kullanılır. //Referans ile (pass-by-reference) bir değişkeninin küpü #include <iostream>//cout ve endl using namespace std; void ReferansIleKup(int&);//prototip int main() { int sayi=5; cout<<"Sayinin orijinal degeri: "<< sayi<<endl; //referans ile fonksiyona parametre aktar ReferansIleKup(sayi);//!!!Dikkat!!! cout<<"Sayinin yeni degeri: "<<sayi<<endl; return 0; } void ReferansIleKup(int &n) n=n*n*n;

int *nPtr=&sayi ataması gerçekleştirilir arka planda ve sayi nin adresi (orijinali) kullanılır. //Pointer referansı ile bir değişkeninin küpü #include <iostream>//cout ve endl using namespace std; void PointerReferansiIleKup(int*);//prototip int main() { int sayi=5; cout<<"Sayinin orijinal degeri: "<< sayi<<endl; //Pointer referansı ile fonksiyona parametre aktar PointerReferansiIleKup(&sayi);//!!!Dikkat!!! cout<<"Sayinin yeni degeri: "<<sayi<<endl; return 0; } void PointerReferansiIleKup(int *nPtr) (*nPtr)=(*nPtr)*(*nPtr)*(*nPtr);

Toplu Halde PROTOTİP KULLANIM TANIM DEĞER İLE int Fonk(int); int sayi=5; sayi=Fonk(sayi); int Fonk(int n){} REFERANS İLE void Fonk(int&); Fonk(sayi); void Fonk(int &n){} POİNTER REFERANSI İLE void Fonk(int*); Fonk(&sayi); void Fonk(int *nPtr){}

Pointer Aritmetiği Pointer değişkenleri üzerinde artırma/azaltma operatörlerini kullanabiliriz. (++ veya --) Bir pointer değişkenine bir integer değeri ekleyip çıkarabiliriz. (+ veya +=,- veya -=) İki pointer değişkenini birbirinden çıkarabiliriz. Pointer aritmetiğini sadece bir diziyi işaret eden pointerlar üzerinde uygulayabiliriz.

vPtr=v; veya vPtr=&v[0]; Pointer Aritmetiği Örnek: 5 elemanlı, integer değerler saklayan bir dizi ve integer değişkenlerini 4 byte üzerinden saklayan bir bilgisayar düşünelim. Kabul edelim ki vPtr pointerı bellekte 3000 adresinde dizinin ilk elemanı olan v[0] ı işaret ediyor. vPtr=v; veya vPtr=&v[0]; vPtr+=2 işlemi vPtr pointer değişkenine 3008 değerini atar. (3008=3000+2*4) vPtr artık v[2] yi işaret eder. Örnek: (Pointer lar üzerinde çıkarma işlemi) Eğer vPtr2=&v[2]; ve vPtr1=&v[0]; ise vPtr2–vPtr1 çıkarma işlemi 2 sonucunu verir ve bu sonuç bize, bu iki adres arasında kaç eleman saklandığını gösterir. (vPtr2=vPtr1+2)

Pointer Aritmetiği Pointerlar atama operatörü (=) ile birlikte kullanılabilirler ancak bu durum iki pointer değişkeninin de aynı veri tipine sahip olması durumunda geçerlidir. Eğer veri tipleri farklı ise çevirme işlemi için cast operatorü kullanılmak zorundadır.

Pointerlar ve Diziler Arasındaki İlişki Diziler ve pointerlar birbirleriyle çok yakından ilişkilidirler. Bir dizinin adı sabit (constant) bir pointer gibi düşünülebilir. Pointerlar diziler üzerinde indis operasyonları için kullanılabilirler.

Pointerlar ve Diziler Arasındaki İlişki Bir dizinin elemanlarına pointer yardımıyla ulaşma: Örnek: int b[5]; int *bPtr; bPtr=b; b[n] elemanına *( bPtr+n) ile de ulaşılabilir. Buna pointer/offset notasyonu denir. Bellekteki adresler anlamında &b[3] ile bPtr+3 aynı şeyi ifade eder.

//Dizi elemanlarına farklı yollarla erişim #include <iostream> using namespace std; int main() { int b[]={10,20,30,40}; int *bPtr=b;//bPtr b dizisinin ilk elemanını işaret ediyor cout<<"Kare Parantezler ve Indis Ile Dizi Elemanlarina Ulasim\n"; for (int i= 0;i<4;i++) cout<<"b["<<i<<"]="<<b[i]<<endl; for(int j=0;j<4;j++) cout<<"bPtr["<<j<<"]="<<bPtr[j]<<endl; cout<<"Pointer/offset Notasyonu Ile Dizi Elemanlarina Ulasim\n"; for(int offset1=0;offset1<4;offset1++) cout<<"*(b+"<<offset1<<")="<<*(b+offset1)<<endl; for(int offset2=0;offset2<4;offset2++) cout<<"*(bPtr+"<<offset2<<")="<<*(bPtr+offset2)<<endl; return 0; }

Pointerlar kare parantezler ve indislerle, benzer şekilde dizi değişkenleri de pointer/offset notasyonu ile kullanılabilirler.

“const”ın Pointerlarla Birlikte Kullanımı Bir fonksiyona pointer değişkenli argüman göndermek için 4 yol vardır: Non-constant pointer to non-constant data (Sabit olmayan pointer, sabit olmayan veri) Data (veri) dereferenced pointer yardımıyla modifiye edilebilir. Pointer başka bir veriyi işaret edebilmek üzere değiştirilebilir. Pointer deklarasyonu “const” içermez. karPtr = ; char *karPtr; (*karPtr) = ;

//Pointer ile küçük alfabe harflerini (lowercase letters) //büyük alfabe harflerine (uppercase letters) dönüştürme #include <iostream>//cout ve endl #include <cctype> //islower ve toupper using namespace std; void BuyukHarflereDonustur(char*); int main() { char metin[]="ErzuRum 25^$.:?*";//Dizi Boyutu?? cout<<"Donusum oncesi metin: "<<metin<<endl; BuyukHarflereDonustur(metin);//Adres Operatörü Yok?? cout<<"Donusum sonrasi metin: "<<metin<<endl; return 0; } void BuyukHarflereDonustur(char *sPtr) while(*sPtr!='\0')//işlenen karakter null olmadığı müddetçe if(islower(*sPtr))//karakter küçük alfabe harfi ise *sPtr=toupper(*sPtr);//büyük harfe dönüştür sPtr++;//pointer değişkeni bir sonraki karaktere götür

Sorular, Sorular, Sorular..... Soru1: Herhangi bir karakterin küçük mü veya büyük mü olduğunu nasıl test edersiniz? <cctype> include edilerek if(islower) if(isupper) if(isalpha(c)&&(c==tolower(c))) if(isalpha(c)&&(c==toupper(c)))

Sorular, Sorular, Sorular..... Soru2: Herhangi bir sayının tamsayı mı veya ondalıklı sayı mı olduğunu nasıl test edersiniz? ceil veya floor gibi herhangi bir yuvarlama fonksiyonu kullanılarak if(x==ceil(x)) if(x!=floor(x))

“const”ın Pointerlarla Birlikte Kullanımı Non-constant pointer to constant data (Sabit olmayan pointer, sabit veri) Pointer değişkeni değerini değiştirebilir. Ama bu pointerın işaret ettiği değişkenin değeri bu pointer yardımıyla değiştirilemez. Pass-by-reference ile sağlanan performans ve pass-by-value ile sağlanan güvenlik bu kullanımın artılarıdır. karPtr = ; const char *karPtr; X (*karPtr) = ;

//Sabit olmayan pointer, sabit veri formu ile //karakter dizilerini ekrana karakter karakter Yazdırma #include <iostream> using namespace std; void KarakterleriYazdir(const char *); int main() { char metin[]="Palandoken Yuce Dag"; cout<<"Metin Dizisi: "; KarakterleriYazdir(metin); return 0; } //sPtr can be modified, but it cannot modify the character //to which it points void KarakterleriYazdir(const char *sPtr) for(;*sPtr!='\0';sPtr++)//no initialization cout<<*sPtr;//display character without modification cout<<endl;

//Pointer kullanarak karakter dizisi kopyalama #include <iostream> using namespace std; void Copy1(char *,const char *); void Copy2(char *,const char *); int main() { char string1[10]; char *string2="Hello"; char string3[10]; char string4[]="Good Bye"; Copy1(string1,string2);//copy string2 into string1 cout<<"string1= "<<string1<<endl; Copy2(string3,string4);//copy string4 into string3 cout<<"string3= "<<string3<<endl; return 0; } //copy sPtr2 to sPtr1 using array notation void Copy1(char *sPtr1,const char *sPtr2) for(int i=0;(sPtr1[i]=sPtr2[i])!='\0';i++) ;//do nothing in body //copy sPtr2 to sPtr1 using pointer notation void Copy2(char *sPtr1,const char *sPtr2) for(;(*sPtr1=*sPtr2)!='\0';sPtr1++,sPtr2++)

“const”ın Pointerlarla Birlikte Kullanımı Constant pointer to non-constant data (Sabit pointer, sabit olmayan veri) Pointer değişkeni daima aynı bellek adresini işaret eder. Yani pointer değişkeninin değeri değiştirilemez. Ama pointerın işaret ettiği değişkenin değeri pointer yardımıyla değiştirilebilir. Böyle bir pointer değişkeninine başlangıçta bir değer atanmalıdır. karPtr = ; X char *const karPtr = &x; (*karPtr) = ;

“const”ın Pointerlarla Birlikte Kullanımı Constant pointer to constant data (Sabit pointer, sabit veri) Pointer değişkeni daima aynı bellek adresini işaret eder. Yani pointer değişkeninin değeri değiştirilemez. Benzer şekilde pointerın işaret ettiği değişkenin değeri de pointer yardımıyla değiştirilemez. X karPtr = ; const char *const karPtr = &x; X (*karPtr) = ;

Neler Oluyor??? 7 a 003CFC4C bPtr 003CFC40 cPtr 003CFC34 dPtr #include <iostream> using namespace std; int main() { int a=7; int *bPtr=&a; int **cPtr=&bPtr; int ***dPtr=&cPtr; cout<<bPtr<<' '<<cPtr<<' '<<dPtr<<endl; ***dPtr=9; cout<<a<<endl; return 0; } 7 a 003CFC4C bPtr 003CFC40 cPtr 003CFC34 dPtr