Yapılar( Structures)

Yapılar

C Programlama Yapılar Başlık Görseli

      Yapılar, birbirleriyle ilişkili değişkenlerin bir isim altında toplanmasıdır. Diziler aynı veri tipinde elemanlar içerebilirken yapılar değişik veri tiplerinde elemanlar içerebilir.

Yapı Tanımlama

     Yapılar, diğer tipte nesneler kullanılarak oluşturulan, türetilmiş veri tipleridir.

struct kisi{
              char *isim;   
              char *soyisim;  
              };

kisi tanıtıcı ismidir. struct anahtar kelimesiyle yapı tipindeki değişkenler bildirimi yapılır.  Yukarıdaki tanımlamada yapı tanımında parantezler içinde bildirilen değişkenler yapı elemanlarıdır. Aynı yapının elemanları kendilerine özel isimlere sahip olmalıdır, farklı iki yapı aynı isimde elemanlar içerebilir. kisi yapısının char* tipinde  iki eleman içermektedir.

struct personel {
                    char ad[15];
                    char soyad[15];
                    int yas;
                    char cins;
                    double ucret;
                          };

Şeklinde diğer değişken türleride kullanılabilir. Fakat yapı içerisinde yapı olmaz.

struct isci {
               char ad[20];
               char soyad[20];
               int yas;
               struct isci kisi; // hatalı tanımlama
               struct isci *aPtr; // gösterici
                };

tanımlamasında,yapının içindeki struct isci kendi kendisinin bir örneğini kisi  içermektedir ve bu bir hatadır.  ePtr ise struct isci2 tipini gösteren bir göstericidir tanımlama içinde kullanılabilir.

struct kart a, deste[30], *cPtr;

şeklinde de bildirilir. struct kart tipinde bir değişkeni, struct kart tipinde 30 elemana sahip bir deste dizisi ve struct kart’ı gösteren bir gösterici değişkeni bildirir.

iki struct  birleşimi yapı tanımının sonundaki parantez ile yapı tanımlamasını sonlandıran noktalı virgül arasına, virgüllerle ayrılmış bir biçimde yazılarak bildirilebilir.

struct kart{ 
              char *sınıf;
              char * takim;
              }a,deste[40],*cPtr;

Yapı etiket ismi içermeyen bir yapı tanımlamasında, yapı tipindeki değişkenler yalnızca yapı tanımlaması içinde bildirile bilirler.

Yapılara Değer Atama

     Yapılara, dizilerde olduğu gibi atama listeleri ile atama yapılır.

struct kart{
                char *taraf;
                char *takim;
                 } a;
 
struct genel z={“kart”,”sayi”};

şeklindeki bildirimi daha önce tanımlanmış struct genel tipinde bir z değişkeni oluşturur. Değişkenin taraf elemanına kart ve takim elemanına sayi  değerini atar. Atama listesinde yapı elemanlarından az sayıda eleman varsa, kalan elemanlar 0  (null) atanır. Yapı değişkenleri fonksiyon tanımı dışında bildirilirse, bu elemanlara değer atanmazsa, ilk değer olarak 0 (null) atanır.

Yapıdaki Elemanlara Ulaşmak

Yapı içerisindeki elemanlara ulaşmanın iki yolu vardır.

  1. Yapı elemanı operatörü (.)
  2. Yapı gösterici operatörü ( ->)
struct kart{
               char *taraf;
               char *takim;
             } a;
 
struct genel z={“kart”,”sayi”};

     z yapısının kart elemanını yazdırmak için:

printf(“%s“,z.takim);

     struct kart yapısını göstermek için bir aPtr göstericisinin bildirildiğini ve a yapısının adresinin aPtr’ye atandığını düşünelim. a yapısının takim elemanını yazdırmak için:

printf(“%s”,aptr->takim);

aPtr-> takim deyimi, (*aPtr).takim ile eşdeğerdir.

  1. #include <stdio.h>
  2.  
  3. struct kart{
  4. char *taraf;
  5. char *takim;
  6. };
  7. int main( )
  8. {
  9. struct kart a;
  10. struct kart *aPtr;
  11.  
  12. a.taraf = "As";
  13. a.takim = "Maca";
  14. aPtr = &a;
  15. printf( "%s %s%s\n%s %s%s\n%s %s%s\n",a.takim, a.taraf, "i",
  16. aPtr->takim, aPtr->taraf, "i",( *aPtr ).takim, ( *aPtr ).taraf, "i" );
  17. return 0;
  18. }
Yapılar ve Fonksiyonlar

     Yapılar fonksiyonlara şu şekillerde geçirilir:

  1. Tüm yapının geçirilmesiyle.
  2. Yapıyı gösteren bir göstericinin geçirilmesiyle.
  3. Değere göre çağırmayla geçilir.
