Asıl sorun: Disk erişimi pahalıdır

RAM üzerindeki verilere erişmek son derece hızlıdır; ancak kalıcı veriler SSD veya sabit diskte tutulur. Diskten tek bir bayt yerine genellikle sayfa ya da blok adı verilen sabit boyutlu veri parçaları okunur. Bir sayfanın boyutu örneğin 4 KB, 8 KB veya 16 KB olabilir.

Bu nedenle disk tabanlı bir veri yapısında temel maliyet, yapılan karşılaştırmalar değil, okunan sayfa sayısıdır. Bir milyon kayıt arasında ikili arama teorik olarak

adım gerektirir. Fakat her düğüm ayrı bir disk sayfasındaysa yaklaşık 20 disk erişimi oldukça pahalı olabilir. B-ağaçları ise bir düğümde çok sayıda anahtar saklayarak ağacın dallanma katsayısını büyütür.

B-ağacının temel mantığı

İkili arama ağacındaki her düğüm en fazla iki çocuğa sahiptir. B-ağacında ise bir düğüm onlarca, hatta yüzlerce çocuk barındırabilir. Düğüm boyutu genellikle bir disk sayfasını dolduracak şekilde seçilir.

Bir B-ağacının dallanma katsayısı $m$ ise yaklaşık yüksekliği şöyledir:

Örneğin bir düğüm 100 çocuk gösterebiliyorsa bir milyon kayıt için:

Yani teorik olarak yalnızca üç sayfa okumasıyla hedef bölgeye ulaşılabilir. Üst düğümlerin önbellekte tutulması durumunda gerçek disk erişimi daha da azalır.

Arama nasıl gerçekleştirilir?

Her düğümde anahtarlar sıralı tutulur. Aranan değer düğümdeki anahtarlarla karşılaştırılır ve uygun çocuk sayfasına geçilir. Aşağıdaki sadeleştirilmiş Python kodu, bellekteki bir B-ağacı düğümünde bu yönlendirmeyi gösterir:

class BTreeNode:
    def __init__(self, keys, children=None, leaf=False):
        self.keys = keys
        self.children = children or []
        self.leaf = leaf

    def search(self, target):
        index = 0

        while index < len(self.keys) and target > self.keys[index]:
            index += 1

        if index < len(self.keys) and target == self.keys[index]:
            return self.keys[index]

        if self.leaf:
            return None

        return self.children[index].search(target)

Kod, önce hedefin hangi anahtar aralığında bulunduğunu belirler. Düğüm yaprak değilse yalnızca ilgili çocuğa ilerler. Gerçek veritabanlarında children listesindeki öğeler çoğunlukla nesne değil, disk sayfalarının adresleridir. Ayrıca düğüm içindeki arama doğrusal tarama yerine ikili aramayla yapılabilir.

Ekleme ve bölünme

Bir düğüm dolduğunda yeni kayıt gelişigüzel başka bir yere konmaz. Düğüm iki parçaya bölünür ve ortadaki anahtar üst düğüme taşınır. Üst düğüm de dolarsa bölünme köke kadar ilerleyebilir. Kök bölündüğünde ağacın yüksekliği yalnızca bir artar.

Bu kurallar bütün yaprakların aynı seviyede kalmasını sağlar. Böylece kötü sıralanmış eklemeler bile ağacı uzun bir zincire dönüştüremez. Arama, ekleme ve silme işlemlerinin maliyeti genel olarak $O(\log_m n)$ seviyesindedir.

B+ ağaçları neden daha yaygın?

Modern veritabanları çoğunlukla B-ağacının bir türevi olan B+ ağacını kullanır. İç düğümler yalnızca yönlendirme anahtarlarını içerirken gerçek kayıtlar yapraklarda saklanır. Yapraklar birbirine bağlı olduğundan WHERE yas BETWEEN 20 AND 30 gibi aralık sorguları, ilk kayıt bulunduktan sonra sayfalar üzerinde sıralı biçimde ilerleyebilir.

Kısacası B-ağaçlarının gücü yalnızca hızlı arama yapmalarından gelmez. Disk sayfalarıyla uyumlu çalışmaları, dengelerini korumaları ve yüksek dallanma katsayıları sayesinde milyonlarca kaydı birkaç disk erişimine indirgemeleri onları veritabanı indekslerinin vazgeçilmez kahramanı yapar.

``

Arayüz: Davranışın sözleşmesi

Arayüz, onu uygulayan türlerin sunması gereken üyeleri tanımlar. Genellikle durum saklamaz ve doğrudan örneklenemez. Böylece kod, belirli bir sınıfa değil davranışa bağımlı olur. Bu yaklaşım bağımlılıkların tersine çevrilmesini ve birim testlerini kolaylaştırır.

public interface IBildirimGonderici
{
    void Gonder(string alici, string mesaj);
}

public class EpostaGonderici : IBildirimGonderici
{
    public void Gonder(string alici, string mesaj)
    {
        Console.WriteLine($"E-posta gönderildi: {alici} - {mesaj}");
    }
}

