C++ Struct'lar: İlişkili Verileri Tek Bir Tipte Toplama

Verileri Neden Bir Arada Tutmalı

Şimdiye kadar her değişken tek başına durdu: bir yerde bir int, başka bir yerde bir string. Ama gerçek programlar birkaç parçadan oluşan şeylerle uğraşır; bir noktanın bir x'i ve bir y'si vardır, bir öğrencinin bir adı, bir yaşı ve bir GPA'sı vardır. Bunları dağınık, ayrı değişkenler olarak dolaştırmak hataya açıktır; hiçbir şey onları birbirine bağlamaz ve üçüne de ihtiyaç duyan bir fonksiyonun üç parametre alması gerekir.

Bir struct bunu çözer. İlişkili değişkenleri — yani üyelerini — tek bir birimde toplayan yeni bir tip tanımlar. Tanımlandıktan sonra, tüm demeti depolayabileceğiniz, kopyalayabileceğiniz ve fonksiyonlara geçirebileceğiniz tek bir değer gibi ele alırsınız.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    int age;
    double gpa;
};   // <- kapanış süslü parantezinden sonra noktalı virgülü unutmayın

int main() {
    Student s;          // üç üyeyi de tutan tek bir nesne
    s.name = "Ada";
    s.age = 19;
    s.gpa = 3.9;

    cout << s.name << " is " << s.age << " (GPA " << s.gpa << ")\n";
}

Her üyeye nokta operatörüyle erişirsiniz (s.name, s.age). Struct tanımının kapanış } işaretinden sonraki noktalı virgül zorunludur; onu atlamak C++'ta yeni başlayanların en sık yaptığı derleme hatalarından biridir.

Bir Struct'ı Başlatma

Her alanı elle atamak işe yarar ama uzun sürer ve bir üyeyi atlamak kolaydır. Daha temiz seçenek aggregate initialization'dır: değerleri, üyelerin tanımlandığı sırayla süslü parantezler içinde listeleyin.

#include <iostream>
using namespace std;

struct Point {
    int x;
    int y;
};

int main() {
    Point a{3, 4};        // x = 3, y = 4 (süslü parantez init, tercih edilen)
    Point origin{};       // her iki üye de değerle 0'a başlatıldı
    Point b = {10, 20};   // eski = {} biçimi, aynı etki

    cout << a.x << "," << a.y << "\n";          // 3,4
    cout << origin.x << "," << origin.y << "\n"; // 0,0
    cout << b.x << "," << b.y << "\n";           // 10,20
}

Boş varsayılana dikkat edin: Point p; (parantezsiz), x ve y'yi çöp değerlerle bırakır, çünkü yerleşik tip üyeleri otomatik olarak sıfırlanmaz. Point p{}; ise onları değerle 0'a başlatır. Süslü parantezleri tercih edin. Varsayılan değerleri doğrudan tanıma da gömebilirsiniz, böylece Point p; bile temiz başlar:

#include <iostream>
using namespace std;

struct Config {
    int width  = 800;     // varsayılan üye başlatıcıları
    int height = 600;
    bool fullscreen = false;
};

int main() {
    Config c;             // tüm varsayılanları kullanır
    Config wide{1920};    // width geçersiz kılındı, diğerleri varsayılanı korur

    cout << c.width << "x" << c.height << "\n";        // 800x600
    cout << wide.width << "x" << wide.height << "\n";  // 1920x600
}

Fonksiyon Parametresi Olarak Struct'lar

Bir struct tek bir değerdir, dolayısıyla bir fonksiyon üç yerine tek bir parametre alabilir. Yalnızca şunu unutmayın: bir struct'ı değere göre geçirmek tüm üyeleri kopyalar. Birkaç int'ten büyük her şey için, kopyayı atlamak adına const referansla geçirin — bunu referanslar sayfasında gördüğünüz kuralın aynısı.

#include <iostream>
#include <string>
using namespace std;

struct Student {
    string name;
    double gpa;
};

// const& string'in kopyalanmasını önler ve s'yi değiştirmemeye söz verir
void printStudent(const Student& s) {
    cout << s.name << ": " << s.gpa << "\n";
}

// bir struct döndürmek sorun değil - derleyici kopyayı eler
Student makeStudent(string name, double gpa) {
    return Student{name, gpa};
}

int main() {
    Student top = makeStudent("Grace", 4.0);
    printStudent(top);
}

Bir fonksiyondan tüm bir struct döndürmek, birden çok değeri aynı anda geri vermenin deyimsel yoludur; birden çok çıkış referansıyla uğraşmaktan çok daha temizdir.

Üye Fonksiyon ve Kurucu Ekleme