typedef

      Kelimesi önceden tanımlanmış veri tipleri için takma isimler yaradan koddur. Yapı isimleri typedef ile kısa tip isimler oluşturur.

typedef struct kart Kart;
 
ifadesi struct {
                    char *taraf;
                    char *takim;
                     } Kart;

kod satırı, Kart tipini ayrı bir typedef ifadesi kullanmaya kalmadan oluştur.

     Kartstruct kart tipinde değişkenler tanımana bilir. 

Kart demet [52];

     52 Kart yapısından  struct kart tipinde değişkenlerden oluşan bir dizi bildirir. typedef ile yeni bir isim yaratmak yeni bir tip yaratmaz; typedef daha önceden var olan bir tip ismi için, eş anlamlı olarak kullanılabilecek yeni tip isimleri oluşturur.

Yapıların kullanılmasıyla kart karma ve dağıtma
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <time.h>
  4.  
  5. struct kart
  6. {
  7. const char *taraf;
  8. const char *takim;
  9. };
  10. typedef struct kart Kart;
  11.  
  12. void desteDoldur( Kart * const, const char *[ ],const char *[ ] );
  13. void desteyiKar ( Kart * const );
  14. void dagit ( const Kart * const );
  15.  
  16. int main( )
  17. {
  18. Kart deste[ 52 ];
  19. const char *taraf [ ] = { "As", "iki", "uc","Dort", "Bes","Alti", "Yedi",
  20. "Sekiz","Dokuz", "On","Vale", "Kiz", "Papaz"};
  21. const char *takim [ ] = { "Kupa", "Karo"," Sinek", "Maca"};
  22.  
  23. srand( time( NULL ) );
  24.  
  25. desteDoldur( deste, taraf, takim );
  26. desteyiKar( deste );
  27. dagit( deste );
  28. return 0;
  29. }
  30.  
  31. void desteDoldur( Kart * const wDeste, const char * wTaraf[ ],const char * wTakim[ ] )
  32. {
  33. int i;
  34. for ( i = 0; i <= 51; i++ )
  35. {
  36. wDeste[ i ].taraf = wTaraf[ i % 13 ];
  37. wDeste[ i ].takim = wTakim[ i / 13 ];
  38. }
  39. }
  40. void desteyiKar( Kart * const wDeste )
  41. {
  42. int i, j;
  43. Kart gecici;
  44. for ( i = 0; i <= 51; i++ )
  45. {
  46. j = rand( ) % 52;
  47. gecici = wDeste[ i ];
  48. wDeste[ i ] = wDeste[ j ];
  49. wDeste[ j ] = gecici;
  50. }
  51. }
  52. void dagit( const Kart * const wDeste )
  53. {
  54. int i;
  55. for ( i = 0; i <= 51; i++ )
  56. printf( "%5s %-8s%c", wDeste[ i ].takim,wDeste[ i ].taraf,( i + 1 ) % 2 ? '\t' : '\n' );
  57. }
Birlikler

     Birlikler (yapılar gibi), türetilmiş veri tipleridir. Birlik elemanları aynı depolama alanını kullanırlar. Bu sebepten, bir birlik kullanılmayan değişkenler için hafızayı boş yere işgal etmek yerine ayrılan alanı kullanır.

Bir birlik union anahtar kelimesiyle, yapılarla aynı biçimde bildirilir.

union sayi{
              int x;
              double y;
                };

birlik bildirimi sayi’nin birlik tipinde olduğunu ve int x ile double y elemanlarına sahip olduğunu belirtir.Birlik tanımlamaları bir programda main’den önce yer alır. Böylece tanımlama, programdaki tüm fonksiyonlarda değişken bildirmek için kullanılabilir.

     Birliklerde yapılabilen işlemler şunlardır: bir birliği aynı tipte başka bir birliğe atamak, birliğin adresini almak (&) ve birlik elemanlarına yapı elemanı operatörü ve yapı gösterici operatörü kullanarak erişmek. Birlikler, yapılarda anlattığımız sebeplerden dolayı, == ve != operatörüyle karşılaştırılamazlar.

  1. #include <stdio.h>
  2.  
  3. union sayi {
  4. int x;
  5. double y;
  6. };
  7. int main( )
  8. {
  9. union sayi deger;
  10.  
  11. deger.x = 100;
  12. printf( "%s\n%s\n%s%d\n%s%f\n\n","Tamsayi uyesine bir sayi koyun",
  13. "ve butun uyeleri yazdirin.",
  14. "int: ", deger.x,
  15. "double:", deger.y );
  16.  
  17. deger.y = 100.0;
  18. printf( "%s\n%s\n%s%d\n%s%f\n","Ondalikli sayi uyesine bir sayi koyun",
  19. "ve butun uyeleri yazdirin.",
  20. "int: ", deger.x,
  21. "double:", deger.y );
  22. return 0;
  23. }
  24.  

Kimler Neler Demiş?

  Abone ol  
Bildir