Bölüm 7 - Göstericiler

© Copyright 1992–2004 by Deitel & Associates, Inc. and Pearson Education Inc. All Rights Reserved.

Bölüm 7 - Göstericiler

İndeks7.1 Giriş7.2 Gösterici Değişkenleri Bildirmek ve Gösterici Değişkenlerine Atama yapmak7.3 Gösterici Operatörleri7.4 Fonksiyonları Referansa Göre Çağırmak7.5 const Belirtecini Göstericilerle Kullanmak7.6 Referansa Göre Çağırma Kullanan Kabarcık Sırlama7.7 Gösterici İfadeleri ve Gösterici Aritmetiği7.8 Göstericiler ve Diziler Arasındaki İlişki7.9 Gösterici Dizileri7.10 Örnek: Kart Karma ve Dağıtma7.11 Fonksiyonları Gösteren Göstericiler


Amaçlar

• Bu Bölümde Öğreneceklerimiz:– Göstericileri kullanabilmek.

– Referansa göre çağrılan fonksiyonlara argümanları geçirmede göstericileri kullanabilme

– Göstericilerin Diziler ve Karakterler (Strings) arasındaki yakın ilişkiyi anlama,

– Fonksiyonlarda göstericilerin kullanımını anlama.

– Karakter dizilerini tanımlayabilme ve kullanma.


7.1 Giriş

• Göstericiler hakkında yorumlar:– Güçlü, fakat yönetilmesi zor

– Öğrenmek zor

– Göstericilerle herşey yapılır.

– C bilenler ikiye ayrılır: Göstericiyi bilenler ve bilmeyenler

• Göstericiler bir C klasiğidir.• Düşük seviyeli programlamaya en iyi örnektir.• Göstericiler C’ve onun uzantısı olan dillere özgü

bir konudur.


7.2 Gösterici Değişkenleri Bildirmek ve Gösterici Değişkenlerine Atama yapmak

• Gösterici Değişkenleri– İçinde , başka değişkenin bellek adresini tutar.

– Normal değişkenler kesin bir değer taşır (direk referans)

– Göstericiler kesin bir değişkene sahip(direk referans) bir değişkenin adresini taşır

– (Dolaylama)Direkt olmayan – bir gösterici değeri referans etme

count

7

count7

countPtr


Adres Operatörü: &

• Değişkenin hangi adreste olacağına biz karar veremeyiz.

• Ancak alınan bölgenin adresini öğrenebiliriz.

int deneme

printf(“%x”,&deneme);

int i;

&i=“240DE4F”;Yanlış atama


7.2 Gösterici Değişkenleri Bildirmek ve Gösterici Değişkenlerine Atama yapmak

• Gösterici tanımlamaları– * gösterici değişkenleri ile kullanılır

int *myPtr;

– Bir sayısal gösterici olarak tanımlar int (gösterici tipi int *)

– Çoklu gösterici tanımlarken her bir değişken tanımından önce bir * kullanılır

int *myPtr1, *myPtr2;

– Herhangi bir veri tipi için gösterici tanımlanabilir

– Göstericilere ilk değer olarak 0,NULL veya bir adres atanabilir• 0 veya NULL – gösterici hiçbir şey referans etmez


7.3 Gösterici Operatörleri

• & (adres operatörleri)– Değişkenin adresini geriye döndürür

int y = 5;int *yPtr; yPtr = &y; /* yPtr, y değişkeninin adresini tutar */yPtr, “y” değişkenini gösterir denir

yPtr

y5

yptr

500000 600000

y

600000 5

Y değişkeninin adresi yptr göstericisinin değeridir



• * (İçerik/geri referans operatorü)– Operandının (yani göstericinin) gösterdiği nesnenin değerini

döndürür.– *yptr geriye y döndürür (çünkü yptr “y” yi gösterir)– * atama içinde kullanılabilir

• Nesneye benzerini döndürür*yptr = 7; /* changes y to 7 */

– Geri referans edilmiş göstericiler (*’ın operandı) bir değer almak zorundadır (sabit değer değil)

• * ve & birbirinin eşleniğidir. – Art arda uygulandıklarında aynı sonucu verirler.

OutlineOutline


1 /* Fig. 7.4: fig07_04.c

2 * ve & operatörlerini kullanmak */

3 #include <stdio.h>

4

5 int main()

6 {

7 int a; /* a bir tam sayırdır */

8 int *aPtr; /* aPtr bir tamsayıyı gösteren bir göstericidir */

9

10 a = 7;

11 aPtr = &a; /* aPtr ‘ ye a’nın adresi atandıs */

12

13 printf( " a ‘nın adresi %p"

14 "\naPtr değişkeninin değeri %p", &a, aPtr );

15

16 printf( "\n\n a’nın değeri %d"

17 "\n * aPtr ‘nin değeri %d", a, *aPtr );

18

19 printf( "\n\n * ve & birbirlerinin "

20 " eşleniğidir.\n&*aPtr = %p"

21 "\n*&aPtr = %p\n", &*aPtr, *&aPtr );

22

23 return 0;

24

25 }