Bir struct yalnızca veriyle sınırlı değildir. Kendi üyeleri üzerinde işlem yapan üye fonksiyonlar ve nesne oluşturulduğu anda onu başlatan bir kurucu barındırabilir. İşte bir struct'ın davranışa sahip küçük bir nesneye benzemeye başladığı yer burasıdır.

#include <iostream>
using namespace std;

struct Rectangle {
    double width;
    double height;

    // kurucu: bir Rectangle oluşturulduğunda çalışır
    Rectangle(double w, double h) : width(w), height(h) {}

    // üye fonksiyon: nesnenin kendi üyelerini kullanır
    double area() const {        // const = "nesneyi değiştirmiyorum"
        return width * height;
    }
};

int main() {
    Rectangle r(4.0, 5.0);
    cout << "area = " << r.area() << "\n";   // area = 20
}

Bir üye fonksiyonun içinde üyelere adlarıyla erişilir (width, height); bunlar bu nesnenin kopyasına atıfta bulunur. area() const olarak işaretlemek, derleyiciye fonksiyonun nesneyi yalnızca okuduğunu söyler; bu da onu const Rectangle değerleri üzerinde de çağırmanıza olanak tanır. Kurucular, o : width(w) başlatıcı liste söz dizimi dahil olmak üzere başlı başına bir konudur; kurucular sayfası derinlemesine ele alır.

Struct vs. class: Gerçek Fark

"Struct'lar veri içindir, class'lar nesne içindir" dendiğini duymuş olabilirsiniz. Bu bir gelenektir, dilin bir kuralı değil. C++'ta bir struct ile bir class neredeyse aynı şeydir; tek yerleşik fark varsayılan erişim düzeyidir.

struct S {
    int x;        // varsayılan olarak public
};

class C {
    int x;        // varsayılan olarak private
};

Bir struct'ın üyeleri aksini işaretlemediğiniz sürece public'tir; bir class'ınkiler ise private olarak başlar. Hepsi bu kadar; her ikisinin de kurucuları, üye fonksiyonları, kalıtımı ve diğer her şeyi olabilir. Üyeleri gizlemek için bir struct'a açıkça erişim belirleyicileri bile ekleyebilirsiniz:

#include <iostream>
using namespace std;

struct Counter {
    int value() const { return count; }   // public
    void bump() { count++; }

private:
    int count = 0;                          // artık gizli
};

int main() {
    Counter c;
    c.bump();
    c.bump();
    cout << c.value() << "\n";   // 2
    // c.count = 99;   // derleme hatası - count private
}

Pratik çıkarım: her alanın serbestçe erişilebilmesi gereken şeffaf veri demetleri için struct'ı kullanın (bir Point, bir Color, bir yapılandırma kaydı); iç durumu genel bir arayüzün ardında korumak istediğinizde ise class'a başvurun. Derleyici ikisine de aynı davranır; anahtar sözcük yalnızca niyetinizi belirtir.

Struct'lardan Oluşan Diziler ve Vector'lar

Bir struct sıradan bir tip olduğundan, birçoğunu bir diziye veya bir vector'e koyabilir ve başka herhangi bir değer gibi üzerlerinde döngü kurabilirsiniz.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

struct Product {
    string name;
    double price;
};

int main() {
    vector<Product> cart = {
        {"Keyboard", 49.99},
        {"Mouse", 19.99},
        {"Monitor", 199.00},
    };

    double total = 0;
    for (const Product& p : cart) {   // const& - öğe başına kopya yok
        cout << p.name << ": $" << p.price << "\n";
        total += p.price;
    }
    cout << "Total: $" << total << "\n";
}

İç içe süslü parantezlere dikkat edin: her {"Keyboard", 49.99} bir Product'ı aggregate olarak başlatır, dıştaki parantezler ise vector'ü oluşturur. Aralık tabanlı döngüde const Product& kullanmak, her yinelemede her struct'ın kopyalanmasını önler; &'yi kaldırırsanız her öğeyi gereksiz yere çoğaltmış olursunuz.

Sonraki: Enum'lar

Struct'lar, bir tipi bir araya getirilmiş birkaç değerden oluşturmanıza olanak tanır. Bir sonraki bölüm tam tersi yöne gider: bir enum, adlandırılmış küçük bir kümeden tam olarak bir değer tutabilen bir tip tanımlar; Color::Red, Direction::North veya bir durum makinesinin durumu gibi şeyler için mükemmeldir. enum class'ın, şimdi inşa ettiğiniz struct ve class'larla doğal biçimde uyum sağlayan okunabilir ve tip güvenli sabitler nasıl sunduğunu göreceksiniz.