Burada IBildirimGonderici, gönderimin nasıl yapılacağını açıklamaz; yalnızca Gonder davranışını zorunlu kılar. Daha sonra SMS veya mobil bildirim sınıfları aynı arayüzü uygulayabilir. Çağıran kodun hangi somut sınıfı kullandığını bilmesine gerek kalmaz.

Modern C# sürümlerinde arayüzler varsayılan metot gövdeleri ve statik üyeler içerebilse de temel amaçları hâlâ ortak davranış sınırı oluşturmaktır. Arayüzü, “Bu etiketi taşıyorsan şu yetenekleri sunmalısın” diyen bir kulüp üyeliği gibi düşünebiliriz.

Struct: Küçük ama ciddi bir değer tipi

struct, sınıflardan farklı olarak bir değer tipidir. Bir yapı değişkene atandığında çoğunlukla referansı değil, içindeki değerler kopyalanır.

public readonly struct Nokta
{
    public double X { get; }
    public double Y { get; }

    public Nokta(double x, double y)
    {
        X = x;
        Y = y;
    }

    public double Uzaklik() => Math.Sqrt(X * X + Y * Y);
}

Bu yapı iki boyutlu bir noktayı temsil eder. Öklid uzaklığı şu formülle hesaplanır:

readonly struct, oluşturulduktan sonra değerin değişmeyeceğini belirtir. Bu özellik hem niyeti açıklar hem de derleyicinin bazı gereksiz savunma kopyalarını azaltmasına yardımcı olabilir.

Temel farklar

\vert Özellik \vert Interface \vert Struct \vert \vert —\vert —\vert —\vert \vert Ana amacı \vert Davranış sözleşmesi tanımlamak \vert Küçük bir değeri temsil etmek \vert \vert Örneklenebilir mi? \vert Hayır \vert Evet \vert \vert Semantik \vert Uygulayan türe bağlı \vert Değer semantiği \vert \vert Kalıtım \vert Bir tür birden fazla arayüz uygulayabilir \vert Başka sınıf veya struct kalıtamaz \vert \vert Durum \vert Normal örnek alanı taşımaz \vert Alan ve özellik taşıyabilir \vert \vert null değeri \vert Referans üzerinden mümkün \vert Yalnızca Nullable<T> ile \vert

Birlikte kullanılabilirler mi?

Elbette! Bir yapı da arayüz uygulayabilir:

public interface IAlanHesaplayici
{
    double AlanHesapla();
}

public readonly struct Dikdortgen : IAlanHesaplayici
{
    public double En { get; }
    public double Boy { get; }

    public Dikdortgen(double en, double boy) => (En, Boy) = (en, boy);

    public double AlanHesapla() => En * Boy;
}

Ancak yapı, arayüz türündeki bir değişkene atanırsa boxing oluşabilir. Boxing sırasında değer, yönetilen yığında bir nesne içine sarılır. Yaklaşık maliyeti yalnızca veri boyutu $S$ değil, nesne başlığı $H$ ile birlikte kabaca $S + H$ olarak düşünülebilir. Sık çalışan döngülerde bu tahsisler çöp toplayıcı üzerinde baskı yaratır. Generic kısıtlar, bazı senaryolarda boxing maliyetini önleyebilir.

Sınırlar ve seçim rehberi

Struct; küçük, mantıksal olarak tek bir değer olan ve tercihen değişmez veri modellerinde uygundur. Koordinat, renk, tarih aralığı veya ölçü birimi iyi adaylardır. Büyük struct’lar her atamada kopyalanabileceği için performansı tersine çevirebilir. Kimliği olan, uzun yaşayan veya sık değişen nesnelerde sınıf tercih edilmelidir.

Arayüz ise farklı türlerin ortak bir yeteneği paylaşması, bağımlılıkların soyutlanması veya test doubles kullanılması gerektiğinde güçlüdür. Kısacası arayüz “ne yapabilir?”, struct ise “hangi değeri temsil eder?” sorusuna cevap verir. Bu ayrımı korumak, hem temiz mimarinin hem de bilinçli bellek kullanımının anahtarıdır.

``

Değişkenin bellekteki yaşamı

Bir değişken tanımlanırken genel olarak veri_tipi isim = değer; kalıbı kullanılır. Örneğin int yas = 25; ifadesi, yas adında bir bellek alanı oluşturur ve buraya 25 değerini yazar.

#include <stdio.h>

int main(void) {
    int yas = 25;
    float sicaklik = 22.5f;
    char seviye = 'A';

    printf("Yaş: %d\n", yas);
    printf("Sıcaklık: %.1f\n", sicaklik);
    printf("Seviye: %c\n", seviye);
    return 0;
}

Burada int tam sayıları, float ondalıklı sayıları, char ise tek bir karakteri saklar. Karakterler bellekte aslında sayısal kodlar hâlinde tutulur. Örneğin ASCII sisteminde 'A' karakterinin karşılığı 65’tir.

Temel veri tipleri

C standardı bazı tiplerin kesin boyutunu değil, asgari kapasitesini ve birbirleriyle ilişkisini tanımlar. Bu nedenle aşağıdaki boyutlar yaygın sistemlerde görülen değerlerdir; kesin sonuç için sizeof kullanılmalıdır.

