C Programlamada Yapılar (Structs): Temel Kullanımından İleri Seviye Uygulamalara Kapsamlı Rehber
Giriş
C programlama dilinde, farklı veri tiplerini tek bir birim altında toplamak için kullanılan güçlü bir özellik olan yapılara (structs) derinlemesine bir bakış atacağız. Yapılar, özellikle karmaşık veri modelleriyle çalışırken kodunuzu daha organize, okunabilir ve yönetilebilir hale getirir. Örneğin, bir öğrencinin adı, numarası, yaşı ve not ortalaması gibi birbiriyle ilişkili verileri tek bir yapı altında toplamak, bu verilere erişimi ve işlemeyi büyük ölçüde kolaylaştırır. Programlama dünyasında verilerin düzenli bir şekilde depolanması ve işlenmesi, yazılımın performansı ve sürdürülebilirliği açısından kritik öneme sahiptir. Yapılar da tam olarak bu ihtiyacı karşılar: birbiriyle ilişkili, ancak farklı türlerdeki verileri bir araya getirme yeteneği sunarak, programcıların gerçek dünya nesnelerini veya kavramlarını yazılımlarında daha doğru bir şekilde modellemelerine olanak tanır. Bu rehberde, yapıların temel tanımlamalarından, üye erişimine, iç içe yapılardan, işaretçilerle kullanımına ve hatta dinamik bellek yönetimiyle nasıl birleştiğine kadar geniş bir yelpazede konuları ele alacağız.
Yapı Nedir?
Bir yapı, farklı veri türlerindeki (int, char, float, diziler vb.) bir veya daha fazla değişkeni tek bir mantıksal birim altında gruplandırmamızı sağlayan, kullanıcı tanımlı bir veri tipidir. Yapılar, gerçek dünyadaki nesneleri veya kavramları modellemek için idealdir. Örneğin, bir kitap, bir araba veya bir tarih gibi. Her üye, yapının içinde kendi veri türüne ve adıyla tanımlanan bağımsız bir değişkendir. Bu sayede, ilişkili verileri ayrı ayrı değişkenler yerine tek bir çatı altında toplamak, programın mantığını basitleştirir ve hata yapma olasılığını azaltır.
Yapı Tanımlama ve Değişken Oluşturma
Bir yapı tanımlamak için `struct` anahtar kelimesi kullanılır. İşte genel sentaks:
Yukarıdaki sentaksta, `YapiAdi` sizin belirleyeceğiniz bir isimdir ve bu yapı tipini temsil eder. `uye1`, `uye2`, ... yapının üyeleri olup, her biri belirli bir `veri_tipi`ne sahiptir. Bir yapı tanımlandığında, aslında bellekte bir yer ayrılmaz; yalnızca bir şablon (blueprint) oluşturulur. Bellekte yer ayırmak ve bu şablonu kullanarak gerçek bir veri nesnesi oluşturmak için bu yapı tipinde bir değişken oluşturmamız gerekir.
Örnek olarak, bir öğrencinin adını, numarasını ve not ortalamasını saklayacak bir yapı tanımlayalım:
Bu `Ogrenci` yapısı tanımlandıktan sonra, bellekte bu yapıya uygun bir değişken oluşturabiliriz:
Bu tanımlamalarla birlikte `ogr1`, `ogr2` ve `ogr3` adlı değişkenler bellekte `Ogrenci` yapısının şablonuna uygun olarak yer kaplamaya başlarlar ve artık içlerindeki üyelere erişilebilir.
Yapı Üyelerine Erişim
Yapı değişkenlerinin üyelerine erişmek ve onlara değer atamak veya değerlerini okumak için nokta (`.`) operatörü kullanılır. Bu operatör, bir yapı değişkeni adından sonra gelerek, o yapının belirli bir üyesine erişim sağlar. Aşağıdaki örnek, bir `Ogrenci` yapısı değişkeninin üyelerine nasıl erişileceğini ve onlara nasıl değer atanacağını göstermektedir:
Bu kod parçasında, `ogr1.ad`, `ogr1.ogrenciNo` ve `ogr1.notOrtalamasi` ifadeleri ile yapı üyelerine erişildiğini ve `strcpy` fonksiyonu ile `ad` üyeliğine string ataması yapıldığını görebilirsiniz. Sayısal verilere doğrudan atama (`=`) operatörü ile değer verilir.
Yapılar ve typedef
`typedef` anahtar kelimesi, C dilinde mevcut bir veri tipine yeni bir isim atamak için kullanılır. Yapılarla birlikte kullanıldığında, `struct` anahtar kelimesini tekrar tekrar yazma zorunluluğunu ortadan kaldırarak kodu daha okunabilir ve yazımı daha kolay hale getirir. Özellikle karmaşık yapı adları veya iç içe yapılarla çalışırken bu kolaylık büyük önem taşır. `typedef` kullanımıyla, yapı tipini sanki dahili bir veri tipiymiş gibi kullanabilirsiniz.
`typedef` kullanımı, özellikle büyük projelerde veya karmaşık veri yapılarında kodun anlaşılırlığını artırır ve programcıya daha esnek bir isimlendirme stratejisi sunar. `struct` anahtar kelimesini her seferinde tekrarlamak yerine, tanımladığınız yeni isimle doğrudan değişkenler oluşturabilirsiniz.
İç İçe Yapılar (Nested Structs)
Bir yapının içinde başka bir yapıyı üye olarak tanımlamak mümkündür. Bu, daha karmaşık ve hiyerarşik veri modelleri oluşturmanızı sağlar. Örneğin, bir öğrencinin doğum tarihini ayrı bir yapı olarak tanımlayıp, bu `Tarih` yapısını daha sonra bir `OgrenciDetay` yapısının içinde kullanabiliriz. Bu yaklaşım, verileri daha modüler bir şekilde organize etmenize ve ilgili bilgileri bir arada tutmanıza yardımcı olur.
İç içe yapılara erişirken birden fazla nokta operatörü kullanıldığına dikkat edin (`ogrDetay1.dogumTarihi.gun`). Bu hiyerarşik erişim, verilerin mantıksal olarak ilişkili olduğu durumlarda kodun daha anlamlı olmasını sağlar.
Yapı Dizileri (Arrays of Structs)
Birden fazla benzer yapı nesnesini depolamak için yapı dizileri kullanılabilir. Tıpkı temel veri tiplerinin dizilerini oluşturduğunuz gibi, yapılar için de diziler tanımlayabilirsiniz. Bu, örneğin bir sınıfın tüm öğrencilerini, bir envanterdeki tüm ürünleri veya bir kütüphanedeki tüm kitapları temsil etmek için idealdir. Her dizi elemanı, belirli bir yapı tipinin tam bir örneğidir ve kendi üyelerine sahiptir.
Dizilere erişimde olduğu gibi, yapı dizisi elemanlarına erişmek için de köşeli parantez (`[]`) kullanılır. Ardından, yapı üyelerine erişim için nokta operatörü kullanılır. Yapı dizileri, özellikle büyük miktarda benzer, yapılandırılmış veriyi işlerken son derece kullanışlıdır.
Yapı İşaretçileri (Pointers to Structs)
Yapılarla çalışırken işaretçiler sıkça kullanılır, özellikle fonksiyonlara yapıları geçirmek, dinamik bellek tahsisi yapmak veya karmaşık veri yapıları (bağlı listeler, ağaçlar vb.) oluşturmak için. Bir yapı işaretçisi, bir yapının bellekteki başlangıç adresini tutar. Doğrudan bir yapı değişkeni yerine, bu yapının adresini tutan bir işaretçi ile çalışmak, özellikle büyük yapılar söz konusu olduğunda, bellek kopyalama maliyetini düşürerek program performansını artırabilir.
Yapı işaretçilerinin üyelerine erişmek için ok (`->`) operatörü kullanılır. Bu operatör, işaretçiyi dereferans edip ardından üyesine erişim sağlar.
Hatırlatma: `ptrU1->uye` ifadesi, `(*ptrU1).uye` ile eşdeğerdir. `->` operatörü, işaretçi üzerinden yapı üyelerine erişimi kolaylaştıran bir kısayoldur. Dinamik bellek tahsisi (malloc/calloc) ile yapıları kullanmak, özellikle programın çalışma zamanında ihtiyaca göre veri yapılarının boyutunu ayarlama esnekliği sağlar.
Yapıların Fonksiyonlara Geçirilmesi
Yapılar, fonksiyonlara değer olarak veya işaretçi olarak geçirilebilir. Her iki yöntemin de kendine göre avantajları ve kullanım durumları vardır:
1. Değer Olarak Geçirme: Yapının bir kopyası fonksiyona gönderilir. Bu, orijinal yapının fonksiyon içinde yapılan değişikliklerden etkilenmemesini sağlar. Ancak, büyük yapılar için bellek kopyalama maliyeti yüksek olabilir, bu da performans düşüşüne yol açabilir.
2. İşaretçi Olarak Geçirme: Yapının adresi (işaretçisi) fonksiyona gönderilir. Fonksiyon içindeki değişiklikler orijinal yapıyı doğrudan etkiler. Bu yöntem genellikle daha verimlidir, çünkü büyük yapının tamamının kopyalanması yerine sadece adresinin kopyalanması gerekir. Ayrıca, fonksiyonun yapının içeriğini değiştirmesi gerekiyorsa bu yöntem tercih edilmelidir.
Bu örnek, değer ve işaretçi ile geçirme arasındaki temel farkı net bir şekilde göstermektedir. İşaretçi ile geçirme, özellikle büyük veri yapılarıyla çalışırken performans ve bellek kullanımı açısından daha avantajlıdır.
(Bu bir görsel temsilinin yerini tutmaktadır ve fonksiyonlara yapı geçirme mekanizmasını gösteren şematik bir diyagramı ifade etmektedir.)
Kendine Referanslı Yapılar (Self-Referential Structs)
Kendine referanslı yapılar, aynı türden başka bir yapının işaretçisini içeren yapılardır. Bu yapılar, bağlı listeler (linked lists), ağaçlar (trees) ve grafikler (graphs) gibi dinamik veri yapılarının temelini oluşturur. Bu tür yapılar, bellekte birbirine bağlı düğümlerden oluşan esnek ve dinamik koleksiyonlar oluşturmanıza olanak tanır. Her düğüm, kendi verisinin yanı sıra, bir sonraki (veya önceki, veya alt) düğümün adresini tutan bir işaretçiye sahiptir.
En yaygın örneklerden biri tek bağlı listedir:
Bu yapıda `sonraki` elemanı, aynı `Dugum` yapısından bir sonraki düğümün adresini tutar. Bu sayede düğümler birbirine bağlanır ve bir zincir oluşturulur. Kendine referanslı yapılar, programlama problemlerinde dinamik bellek kullanımı ve esnek veri düzenlemeleri için vazgeçilmezdir.
Diğer İlgili Konular (Kısa Değinmeler)
Yapılarla ilgili olarak, daha ileri seviye kullanımlar ve optimizasyonlar için bilmeniz gereken birkaç ek konu bulunmaktadır:
Sonuç
C programlamada yapılar, karmaşık ve birbiriyle ilişkili verileri düzenlemek için vazgeçilmez bir araçtır. Nesne tabanlı programlamadaki sınıfların basit bir öncüsü olarak düşünülebilirler; zira verileri ve bu verilere ait olabilecek (fonksiyon işaretçileri aracılığıyla) davranışları bir araya getirme potansiyeline sahiptirler. Yapıları anlamak ve etkili bir şekilde kullanmak, daha düzenli, okunabilir ve güçlü C programları yazmanızı sağlar. Özellikle veri yapıları ve algoritma konularında ilerlemek isteyen her C programcısı için yapıların kullanımı hayati öneme sahiptir. Bağlı listeler, ağaçlar, kuyruklar ve yığınlar gibi temel veri yapıları, yapıların kendine referanslı özelliklerinden faydalanarak inşa edilir. Dolayısıyla, yapıları kavramak, C dilindeki ileri düzey konulara açılan bir kapıdır. Bu rehber, C yapılarının temelden ileri seviyeye kadar birçok yönünü ele alarak, size sağlam bir temel sunmayı amaçlamıştır. Daha fazla bilgi ve örnek için resmi C dili dokümantasyonlarına başvurmanızı öneririz. https://en.cppreference.com/w/c/language/struct veya https://www.tutorialspoint.com/cprogramming/c_structures.htm gibi güvenilir kaynaklardan daha fazla araştırma yapabilirsiniz. Yapıların sunduğu esneklik ve güç ile kendi karmaşık veri modellerinizi oluşturmaya başlayabilirsiniz.
Giriş
C programlama dilinde, farklı veri tiplerini tek bir birim altında toplamak için kullanılan güçlü bir özellik olan yapılara (structs) derinlemesine bir bakış atacağız. Yapılar, özellikle karmaşık veri modelleriyle çalışırken kodunuzu daha organize, okunabilir ve yönetilebilir hale getirir. Örneğin, bir öğrencinin adı, numarası, yaşı ve not ortalaması gibi birbiriyle ilişkili verileri tek bir yapı altında toplamak, bu verilere erişimi ve işlemeyi büyük ölçüde kolaylaştırır. Programlama dünyasında verilerin düzenli bir şekilde depolanması ve işlenmesi, yazılımın performansı ve sürdürülebilirliği açısından kritik öneme sahiptir. Yapılar da tam olarak bu ihtiyacı karşılar: birbiriyle ilişkili, ancak farklı türlerdeki verileri bir araya getirme yeteneği sunarak, programcıların gerçek dünya nesnelerini veya kavramlarını yazılımlarında daha doğru bir şekilde modellemelerine olanak tanır. Bu rehberde, yapıların temel tanımlamalarından, üye erişimine, iç içe yapılardan, işaretçilerle kullanımına ve hatta dinamik bellek yönetimiyle nasıl birleştiğine kadar geniş bir yelpazede konuları ele alacağız.
Yapı Nedir?
Bir yapı, farklı veri türlerindeki (int, char, float, diziler vb.) bir veya daha fazla değişkeni tek bir mantıksal birim altında gruplandırmamızı sağlayan, kullanıcı tanımlı bir veri tipidir. Yapılar, gerçek dünyadaki nesneleri veya kavramları modellemek için idealdir. Örneğin, bir kitap, bir araba veya bir tarih gibi. Her üye, yapının içinde kendi veri türüne ve adıyla tanımlanan bağımsız bir değişkendir. Bu sayede, ilişkili verileri ayrı ayrı değişkenler yerine tek bir çatı altında toplamak, programın mantığını basitleştirir ve hata yapma olasılığını azaltır.
Yapı Tanımlama ve Değişken Oluşturma
Bir yapı tanımlamak için `struct` anahtar kelimesi kullanılır. İşte genel sentaks:
Kod:
struct YapiAdi {
veri_tipi uye1;
veri_tipi uye2;
// ...
veri_tipi uyeN;
};Yukarıdaki sentaksta, `YapiAdi` sizin belirleyeceğiniz bir isimdir ve bu yapı tipini temsil eder. `uye1`, `uye2`, ... yapının üyeleri olup, her biri belirli bir `veri_tipi`ne sahiptir. Bir yapı tanımlandığında, aslında bellekte bir yer ayrılmaz; yalnızca bir şablon (blueprint) oluşturulur. Bellekte yer ayırmak ve bu şablonu kullanarak gerçek bir veri nesnesi oluşturmak için bu yapı tipinde bir değişken oluşturmamız gerekir.
Örnek olarak, bir öğrencinin adını, numarasını ve not ortalamasını saklayacak bir yapı tanımlayalım:
Kod:
struct Ogrenci {
char ad[50];
int ogrenciNo;
float notOrtalamasi;
};Bu `Ogrenci` yapısı tanımlandıktan sonra, bellekte bu yapıya uygun bir değişken oluşturabiliriz:
Kod:
struct Ogrenci ogr1; // ogr1 adında bir Ogrenci yapısı değişkeni oluşturuldu
struct Ogrenci ogr2, ogr3; // Birden fazla değişken aynı anda tanımlanabilirYapı Üyelerine Erişim
Yapı değişkenlerinin üyelerine erişmek ve onlara değer atamak veya değerlerini okumak için nokta (`.`) operatörü kullanılır. Bu operatör, bir yapı değişkeni adından sonra gelerek, o yapının belirli bir üyesine erişim sağlar. Aşağıdaki örnek, bir `Ogrenci` yapısı değişkeninin üyelerine nasıl erişileceğini ve onlara nasıl değer atanacağını göstermektedir:
Kod:
#include <stdio.h>
#include <string.h> // strcpy için
struct Ogrenci {
char ad[50];
int ogrenciNo;
float notOrtalamasi;
};
int main() {
struct Ogrenci ogr1; // ogr1 adında bir Ogrenci yapısı değişkeni tanımlandı
// Üyelere değer atama
// Karakter dizisi (string) üyelerine atama yaparken strcpy kullanmak önemlidir.
strcpy(ogr1.ad, "Ayşe Yılmaz");
ogr1.ogrenciNo = 101;
ogr1.notOrtalamasi = 85.5;
// Üyelerin değerlerini yazdırma
printf("Öğrenci Adı: %s\n", ogr1.ad);
printf("Öğrenci No: %d\n", ogr1.ogrenciNo);
printf("Not Ortalaması: %.2f\n", ogr1.notOrtalamasi);
// Başka bir öğrenci değişkeni tanımlayıp direkt başlatma
struct Ogrenci ogr2 = {"Can Berk", 102, 78.0};
printf("\nÖğrenci Adı: %s\n", ogr2.ad);
printf("Öğrenci No: %d\n", ogr2.ogrenciNo);
printf("Not Ortalaması: %.2f\n", ogr2.notOrtalamasi);
return 0;
}Yapılar ve typedef
`typedef` anahtar kelimesi, C dilinde mevcut bir veri tipine yeni bir isim atamak için kullanılır. Yapılarla birlikte kullanıldığında, `struct` anahtar kelimesini tekrar tekrar yazma zorunluluğunu ortadan kaldırarak kodu daha okunabilir ve yazımı daha kolay hale getirir. Özellikle karmaşık yapı adları veya iç içe yapılarla çalışırken bu kolaylık büyük önem taşır. `typedef` kullanımıyla, yapı tipini sanki dahili bir veri tipiymiş gibi kullanabilirsiniz.
Kod:
typedef struct {
char baslik[100];
char yazar[50];
int yayinYili;
} Kitap; // Artık Kitap, struct Kitap tipini temsil ediyor
int main() {
Kitap k1; // struct Kitap yazmak yerine sadece Kitap yazabildik
strcpy(k1.baslik, "C Programlama Dili");
strcpy(k1.yazar, "Brian W. Kernighan");
k1.yayinYili = 1978;
printf("Kitap: %s (%d) - %s\n", k1.baslik, k1.yayinYili, k1.yazar);
// Yapı tipini tanımlarken isimsiz struct kullanabiliriz
typedef struct {
int saat;
int dakika;
} Zaman;
Zaman simdi = {14, 30};
printf("Şimdiki Zaman: %02d:%02d\n", simdi.saat, simdi.dakika);
return 0;
}İç İçe Yapılar (Nested Structs)
Bir yapının içinde başka bir yapıyı üye olarak tanımlamak mümkündür. Bu, daha karmaşık ve hiyerarşik veri modelleri oluşturmanızı sağlar. Örneğin, bir öğrencinin doğum tarihini ayrı bir yapı olarak tanımlayıp, bu `Tarih` yapısını daha sonra bir `OgrenciDetay` yapısının içinde kullanabiliriz. Bu yaklaşım, verileri daha modüler bir şekilde organize etmenize ve ilgili bilgileri bir arada tutmanıza yardımcı olur.
Kod:
#include <stdio.h>
#include <string.h> // strcpy için
// Tarih yapısının tanımı
struct Tarih {
int gun;
int ay;
int yil;
};
// OgrenciDetay yapısının tanımı, Tarih yapısını içeriyor
struct OgrenciDetay {
char ad[50];
struct Tarih dogumTarihi; // İç içe yapı: Tarih tipi bir üye
int ogrenciNo;
};
int main() {
struct OgrenciDetay ogrDetay1;
// İç içe yapı üyelerine erişim
strcpy(ogrDetay1.ad, "Fatma Demir");
ogrDetay1.dogumTarihi.gun = 15; // İki nokta operatörü ile erişim
ogrDetay1.dogumTarihi.ay = 7;
ogrDetay1.dogumTarihi.yil = 2000;
ogrDetay1.ogrenciNo = 102;
printf("Öğrenci Adı: %s\n", ogrDetay1.ad);
printf("Doğum Tarihi: %d/%d/%d\n", ogrDetay1.dogumTarihi.gun,
ogrDetay1.dogumTarihi.ay,
ogrDetay1.dogumTarihi.yil);
// Başka bir örnek: Adres bilgisi içeren bir Kişi yapısı
typedef struct {
char sokak[50];
char sehir[30];
char postaKodu[10];
} Adres;
typedef struct {
char isim[50];
Adres ikametAdresi;
} Kisi;
Kisi kisiselBilgi;
strcpy(kisiselBilgi.isim, "Deniz Akdeniz");
strcpy(kisiselBilgi.ikametAdresi.sokak, "Menekşe Sk. No:5");
strcpy(kisiselBilgi.ikametAdresi.sehir, "İstanbul");
strcpy(kisiselBilgi.ikametAdresi.postaKodu, "34000");
printf("\nKişi: %s\n", kisiselBilgi.isim);
printf("Adres: %s, %s %s\n", kisiselBilgi.ikametAdresi.sokak,
kisiselBilgi.ikametAdresi.sehir,
kisiselBilgi.ikametAdresi.postaKodu);
return 0;
}Yapı Dizileri (Arrays of Structs)
Birden fazla benzer yapı nesnesini depolamak için yapı dizileri kullanılabilir. Tıpkı temel veri tiplerinin dizilerini oluşturduğunuz gibi, yapılar için de diziler tanımlayabilirsiniz. Bu, örneğin bir sınıfın tüm öğrencilerini, bir envanterdeki tüm ürünleri veya bir kütüphanedeki tüm kitapları temsil etmek için idealdir. Her dizi elemanı, belirli bir yapı tipinin tam bir örneğidir ve kendi üyelerine sahiptir.
Kod:
#include <stdio.h>
#include <string.h> // strcpy için
#define MAX_OGRENCI 3 // Maksimum öğrenci sayısı
struct Ogrenci {
char ad[50];
int ogrenciNo;
float notOrtalamasi;
};
int main() {
// 3 öğrencilik bir yapı dizisi tanımlama
struct Ogrenci sinif[MAX_OGRENCI];
// İlk öğrenciyi başlatma
strcpy(sinif[0].ad, "Mehmet Can");
sinif[0].ogrenciNo = 201;
sinif[0].notOrtalamasi = 78.0;
// İkinci öğrenciyi başlatma
strcpy(sinif[1].ad, "Zeynep Ata");
sinif[1].ogrenciNo = 202;
sinif[1].notOrtalamasi = 92.5;
// Üçüncü öğrenciyi başlatma
strcpy(sinif[2].ad, "Ali Veli");
sinif[2].ogrenciNo = 203;
sinif[2].notOrtalamasi = 65.0;
// Alternatif olarak, diziyi tanımlarken doğrudan başlatma:
// struct Ogrenci sinif2[] = {
// {"Gizem Solmaz", 301, 88.0},
// {"Ozan Kara", 302, 72.5}
// };
// Tüm öğrencilerin bilgilerini döngü kullanarak yazdırma
printf("Sınıf Listesi:\n");
for (int i = 0; i < MAX_OGRENCI; i++) {
printf("Öğrenci %d: %s (No: %d, Ort: %.2f)\n", i + 1,
sinif[i].ad, sinif[i].ogrenciNo, sinif[i].notOrtalamasi);
}
return 0;
}Yapı İşaretçileri (Pointers to Structs)
Yapılarla çalışırken işaretçiler sıkça kullanılır, özellikle fonksiyonlara yapıları geçirmek, dinamik bellek tahsisi yapmak veya karmaşık veri yapıları (bağlı listeler, ağaçlar vb.) oluşturmak için. Bir yapı işaretçisi, bir yapının bellekteki başlangıç adresini tutar. Doğrudan bir yapı değişkeni yerine, bu yapının adresini tutan bir işaretçi ile çalışmak, özellikle büyük yapılar söz konusu olduğunda, bellek kopyalama maliyetini düşürerek program performansını artırabilir.
Yapı işaretçilerinin üyelerine erişmek için ok (`->`) operatörü kullanılır. Bu operatör, işaretçiyi dereferans edip ardından üyesine erişim sağlar.
Kod:
#include <stdio.h>
#include <string.h>
#include <stdlib.h> // malloc ve free için
typedef struct {
char urunAdi[50];
float fiyat;
int stokAdedi;
} Urun;
int main() {
// Statik olarak tanımlanmış bir Urun yapısı
Urun u1 = {"Laptop", 12000.0, 50};
Urun *ptrU1; // Urun tipinde bir işaretçi tanımlama
ptrU1 = &u1; // u1'in adresini işaretçiye atama
// İşaretçi kullanarak üyelere erişim (ok -> operatörü)
printf("Statik Ürün Bilgisi:\n");
printf("Ürün Adı: %s\n", ptrU1->urunAdi);
printf("Fiyat: %.2f TL\n", ptrU1->fiyat);
printf("Stok Adedi: %d\n", ptrU1->stokAdedi);
// Dinamik bellek tahsisi ile yapı oluşturma
// malloc ile Urun yapısı boyutunda bellek ayrılıyor
Urun *yeniUrun = (Urun *)malloc(sizeof(Urun));
if (yeniUrun == NULL) {
printf("Bellek tahsisi başarısız! Program sonlandırılıyor.\n");
return 1; // Hata kodu ile çıkış
}
// Dinamik olarak oluşturulan yapının üyelerine değer atama
strcpy(yeniUrun->urunAdi, "Kablosuz Mouse");
yeniUrun->fiyat = 250.0;
yeniUrun->stokAdedi = 100;
printf("\nDinamik Olarak Oluşturulan Ürün Bilgisi:\n");
printf("Ürün Adı: %s\n", yeniUrun->urunAdi);
printf("Fiyat: %.2f TL\n", yeniUrun->fiyat);
printf("Stok Adedi: %d\n", yeniUrun->stokAdedi);
// İşlem bittikten sonra dinamik olarak ayrılan belleği serbest bırakma
free(yeniUrun);
yeniUrun = NULL; // İşaretçiyi NULL'a eşitleyerek dangling pointer olmasını engelleme
return 0;
}Yapıların Fonksiyonlara Geçirilmesi
Yapılar, fonksiyonlara değer olarak veya işaretçi olarak geçirilebilir. Her iki yöntemin de kendine göre avantajları ve kullanım durumları vardır:
1. Değer Olarak Geçirme: Yapının bir kopyası fonksiyona gönderilir. Bu, orijinal yapının fonksiyon içinde yapılan değişikliklerden etkilenmemesini sağlar. Ancak, büyük yapılar için bellek kopyalama maliyeti yüksek olabilir, bu da performans düşüşüne yol açabilir.
2. İşaretçi Olarak Geçirme: Yapının adresi (işaretçisi) fonksiyona gönderilir. Fonksiyon içindeki değişiklikler orijinal yapıyı doğrudan etkiler. Bu yöntem genellikle daha verimlidir, çünkü büyük yapının tamamının kopyalanması yerine sadece adresinin kopyalanması gerekir. Ayrıca, fonksiyonun yapının içeriğini değiştirmesi gerekiyorsa bu yöntem tercih edilmelidir.
Kod:
#include <stdio.h>
#include <string.h> // strcpy için
typedef struct {
char marka[30];
char model[30];
int yil;
} Araba;
// Yapıyı değer olarak alan fonksiyon
// Fonksiyonun içinde yapılan değişiklikler orijinal 'arabam' değişkenini etkilemez.
void bilgiGoster(Araba oto) {
printf("Marka: %s, Model: %s, Yıl: %d\n", oto.marka, oto.model, oto.yil);
strcpy(oto.marka, "Değiştirildi"); // Bu değişiklik sadece kopyayı etkiler
printf("[bilgiGoster içinde] Marka: %s\n", oto.marka);
}
// Yapı işaretçisi alan ve üzerinde değişiklik yapan fonksiyon
// Fonksiyonun içinde yapılan değişiklikler orijinal 'arabam' değişkenini etkiler.
void yilGuncelle(Araba *otoPtr, int yeniYil) {
otoPtr->yil = yeniYil; // Ok (->) operatörü ile üyeye erişim
printf("[yilGuncelle içinde] Yeni Yıl: %d\n", otoPtr->yil);
}
int main() {
Araba arabam = {"Ford", "Focus", 2018};
printf("Başlangıç Bilgisi:\n");
bilgiGoster(arabam); // Yapı değer olarak gönderildi
printf("bilgiGoster sonrası orijinal Marka: %s\n", arabam.marka); // Orijinal marka değişmedi
printf("\nYıl Güncelleme Öncesi: %d\n", arabam.yil);
yilGuncelle(&arabam, 2022); // Yapının adresi (işaretçisi) gönderildi
printf("Yıl Güncelleme Sonrası: %d\n", arabam.yil); // Orijinal yıl değişti
return 0;
}
Kendine Referanslı Yapılar (Self-Referential Structs)
Kendine referanslı yapılar, aynı türden başka bir yapının işaretçisini içeren yapılardır. Bu yapılar, bağlı listeler (linked lists), ağaçlar (trees) ve grafikler (graphs) gibi dinamik veri yapılarının temelini oluşturur. Bu tür yapılar, bellekte birbirine bağlı düğümlerden oluşan esnek ve dinamik koleksiyonlar oluşturmanıza olanak tanır. Her düğüm, kendi verisinin yanı sıra, bir sonraki (veya önceki, veya alt) düğümün adresini tutan bir işaretçiye sahiptir.
En yaygın örneklerden biri tek bağlı listedir:
Kod:
#include <stdio.h>
#include <stdlib.h> // malloc ve free için
// Bağlı liste düğümü tanımı
typedef struct Dugum {
int veri; // Düğümün sakladığı veri
struct Dugum *sonraki; // Kendine referanslı işaretçi: Bir sonraki düğümün adresi
} Dugum;
// Yeni bir düğüm oluşturma ve başlatma fonksiyonu
Dugum* yeniDugumOlustur(int veri) {
Dugum* yeni = (Dugum*)malloc(sizeof(Dugum)); // Bellekte yeni bir Dugum için yer ayır
if (yeni == NULL) {
printf("Bellek tahsisi hatası! Program sonlandırılıyor.\n");
exit(1); // Hata durumunda programdan çık
}
yeni->veri = veri; // Veriyi ata
yeni->sonraki = NULL; // Başlangıçta sonraki düğüm yok
return yeni; // Oluşturulan düğümün işaretçisini döndür
}
// Bağlı listeyi baştan sona yazdırma fonksiyonu
void listeyiYazdir(Dugum* baslangic) {
Dugum* gecici = baslangic;
printf("Liste: ");
while (gecici != NULL) {
printf("%d -> ", gecici->veri);
gecici = gecici->sonraki; // Bir sonraki düğüme geç
}
printf("NULL\n"); // Listenin sonunu belirtmek için
}
int main() {
// Bağlı liste oluşturma: Üç düğümlü basit bir liste
Dugum* bas = yeniDugumOlustur(10); // İlk düğüm (başlangıç)
bas->sonraki = yeniDugumOlustur(20); // İkinci düğüm
bas->sonraki->sonraki = yeniDugumOlustur(30); // Üçüncü düğüm
listeyiYazdir(bas); // Listeyi ekrana yazdır
// Belleği temizleme: Bağlı liste düğümlerini serbest bırakma
Dugum* temp; // Geçici işaretçi
while (bas != NULL) {
temp = bas; // Mevcut düğümü temp'e kaydet
bas = bas->sonraki; // Başlangıcı bir sonraki düğüme taşı
free(temp); // Mevcut düğümün belleğini serbest bırak
}
printf("Bellek temizlendi.\n");
return 0;
}Diğer İlgili Konular (Kısa Değinmeler)
Yapılarla ilgili olarak, daha ileri seviye kullanımlar ve optimizasyonlar için bilmeniz gereken birkaç ek konu bulunmaktadır:
- Struct vs Union: Hem `struct` hem de `union` farklı veri tiplerini gruplamak için kullanılır. Ancak, temel farkları bellek tahsisindedir. Bir `union`'ın tüm üyeleri aynı bellek alanını paylaşır ve aynı anda sadece bir üyesi aktif olabilir. Bu, bellekten tasarruf etmek istendiğinde faydalıdır. Buna karşılık, bir `struct`'ın tüm üyeleri kendi bağımsız bellek alanlarına sahiptir ve hepsi aynı anda erişilebilir durumdadır. Bu, birden fazla bilginin eş zamanlı olarak saklanması gerektiğinde tercih edilir.
- Bellek Hizalama (Memory Alignment): C derleyicileri, işlemci mimarisine ve performansa uygun olarak yapı üyelerini bellekte belirli adreslere hizalayabilir. Bu durum, bir yapının görünen (yani üyelerin toplam boyutu) boyutundan daha fazla bellek tüketmesine neden olabilir. Örneğin, 4 baytlık bir `int` ve 1 baytlık bir `char` içeren bir yapı, 5 bayt yerine 8 bayt yer kaplayabilir, çünkü `int`'in 4 baytlık bir sınırda başlaması gerekebilir. `sizeof` operatörü ile bir yapının bellekteki gerçek boyutunu kontrol edebilirsiniz. Bu durum özellikle gömülü sistemlerde veya ağ protokolleri üzerinde çalışırken önemlidir.
- Bit Alanları (Bit Fields): Yapı üyelerinin bellekteki bit seviyesinde alan kaplamasını kontrol etmek için kullanılır. Bu özellik, özellikle çok sayıda boolean (doğru/yanlış) bayrağı veya küçük sayısal değerleri depolarken yerden tasarruf etmek için faydalıdır. Bit alanları ile, bir tam sayı tipi içinde tek tek bitlere veya belirli sayıda bite erişebilir ve bunları yönetebilirsiniz. Bellek kısıtlı ortamlarda (örneğin, mikrodenetleyicilerde) veya donanım kontrolünde kritik öneme sahiptir.
Sonuç
C programlamada yapılar, karmaşık ve birbiriyle ilişkili verileri düzenlemek için vazgeçilmez bir araçtır. Nesne tabanlı programlamadaki sınıfların basit bir öncüsü olarak düşünülebilirler; zira verileri ve bu verilere ait olabilecek (fonksiyon işaretçileri aracılığıyla) davranışları bir araya getirme potansiyeline sahiptirler. Yapıları anlamak ve etkili bir şekilde kullanmak, daha düzenli, okunabilir ve güçlü C programları yazmanızı sağlar. Özellikle veri yapıları ve algoritma konularında ilerlemek isteyen her C programcısı için yapıların kullanımı hayati öneme sahiptir. Bağlı listeler, ağaçlar, kuyruklar ve yığınlar gibi temel veri yapıları, yapıların kendine referanslı özelliklerinden faydalanarak inşa edilir. Dolayısıyla, yapıları kavramak, C dilindeki ileri düzey konulara açılan bir kapıdır. Bu rehber, C yapılarının temelden ileri seviyeye kadar birçok yönünü ele alarak, size sağlam bir temel sunmayı amaçlamıştır. Daha fazla bilgi ve örnek için resmi C dili dokümantasyonlarına başvurmanızı öneririz. https://en.cppreference.com/w/c/language/struct veya https://www.tutorialspoint.com/cprogramming/c_structures.htm gibi güvenilir kaynaklardan daha fazla araştırma yapabilirsiniz. Yapıların sunduğu esneklik ve güç ile kendi karmaşık veri modellerinizi oluşturmaya başlayabilirsiniz.
