Çalıştırılabilir C Dokümanları: yapılar

Q: C'de bir yapı nasıl bildirilir?

struct yazın, ardından bir etiket adı ve süslü parantez içinde üye listesi: struct Point { int x; int y; };. Bu bir değişken değil bir tip bildirir. Bir değişken yapmak için sonra struct Point p; yazarsınız - C'de struct kelimesi tip adının bir parçasıdır; kodun çoğunun onu bir typedef ile eşlemesinin sebebi budur.

Q: Yapılar için `.` ile `->` arasındaki fark nedir?

Yapının kendisine sahipken . (p.x), ona bir göstericiye sahipken -> (ptr->x) kullanın. Ok, (*ptr).x'in kısaltmasıdır. Ayrıntılar için bkz. yapılar ve göstericiler.

Q: C'de bir yapıya nasıl ilk değer veririm?

Ya konumsal olarak, struct Point p = {3, 4}; ya da belirtilmiş ilk değerlerle, struct Point p = {.y = 4, .x = 3};. Belirtilmiş biçim her üyeyi adlandırır, dolayısıyla birinin sonradan yapıyı yeniden sıralamasından sağ çıkar ve adlandırılmayan üyeleri sıfırlanmış bırakır.

Bir dizi tek tipten çok değer tutar. Bir struct bunun tersini yapar: farklı tiplerden birkaç değer tutar ve onlara tek bir şey gibi davranır. Bir nokta bir x ve bir y'dir. Bir çalışan bir isim, bir kimlik ve bir maaştır. Yapılar olmadan bunları üç ayrı değişken olarak taşır ve kimin maaşının kime ait olduğunu hiç karıştırmadığınızı umardınız.

Bir Yapı Tipi Bildirmek

Bir yapı bildirimi bir etiket adlandırır ve üyeleri süslü parantez içinde listeler:

struct Point {
    int x;
    int y;
};

Kapanış parantezinden sonraki noktalı virgül zorunludur - onu unutmak, bir C acemisinin karşılaşacağı en kafa karıştırıcı hata mesajlarından biridir, çünkü derleyici sonraki satırı suçlar.

Bu bir değişken değil bir tip bildirir. C'de tipin tam adı, anahtar kelime dahil, struct Point'tir:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point p;
    p.x = 3;
    p.y = 4;

    printf("(%d, %d)\n", p.x, p.y);
    return 0;
}

Üyeler nokta operatörüyle, p.x, okunur ve yazılır. Bir yapı değişkeni sıradan bir değişkendir: yığında yaşar, = ile aynı tipten başka bir yapıya atanabilir ve kapsamının sonunda yok olur.

Her yerde struct Point yazmak yorucu olur; neredeyse tüm gerçek C kodunun bildirimi bir typedef ile sarmasının ve tipin yalnızca Point olmasının sebebi budur.

Bir Yapıya İlk Değer Vermek

Bir yapıyı bildirdiğiniz anda doldurabilirsiniz. Konumsal biçim değerleri bildirim sırasına göre listeler:

struct Point p = {3, 4};   // x = 3, y = 4

Belirtilmiş ilk değer bunun yerine her üyeyi adlandırır ki bu daha anlaşılır ve daha güvenlidir:

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee a = {101, "Ada", 92000.0};
    struct Employee b = {.name = "Grace", .id = 102, .salary = 105000.0};
    struct Employee blank = {0};

    printf("%d %s %.2f\n", a.id, a.name, a.salary);
    printf("%d %s %.2f\n", b.id, b.name, b.salary);
    printf("%d [%s] %.2f\n", blank.id, blank.name, blank.salary);
    return 0;
}

Dikkate değer üç şey:

Belirtilmiş biçim üyeleri herhangi bir sırada listeleyebilir, dolayısıyla sonradan bir üye eklemek ya da yeniden sıralamak değerleri sessizce yanlış yuvalara kaydırmaz.
Dışarıda bıraktığınız her üyeye sıfır atanır - {0}, bütün bir yapıyı sıfırlamanın deyimsel yoludur.
char name[32] üyesi yapının içindeki gerçek bir dizidir, dolayısıyla metin başka bir yerde değil yapının kendisinde saklanır. Bu ayrıca sonradan a.name = "Ada";'nın geçersiz olduğu anlamına gelir; strcpy'ye ihtiyacınız var (bkz. metin fonksiyonları).

İlk değeri olmayan bir yapı ilk değersizdir ve üyelerini yazmadan önce okumak tanımsız davranıştır. = {0} hiçbir şeye mal olmaz ve tüm hata kategorisini ortadan kaldırır.

Atamak ve Karşılaştırmak

Yapı ataması her üyeyi kopyalar:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void) {
    struct Point a = {1, 2};
    struct Point b = a;   // tam kopya

    b.x = 99;

    printf("a = (%d, %d)\n", a.x, a.y);
    printf("b = (%d, %d)\n", b.x, b.y);
    return 0;
}

a'ya dokunulmadı: b kendi kopyasını aldı. Ama C'nin size vermediği şeye dikkat edin - yapılar için == yoktur. if (a == b) derlenmez. Karşılaştırmak, üyeleri karşılaştırmak demektir:

if (a.x == b.x && a.y == b.y) { /* eşit */ }

Kısayol olarak memcmp'ye uzanmayın. Derleyiciler hizalama için üyeler arasına görünmez dolgu baytları ekler ve o baytlar çöp tutabilir, dolayısıyla üyeleri özdeş iki yapı bayt bayt eşitsiz karşılaştırılabilir.

Yapı Dizileri

Bir yapı diğerleri gibi bir tip olduğu için onlardan bir dizi yapabilirsiniz - bir kayıt tablosu tutmanın standart yolu.

#include <stdio.h>

struct Employee {
    int id;
    char name[32];
    double salary;
};

int main(void) {
    struct Employee staff[3] = {
        {101, "Ada",    92000.0},
        {102, "Grace",  105000.0},
        {103, "Alan",   87000.0},
    };

    int n = sizeof(staff) / sizeof(staff[0]);
    double total = 0.0;

    for (int i = 0; i < n; i++) {
        printf("%-3d %-8s %10.2f\n", staff[i].id, staff[i].name, staff[i].salary);
        total += staff[i].salary;
    }

    printf("Ortalama: %.2f\n", total / n);
    return 0;
}

staff[i].salary, "eleman i, sonra onun salary üyesi" diye okunur - indeksleme noktadan daha sıkı bağlanır, dolayısıyla parantez gerekmez.

Yapılar Fonksiyonlara Kopyalanır

İnsanları yakalayan kural budur. Bir fonksiyona yapı geçirdiğinizde C onu kopyalar. Fonksiyon kendi özel kopyası üzerinde çalışır:

#include <stdio.h>

struct Point {
    int x;
    int y;
};

void try_to_move(struct Point p) {
    p.x += 100;   // yalnizca kopyayi degistirir
}

double distance_from_origin(struct Point p) {
    return p.x * p.x + p.y * p.y;   // uzakligin karesi, math.h gerekmez
}

int main(void) {
    struct Point p = {3, 4};

    try_to_move(p);
    printf("try_to_move sonrasi: (%d, %d)\n", p.x, p.y);
    printf("uzakligin karesi: %.0f\n", distance_from_origin(p));
    return 0;
}

p hâlâ (3, 4)'tür. distance_from_origin'in yaptığı gibi bir yapıyı değerle okumak gayet sorunsuzdur ve küçük yapılar için çoğu zaman en anlaşılır seçimdir. Ama fonksiyonun çağıranın yapısını değiştirmesi gerekiyorsa - ya da yapı, kopyalamanın israf olacağı kadar büyükse - bunun yerine bir gösterici geçirin. Bu, yapılar ve göstericiler sayfasının konusudur.

Bir yapıyı değerle döndürmek de aynı şekilde çalışır ve tamamen geçerlidir:

struct Point make_point(int x, int y) {
    struct Point p = {x, y};
    return p;
}

İç İçe Yapılar

Bir yapı üyesi kendisi bir yapı olabilir. İçeri ulaşmak için noktaları zincirleyin:

#include <stdio.h>

struct Date {
    int year;
    int month;
    int day;
};

struct Book {
    char title[64];
    struct Date published;
    int pages;
};

int main(void) {
    struct Book b = {
        .title = "The C Programming Language",
        .published = {.year = 1978, .month = 2, .day = 22},
        .pages = 228,
    };

    printf("%s (%d-%02d-%02d), %d sayfa\n",
           b.title,
           b.published.year, b.published.month, b.published.day,
           b.pages);
    return 0;
}

b.published.year her seferinde bir seviye içeri yürür. İç içe yerleştirme, C'de gerçek veri modellerini kurma yolunuzdur - ve içteki yapı dıştakinin içinde saklanır, gösterilmez, dolayısıyla tüm Book tek bir bitişik bellek bloğudur.

Boyut, Dolgu ve Üye Sırası

sizeof size bir yapının ne kadar büyük olduğunu söyler ve cevap çoğu zaman üyelerinin toplamından büyüktür:

#include <stdio.h>

struct Wasteful {
    char  a;    // 1 bayt
    int   b;    // 4 bayt
    char  c;    // 1 bayt
};

struct Tidy {
    int   b;
    char  a;
    char  c;
};

int main(void) {
    printf("Wasteful: %zu bayt\n", sizeof(struct Wasteful));
    printf("Tidy:     %zu bayt\n", sizeof(struct Tidy));
    return 0;
}

Tipik bir makinede Wasteful 12 bayt ve Tidy 8 bayttır; her ikisi de aynı üç üyeyi tutmasına rağmen. Derleyici, her üye tipinin sevdiği bir adreste otursun diye dolgu ekler - bir int genellikle 4'ün katını ister. Büyük üyeleri küçüklerden önce gruplamak daha iyi paketleme eğilimindedir.

Bu nadiren önemlidir (bir milyon elemanlı bir dizi, bir ağ paketi düzeni) ve kendi kodunuzun doğruluğu için asla önemli değildir. Açıkladığı şey, sizeof'un sizi neden şaşırttığı ve yapılarda memcmp'nin neden kötü bir fikir olduğudur.

Sıkça Sorulan Sorular

C'de bir yapı nasıl bildirilir?

struct yazın, ardından bir etiket adı ve süslü parantez içinde üye listesi: struct Point { int x; int y; };. Bu bir değişken değil bir tip bildirir. Bir değişken yapmak için sonra struct Point p; yazarsınız - C'de struct kelimesi tip adının bir parçasıdır; kodun çoğunun onu bir typedef ile eşlemesinin sebebi budur.

Yapılar için . ile -> arasındaki fark nedir?

Yapının kendisine sahipken . (p.x), ona bir göstericiye sahipken -> (ptr->x) kullanın. Ok, (*ptr).x'in kısaltmasıdır. Ayrıntılar için bkz. yapılar ve göstericiler.

C'de yapılar değerle mi referansla mı geçirilir?

Her zaman değerle. Bir fonksiyona yapı geçirmek her üyeyi kopyalar, dolayısıyla fonksiyonun içindeki değişiklikler çağıranın değişkenini etkilemez. Özgünü değiştirmek - ya da büyük bir yapıyı kopyalamaktan kaçınmak - için bunun yerine bir gösterici geçirin.

C'de bir yapıya nasıl ilk değer veririm?

Ya konumsal olarak, struct Point p = {3, 4}; ya da belirtilmiş ilk değerlerle, struct Point p = {.y = 4, .x = 3};. Belirtilmiş biçim her üyeyi adlandırır, dolayısıyla birinin sonradan yapıyı yeniden sıralamasından sağ çıkar ve adlandırılmayan üyeleri sıfırlanmış bırakır.

İlgili kavramlar