Bir tip $n$ bitlik işaretsiz bir tamsayı saklıyorsa değer aralığı genellikle $0$ ile $2^n-1$ arasındadır. İki’nin tümleyeni kullanılan işaretli sistemlerde yaklaşık aralık $-2^{n-1}$ ile $2^{n-1}-1$ olur. Örneğin 8 bitlik işaretsiz değer $0$–$255$ aralığını kapsar.

#include <stdio.h>

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

sizeof, türün veya değişkenin kaç bayt kapladığını döndürür. Sonuç size_t tipinde olduğu için %zu biçim belirteci kullanılır.

Niteleyiciler neyi değiştirir?

short, long, signed ve unsigned, tamsayı tiplerinin kapasitesini veya işaret davranışını düzenler. const ve volatile ise erişim kurallarını belirtir.

volatile, özellikle mikrodenetleyici yazmaçlarında veya sinyal işleyicilerinde önemlidir. Derleyicinin değeri bir kez okuyup önbellekte tutmasını engeller; ancak değişkeni eşzamanlı erişime karşı güvenli yapmaz.

Sabit oluşturma yöntemleri

#include <stdint.h>

#define BUFFER_SIZE 256

enum { MAX_RETRY = 3 };

int main(void) {
    const double pi = 3.1415926535;
    uint32_t paket_no = 42U;
    double alan = pi * 5.0 * 5.0;
    return alan > 0.0 && paket_no < BUFFER_SIZE ? 0 : 1;
}

const, türü belli salt okunur bir nesne oluşturur. #define metinsel ön işlemci değişimidir ve tip denetimi sağlamaz. enum ise tamsayı sabitleri için kullanışlıdır. stdint.h içindeki uint32_t gibi tipler, mevcut olduklarında kesin bit genişliği sağlayarak taşınabilir veri formatlarında belirsizliği azaltır.

Sonuç olarak doğru veri tipi seçimi yalnızca bellek tasarrufu değildir; sayı taşmalarını, hassasiyet kaybını ve platformlar arası sürprizleri önleyen temel bir tasarım kararıdır. C, belleği gizlemek yerine size anahtarları verir; fakat hangi kapıyı açtığınıza dikkat etmek tamamen sizin sorumluluğunuzdadır.

``

Dizi Nedir?

Dizi, aynı veri türüne sahip sabit sayıda elemanın bellekte art arda tutulduğu veri yapısıdır. Beş öğrencinin notlarını saklamak için beş değişken tanımlamak yerine şöyle bir dizi oluşturabiliriz:

int notlar[5] = {78, 85, 92, 64, 90};

Burada notlar dizinin adı, int eleman türü ve 5 kapasitesidir. C dizilerinde indeksler sıfırdan başladığı için ilk eleman notlar[0], son eleman ise notlar[4] olur.

Bellekte Yerleşim Mantığı

Bir dizinin en önemli özelliği, elemanlarının ardışık adreslerde bulunmasıdır. Dizinin başlangıç adresi $B$, her elemanın boyutu $s$ bayt ise $i$ indeksli elemanın adresi şu formülle hesaplanır:

Örneğin int türünün 4 bayt olduğu bir sistemde başlangıç adresi 1000 olan dizinin A[3] elemanı şu adrestedir:

Bu doğrudan hesaplama sayesinde herhangi bir elemana erişim sabit zamanda gerçekleşir: $O(1)$. Bilgisayarın önceki elemanları tek tek gezmesi gerekmez.

#include <stdio.h>

int main(void) {
    int sayilar[4] = {10, 20, 30, 40};

    for (int i = 0; i < 4; i++) {
        printf("sayilar[%d] = %d, adres = %p\n",
               i, sayilar[i], (void *)&sayilar[i]);
    }

    return 0;
}

Bu program her elemanın değerini ve adresini gösterir. Çıktıdaki adres farklarının genellikle sizeof(int) kadar olduğunu görebilirsiniz. Böylece ardışık yerleşim yalnızca teori olmaktan çıkar, terminalde görünür hâle gelir.

Dizi Adı ve Pointer İlişkisi

Çoğu ifadede dizi adı, ilk elemanın adresine dönüşür. Bu nedenle sayilar ile &sayilar[0] aynı başlangıç konumunu gösterir. İndeksleme de pointer aritmetiğiyle yakından ilişkilidir:

int degerler[] = {5, 10, 15};
printf("%d\n", degerler[1]);
printf("%d\n", *(degerler + 1));

İki satır da 10 yazdırır. Ancak dizi ve pointer tamamen aynı kavram değildir. Dizi için ayrılmış alan sabittir; dizi adına yeni bir adres atanamaz. Pointer ise farklı adresleri gösterebilen ayrı bir değişkendir.

Dizileri Döngülerle Yönetmek

Dizilerin asıl gücü döngülerle ortaya çıkar. Aşağıdaki kod, notların toplamını ve ortalamasını hesaplar:

#include <stdio.h>