fig07_04.cA nın adresi aPtr nin değeridir.

OutlineOutline


Program Output

A ‘nın adresi 0012FF7CaPtr değişkeninin değeri 0012FF7C A’nın değeri 7*aPtr’nin değeri 7 * ve & birbirinin eşleniğidir.&*aPtr = 0012FF7C*&aPtr = 0012FF7C


Operatörler İşleyiş Tip

() [] Soldan sağa En yüksek

+ - ++ -- ! * & (type) Sağdan sola tekli * / % Soldan sağa multiplicative + - Soldan sağa additive < <= > >= Soldan sağa karşılaştırma == != Soldan sağa eşitlik && Soldan sağa Mantıksal ve || Soldan sağa Mantıksal veya

?: Soldan sağa koşullu = += -= *= /= %= Soldan sağa Atama , Soldan sağa virgül Fig. 7.5 Operatör öncelikleri



7.7 Gösterici İfadeleri ve Gösterici Aritmetiği

• Aritmetik operatörler göstericilerde de uygulanabilir– Gösterici artırma/azaltma (++ veya --)

– Göstericiye bir tam sayı değer ekleme( + or += , - or -=)

– Göstericiler birbirlerinden çıkarılabilirler

– Operatörler bir dizi üzerinde uygulanmadıkça anlamsızdır



• 4 byte tamsayılar (ints) kullanan bir makinada 5 elemanlı tamsayı(int) dizisi– vPtr , v[ 0 ] ilk elemanını gösterir

• 3000 deki konumu (vPtr = 3000)

– vPtr += 2; vPtr 3008 olarak değiştirir• vPtr ,v[ 2 ]’yi gösterir (2 artırılmış), fakat makina 4 byte

tamsayılara sahiptir, öyleyse vPtr 3008 adresini gösterir

pointer variable vPtr

v[0] v[1] v[2] v[4]v[3]

3000 3004 3008 3012 3016konum


• Göstericileri çıkarma– Birinden diğerine elemanların sayısını döndürür. Eğer

vPtr2 = &v[ 2 ];vPtr = &v[ 0 ];

– vPtr2 - vPtr 2 ‘yi üretir

• Gösterici karşılaştırma ( <, == , > )– Dizilerde adres değeri karşılaştırılarak dizide önceki eleman

mı yoksa sonraki eleman mı olduğu tespit edilebilir.

– Bir gösterici içinde adres barındırıp barındırmadığı karşılaştırılabilir.




• Aynı tip göstericiler birbirlerine atanabilirler– Eğer aynı tip değilse, dönüşüm (casting) yapılmak zorunda

– void (tipi void *) gösteren göstericiler istisnadır• Genel göstericiler herhangi biri tipi temsil edebilir

• Dönüşüme ihtiyaç yoktur, bütün göstericiler void göstericiye atanabilir

• void göstericilerin gösterdiği nesneye erişilemez.

• void göstericiler üzerinde aritmetik işlemler de yapılamaz.

• Tek işleri adres bilgisini tutmak ve zamanı geldiğinde bu adres bilgisini diğer uygun göstericilere atamaktır.


7.4 Göstericilerin Fonksiyonlarla Kullanımı(Fonksiyonları Referansa Göre Çağırmak)

• Gösterici argümanları ile referansa göre çağırma– & operatörünü kullanarak argümanın adresini geçirme

– Hafızadaki gerçek pozisyonu değiştirmenize izin verir

– Diziler & operatörü ile geçirilmez çünkü dizinin adresini otomatik olarak geçirir

• * operatörü– Fonksiyonun içerdiği değişken için takma ad kullanılır

void double( int *number ) {*number = 2 * ( *number );

}

– *number geçirilmiş değişken için takma ad olarak kullanılır

OutlineOutline


fig07_06.c

1 /* Fig. 7.6: fig07_06.c

2 Değere göre çağırma kullanarak bir değerin küpünü almak */


4

5 int degereGoreKup( int n ); /* prototip */

6

7 int main()

8 {

9 int number = 5;

10

11 printf( "Sayının esas değeri %d", number );

12

13

14 number = degereGoreKup( number );

15

16 printf( "\n Sayının yeni değeri %d\n", number );

17

18 return 0;

19

20 }

21

22

23 int degereGoreKup( int n )

24 {

25 return n * n * n; /* maindeki sayının küpü alındı */

26

27 }

OutlineOutline


1 /* Fig. 7.7: fig07_07.c

2 Referansa göre çağırma kullanarak bir değerin küpünü almak */

3


5

6 void referansaGoreKup( int *nPtr ); /* prototi */

7

8 int main()

9 {

10 int number = 5;

11

12 printf( "Sayının esas degeri %d", number );

13

14

15 referansaGoreKup ( &number );

16

17 printf( "\nSayının yeni degeri %d\n", number );

18

19 return 0;

20

21 }