int main(void) {
    int notlar[] = {78, 85, 92, 64, 90};
    int adet = sizeof(notlar) / sizeof(notlar[0]);
    int toplam = 0;

    for (int i = 0; i < adet; i++) {
        toplam += notlar[i];
    }

    double ortalama = (double) toplam / adet;
    printf("Ortalama: %.2f\n", ortalama);
    return 0;
}

sizeof(notlar) / sizeof(notlar[0]) ifadesi toplam dizi boyutunu tek elemanın boyutuna bölerek eleman sayısını bulur. Bu yöntem yalnızca gerçek dizi aynı kapsamdayken güvenilirdir; fonksiyona aktarılan dizi parametresi pointer gibi davranır.

Sınırların Dışına Çıkma Tehlikesi

C, indeksleri otomatik olarak denetlemez. Beş elemanlı bir dizide notlar[5] kullanmak tanımsız davranıştır. Program çökebilir, yanlış sonuç üretebilir veya çalışıyor gibi görünebilir. En sinsi ihtimal de sonuncusudur!

Bu nedenle döngü koşullarında i < adet tercih edilmeli, i <= adet hatasından kaçınılmalıdır. Diziler hızlı ve verimlidir; fakat güvenlik kemerini programcı takar.

``

Fonksiyon çözümlemesinin iki perdesi

Niteliksiz bir f(x) çağrısında adaylar temel olarak iki kaynaktan gelir:

1. Normal niteliksiz isim araması: Çağrının bulunduğu kapsam, üst kapsamlar ve ilgili using bildirimleri incelenir.
2. Argument-Dependent Lookup (ADL): Argüman türleriyle ilişkili namespace ve sınıflardaki fonksiyonlar aranır.

Bunu kavramsal olarak şöyle gösterebiliriz:

Ardından overload resolution, uygulanabilir adaylar arasından dönüşümler bakımından en iyi olanı seçer. Yani ADL doğrudan kazananı belirlemez; yarışa yeni fonksiyonlar ekler.

ADL’nin sahneye çıkışı

Aşağıdaki fonksiyon çağrı noktasında açıkça içeri alınmamıştır:

#include <iostream>

namespace grafik {
    struct Nokta {
        int x;
        int y;
    };

    void yazdir(const Nokta& n) {
        std::cout << n.x << ", " << n.y << '\n';
    }
}

int main() {
    grafik::Nokta n{3, 7};
    yazdir(n); // ADL, grafik::yazdir fonksiyonunu bulur.
}

Nokta, grafik namespace’ine ait olduğu için bu namespace çağrıyla ilişkilendirilir. Argüman int olsaydı kullanıcı tanımlı ilişkili bir namespace bulunmayacağından aynı numara işe yaramazdı.

Çağrıyı ::yazdir(n) biçiminde nitelendirmek ise yalnızca global kapsamdaki ismi istemek anlamına gelir ve ADL katkısını ortadan kaldırır. Bu ayrım, hata ayıklarken oldukça değerlidir.

Gizli arkadaşlar: Kontrollü görünürlük

ADL’nin en güçlü kullanım alanlarından biri sınıf içinde tanımlanan friend fonksiyonlardır:

#include <compare>

namespace matematik {
    class Kesir {
        int pay;
        int payda;

    public:
        Kesir(int p, int q) : pay(p), payda(q) {}

        friend bool operator==(const Kesir& a, const Kesir& b) {
            return a.pay * b.payda == b.pay * a.payda;
        }
    };
}

Bu operatör normal namespace aramasında kolayca görünmez; fakat Kesir argümanlarıyla yapılan a == b ifadesinde ADL tarafından bulunur. Böylece namespace yüzeyi gereksiz fonksiyonlarla kirletilmeden türe ait işlem sunulur. Buna hidden friend idiomu denir.

swap kalıbı neden önemlidir?

Genel kodda yalnızca std::swap(a, b) yazmak, kullanıcı türünün kendi optimize edilmiş swap fonksiyonunu engelleyebilir. Geleneksel çözüm şöyledir:

using std::swap;
swap(a, b);

İlk satır standart sürümü yedek aday yapar. İkinci satır niteliksiz çağrı olduğu için ADL’ye izin verir. Türün namespace’inde daha uygun bir swap varsa overload resolution onu seçer; yoksa std::swap kullanılır.

Sürprizlerden korunma rehberi

Aynı isimli fonksiyonları geniş namespace’lere gelişigüzel yerleştirmek beklenmeyen belirsizlikler oluşturabilir. Özellikle bir çağrının argüman türü değiştiğinde ilişkili namespace kümesi de değişebilir. Şablonlarda bu etki daha belirgindir; bağımlı çağrıların bazı adayları ancak şablon örneklendiğinde belirlenir.

Kütüphane tasarlarken işlemleri ilgili türle aynı namespace’e koymak, global kapsamı kirletmemek ve özelleştirilebilir işlemlerde niteliksiz çağrı kullanmak iyi bir dengedir. Bir çağrının gizemli davrandığı durumlarda ise şu soruyu sorun: “Bu fonksiyon normal aramayla mı geldi, yoksa argümanlardan biri ADL için gizli bir kapı mı açtı?”