22

23

24 void referansaGoreKup ( int *nPtr )

25 {

26 *nPtr = *nPtr * *nPtr * *nPtr; /* main deki sayının küpü alındı */

27 }

fig07_07.c

referansaGoreKup ‘ün içinde, *nPtr kullanıldı (*nPtr bir sayıdır).

Dikkat!! Fonksiyon prototipi bir tam sayı için gösterici aldı

OutlineOutline


Program Output

Sayının esas degeri 5Sayının yeni degeri 125

OutlineOutline


Program Output

Sayının esas degeri 5Sayının yeni degeri 125


int main(){

int sayi = 5;

sayi =degereGoreKup(sayi );}

int degereGoreKup( int n ){

return n * n * n;}

sayi

5

n

main, değer fonksiyonunu çağırmadan önce :

tanımlanmamış

int main(){

int sayi = 5;

sayi = degereGoreKup( sayi );}

int degereGoreKup ( int n){

return n * n * n;}

sayi

5

n

degereGoreKup fonksiyonu çağrıldığında

5

125


return n * n * n;}

int main(){

int sayi = 5;

sayi = degereGoreKup(sayi );}

sayi

5

n

degereGoreKup fonksiyonunu n parametresinin küpünü aldıktan sonra :

5

Fig. 7.8 tipik bir değere göre çağırma işleminin analizi (Part 1 of 2.)


125

int main(){

int sayi = 5;

sayi = degereGoreKup( number );}


return n * n * n;}

sayi

5

n

degerGoreKup fonksiyonundan main fonksiyonuna dönüldükten sonra :

tanımlanmamış

125125

int main(){

int number = 5;

sayi = degereGoreKup(sayi );}


return n * n * n;}

sayi

125

n

Main sayi değişkenine atanma işlemini bitirdiği zaman :

tanımlanmamış

Fig. 7.8 tipik bir değere göre çağırma işleminin analizi. (Part 2 of 2.)


Fig. 7.9 bir gösterici argümanıyla tipik bir referansa göre çağırma işleminin analizi.

125void referansaGoreKup( int *nPtr ){ *nPtr = *nPtr * *nPtr * *nPtr;}

void referansaGoreKup( int *nPtr ){ *nPtr = *nPtr * *nPtr * *nPtr;}

int main(){

int sayi = 5;

referansaGoreKup( & sayi);}

void referansaGoreKup( int *nPtr ){ *nPtr = *nPtr * *nPtr * *nPtr;}