C++ programında dosya açmak, bellek ayırmak veya kilit edinmek kolaydır; asıl macera, işler ters gittiğinde bunları güvenle bırakabilmektir. Bir istisna normal kontrol akışını aniden kesebilir. RAII (Resource Acquisition Is Initialization), kaynakların ömrünü nesnelerin ömrüne bağlayarak bu sorunu dil seviyesindeki otomatik ömür yönetimine teslim eder.

``

RAII tam olarak ne söyler?

RAII prensibinde kaynak, bir nesnenin kurucusunda edinilir ve yıkıcısında serbest bırakılır. Nesne kapsamdan normal biçimde çıksa da bir istisna nedeniyle ayrılsa da yıkıcı otomatik olarak çağrılır. Böylece delete, close veya unlock çağrılarını her çıkış yoluna elle yerleştirmek gerekmez.

Bir fonksiyonda $n$ farklı erken çıkış ve hata yolu bulunduğunu düşünelim. Elle yönetimde denetlenmesi gereken temizlik senaryoları kabaca $O(n)$ büyür; birden fazla bağımsız kaynak etkileşime girdiğinde olası durumlar $2^k$ seviyesine yaklaşabilir. RAII ise her kaynağın sorumluluğunu kendi nesnesine dağıtır: kapsam çözülürken nesneler edinilme sırasının tersine yok edilir.

Yığın çözme ve istisna güvenliği

Bir istisna fırlatıldığında C++, uygun catch bloğunu ararken aradaki kapsamları terk eder. Bu sürece stack unwinding, yani yığın çözme denir. Her terk edilen kapsamın otomatik nesneleri yok edilir. RAII’nin merkezi rolü tam burada ortaya çıkar: yıkıcı, hem başarı hem başarısızlık yolunun ortak temizlik kapısıdır.

#include <fstream>
#include <stdexcept>
#include <string>

void kaydet(const std::string& veri) {
    std::ofstream dosya("sonuc.txt");
    if (!dosya) {
        throw std::runtime_error("Dosya açılamadı");
    }

    dosya << veri;
    if (!dosya) {
        throw std::runtime_error("Yazma başarısız");
    }
} // ofstream yıkıcısı dosyayı kapatır

İkinci hata oluşursa fonksiyon sonundaki açıklama satırına normal akışla ulaşılamaz. Buna rağmen dosya nesnesinin yıkıcısı çalışır ve işletim sistemi tanıtıcısı serbest bırakılır. RAII, unutkan programcıya karşı oldukça sabırlı bir güvenlik görevlisidir.

İstisna güvenliği garantileri

C++ kodunda genellikle üç güvence seviyesi konuşulur:

RAII tek başına güçlü garantiyi sihirli biçimde sağlamaz; fakat onun temelini oluşturur. Örneğin önce geçici bir sonuç hazırlanıp yalnızca başarıdan sonra mevcut değerle değiştirilebilir:

void guncelle(std::vector<int>& hedef,
              const std::vector<int>& yeniVeri) {
    std::vector<int> gecici = yeniVeri; // Kopyalama hata verebilir
    hedef.swap(gecici);                 // Başarılıysa değiştir
} // Eski veri gecici ile birlikte temizlenir

Kopyalama başarısız olursa hedef değişmez. Başarılı olursa eski içerik gecici nesnesinin yıkımıyla temizlenir. Bu, güçlü garantinin “ya tamamen uygula ya hiç uygulama” mantığıdır.

Modern C++ araçları

Ham new ve delete yerine std::unique_ptr tek sahipliği, std::shared_ptr paylaşımlı sahipliği temsil eder. std::lock_guard ve std::scoped_lock kilitleri kapsam sonunda bırakır. Dosya akışları da aynı prensibi uygular.

Yıkıcıların mümkün olduğunca istisna fırlatmaması gerekir. Yığın çözülürken çalışan bir yıkıcı ikinci bir istisna üretirse program std::terminate ile sonlanabilir. Bu nedenle pratik formül şudur: kaynağı kurucuda edin, sahipliği açıkça modelle, yıkıcıda güvenle bırak ve ham kaynağı mümkün olduğunca kısa süre çıplak tut. RAII yalnızca temizlik tekniği değil, C++’ta güvenilir tasarımın omurgasıdır.

Kısa Bir Tarih Yolculuğu

C’nin hikâyesi 1970’lerin başında Bell Laboratuvarları’nda başladı. Dennis Ritchie, Ken Thompson’ın geliştirdiği B dilinden esinlenerek daha güçlü ve taşınabilir bir dil tasarladı. Temel amaç, Unix işletim sistemini donanıma bağımlı Assembly kodları yerine daha üst seviyeli bir dille geliştirmekti.

Bu tercih büyük bir dönüşüm yarattı: Unix farklı bilgisayarlara daha kolay taşınırken C de sistem programlamanın ortak dili hâline geldi. Brian Kernighan ve Dennis Ritchie’nin 1978’de yayımladığı kitap, dilin ilk yaygın başvuru kaynağı oldu. Ardından ANSI C ya da C89 standardı geldi; C99, C11, C17 ve C23 sürümleri ise dili modern ihtiyaçlara göre geliştirdi.

Bir C Programının Anatomisi

C programları fonksiyonlardan oluşur ve yürütme genellikle main fonksiyonundan başlar. Kütüphaneler başlık dosyalarıyla programa tanıtılır. Değişkenler veriyi, ifadeler hesaplamayı, kontrol yapıları ise programın kararlarını temsil eder.

#include <stdio.h>

int kare(int sayi) {
    return sayi * sayi;
}

int main(void) {
    int deger = 6;
    int sonuc = kare(deger);

    printf("%d sayısının karesi: %d\n", deger, sonuc);
    return 0;
}

Burada #include <stdio.h> standart giriş-çıkış araçlarını bildirir. kare fonksiyonu aldığı tam sayıyı kendisiyle çarpar. Matematiksel olarak işlem

şeklinde gösterilebilir. main, değişkenleri oluşturur, fonksiyonu çağırır ve sonucu printf ile ekrana yazar. return 0 ifadesi de programın başarıyla tamamlandığını işletim sistemine bildirir.

C’de tür bilgisi önemlidir. Örneğin int tam sayıları, char karakterleri, float ve double ondalıklı değerleri saklar. Bir dizinin bellekte kapladığı yaklaşık alan şu ilişkiyle düşünülebilir:

Bu nedenle C, programcıya hem güç hem de sorumluluk verir; yanlış sınır kullanımı bellek hatalarına yol açabilir.

Kaynak Kod Nasıl Çalışan Programa Dönüşür?

C çoğunlukla derlenen bir dildir. Yazdığımız kaynak kod işlemci tarafından doğrudan anlaşılmaz. Dönüşüm zinciri genel olarak şöyledir:

GCC ile örnek program şöyle derlenebilir:

gcc -Wall -Wextra -std=c17 program.c -o program
./program

-Wall ve -Wextra, olası sorunlar hakkında uyarılar üretir; -std=c17 kullanılacak standardı seçer. Uyarıları görmezden gelmemek, C dünyasında emniyet kemeri takmaya benzer: Program yine ilerleyebilir ama ilk sert virajda farkı anlarsınız.

C’nin kalıcı etkisi; küçük çalışma zamanı, donanıma yakınlık, taşınabilirlik ve öngörülebilir performanstan gelir. Değişkenler, fonksiyonlar, koşullar ve döngüler temeli oluştururken derleme modelini anlamak hataları çözmeyi kolaylaştırır. Kısacası C, bilgisayara yalnızca ne yapacağını değil, bunu kaynakları nasıl kullanarak yapacağını da anlatmayı öğretir.

Bir metnin içinde en az iki kez geçen en uzun parça hangisidir? İlk bakışta bütün alt dizgileri üretip karşılaştırmak makul görünebilir. Ancak metin büyüdüğünde bu yöntem, samanlıkta iğne ararken önce bütün samanları tek tek numaralandırmaya dönüşür. Son ek dizisi ve LCP dizisi ise tekrarları düzenli, hızlı ve şaşırtıcı derecede zarif biçimde ortaya çıkarır. ``

Problem tam olarak nedir?

Bir $S$ metni verildiğinde, metin içinde farklı başlangıç konumlarında en az iki kez bulunan en uzun alt dizgiyi ararız. Örneğin banana metninde cevap ana olur:

• İlk geçiş: b[ana]na
• İkinci geçiş: ban[ana]

Geçişlerin çakışmasına izin verilebilir. Örneğin aaaa içinde aaa, 0 ve 1 indislerinden başlayarak iki kez görünür.

Naif yaklaşım tüm alt dizgileri karşılaştırır. Uzunluğu $n$ olan bir metinde yaklaşık $n(n+1)/2$ alt dizgi bulunduğundan maliyet hızla büyür.

Son ek dizisi neden işe yarar?

Bir son ek, metnin herhangi bir konumundan başlayıp sona kadar giden parçadır. banana için son ekler şöyledir:

Bunlar alfabetik sıralandığında başlangıç indisleri [5, 3, 1, 0, 4, 2] olur. Bu indis listesine son ek dizisi denir.

Kritik fikir şudur: Ortak başlangıca sahip son ekler alfabetik sıralamada yan yana gelir. Dolayısıyla bütün son ek çiftlerini karşılaştırmak yerine yalnızca komşuları incelemek yeterlidir.

Komşu son eklerin ortak önek uzunluklarını tutan yapıya LCP (Longest Common Prefix) dizisi denir. Aradığımız sonuç:

banana için en büyük LCP değeri 3’tür; ilgili parça anadır.

Python ile çözüm

Aşağıdaki uygulama, son ek dizisini önek katlama yöntemiyle kurar. Her turda karşılaştırılan önek uzunluğu iki katına çıkar. Ardından Kasai algoritması LCP dizisini doğrusal zamanda hesaplar.