int main(){

int sayi = 5;


int main(){

int sayi = 5;


sayi

5

nPtr

sayi

5

nPtr

sayi

125

nPtr

referansaGoreKup fonksiyonunu referansa göre çağrılmadan önce:

referansaGoreKup fonksiyonu referansa göre çağrıldıktan sonra ve *nPtr nin küpü

*nPtr’nin küpü alındıktan sonra

tanımlanmamış


7.8 Göstericiler ve Diziler Arasındaki İlişki

• Diziler ve Göstericiler arasındaki yakın ilişki– Dizi adı gösterici sabitine benzer

– Göstericiler her işlemde kullanılabilir

• Bir 5 elemanlı b dizisi tanımlansın ve bir göstericiyi bPtr tanımlansın.– Dizinin ilk elemanına eşitleme:

bPtr = b; • b dizisinin ilk elemanının adresini atama

bPtr = &b[ 0 ] • b dizisinin ilk elemanının adresini bPtr ye atamanın diğer yolu


7.8 Göstericiler ve Diziler Arasındaki İlişki

– Eleman b[ 3 ] • *( bPtr + 3 ) olarak da belirtilebilir

– 3 (n) göstericinin offset’idir . Bu gösterime gösterici/offset gösterimi denir.

• bptr[ 3 ] olarak kullanım

– Gösterici/belirteç gösterimi denir– bPtr[ 3 ] ile b[ 3 ] aynı şeyi ifade eder

• Dizinin kendisinde de bir gösterici olarak kullanılabilir ve gösterici aritmetiğinde kullanılabilir*( b + 3 )

OutlineOutline


fig07_20.c (Part 1 of 2)

1 /* Fig. 7.20: fig07_20.cpp

2 dizi elemanlarını belirlemenin dört metodu */

3


5

6 int main()

7 {

8 int b[] = { 10, 20, 30, 40 };

9 int *bPtr = b;

10 int i;

11 int offset;

12

13

14 printf( "b dizisi aşağıdaki metodla yazılmıştır\n Dizi belirteçleri yöntemi\n" );

15

16

17 for ( i = 0; i < 4; i++ ) {

18 printf( "b[ %d ] = %d\n", i, b[ i ] );

19 }

20

21

22 printf( "\nGösterici/offset yöntemi\n"

23 "gösterici dizinin ismidir\n" );

24

OutlineOutline



25

26 for ( offset = 0; offset < 4; offset++ ) {

27 printf( "*( b + %d ) = %d\n", offset, *( b + offset ) );

28 }

29

30

31 printf( "\nGösterici belirteç yöntemi \n" );

32

33

34 for ( i = 0; i < 4; i++ ) {

35 printf( "bPtr[ %d ] = %d\n", i, bPtr[ i ] );

36 }

37

38

39 printf( "\n Gösterici/offset yöntemi\n" );

40

41

42 for ( offset = 0; offset < 4; offset++ ) {

43 printf( "*( bPtr + %d ) = %d\n", offset, *( bPtr + offset ) );

44 }

45

46 return 0;

47

48 }

OutlineOutline


Program Output

B dizisi aşağıdaki metodla yazılmıştır:Dizi belirteçleri yöntemib[ 0 ] = 10b[ 1 ] = 20b[ 2 ] = 30b[ 3 ] = 40

Gösterici/offset yöntemiGösterici dizinin ismidir*( b + 0 ) = 10*( b + 1 ) = 20*( b + 2 ) = 30*( b + 3 ) = 40 Gösterici/belirteç yöntemibPtr[ 0 ] = 10bPtr[ 1 ] = 20bPtr[ 2 ] = 30bPtr[ 3 ] = 40 Gösterici/offset yöntemi*( bPtr + 0 ) = 10*( bPtr + 1 ) = 20*( bPtr + 2 ) = 30*( bPtr + 3 ) = 40


7.5 const Belirtecini Göstericilerle Kullanmak

• const belirteci– Değişkenler değiştirilemez– Eğer fonksiyonun bir değişkeni değiştirmeye ihtiyacı yok ise

const kullanılır– Bir const değişkeni değiştirmeyi denemek bir hata üretir

• const göstericileri– Bir sabit hafıza pozisyonunu gösterme– Tanımlanırken ilk değer atanmalıdır– int *const myPtr = &x;

• Tipi int *const – bir tamsayıyı gösteren sabit gösterici

– const int *myPtr = &x;• sabit bir tamsayıyı gösteren gösterici

– const int *const Ptr = &x;• Sabit bir tamsayıyı sabit gösterici• x değiştirilebilir, fakat *Ptr değil

OutlineOutline



1 /* Fig. 7.10: fig07_10.c

2 Sabit olmayan veriyi gösteren sabit olmayan gösterici kullanarak

3 küçük harfleri büyük harfe çevirmek */

4


6 #include <ctype.h>

7

8 void buyukHarfeCevir( char *sPtr ); /* prototipi */

9

10 int main()

11 {

12 char string[] = "karakterler $32.98";

13

14 printf( "çevrilmeden önce string: %s", string );

15 buyukHarfeCevir( string );

16 printf( "\nçevrildikten sonraki string is: %s\n", string );

17

18 return 0;

19

20 }

21

OutlineOutline


22

23 void buyukHarfeCevir( char *sPtr )

24 {

25 while ( *sPtr != '\0' ) {

26

27 if ( islower( *sPtr ) ) {

28 *sPtr = toupper( *sPtr ); /* büyük harfe çevir */

29 }

30

31 ++sPtr; /* sPtr ile diğer karaktere geç */

32 }

33

34 }


Program OutputÇevrilmeden önceki string : karakter ve $32.98Çevrildikten sonraki string : karakter ve $32.98

OutlineOutline



1 /* Fig. 7.11: fig07_11.c

2 Sabit bir veriyi gösteren sabit olmayan bir gösteri kullanarak

3 bir string karakterlerini sırayla yazdırmak */

4


6

7 void karakterleriYazdır( const char *sPtr );

8

9 int main()

10 {

11

12 char string[] = "string karakterlerini yaz";

13

14 printf( "string:\n" );

15 karakterleriYazdır ( string );

16 printf( "\n" );

17

18 return 0;

19

20 }

21

OutlineOutline


22 /* karakterleriYazdır fonkiyonunda sPtr bir karakter sabitini

23 gösteren göstericidir.Karakterler sPtr kullanarak değiştirilemezler*/

24 void karakterleriYazdır ( const char *sPtr )

25 {

26

27 for ( ; *sPtr != '\0'; sPtr++ ) { /* ilk değer ataması yok */

28 printf( "%c", *sPtr );

29 }

30

31 }


Program Outputstring:String karakterini yaz

OutlineOutline


fig07_12.c

1 /* Fig. 7.12: fig07_12.c

2 sabit bir veri için sabit olmayan gösterici

3 kullanarak değeri değiştirmeye çalışmak */


5

6 void f( const int *xPtr ); /* prototipi */

7

8 int main()

9 {

10 int y;

11

12 f( &y ); /* f doğru olmayan bir değişiklik yapmaya çalıştı */

13

14 return 0;

15

16 }

17

18 /* f içinde xPtr, bir tamsayı sabitini gösteren göstericidir

19 */

20 void f( const int *xPtr )

21 {

22 *xPtr = 100; /* const nesnesi değiştirilemez */

23 }

OutlineOutline


Program Output

Compiling...FIG07_12.cd:\books\2003\chtp4\examples\ch07\fig07_12.c(22) : error C2166: l-value specifies const objectError executing cl.exe. FIG07_12.exe - 1 error(s), 0 warning(s)

OutlineOutline


1 /* Fig. 7.13: fig07_13.c

2 Sabit olmayan bir veriyi gösteren sabit

3 bir göstericiyi değiştirmeye calışmak */


5 int main()

6 {

7 int x;

8 int y;

9

10 /* ptr tamsayıyı gösteren sabit bir göstericidir

11 bir tamsayı ptr ile değiştirilebilir

12 ama ptr hafızada her zaman aynı yeri gösterir*/

13 int * const ptr = &x;

14 *ptr = 7;

15 ptr = &y;

16

17 return 0;

18

19 }

fig07_13.c

Program OutputCompiling...FIG07_13.cD:\books\2003\chtp4\Examples\ch07\FIG07_13.c(15) : error C2166: l-value specifies const objectError executing cl.exe. FIG07_13.exe - 1 error(s), 0 warning(s)

OutlineOutline


fig07_14.c

1 /* Fig. 7.14: fig07_14.c

2 sabit bir veriyi gösteren sabit bir göstericiyi değiştirmeye çalışmak*/


4

5 int main()

6 {

7 int x = 5;

8 int y;

9

10 /* ptr sabit bir tamsayıyı gösteren sabit bir göstericidir.

11 ptr her zaman aynı hafıza konumunu gösterir ve

12 o konumdaki tamsayı değiştirilemez */

13 const int *const ptr = &x;

14

15 printf( "%d\n", *ptr );

16

17 *ptr = 7;

18 ptr = &y;

19

20 return 0;

21

22 }

OutlineOutline


Program Output

Compiling...FIG07_14.cD:\books\2003\chtp4\Examples\ch07\FIG07_14.c(17) : error C2166: l-value specifies const objectD:\books\2003\chtp4\Examples\ch07\FIG07_14.c(18) : error C2166: l-value specifies const objectError executing cl.exe. FIG07_12.exe - 2 error(s), 0 warning(s)

OutlineOutline



1 /* Fig. 7.21: fig07_21.c

2 Bir stringi dizi gösterimi ve göstericileri kullanarak kopyalamak*/


4

5 void copy1( char *, const char * );

6 void copy2( char *, const char * );

7

8 int main()

9 {

10 char string1[ 10 ];

11 char *string2 = "Merhaba";

12 char string3[ 10 ];

13 char string4[] = "Güle Güle";

14

15 copy1( string1, string2 );

16 printf( "string1 = %s\n", string1 );

17

18 copy2( string3, string4 );

19 printf( "string3 = %s\n", string3 );

20

21 return 0;

22

23 }

24

OutlineOutline


25 /* s2 yi s1e dizi gösterimi ile kopyalama */

26 void copy1( char *s1, const char *s2 )

27 {

28 int i;

29

30

31 for ( i = 0; ( s1[ i ] = s2[ i ] ) != '\0'; i++ ) {

32 ; /* döngünün içinde bir şey yapma */

33 }

34

35 }

36

37 /* s2 yi s1 e gösterici gösterimi ile kopyala */

38 void copy2( char *s1, const char *s2 )

39 {

40 /* loop through strings */

41 for ( ; ( *s1 = *s2 ) != '\0'; s1++, s2++ ) {

42 ; /* döngünün içinde bir şey yapma */

43 }

44

45 }


Program Output

string1 = Merhabastring3 = Güle güle


7.6 Referansa Göre Çağırma Kullanan Kabarcık Sıralama

• Gösterici kullanarak kabarcıksıralama’yı uygulama– İki elemanı yer değiştir– Yer değiştirme fonksiyonu dizi elemanlarının adresini

içermek zorundadır (& kullanarak)• Dizi elemanları varsayılan olarak değere göre çağrılmayla

geçirilir

– Göstericileri ve * operatörü kullanarak dizi elemanlarının yerlerini değiştirme

• Psuedocode (Sahte kodlar)diziye ilk değer atama veri orijinal sırasında yazdırKabarcık sıralama fonksiyonunu çağır

sıralanmış diziyi yazdırKabarcık sıralamayı tanımla


7.6 Referansa Göre Çağırma Kullanan Kabarcık Sıralama

• sizeof– Operandın boyutunu byte cinsinden geriye döndürür

– Diziler için: 1 elemanın boyutu * elemanların sayısı

– Eğer sizeof( int ) eşit 4 byte ise, int myArray[ 10 ];printf( "%d", sizeof( myArray ) );

• 40 yazılacak

• sizeof aşağıdakiler ile birlikte kullanılabilir– Değişken adları

– Tip adı

– Sabit değişkenler

OutlineOutline



1 /* Fig. 7.15: fig07_15.c

2 Bu program değerleri diziye koyar ve artan

3 sıralamada sıralar, ve dizinin son halini yazdırır */


5 #define BOYUT 10

6

7 void kabarcıkSıralama( int *, const int); /* prototipi*/

8

9 int main()

10 {

11

12 int a[ BOYUT ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };

13

14 int i;

15

16 printf( "Veriler orjinal sırada \n" );

17

18

19 for ( i = 0; i < BOYUT; i++ ) {

20 printf( "%4d", a[ i ] );

21 }

22

23 kabarcıkSıralama ( a, BOYUT );

24

25 printf( "\nVeriler artan sırada \n" );

26

OutlineOutline



27

28 for ( i = 0; i < BOYUT; i++ ) {

29 printf( "%4d", a[ i ] );

30 }

31

32 printf( "\n" );

33

34 return 0;

35

36 }

37

38

39 void kabarcıkSıralama( int *dizi, const int boyut )

40 {

41 void yerDeğistir( int *, int * ); /* prototipi */

42 int tur;

43 int j;

44

45

46 for (tur = 0; tur < boyut - 1; tur ++ ) {

47

48

49 for ( j = 0; j < boyut - 1; j++ ) {

50

OutlineOutline



Program Output

51

52 if ( dizi[ j ] > dizi [ j + 1 ] ) {

53 yerDegistir( & dizi[ j ], & dizi[ j + 1 ] );

54 }

55

56 }

57

58 }

59

60 }

61

62

63

64 void yerDegistir( int *element1Ptr, int *element2Ptr )

65 {

66 int temp = *element1Ptr;

67 *element1Ptr = *element2Ptr;

68 *element2Ptr = temp;

69 }

Veriler orijinal sırada 2 6 4 8 10 12 89 68 45 37Veriler artan sırada 2 4 6 8 10 12 37 45 68 89

OutlineOutline


fig07_16.c

Program Output

1 /* Fig. 7.16: fig07_16.c

2 Sizeof operatörü dizi isimlerine uygulandığında

3 dizideki byte sayısını döndürür */


5

6 size_t buyukluguBul( float *ptr ); /* prototipi */

7

8 int main()

9 {

10 float dizi[ 20 ];

11

12 printf( "dizinin byte uzunluğu %d"

13 "\nbuyukluguBul ile döndürülen byte sayısı %d\n",

14 sizeof( dizi ), buyukluguBul( dizi ) );

15

16 return 0;

17

18 }

19

20

21 size_t buyukluguBul ( float *ptr )

22 {

23 return sizeof( ptr );

24

25 }

Dizinin byte büyüklüğü 80buyukluguBul ile döndürülen byte sayısı 4

OutlineOutline



1 /* Fig. 7.17: fig07_17.c

2 sizeof operatörü uygulaması */


4

5 int main()

6 {

7 char c;

8 short s;

9 int i;

10 long l;

11 float f;

12 double d;

13 long double ld;

14 int array[ 20 ];

15 int *ptr = array;

16

17 printf( " sizeof c = %d\tsizeof(char) = %d"

18 "\n sizeof s = %d\tsizeof(short) = %d"

19 "\n sizeof i = %d\tsizeof(int) = %d"

20 "\n sizeof l = %d\tsizeof(long) = %d"

21 "\n sizeof f = %d\tsizeof(float) = %d"

22 "\n sizeof d = %d\tsizeof(double) = %d"

23 "\n sizeof ld = %d\tsizeof(long double) = %d"

24 "\n sizeof dizi = %d"

25 "\n sizeof ptr = %d\n",

OutlineOutline


26 sizeof c, sizeof( char ), sizeof s,

27 sizeof( short ), sizeof i, sizeof( int ),

28 sizeof l, sizeof( long ), sizeof f,

29 sizeof( float ), sizeof d, sizeof( double ),

30 sizeof ld, sizeof( long double ),

31 sizeof array, sizeof ptr );

32

33 return 0;

34

35 }


Program Output sizeof c = 1 sizeof(char) = 1 sizeof s = 2 sizeof(short) = 2 sizeof i = 4 sizeof(int) = 4 sizeof l = 4 sizeof(long) = 4 sizeof f = 4 sizeof(float) = 4 sizeof d = 8 sizeof(double) = 8 sizeof ld = 8 sizeof(long double) = 8 sizeof dizi = 80 sizeof ptr = 4


7.9 Gösterici Dizileri

• Diziler göstericiler içerebilir.

• Örnek: karakterler dizisichar *suit[ 4 ] = { "Hearts", "Diamonds", "Clubs", "Spades" };

– Stringler ilk karakteri gösteren göstericilerdir– char * –takım dizisinin her elemanının char gösteren tipte bir

gösterici olduğunu belirtir

– Gerçekte stringler takım dizisinde saklanmazlar, sadece stringlerin göstericileri saklanır

– Takim dizisi sabit bir boyuta sahiptir,fakat stringler farklı olabilir

takim[3]

takim[2]

takim[1]

takim[0] ’H’ ’e’ ’a’ ’r’ ’t’ ’s’ ’\0’

’D’ ’i’ ’a’ ’m’ ’o’ ’n’ ’d’ ’s’ ’\0’

’C’ ’l’ ’u’ ’b’ ’s’ ’\0’

’S’ ’p’ ’a’ ’d’ ’e’ ’s’ ’\0’


7.10 Örnek: Kart Karma ve Dağıtma

• Kart karma ve dağıtma programı– Göstericilerin dizisini karakterleri göstermede kullanma

– İki boyutlu takım dizisi kullan (satır, sütun)

– 1-52 arasındaki sayılar diziye gönderilir• Bu noktada deste tamamen karılmış olur

deste[ 2 ][ 12 ] sinek papazı gösterir

Kupa

Karo

Sinek

Maça

0

1

2

3

As iki üç Dört beş altı yedi sekiz dokuz on vale kız papaz0 1 2 3 4 5 6 7 8 9 10 11 12

sinek papaz



• Pseudocode (Sahte kodlar)– İlk olarak:

52 kartı kar ve dağıt

– İlk iyileştirme:takım dizisine ilk değer atama

Taraf dizisine değerler ata

Deste dizisine değerler ata

Desteyi kar

52 kartı dağıt



– İkinci iyileştirme• desteyi karma şu şekilde genişletilebilir

52 kartın her biri için (for)Destenin rasgele seçilmiş boş bir alanına kart sayısını yerleştir

• 52 kartı dağıtma şu şekilde genişletilebilir52 kartın her biri için (for) Deste dizisinde kart sayısını bul ve kartın hangi desteye ait

olduğunu ve değerini yazdır



– Üçüncü iyileştirme• desteyi karma şu şekilde genişletilebilir

Destedeki alanı rasgele seç Destedeki bu alan daha önceden seçildiği sürece (While)

Destedeki alanı rasgele seçmeye devam etDestede seçilen alana kart sayısını yerleştir

• 52 kartı dağıtma şu şekilde genişletilebilirDeste dizisindeki her alan için (For)

Eğer alan kart sayısı içeriyorsa (if) Kartın hangi desteye ait olduğunu ve değerini yazdır

OutlineOutline



1 /* Fig. 7.24: fig07_24.c

2 Kart dağıtma Programı */


4 #include <stdlib.h>

5 #include <time.h>

6

7

8 void kar( int [][ 13 ] );

9 void dagit( const int [][ 13 ], const char * [],

10 const char *[] );

11

12 int main()

13 {

14

15 const char *takım[ 4 ] = { "kupa", "karo", "sinek", "maça" };

16

17

18 const char *taraf[ 13 ] =

19 { "As", "iki", "üç", "dört",

20 "beş", "altı", "yedi", "sekiz",

21 "dokuz", "on", "vale", "kız", "papaz" };

22

23

24 int deck[ 4 ][ 13 ] = { 0 };

25

OutlineOutline



26 srand( time( 0 ) );

27

28 kar( deste );

29 dagit( deste, taraf, takim );

30

31 return 0;

32

33 }

34

35

36 void kar( int wDeste[][ 13 ] )

37 {

38 int satir;

39 int sutun;

40 int kart;

41

42

43 for ( kart = 1; kart <= 52; kart++ ) {

44

45

46 do {

47 satir = rand() % 4;

48 sutun = rand() % 13;

49 } while( wDeste[ satir ][ sutun ] != 0 );

50

OutlineOutline



51

52 wDeste[ satir][ sutun ] = kart;

53 }

54

55 }

56

57

58 void dagit( const int wDeste[][ 13 ], const char *wTaraf[],

59 const char *wTakim[] )

60 {

61 int kart;

62 int satir;

63 int sutun;

64

65

66 for ( kart = 1; kart <= 52; kart ++ ) {

67

68

69 for (satir = 0; satir <= 3; satir ++ ) {

70

71

72 for (sutun = 0; sutun <= 12; sutun ++ ) {

73

74

75 if (wDeste[satir][ sutun] == kart) {

OutlineOutline



76 printf( "%5s of %-8s%c", wTakim[ satir ], wTaraf[ sutun ],

77 kart % 2 == 0 ? '\n' : '\t' );

78 }

79

80 }

81

82 }

83

84 }

85

86 } /* end function deal */

OutlineOutline


Program Output

Karo Sekiz Kupa ASSinek Sekiz Sinek Beş Kupa Yedi Karo ikiSienk As Karo on Maça iki Karo altı Maça yedi Sinek ikiSinek vale Maça on Kupa papaz Karo Vale Kupa üç Karo üçSinek üç Sinek dokuz Kupa on Kupa ikiSinek on Karo yediSinek altı Maça kız Kupa altı Maça üç Karo dokuz Karo as Maça vale Sinek beş Karo papaz Sinek yedi Maça dokuz Kupa dört Maça altı Maça sekiz Karo kız Karo beş Maça as Kupa dokuzSinek papaz Kupa beş Maça papaz Karo dört Kupa kız Kupa sekiz Maça dört Kupa valeSinek dört Sinek kız


7.11 Fonksiyonları Gösteren Göstericiler

• Fonksiyonları gösteren göstericiler– Fonksiyonların adreslerini tutarlar

– Dizi adının dizinin ilk elemanın adresi olmasına benzer

– Fonksiyon ismi, fonksiyonun görevini yapan kodun hafızadaki başlangıç adresidir

• Fonksiyon göstericileri – Fonksiyonlara geçirilebilir

– Dizilerde saklanabilir

– Başka fonksiyon göstericilerine atanabilir


7.11 Fonksiyonları Gösteren Göstericiler

• Örnek: kabarcık sıralama– Kabarcık fonksiyonu bir fonksiyon göstericisi alır

• Kabarcık bu yardım fonksiyonu cağırır

• azalan veya artan sıralamayı belirler

– Fonksiyon göstericisi için kabarcıksıralama’daki argüman:int ( *karsilastir)( int, int )

tells bubblesort to expect a pointer to a function that takes two ints and returns an int

Kabarcık fonksiyonuna iki tamsayı parametresi alan ve bir tamsayı sonucunu döndüren bir fonksiyonu gösteren bir gösterici alacağını söyler

– Eğer parantezleri dahil etmeseydik:int * karsilastir( int, int )

• İki tamsayıyı alan ve bir tamsayıyı gösteren bir gösterici döndüren bir fonksiyon bildirir

OutlineOutline



1 /* Fig. 7.26: fig07_26.c

2 fonksiyonları gösteren göstericiler kullanan çok amaçlı bir sıralama fonksiyonuu */


4 #define BOYUT 10

5

6

7 void kabarcik( int [], const int , int (*)( int, int ) );

8 int artan( int, int);

9 int azalan( int, int );

10

11 int main()

12 {

13 int secim;

14 int sayici;

15

16

17 int a[BOYUT] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };

18

19 printf( "Artan sıralama için 1 girin,\n"

20 " Azalan sıralama için 2 girin: " );

21 scanf( "%d", &secim);

22

23 printf( "\nVeriler orjinal sırasında \n" );

24

OutlineOutline



25

26 for ( sayici = 0; sayici < BOYUT; sayici++ ) {

27 printf( "%5d", a[sayici] );

28 }

29

30

31

32 if ( secim == 1 ) {

33 kabarcik( a,BOYUT, artan );

34 printf( "\nVeriler artan sırada \n" );

35 }

36 else {

37 kabarcik ( a, BOYUT, azalan );

38 printf( "\nVeriler azalan sırada \n" );

39 }

40

41

42 for (sayici = 0; sayici < BOYUT; sayici++ ) {

43 printf( "%5d", a[sayici] );

44 }

45

46 printf( "\n" );

47

48 return 0;

49

50 }

51

OutlineOutline



52

53

54 void kabarcik( int is[], const int boyut, int (*karsilastir)( int, int ) )

55 {

56 int tur;

57 int sayici;

58

59 void yerdegistir( int *element1Ptr, int *element2ptr );

60

61

62 for (tur = 1; tur < boyut; tur ++ ) {

63

64

65 for (sayici = 0; sayici < boyut - 1; sayici++ ) {

66

67

68 if ( (*karsilastir)( is[sayici], is[sayici + 1 ] ) ) {

69 yerdegistir( &is[sayici], &is[sayici + 1 ] );

70 }

71

72 }

73

74 }

75

76 }

77

OutlineOutline



78

79

80 void yerdegistir( int *element1Ptr, int *element2Ptr )

81 {

82 int temp;

83

84 temp = *element1Ptr;

85 *element1Ptr = *element2Ptr;

86 *element2Ptr = temp;

87 }

88

89

90

91 int artan( int a, int b )

92 {

93 return b < a; /*b, a ‘dan küçükse yer değiştir*/

94

95 }

96

97

98

99 int azalan( int a, int b )

100 {

101 return b > a; /*b. a ‘dan büyükse yer değiştir*/

102

103 }

OutlineOutline


Program Output

Artan sıralama için 1 girin,Azalan sıralama için 2 girin: 1 Veriler orijinal sırasında 2 6 4 8 10 12 89 68 45 37Veriler artan sırada 2 4 6 8 10 12 37 45 68 89

Artan sıralama için 1 girin,

Azalan sıralama için 2 girin:2 Veriler orijinal sırasında 2 6 4 8 10 12 89 68 45 37Veriler azalan sırada 89 68 45 37 12 10 8 6 4 2

Documents

Bölüm 7 - Göstericiler