def suffix_array(text):
    n = len(text)
    sa = list(range(n))
    rank = [ord(ch) for ch in text]
    k = 1

    while k < n:
        sa.sort(key=lambda i: (
            rank[i],
            rank[i + k] if i + k < n else -1
        ))

        new_rank = [0] * n
        for j in range(1, n):
            previous, current = sa[j - 1], sa[j]
            prev_key = (rank[previous],
                        rank[previous + k] if previous + k < n else -1)
            curr_key = (rank[current],
                        rank[current + k] if current + k < n else -1)
            new_rank[current] = new_rank[previous] + (prev_key != curr_key)

        rank = new_rank
        if rank[sa[-1]] == n - 1:
            break
        k *= 2

    return sa


def longest_repeated_substring(text):
    if not text:
        return ""

    sa = suffix_array(text)
    rank = [0] * len(text)
    for position, suffix_start in enumerate(sa):
        rank[suffix_start] = position

    best_length = best_start = common = 0

    for i in range(len(text)):
        position = rank[i]
        if position == 0:
            continue

        j = sa[position - 1]
        while (i + common < len(text) and
               j + common < len(text) and
               text[i + common] == text[j + common]):
            common += 1

        if common > best_length:
            best_length, best_start = common, i

        common = max(0, common - 1)

    return text[best_start:best_start + best_length]


print(longest_repeated_substring("banana"))  # ana

Kasai algoritmasındaki common değerinin her adımda tamamen sıfırlanmaması önemlidir. Bir sonraki son eke geçildiğinde ortak önek uzunluğu en fazla bir azalır; böylece tekrar tekrar aynı karakterleri okumaktan kaçınılır.

Karmaşıklık ve kullanım alanları

Bu Python uygulamasında sıralama nedeniyle son ek dizisinin kurulması yaklaşık $O(n \log^2 n)$, LCP hesabı ise $O(n)$ sürer. Özel sıralama teknikleriyle toplam süre $O(n \log n)$, gelişmiş yöntemlerle $O(n)$ seviyesine indirilebilir.

Aynı yaklaşım DNA dizilerindeki tekrarları, belgelerdeki kopya bölümleri, sıkıştırılabilir kalıpları ve kod içindeki benzer parçaları bulmak için kullanılabilir. Kısacası son ek dizisi, metni yalnızca sıralamaz; görünmeyen tekrarların yan yana gelmesini sağlayarak problemi kolay bir maksimum aramasına dönüştürür.

Önce “yol” kavramını netleştirelim

Bir graf $G=(V,E)$, düğümlerden oluşan $V$ kümesi ile bu düğümleri bağlayan $E$ kenar kümesidir. Ağırlıklı bir grafta her kenarın $w(u,v)$ maliyeti bulunur. Bir $P$ yolunun toplam ağırlığı şöyle hesaplanır:

Buradaki kritik ayrıntı, aradığımız yapının basit yol olmasıdır; yani hiçbir düğüm birden fazla ziyaret edilemez. Tekrara izin verilseydi pozitif ağırlıklı bir döngünün çevresinde sonsuza kadar dolaşarak yol uzunluğunu sınırsız büyütebilirdik. Dolayısıyla anlamlı optimizasyon problemi, tekrar içermeyen en uzun yolu arar.

En kısa yol kolayken en uzun yol neden zor?

En kısa yol algoritmaları optimal alt yapıdan yararlanır. Bir düğüme ulaşmanın en iyi maliyeti bulunduğunda, özellikle negatif ağırlık yoksa bu karar güvenle kullanılabilir. En uzun basit yolda ise erken seçilen bir kenar, ileride ihtiyaç duyulan önemli bir düğümü tüketebilir. Yerel olarak uzun görünen seçim, küresel olarak kısa bir çıkmaza dönüşebilir.

Örneğin en ağır komşuya gitmeyi seçen açgözlü algoritma, birkaç adım sonra kapanan bir kola sapabilir. Daha hafif başlayan başka bir kol ise grafın neredeyse tamamını dolaşabilir. Algoritmanın bütün olası düğüm sıralamalarını hesaba katması gerekebilir; bu olasılık sayısı üstel biçimde büyür.

Hamilton Yolu bağlantısı

Zorluğu göstermenin klasik yolu, Hamilton Yolu Problemi ile ilişki kurmaktır. Hamilton yolu, graftaki her düğümü tam bir kez ziyaret eden basit bir yoldur ve bu karar problemi NP-tamdır.

Ağırlıksız bir grafta her kenara $1$ ağırlığını verelim. $\vert V\vert =n$ düğüm varsa Hamilton yolu tam olarak $n-1$ kenar içerir. Şu soruyu sorabiliriz:

Bu soruya cevap verebilen bir en uzun yol algoritması, Hamilton yolu olup olmadığını da belirler. Dönüşüm polinom zamanda yapıldığı için en uzun yol problemi NP-zordur. Ayrıca verilen bir yolun basit olduğunu ve hedef uzunluğa ulaştığını hızlıca doğrulayabildiğimizden karar sürümü NP-tamdır.

Her graf türünde umutsuz muyuz?

Hayır! Graf bir DAG, yani yönlendirilmiş döngüsüz graf ise topolojik sıralama sayesinde problem $O(\vert V\vert +\vert E\vert )$ zamanda çözülebilir. Döngü bulunmadığından geçmiş bir düğüme dönme ihtimali yoktur.

def longest_path_dag(vertices, edges, order, source):
    dist = {v: float("-inf") for v in vertices}
    dist[source] = 0

    for u in order:
        if dist[u] == float("-inf"):
            continue
        for v, weight in edges[u]:
            dist[v] = max(dist[v], dist[u] + weight)

    return dist

Kod, düğümleri topolojik sırayla işler. dist[v], kaynaktan v düğümüne bulunan en uzun mesafeyi saklar; her kenar yalnızca bir kez gevşetilir. Bu, en kısa yol gevşetmesine benzer, fakat min yerine max kullanılır.

Genel graflarda ise kesin çözüm için geri izleme, bitmask dinamik programlama veya dal-sınır yöntemleri kullanılabilir. Büyük örneklerde yaklaşım algoritmaları ve sezgiseller tercih edilir. Kısacası tek kelimelik “en” değişikliği, kolay bir rota probleminden kombinatoryal bir labirente geçmemize yeter!

Rüzgâr neden bir bozucudur?

Bir İHA’nın hareketi basitleştirilmiş biçimde Newton’un ikinci yasasıyla açıklanabilir:

Burada $\vec{F}_{rüzgar}$ kontrolcünün doğrudan yönetemediği dış kuvvettir. Rüzgârın sürükleme kuvveti yaklaşık olarak

ile modellenir. $\rho$ hava yoğunluğu, $C_d$ sürükleme katsayısı, $A$ rüzgâra maruz kalan alan ve $v_r$ bağıl hava hızıdır. Hızın karesi özellikle önemlidir: Rüzgâr iki katına çıktığında sürükleme yaklaşık dört katına çıkabilir. Küçük drone’un neden sert rüzgârda alışveriş poşeti gibi savrulduğu böylece anlaşılır.

Kontrol döngüleri nasıl çalışır?

Modern uçuş kontrolcüleri genellikle iç içe geçmiş kontrol döngüleri kullanır. En içte açısal hız, onun dışında tutum, daha dışta hız ve konum kontrolü bulunur. İç döngüler yüzlerce veya binlerce hertz hızında çalışırken GPS tabanlı konum döngüsü daha yavaştır.

Rüzgâr drone’u sağa sürüklediğinde konum kontrolcüsü sola doğru hız talep eder. Hız kontrolcüsü bu talebi bir eğim açısına dönüştürür; tutum kontrolcüsü de motorların devirlerini değiştirir. Sonuçta drone, rüzgâra doğru hafifçe yatıp konumunu korur.

PID kontrolünün rolü

Yaygın PID kontrol yasası şöyledir:

$K_p$ mevcut hataya tepki verir, $K_i$ sürekli rüzgârın oluşturduğu kalıcı kaymayı giderir, $K_d$ ise hızlı değişimleri sönümler. Fazla yüksek kazançlar titreşime, düşük kazançlar ise ağır ve yetersiz tepkiye yol açar.

Aşağıdaki örnek, yatay hız hatasından pitch komutu üreten sade bir PID döngüsüdür:

class PID:
    def __init__(self, kp, ki, kd):
        self.kp, self.ki, self.kd = kp, ki, kd
        self.integral = 0.0
        self.previous_error = 0.0

    def update(self, target, measured, dt):
        error = target - measured
        self.integral += error * dt
        derivative = (error - self.previous_error) / dt
        self.previous_error = error
        return self.kp * error + self.ki * self.integral + self.kd * derivative

pid = PID(0.8, 0.15, 0.05)
pitch_command = pid.update(target=0.0, measured=1.2, dt=0.01)

Burada hedef hız sıfırdır; ölçülen pozitif hız rüzgâr kaynaklı sürüklenmeyi temsil eder. Üretilen pitch komutu, drone’un ters yönde kuvvet oluşturmasını sağlar. Gerçek sistemlerde integral taşmasını önleyen sınırlar, çıkış doyumu ve türev filtresi de eklenmelidir.

Dayanıklılığı artıran unsurlar

Başarılı rüzgâr dayanıklılığı yalnızca kontrol algoritmasına bağlı değildir. Düşük gürültülü IMU, doğru sensör füzyonu, rijit gövde, yeterli motor rezervi ve dengeli pervaneler birlikte çalışmalıdır. Kalman filtresi; jiroskop, ivmeölçer, barometre ve GPS verilerini birleştirerek daha güvenilir durum tahmini üretir.

Kontrolcü ayrıca motorların maksimum itki sınırını bilmelidir. Rüzgârı yenmek için gereken kuvvet fiziksel kapasiteyi aşarsa dünyanın en akıllı algoritması bile mucize yaratamaz. Bu nedenle dayanıklı bir İHA; iyi modellenmiş, doğru ayarlanmış, simülasyonda sınanmış ve kontrollü saha testleriyle doğrulanmış sistemdir. Kısacası rüzgârla kavga etmek yerine onu ölçer, tahmin eder ve motorlara doğru karşı hamleyi yaptırır.