<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Osman Balcıoglu on Medium]]></title>
        <description><![CDATA[Stories by Osman Balcıoglu on Medium]]></description>
        <link>https://medium.com/@osmanbalcioglu?source=rss-3e96a6e798ed------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*aglkg1FZkFL7oV3F</url>
            <title>Stories by Osman Balcıoglu on Medium</title>
            <link>https://medium.com/@osmanbalcioglu?source=rss-3e96a6e798ed------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 12:15:39 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@osmanbalcioglu/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[C Dilinde Metin Dosyaları: Veriyi Kalıcı Hale Getirmek]]></title>
            <link>https://medium.com/@osmanbalcioglu/c-dilinde-metin-dosyalar%C4%B1-veriyi-kal%C4%B1c%C4%B1-hale-getirmek-9a0d36e5def2?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a0d36e5def2</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[c-language]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 05:52:46 GMT</pubDate>
            <atom:updated>2026-11-18T05:52:46.017Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dwYfjUkrsK58nKy9iTGgFA.png" /></figure><p>Bir program çalışırken değişkenlerde tuttuğu bilgiler genellikle programın belleğinde bulunur. Program sonlandığında bu çalışma belleğindeki değerler de kaybolur. Bir öğrencinin notlarını, bir kullanıcının tercihlerini ya da programın ürettiği raporu daha sonra yeniden kullanmak istiyorsak bilgileri bir dosyaya kaydetmemiz gerekir.</p><p>Metin dosyaları, bu verileri insanlar tarafından okunabilir biçimde saklamanın yaygın yollarından biridir. C’de dosyalarla çalışmak için &lt;stdio.h&gt; başlığındaki akış ve dosya işlevleri kullanılır.</p><p><strong>1. Metin dosyalarına neden ihtiyaç duyarız?</strong></p><p>Dosyalar, programın çalışması sona erdikten sonra da korunması gereken veriler için kullanılır. Program bir dosyadan önceki sonuçları okuyabilir, yeni sonuçları dosyaya ekleyebilir veya dosyada tutulan bilgileri güncelleyebilir.</p><p>Örneğin öğrenci kayıtları metin dosyasında şöyle saklanabilir:</p><p>1024 Ada 88.5</p><p>1025 Ece 91.0</p><p>1026 Can 76.5</p><p><strong>2. Dosya ve akış kavramları</strong></p><p>C, dosyalarla doğrudan diskin fiziksel ayrıntılarına göre değil, akışlar üzerinden çalışır. FILE türü, &lt;stdio.h&gt; içinde tanımlıdır. Bir dosya açıldığında C, o dosyayla ilişkilendirilmiş bir akış sunar ve program bu akışa FILE * pointer’ı üzerinden erişir:</p><p>FILE *dosya;</p><p>FILE nesnesinin iç yapısına programcı doğrudan erişmez. Dosyayı açma, okuma, yazma ve kapatma işlemlerini standart kütüphane işlevleri yürütür.</p><p>C dili metin akışlarıyla ikili akışları ayırır. Metin akışı karakterleri satırlar halinde işler; farklı sistemlerde satır sonu gösterimi gibi ayrıntılar okunurken veya yazılırken dönüştürülebilir. Bu nedenle dosyadaki dış gösterim ile programın okuduğu karakterler arasında her zaman bire bir eşleşme olması gerekmez. İkili akışta ise veriler, aynı sistemde yazıldığında ve okunduğunda aynı karakter dizisi olarak korunur.</p><p>Metin dosyası açarken genellikle “r”, “w” ve “a” gibi kipler kullanılır. “b” eklenirse ikili dosya kipi belirtilir; örneğin “rb” veya “wb”.</p><p><strong>3. Dosya açma ve kapatma</strong></p><p>fopen, dosya adını ve açma kipini alır. Başarılı olursa dosyayı gösteren bir FILE *, açamazsa NULL döndürür:</p><p>FILE *dosya = fopen(“notlar.txt”, “r”);</p><p>if (dosya == NULL) {</p><p>fprintf(stderr, “Dosya acilamadi.\n”);</p><p>return 1;</p><p>}</p><p>Yaygın dosya açma kipleri şöyledir:</p><p><strong>Kip</strong></p><p><strong>İşlevi</strong></p><p>“r”</p><p>Var olan metin dosyasını okumak için açar. Dosya yoksa açma başarısız olur.</p><p>“w”</p><p>Yazmak için açar; yoksa oluşturur, varsa içeriğini silerek yeniden başlatır.</p><p>“a”</p><p>Dosyanın sonuna ekleme yapmak için açar; yoksa oluşturur.</p><p>“r+”</p><p>Var olan dosyayı hem okumak hem yazmak için açar.</p><p>“w+”</p><p>Hem okumak hem yazmak için açar; varsa içeriğini siler, yoksa oluşturur.</p><p>“a+”</p><p>Hem okumak hem yazmak için açar; yazma işlemleri dosyanın sonuna yapılır.</p><p>İş bittikten sonra dosya fclose ile kapatılır:</p><p>if (fclose(dosya) == EOF) {</p><p>fprintf(stderr, “Dosya kapatilirken hata olustu.\n”);</p><p>}</p><p>fclose, bekleyen yazma verilerini dosyaya aktarmaya çalışır ve akışı kapatır. Bu nedenle yazma işlemi sırasında oluşan bazı hatalar ancak kapatma sırasında fark edilebilir. fclose başarısız olursa EOF döndürür.</p><p><strong>4. Dosyadan veri okuma</strong></p><p>Dosyadan karakter okumak için fgetc kullanılabilir. Sonraki karakteri veya dosya sonu ve hata durumlarını gösterebildiği için dönüş değeri int türünde tutulmalıdır:</p><p>int karakter;</p><p>while ((karakter = fgetc(dosya)) != EOF) {</p><p>putchar(karakter);</p><p>}</p><p>if (ferror(dosya)) {</p><p>fprintf(stderr, “Dosya okunurken hata olustu.\n”);</p><p>}</p><p>fgetc, dosya sonuna ulaşıldığında veya okuma hatası oluştuğunda EOF döndürür.</p><p>Bir satırı okumak için fgets kullanılabilir:</p><p>char satir[128];</p><p>while (fgets(satir, sizeof satir, dosya) != NULL) {</p><p>fputs(satir, stdout);</p><p>}</p><p>if (ferror(dosya)) {</p><p>fprintf(stderr, “Satir okunurken hata olustu.\n”);</p><p>}</p><p>fgets, en fazla ayrılan alanın bir eksiği kadar karakter okur, satır sonu karakteri alana sığarsa onu da saklar ve sonuna ‘\0’ ekler. Satır tampona sığmayacak kadar uzunsa kalan kısmı sonraki okumada ele almak gerekir.</p><p>fscanf, biçimlendirilmiş verileri dosyadan okumak için kullanılır. scanf işlevine benzer; ek olarak hangi dosyadan okunacağını belirten FILE * parametresi alır:</p><p>int numara;</p><p>char ad[40];</p><p>double ortalama;</p><p>if (fscanf(dosya, “%d %39s %lf”, &amp;numara, ad, &amp;ortalama) == 3) {</p><p>printf(“%d %s %.1f\n”, numara, ad, ortalama);</p><p>}</p><p>Dönüş değeri başarıyla atanan alanların sayısını verir. %39s sınırı, ad dizisinde sonlandırıcı karakter için yer bırakır. Bu örnek adların tek sözcük olduğu basit bir dosya biçimi içindir; boşluk içeren alanlarda veya daha karmaşık metin biçimlerinde satırı fgets ile okuyup ayrıca ayrıştırmak daha uygundur.</p><p><strong>5. Dosyaya veri yazma</strong></p><p>fputc tek karakter, fputs bir dizgi, fprintf ise biçimlendirilmiş veri yazar:</p><p>fputc(‘A’, dosya);</p><p>fputs(“C programlama\n”, dosya);</p><p>fprintf(dosya, “%d %s %.1f\n”, numara, ad, ortalama);</p><p>fputs dizginin sonundaki ‘\0’ karakterini dosyaya yazmaz ve kendiliğinden satır sonu eklemez. Satır sonu gerekiyorsa dizgiye \n eklenmelidir.</p><p><strong>6. Dosyada rastgele erişim</strong></p><p>Sıralı erişimde program dosyayı baştan başlayarak okur. Rastgele erişimde ise dosya konumu değiştirilerek istenen bölüme gidilir. C’de bu iş için fseek, ftell, rewind, fgetpos ve fsetpos kullanılır.</p><p>fseek, dosya konumunu değiştirir. İkili akışlarda konum, dosyanın başlangıcına, mevcut konuma veya sonuna göre belirlenebilir:</p><p>if (fseek(dosya, 0L, SEEK_SET) != 0) {</p><p>fprintf(stderr, “Dosya konumuna gidilemedi.\n”);</p><p>}</p><p>Metin akışlarında keyfî bir bayt uzaklığına atlamak taşınabilir bir yöntem değildir. Metin dosyasında fseek için ya 0 kullanılmalı ya da aynı dosyadan daha önce alınmış ftell konumu, SEEK_SET ile yeniden kullanılmalıdır. Ayrıca metin akışındaki ftell değeri her zaman okunmuş baytların sayısı anlamına gelmez; daha çok önceki konuma geri dönebilmek için kullanılan bir konum bilgisidir.</p><p>long konum = ftell(dosya);</p><p>if (konum != -1L) {</p><p>/* Dosyada başka işlemler yapılabilir. */</p><p>if (fseek(dosya, konum, SEEK_SET) != 0) {</p><p>fprintf(stderr, “Kaydedilen konuma donulemedi.\n”);</p><p>}</p><p>}</p><p>rewind(dosya), dosya konumunu başa alır ve dosyanın sonu ile hata göstergelerini temizler. Daha genel konumları saklamak için fgetpos ile fpos_t değeri alınıp fsetpos ile geri yüklenebilir.</p><p><strong>7. Standart girdi, çıktı ve hata akışları</strong></p><p>C programı başladığında üç standart akış hazır bulunur:</p><ul><li>stdin: standart girdi; çoğunlukla klavyeden veya yönlendirilmiş girdiden okur.</li><li>stdout: standart çıktı; çoğunlukla ekrana veya yönlendirilmiş çıktıya yazar.</li><li>stderr: tanı ve hata mesajları için kullanılır.</li></ul><p>Bu akışlar da FILE * türündedir. printf, fprintf(stdout, …) ile; scanf, fscanf(stdin, …) ile aynı kaynağa yönelir. getchar() standart girdiden karakter okur, putchar() standart çıktıya karakter yazar.</p><p>Hata mesajlarını stderr üzerinden yazmak, programın normal çıktısıyla tanı mesajlarını ayrı tutar:</p><p>fprintf(stderr, “Dosya okunamadi.\n”);</p><p>Standart akışlar işletim sisteminde yönlendirilebilir. Böylece programın girdisi klavye yerine bir dosyadan alınabilir veya çıktısı ekrana yazılmak yerine başka bir dosyaya gönderilebilir.</p><p><strong>8. Hataları kontrol etmek</strong></p><p>Dosya işlemlerinde her adımın sonucu kontrol edilmelidir:</p><ul><li>fopen başarısız olursa NULL döndürür.</li><li>fscanf için dönüş değeri beklenen alan sayısıyla karşılaştırılmalıdır.</li><li>fgets NULL döndürürse dosya sonu veya okuma hatası olabilir; ferror ile hata kontrol edilir.</li><li>fgetc EOF döndürdüğünde ferror ve feof ile neden ayırt edilir.</li><li>fprintf, fputs ve fputc yazma sonuçları denetlenmelidir.</li><li>fclose sonucu da kontrol edilmelidir.</li></ul><p><strong>Kaynakça</strong></p><ul><li>Deitel, Paul ve Harvey Deitel. <em>C ile Programlama</em>. 7. baskıdan çeviri. Palme Yayınları.</li><li>Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice Hall, 1988.</li><li>Kochan, Stephen G. <em>Programming in C</em>. 4. baskı. Pearson, 2015.</li><li>WG14. <em>N1570: Programming Languages — C</em>, C11 komite taslağı, 2011. <a href="https://open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf">Belge</a>.</li><li>WG14. <em>N3220: ISO/IEC 9899:2024, Programming Languages — C</em>. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3220.pdf">Belge</a>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a0d36e5def2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C Dilinde Yapılar ve Birleşimler: İlişkili Verileri Bir Arada Tutmak]]></title>
            <link>https://medium.com/@osmanbalcioglu/c-dilinde-yap%C4%B1lar-ve-birle%C5%9Fimler-i%CC%87li%C5%9Fkili-verileri-bir-arada-tutmak-d37d562590be?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/d37d562590be</guid>
            <category><![CDATA[c-programming]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[tech]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Tue, 17 Nov 2026 13:31:04 GMT</pubDate>
            <atom:updated>2026-11-17T13:31:04.381Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sd9O1A3wlZTB1FJLqzdNZQ.png" /></figure><p><strong>C Dilinde Yapılar ve Birleşimler: İlişkili Verileri Bir Arada Tutmak</strong></p><p>Bir öğrenci kaydında numara, ad ve not ortalaması gibi farklı türden bilgiler bulunur. Bu bilgileri ayrı değişkenlerde tutabiliriz; ancak öğrenci sayısı arttıkça hangi değişkenlerin aynı kişiye ait olduğunu izlemek zorlaşır. C’de struct kullanarak bu alanları tek bir veri türü altında toplayabiliriz. union ise farklı türdeki değerler için aynı bellek alanını ortak kullandırır.</p><p>Bu iki yapı, C’de veriyi düzenlemenin temel araçlarındandır. Aralarındaki farkı anlamak için önce değişken, veri türü ve veri yapısı kavramlarını ayırmak gerekir.</p><p><strong>1. Değişken, veri türü ve veri yapısı</strong></p><p>Bir değişken, programın çalışması sırasında değer tutan adlandırılmış bir nesnedir:</p><p>int yas = 20;</p><p>Burada yas değişkenin adı, int türü, 20 ise başlangıç değeridir. Veri türü, bir değerin nasıl yorumlanacağını ve o değer üzerinde hangi işlemlerin yapılabileceğini belirler. C’de int, double ve char gibi temel türlerin yanı sıra diziler, pointer’lar, yapılar ve birleşimler de vardır.</p><p>Veri yapısı, bilgileri belirli bir düzene göre bir arada tutma biçimidir. Örneğin bir öğrenciye ait numara, ad ve ortalama farklı türlerde olsa da aynı kaydın parçalarıdır. struct, bu alanları tek bir nesne altında gruplar. Daha geniş anlamda bağlı listeler, ağaçlar ve tablolar da veri yapılarıdır; C bunları hazır türler olarak sunmaz, programcı struct, pointer ve dizileri kullanarak kurar.</p><p><strong>2. C’nin programlama yaklaşımı</strong></p><p>C, prosedürel ve imperatif bir dil olarak sınıflandırılır. Programın işleyişi, veriler ve bu veriler üzerinde işlem yapan fonksiyonlar etrafında kurulur.</p><p>Java ve C# genellikle sınıf temelli nesne yönelimli diller olarak öğretilir. C++ ise nesne yönelimli özelliklerin yanı sıra prosedürel programlama özelliklerini de destekleyen bir dildir.</p><p>C’nin struct ve union türleri ilişkili verileri düzenlemeye yardımcı olur ancak tek başlarına sınıf, kalıtım, erişim belirleyicileri veya nesne yönelimli dillerdeki üye fonksiyonlarını sağlamazlar. Bu özellikler C’ye sonradan yerleşik OOP özellikleri kazandırmak değil, dilin sunduğu araçlarla benzer düzenleri kurmaktır.</p><p><strong>3. Yapı (struct) tanımlamak ve kullanmak</strong></p><p>struct, farklı türlerdeki üyeleri tek bir bileşik tür altında toplar:</p><p>struct Ogrenci {</p><p>int numara;</p><p>char ad[40];</p><p>double ortalama;</p><p>};</p><p>Bu bildirim struct Ogrenci türünün üyelerini tanımlar. Tek başına bir öğrenci değişkeni oluşturmaz. Bu türden bir nesne tanımlamak için:</p><p>struct Ogrenci ogrenci1;</p><p>Artık ogrenci1, numara, ad ve ortalama alanlarına sahip tek bir değişkendir.</p><p>Yapı tanımlanırken ilk değerler de verilebilir:</p><p>struct Ogrenci ogrenci1 = {1024, “Ada”, 88.5};</p><p>Değerler, yapı üyelerinin tanımlanma sırasına göre yerleştirilir.</p><p>struct Ogrenci ogrenci2 = {</p><p>.ad = “Ece”,</p><p>.numara = 1025,</p><p>.ortalama = 91.0</p><p>};</p><p>struct Ogrenci yeni = {0}; biçimi de yapının üyelerini sıfır değerleriyle başlatır.</p><p>Bir yapı elemanına . işleciyle erişilir:</p><p>ogrenci1.ortalama = 92.0;</p><p>printf(“%s: %.1f\n”, ogrenci1.ad, ogrenci1.ortalama);</p><p>Yapı üyeleri bellekte tanımlanma sırasını izler; ancak derleyici hizalama gereksinimleri nedeniyle aralara veya sona boşluk baytları ekleyebilir. Bu nedenle sizeof(struct Ogrenci) sonucunun üyelerin boyutları toplamına eşit olacağı varsayılmamalıdır.</p><p><strong>İç içe yapılar</strong></p><p>Bir yapının üyesi başka bir yapı türünde olabilir. Örneğin doğum tarihini ayrı bir tür olarak tanımlayabiliriz:</p><p>struct Tarih {</p><p>int gun;</p><p>int ay;</p><p>int yil;</p><p>};</p><p>struct Ogrenci {</p><p>int numara;</p><p>char ad[40];</p><p>double ortalama;</p><p>struct Tarih dogum;</p><p>};</p><p>İç içe yapı üyelerine birden fazla . işleciyle ulaşılır:</p><p>ogrenci1.dogum.gun = 12;</p><p>ogrenci1.dogum.ay = 4;</p><p>ogrenci1.dogum.yil = 2003;</p><p>İlk değerler iç içe yazılabilir:</p><p>struct Ogrenci ogrenci2 = {</p><p>.numara = 1025,</p><p>.ad = “Ece”,</p><p>.ortalama = 91.0,</p><p>.dogum = {.gun = 8, .ay = 6, .yil = 2002}</p><p>};</p><p><strong>4. Yapılar ve fonksiyonlar</strong></p><p>C’de yapı türündeki değerler fonksiyonlara gönderilebilir ve fonksiyonlardan döndürülebilir. Yapı fonksiyona değer olarak gönderildiğinde parametre, yapının bir kopyasını alır. Bu nedenle fonksiyon içinde parametrede yapılan değişiklik, çağıranın elindeki yapıyı kendiliğinden değiştirmez.</p><p>Büyük bir yapıyı kopyalamak yerine pointer göndermek veya çağırandaki yapıyı değiştirmek için pointer kullanılır:</p><p>void ogrenci_yazdir(const struct Ogrenci *ogrenci) {</p><p>printf(“%d %s %.1f\n”,</p><p>ogrenci-&gt;numara,</p><p>ogrenci-&gt;ad,</p><p>ogrenci-&gt;ortalama);</p><p>}</p><p>Pointer üzerinden üyeye erişirken -&gt; kullanılır. Örneğin ogrenci-&gt;ortalama, (*ogrenci).ortalama ile aynı üyeyi belirtir. const burada fonksiyonun gösterilen yapıyı değiştirmeyeceğini bildirir.</p><p><strong>5. Yapı dizileri, typedef ve pointer’lar</strong></p><p>Birden fazla öğrenci kaydını tutmak için yapı dizisi kullanılabilir:</p><p>struct Ogrenci sinif[] = {</p><p>{1024, “Ada”, 88.5},</p><p>{1025, “Ece”, 91.0},</p><p>{1026, “Can”, 76.5}</p><p>};</p><p>Dizi boyutu başlangıç listesinden çıkarılabilir. Eleman sayısı şu şekilde bulunur:</p><p>size_t adet = sizeof sinif / sizeof sinif[0];</p><p>Her elemana önce dizi indisiyle, sonra yapı üyesiyle erişilir:</p><p>printf(“%s\n”, sinif[1].ad);</p><p>typedef, bir türe başka bir ad vermeyi sağlar. Yeni ve farklı bir tür oluşturmaz:</p><p>typedef struct Ogrenci Ogrenci;</p><p>Ogrenci ogrenci3 = {1027, “Deniz”, 84.0};</p><p>Böylece her bildirimde struct yazmak gerekmez.</p><p>Bir yapı pointer’ı, yapının bellekteki adresini tutar:</p><p>struct Ogrenci *p = &amp;ogrenci1;</p><p>p-&gt;ortalama = 95.0;</p><p>Bu gösterim, özellikle bir yapı nesnesini fonksiyona kopyalamadan aktarmada ve dinamik veri yapıları kurmada kullanılır. Örneğin bağlı listedeki bir düğüm, aynı türden başka bir düğümü gösteren pointer üyesi taşıyabilir:</p><p>struct Dugum {</p><p>int deger;</p><p>struct Dugum *sonraki;</p><p>};</p><p>sonraki, düğümün kendisini içermez; başka bir struct Dugum nesnesinin adresini tutar.</p><p><strong>6. Birleşim (union)</strong></p><p>union, farklı türlerdeki üyelerin aynı bellek alanını paylaşmasını sağlar:</p><p>union Deger {</p><p>int tamsayi;</p><p>double ondalik;</p><p>char *metin;</p><p>};</p><p>Üyelerin başlangıç adresi ortaktır ve union boyutu en büyük üyeyi saklayabilecek kadar olur; hizalama nedeniyle ek boşluk da bulunabilir. Yapıda üyelerin değerleri aynı anda saklanabilirken birleşimde üyeler bağımsız bellek alanları kullanmaz.</p><p>Birleşim ilk değer ataması alabilir:</p><p>union Deger deger = {.ondalik = 3.14};</p><p>Daha sonra başka bir üyeye değer yazılabilir:</p><p>deger.tamsayi = 42;</p><p>Bu işlem, aynı alanın içeriğini yeni türe uygun biçimde değiştirir. Birleşimin amacı, tüm alternatif değerleri aynı anda tutmak değil, aynı nesnenin farklı zamanlarda farklı türde değerler saklayabilmesidir.</p><p>Birleşimler, bir kaydın olası değer biçimlerinden yalnızca birini tuttuğu durumlarda alan kullanımını azaltabilir.</p><h3>7. Yapı ile birleşimi birlikte kullanmak</h3><p>Yapıdaki bir karakter alanı, birleşimin hangi üyesinin kullanıldığını belirtebilir. Bu örnekte &#39;T&#39; tamsayıyı, &#39;O&#39; ise ondalıklı sayıyı gösteriyor:</p><pre>struct Deger {</pre><pre>char tur;  /* &#39;T&#39;: tamsayı, &#39;O&#39;: ondalıklı sayı */</pre><pre>union {</pre><pre>long tamsayi;</pre><pre>double ondalik;</pre><pre>} veri;</pre><pre>};</pre><pre>struct Deger sonuc = {</pre><pre>.tur = &#39;T&#39;,</pre><pre>.veri.tamsayi = 42</pre><pre>};</pre><p>Birleşimde hangi değerin bulunduğunu tur alanına bakarak anlayabiliriz:</p><pre>if (sonuc.tur == &#39;T&#39;) {</pre><pre>printf(&quot;%ld\n&quot;, sonuc.veri.tamsayi);</pre><pre>} else if (sonuc.tur == &#39;O&#39;) {</pre><pre>printf(&quot;%f\n&quot;, sonuc.veri.ondalik);</pre><pre>}</pre><p>Burada program, tur alanıyla birleşimin hangi üyesinin geçerli olduğunu takip eder.</p><p>Yapı, ilişkili alanları tek bir türde bir araya getirir; birleşim ise alternatif alanların belleği paylaşmasını sağlar. Bu iki türü ve pointer’ları birlikte kullanarak C’de kayıtlar, bağlı listeler ve başka veri düzenleri kurulabilir.</p><p><strong>Kaynakça</strong></p><ul><li>Çağıltay, Nergiz Ercil, Fügen C. Selbes, Gül Tokdemir ve Çiğdem Turhan. <em>C Dersi: Programlamaya Giriş</em>. 6. baskı. Ankara, 2014.</li><li>Kelley, Al ve Ira Pohl. <em>A Book on C: Programming in C</em>. 4. baskı. Addison-Wesley, 1998.</li><li>Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice Hall, 1988.</li><li>WG14. <em>N1570: Programming Languages — C</em>, C11 komite taslağı, 2011. <a href="https://open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf">Belge</a>.</li><li>WG14. <em>N3220: ISO/IEC 9899:2024, Programming Languages — C</em>. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3220.pdf">Belge</a>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d37d562590be" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C Dilinde Dizgiler (Strings): Karakter Dizileriyle Metin İşlemek]]></title>
            <link>https://medium.com/@osmanbalcioglu/c-dilinde-dizgiler-strings-karakter-dizileriyle-metin-i%CC%87%C5%9Flemek-bb32480abd2d?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/bb32480abd2d</guid>
            <category><![CDATA[c-programming]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[tech]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 13:32:26 GMT</pubDate>
            <atom:updated>2026-11-16T13:32:26.087Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*61NX1DXA_PCXwLepvIRqCQ.png" /></figure><p>Bir program öğrencinin adını, bir dosya yolunu ya da kullanıcının yazdığı bir cümleyi saklayıp ekrana yazdırmak isteyebilir. Sayılar için int ve double gibi türlerimiz vardır. C’de metinler içinse ayrı bir string türü bulunmaz. Metinleri, karakter dizileri ve bu dizilerin sonunu belirten özel bir karakter aracılığıyla işleriz.</p><p>Bu gösterim, dizgileri esnek ve verimli kılar ancak programcının bellek kapasitesini ve sonlandırma karakterini doğru yönetmesini gerektirir. Bir char dizisi tanımlamak tek başına onu geçerli bir dizgi yapmaz.</p><p><strong>1. Dizgi nedir, ne değildir?</strong></p><p>C’de dizgi, ilk ‘\0’ sonlandırıcı karakteriyle biten karakterler dizisidir. Sonlandırıcı karakter dizginin parçasıdır ancak dizginin uzunluğu hesaplanırken sayılmaz. D izgi uzunluğu, sonlandırıcı karakterden önceki baytların sayısıdır.</p><p>char dil[] = “C”;</p><p>Bu tanım bellekte iki elemanlı bir dizi oluşturur:</p><p>‘C’ ‘\0’</p><p>‘\0’, değeri sıfır olan karakter sabitidir. ‘0’ ile aynı şey değildir: ‘0’ ekranda görünen sıfır rakamıdır. NULL ise bir null pointer sabitini ifade eder; ‘\0’ ile birbirinin yerine kullanılamaz.</p><p>Karakter sabitiyle dizgi sabiti de farklıdır:</p><p>char harf = ‘A’; /* Tek karakter */</p><p>char metin[] = “A”; /* ‘A’ ve ‘\0’ karakterlerinden oluşan dizgi */</p><p>Bir karakter dizisi, sonlandırıcı karakter içermiyorsa C dizgisi değildir:</p><p>char veriler[] = {‘C’, ‘d’, ‘i’, ‘l’, ‘i’};</p><p>Bu dizide ‘\0’ bulunmadığı için printf(“%s”, veriler) veya strlen(veriler) gibi dizgi işlemlerinde kullanılması güvenli değildir. Bu işlevler, bellekte sonlandırıcı karakter bulana kadar okumaya devam edebilir.</p><p>Dizgi sabitleri çift tırnakla yazılır:</p><p>“C dili”</p><p>C, bu sabit için sonlandırıcı karakteri de içeren bir karakter dizisi oluşturur. Dizgi sabitini değiştirmeye çalışmak tanımsız davranışa yol açar. Bu nedenle sabit bir dizgiye işaret eden pointer’ı const char * olarak tanımlamak doğru yaklaşımdır.</p><p>const char *mesaj = “Merhaba”;</p><p><strong>2. Dizgi nasıl tanımlanır?</strong></p><p>Dizgiler genellikle karakter dizileriyle tanımlanır:</p><p>char sehir[] = “Ankara”;</p><p>char kullanici[32];</p><p>İlk satırda C, karakterleri ve ‘\0’ sonlandırıcısını tutacak alanı kendi belirler. İkinci satırda ise 32 karakterlik yer ayrılır. Dizginin en fazla 31 karakteri ve sonlandırıcı karakteri bu alana sığabilir.</p><p>Dizginin uzunluğu ile dizinin kapasitesi aynı kavram değildir:</p><p><strong>İfade</strong></p><p><strong>Anlamı</strong></p><p>strlen(sehir)</p><p>‘\0’ öncesindeki karakterlerin uzunluğu</p><p>sizeof sehir</p><p>sehir hâlâ dizi olduğu kapsamda dizinin toplam boyutu</p><p>sizeof kullanici</p><p>kullanici dizisinin bayt cinsinden kapasitesi</p><p>Örneğin:</p><p>char sehir[] = “Ankara”;</p><p>Burada strlen(sehir) 6, sizeof sehir ise 7’dir. Yedinci eleman ‘\0’ sonlandırıcısı için ayrılmıştır.</p><p>Başlangıç değerleri süslü parantezle de verilebilir:</p><p>char kod[] = {‘C’, ‘\0’};</p><p>Başlangıç listesi bir dizinin tüm elemanlarını doldurmuyorsa kalan elemanlar sıfırla başlatılır:</p><p>char kod[5] = {‘C’};</p><p>Bu tanımda ilk eleman ‘C’, diğer elemanlar sıfır değerini alır. Ancak başlangıç değeri verilmeyen yerel bir karakter dizisinin elemanları kendiliğinden sıfırlanmaz:</p><p>char metin[20]; /* Henüz geçerli bir dizgi değil */</p><p>Bu diziyi %s ile yazdırmadan veya strlen ile ölçmeden önce geçerli bir dizgi olacak şekilde başlatmak gerekir.</p><p>sizeof konusunda bir ayrıntı daha vardır. Dizi adı çoğu ifadede ilk elemana işaret eden pointer’a dönüşür. Fonksiyon parametresi olarak kullanılan char metin[] de pointer parametresi gibi davranır. Bu yüzden fonksiyonun içinde sizeof metin, çağıranın gönderdiği dizinin kapasitesini vermez.</p><p><strong>3. Dizgi girdi ve çıktı işlemleri</strong></p><p>Dizgiyi ekrana yazdırmak için printf içinde %s dönüşüm belirteci kullanılabilir:</p><p>printf(“%s\n”, sehir);</p><p>%s, sonlandırıcı ‘\0’ karakterine kadar okur. Bu nedenle yazdırılan dizinin geçerli biçimde sonlandırılmış olması gerekir. puts dizgiyi yazdırdıktan sonra satır sonu ekler; fputs ise kendiliğinden satır sonu eklemez.</p><p>Kullanıcıdan tek bir sözcük almak için scanf kullanılabilir. Ancak %s boşlukta durur ve genişlik sınırı verilmezse ayrılan belleğin dışına yazabilir:</p><p>char ad[32];</p><p>if (scanf(“%31s”, ad) == 1) {</p><p>printf(“Merhaba, %s\n”, ad);</p><p>}</p><p>Buradaki 31 genişlik sınırı, ‘\0’ için 32. elemanı boş bırakır. Bu yöntem boşluk içeren bir satırı değil, yalnızca bir sözcüğü okur.</p><p>Bir satırın tamamını okumak için fgets daha uygundur:</p><p>#include &lt;stdio.h&gt;</p><p>#include &lt;string.h&gt;</p><p>char satir[128];</p><p>if (fgets(satir, sizeof satir, stdin) != NULL) {</p><p>satir[strcspn(satir, “\n”)] = ‘\0’;</p><p>}</p><p>fgets, alana en fazla kapasitenin bir eksiği kadar karakter okur; satır sonu karakterini alana sığdığı durumda saklar ve sonuna ‘\0’ ekler. Örnekte strcspn, satır sonu varsa yerini bulur; o konuma ‘\0’ yazılarak satır sonu kaldırılır.</p><p>Girdi, ayrılan alandan uzunsa satırın tamamı okunmamış olabilir; kalan bölüm bir sonraki okuma işleminde gelebilir. Programın bu durumu ele alması gerekir.</p><p><strong>4. Dizgi işlemleri</strong></p><p>C dilinde dizgi işlevlerinin çoğu &lt;string.h&gt; başlığında tanımlanır. Bu işlevler kendilerine verilen adresin geçerli bir dizgiyi gösterdiğini varsayar; ayrılan belleğin yeterli olup olmadığını genel olarak denetlemez.</p><p><strong>İşlev</strong></p><p><strong>Kullanımı</strong></p><p>strlen(s)</p><p>s dizgisinin ‘\0’ öncesindeki uzunluğunu verir.</p><p>strcpy(hedef, kaynak)</p><p>Kaynağı, ‘\0’ dahil olacak şekilde hedefe kopyalar.</p><p>strncpy(hedef, kaynak, n)</p><p>Kaynaktan en fazla n karakter kopyalar.</p><p>strcat(hedef, kaynak)</p><p>Kaynağı hedef dizginin sonuna ekler.</p><p>strcmp(s1, s2)</p><p>İki dizgiyi karşılaştırır.</p><p>strncmp(s1, s2, n)</p><p>İlk n karakteri karşılaştırır.</p><p>strchr(s, c)</p><p>s içinde c karakterinin ilk geçtiği yeri arar.</p><p>strstr(s, alt)</p><p>s içinde alt alt dizgisini arar.</p><p>strtok(s, ayraçlar)</p><p>Dizgiyi ayraçlara göre parçalara ayırır.</p><p><strong>Kopyalama ve birleştirme</strong></p><p>C’de diziler = ile birbirine atanamaz:</p><p>char kaynak[] = “Programlama”;</p><p>char hedef[32];</p><p>/* hedef = kaynak; geçersiz */</p><p>Karakterleri kopyalamak için strcpy kullanılabilir; hedef alan kaynak ve sonlandırıcı için yeterli büyüklükte olmalıdır:</p><p>char kaynak[] = “Programlama”;</p><p>char hedef[sizeof kaynak];</p><p>strcpy(hedef, kaynak);</p><p>strcpy, kaynak dizginin sonundaki ‘\0’ karakterini de kopyalar. Hedef alan yeterli değilse bellek sınırı aşılabilir.</p><p>strcat de hedef dizinin baştan geçerli bir dizgi olmasını ve yeni içerikle sonlandırıcıya yetecek kadar kapasite bulunmasını gerektirir:</p><p>char aciklama[32] = “C”;</p><p>strcat(aciklama, “ dili”);</p><p>Hedefte yeterli yer yoksa strcat güvenli hale gelmez; belleğin dışına yazabilir.</p><p><strong>Karşılaştırma ve arama</strong></p><p>Dizgilerin içeriğini karşılaştırmak için == değil, strcmp kullanılır:</p><p>if (strcmp(kullanici, “admin”) == 0) {</p><p>puts(“Kullanıcı bulundu.”);</p><p>}</p><p>==, dizgilerin içeriğini karşılaştırmaz; pointer değerlerini karşılaştırır. strcmp ise sıfır, negatif veya pozitif bir sonuç verir. Sonucun kesin olarak -1 ya da 1 olması beklenmemelidir; sıfır eşitliği, negatif değer ilk dizginin sıralamada önce geldiğini, pozitif değer ise sonra geldiğini belirtir.</p><p>strchr, bir karakteri; strstr ise bir alt dizgiyi arar. Bulduklarında eşleşmenin başladığı konumu gösteren bir pointer, bulamadıklarında NULL döndürür.</p><p><strong>5. Dizgiler, fonksiyonlar ve pointer’lar</strong></p><p>Bir dizgi fonksiyona gönderildiğinde genellikle karakterlerin tamamı kopyalanmaz; ilk elemana işaret eden adres aktarılır. Bu nedenle dizi parametresi gösterimi pointer parametresine denk gelir:</p><p>void yazdir(const char metin[]);</p><p>Bu bildirim şu biçimle eşdeğerdir:</p><p>void yazdir(const char *metin);</p><p>Fonksiyon dizginin uzunluğunu veya ayrılan belleğin kapasitesini pointer’dan kendiliğinden öğrenemez. Yazma ya da ekleme işlemi yapan bir fonksiyona kapasite de ayrı bir parametre olarak verilmelidir.</p><p>Bir pointer’ın kullanılabilmesi için geçerli bir belleği göstermesi gerekir:</p><p>char *ad;</p><p>strcpy(ad, “Ada”); /* ad geçerli bir alanı göstermiyor */</p><p>Bu örnekte ad için bellek ayrılmamıştır. Pointer’a adres vermeden üzerinden yazmak hatalıdır. Sabit kapasiteli bir dizi kullanılabilir:</p><p>char ad[16];</p><p>strcpy(ad, “Ada”);</p><p>Dizi ile pointer ilişkisi bir dizginin karakterleri üzerinde ilerlerken de görülür:</p><p>char metin[] = “C dili”;</p><p>const char *p = metin;</p><p>while (*p != ‘\0’) {</p><p>putchar(*p);</p><p>++p;</p><p>}</p><p>p, her adımda bir sonraki karakteri gösterir ve döngü ‘\0’ karakterine ulaşınca biter. Sonlandırıcıdan sonraki konum bir değer okunacak yer değildir.</p><p>Dizi adı bir pointer değişkeni değildir. Örneğin:</p><p>char metin[] = “Merhaba”;</p><p>const char *p = metin;</p><p>p başka bir adresi gösterebilir; dizi adı ise başka bir adrese atanamaz veya artırılamaz. Ayrıca sizeof metin dizinin tamamının boyutunu verirken sizeof p yalnızca pointer’ın boyutunu verir.</p><p><strong>Pointer dizileri</strong></p><p>Birden fazla dizgiyi pointer dizisiyle tutabiliriz:</p><p>const char *diller[] = {“C”, “Python”, “Rust”};</p><p>Burada diller dizisinin elemanları karakter değil, dizgilerin başlangıcını gösteren pointer’lardır. Örneğin diller[1], “Python” dizgisinin ilk karakterine işaret eder. Sabit dizgileri gösterdikleri için pointer’lar const char * olarak tanımlanmıştır.</p><p>Bir başka seçenek, satırları eşit kapasitede olan iki boyutlu karakter dizisidir:</p><p>char diller[3][16] = {“C”, “Python”, “Rust”};</p><p>Bu yapıda her satır 16 karakterlik alan ayırır. Pointer dizisi ile iki boyutlu karakter dizisi aynı bellek düzenine sahip değildir: ilki adresleri, ikincisi karakter alanlarını tutar.</p><p><strong>6. Karakter fonksiyonları</strong></p><p>&lt;ctype.h&gt; başlığı tek tek karakterleri sınıflandırmak ve harf dönüşümü yapmak için işlevler sağlar:</p><p><strong>İşlev</strong></p><p><strong>Görevi</strong></p><p>isalpha(c)</p><p>Harf olup olmadığını denetler.</p><p>isdigit(c)</p><p>Rakam olup olmadığını denetler.</p><p>isalnum(c)</p><p>Harf veya rakam olup olmadığını denetler.</p><p>isspace(c)</p><p>Boşluk, sekme veya satır sonu gibi boşluk karakterlerini denetler.</p><p>islower(c) / isupper(c)</p><p>Küçük veya büyük harf olup olmadığını denetler.</p><p>tolower(c) / toupper(c)</p><p>Harfi küçük veya büyük harfe dönüştürür.</p><p>ctype.h işlevlerine geçirilen değer EOF ya da unsigned char ile temsil edilebilir bir değer olmalıdır.</p><p><strong>7. Türkçe karakterler ve bayt uzunluğu</strong></p><p>C dizgileri char elemanlarından oluşur. UTF-8 kullanılan bir ortamda bazı Türkçe harfler birden fazla baytla temsil edilir. Bu nedenle strlen, ekranda görülen harf sayısını değil, ‘\0’ öncesindeki bayt sayısını verir.</p><p>Örneğin kaynak ve çalışma karakter kodlaması UTF-8 ise “çay” ekranda üç harf görünse de strlen(“çay”) genellikle 4 verir: ç iki bayt, a ve y birer bayt kullanır. C dili her ortamda UTF-8 kullanılacağını garanti etmez.</p><p>Aynı nedenle toupper ve tolower ile UTF-8 içindeki Türkçe harfleri dönüştürmek beklenen sonucu vermeyebilir.</p><p><strong>Kaynakça</strong></p><ul><li>Çağıltay, Nergiz Ercil, Fügen C. Selbes, Gül Tokdemir ve Çiğdem Turhan. <em>C Dersi: Programlamaya Giriş</em>. 6. baskı. Ankara, 2014.</li><li>Kelley, Al ve Ira Pohl. <em>A Book on C: Programming in C</em>. 4. baskı. Addison-Wesley, 1998.</li><li>Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice Hall, 1988.</li><li>WG14. <em>N1570: Programming Languages — C</em>, C11 komite taslağı, 2011. <a href="https://open-std.org/jtc1/sc22/wg14/www/docs/n1570.pdf">Belge</a>.</li><li>WG14. <em>N3220: ISO/IEC 9899:2024, Programming Languages — C</em>. <a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3220.pdf">Belge</a>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bb32480abd2d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C Dilinde Diziler (Arrays): Aynı Türden Değerleri Tek Bir Yapıda Tutmak]]></title>
            <link>https://medium.com/@osmanbalcioglu/cde-diziler-arrays-ayn%C4%B1-t%C3%BCrden-de%C4%9Ferleri-tek-bir-yap%C4%B1da-tutmak-efcc6a56e864?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/efcc6a56e864</guid>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[c-programming]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Sun, 15 Nov 2026 11:41:23 GMT</pubDate>
            <atom:updated>2026-11-15T12:49:22.930Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*brPzu-n5ZlKIMnUH5t5kCw.png" /></figure><p>Bir sınıftaki 30 öğrencinin üçer sınav notunu hesaplamak istediğimizi düşünelim. Notları ogrenci1_not1, ogrenci1_not2 diye ayrı ayrı tanımlarsak toplam 90 değişken gerekir. Üstelik her birini okumak, toplamak ve ortalamasını bulmak için aynı işlemleri tekrar tekrar yazmamız gerekir.</p><p>C’de değişken adlarını bir döngü içinde üretemeyiz. Bunun yerine aynı türdeki değerleri tek bir dizi altında toplar, her değere bir indisle ulaşırız: notlar[i].</p><p><strong>1. Dizilere neden ihtiyaç duyarız?</strong></p><p>Dizilerden önce her değeri ayrı bir değişkende tuttuğumuzu düşünelim:</p><p>int not1;</p><p>int not2;</p><p>int not3;</p><p>int not4;</p><p>int not5;</p><p>Beş not için bu yöntem idare edebilir. Yüz not gerektiğinde değişkenleri tek tek tanımlamak, kodu uzatır ve üzerinde işlem yapmayı zorlaştırır. Bir dizide ise aynı türden değerler tek bir ad altında toplanır. Bir döngüyle sırayla okunabilir, toplanabilir veya karşılaştırılabilirler.</p><p>Diziler, özellikle aynı işlem birçok değer için tekrarlanacaksa kullanışlıdır. Sınav notları, sıcaklık ölçümleri ve anket sonuçları bu tür verilere örnektir.</p><p><strong>2. Dizi nedir ve nasıl tanımlanır?</strong></p><p>Dizi, aynı türden elemanların bellekte ardışık biçimde yer aldığı bir veri yapısıdır. Dizi tanımında elemanların türü, dizi adı ve eleman sayısı belirtilir:</p><p>int notlar[5];</p><p>Bu tanım, int türünde beş elemanlı bir dizi oluşturur. C’de dizi indisleri sıfırdan başlar; bu nedenle elemanlar notlar[0] ile notlar[4] arasındadır.</p><p>Genel biçim şöyledir:</p><p>veri_turu dizi_adi[eleman_sayisi];</p><p>Dizi elemanları aynı türde olmak zorundadır. int dizisi tamsayıları, double dizisi gerçek sayıları tutar. Dizi elemanlarının türünü değiştirmek mümkün değildir.</p><p>Dizi tanımlanırken elemanlara başlangıç değerleri de verilebilir:</p><p>int notlar[5] = {80, 75, 90, 85, 95};</p><p>Eleman sayısı başlangıç listesinden anlaşılabiliyorsa köşeli parantez içi boş bırakılabilir:</p><p>int notlar[] = {80, 75, 90};</p><p>Bu tanım üç elemanlı bir dizi oluşturur. Liste dizinin tüm elemanlarını doldurmuyorsa kalan elemanlar sıfırla başlatılır:</p><p>int notlar[5] = {80, 75};</p><p>Burada notlar[2], notlar[3] ve notlar[4] sıfır değerini alır. Başlangıç değeri verilmeyen yerel dizilerin elemanları ise kendiliğinden sıfırlanmaz; bu elemanların değeri belirsizdir.</p><p><strong>Gösterim</strong></p><p><strong>Anlamı</strong></p><p>notlar[0]</p><p>İlk elemanın değeri</p><p>&amp;notlar[0]</p><p>İlk elemanın adresi</p><p>notlar + 1</p><p>İkinci elemana işaret eden pointer</p><p>sizeof notlar</p><p>Bu kapsamda dizi nesnesinin bellekte kapladığı toplam boyut</p><p><strong>3. Dizi elemanlarına erişmek ve değer atamak</strong></p><p>Dizi elemanına ulaşmak için dizi adının ardından köşeli parantez içinde indis yazılır:</p><p>notlar[0] = 80;</p><p>notlar[1] = 75;</p><p>Aynı işlem bir döngüyle de yapılabilir:</p><p>size_t i;</p><p>for (i = 0; i &lt; 5; ++i) {</p><p>notlar[i] = 0;</p><p>}</p><p>Burada indis 0’dan başlar ve 4 değerinde sonlanır. Döngü koşulunda i &lt; 5 kullanılması önemlidir. i &lt;= 5 yazılsaydı döngü, dizide bulunmayan notlar[5] elemanına erişmeye çalışırdı.</p><p>C, dizi indislerini çalışma zamanında sınırlandırmaz. Geçerli indis aralığının dışındaki bir elemana erişmek tanımsız davranışa yol açar. Program yanlış sonuç verebilir, çökebilir veya hata ilk bakışta görünmeyebilir. Bu nedenle döngü koşulunu dizi boyutuyla uyumlu kurmak gerekir.</p><p>Karakter dizileri de aynı kurallara uyar. C’de bir metni tutan karakter dizisinin sonunda ‘\0’ sonlandırıcı karakteri bulunur. Örneğin char isim[] = “Ada”; tanımı dört eleman ayırır: A, d, a ve ‘\0’.</p><p><strong>4. Diziler ve Pointerlar(işaretçiler)</strong></p><p>Dizi adıyla pointer arasında yakın bir ilişki vardır. Çoğu ifade içinde dizi adı, dizinin ilk elemanına işaret eden bir işaretçiye dönüşür. Bu nedenle aşağıdaki iki ifade aynı elemanı verir:</p><p>notlar[1]</p><p>*(notlar + 1)</p><p>Dizi adı bir işaretçi değişkeni değildir. Örneğin notlar++ yazılamaz; dizi adının gösterdiği başlangıç adresi değiştirilemez. Buna karşılık bir işaretçi değişkeninin tuttuğu adres ilerletilebilir.</p><p>int degerler[] = {12, 24, 36};</p><p>int *p = degerler;</p><p>Bu tanımdan sonra *p, degerler[0] değerine; *(p + 1) ise degerler[1] değerine erişir. Pointer aritmetiğinde p + 1, adresi bir bayt ilerletmez; pointer türündeki bir sonraki elemana ilerletir.</p><p>Dizi içindeki bir elemana veya dizinin son elemanından sonraki konuma işaret eden işaretçi oluşturulabilir. Ancak son elemandan sonraki konumun gösterdiği bir değer yoktur; bu adres çözümlenmemelidir.</p><p><strong>5. Diziler ve fonksiyonlar</strong></p><p>C’de fonksiyonlara dizi gönderildiğinde dizinin bütün elemanları kopyalanmaz. Fonksiyon, dizinin ilk elemanına işaret eden adresi alır. Bu yüzden fonksiyon parametresinde yazılan dizi gösterimi pointer parametresine dönüşür:</p><p>void yazdir(const int degerler[], size_t adet);</p><p>Bu parametre biçimi şu gösterime denktir:</p><p>void yazdir(const int *degerler, size_t adet);</p><p>Fonksiyon dizi boyutunu kendiliğinden öğrenmez. Eleman sayısı ayrıca parametre olarak gönderilir. sizeof degerler ifadesi fonksiyonun içinde tüm dizinin boyutunu vermez; çünkü degerler burada dizi değil işaretçi parametresidir. Boyutu, sizeof kullanarak dizinin hala dizi olduğu çağıran yerde hesaplayabiliriz:</p><p>size_t adet = sizeof dizi / sizeof dizi[0];</p><p><strong>6. İki boyutlu diziler</strong></p><p>Bir satır ve sütun düzeninde tutulması gereken veriler için iki boyutlu dizi kullanabiliriz:</p><p>int notlar[3][3];</p><p>Bu tanım, üç satırdan ve her satırda üç int elemanından oluşan bir dizi oluşturur. Bir elemanın ilk indisi satırı, ikinci indisi sütunu gösterir:</p><p>notlar[1][2] = 90;</p><p>Bu ifade ikinci satırın üçüncü elemanına değer atar. Her iki indis de sıfırdan başladığı için geçerli satırlar 0–2, sütunlar da 0–2 aralığındadır.</p><p>C’de iki boyutlu diziler satırlar üzerinden ardışık biçimde bellekte tutulur. int notlar[3][3], int işaretçilerden oluşan bir yapı değildir; üç elemanlı satır dizilerinden oluşan üç elemanlı bir dizidir.</p><p>İki boyutlu dizi bir fonksiyona gönderildiğinde sütun sayısının bilinmesi gerekir. Örneğin üç sütunlu bir dizi için parametre şöyle yazılabilir:</p><p>void ortalamalari_hesapla(const int notlar[][3], size_t ogrenci_sayisi);</p><p>Derleyici her satırın nerede başlayacağını hesaplayabilmek için satırdaki eleman sayısını bilmelidir.</p><p><strong>Kaynakça</strong></p><ul><li>Çağıltay, Nergiz Ercil, Fügen C. Selbes, Gül Tokdemir ve Çiğdem Turhan. <em>C Dersi: Programlamaya Giriş</em>. 6. baskı. Ankara, 2014.</li><li>Deitel, Paul ve Harvey Deitel. <em>C ile Programlama</em>. 7. baskıdan çeviri. Palme Yayınları.</li><li>Kelley, Al ve Ira Pohl. <em>A Book on C: Programming in C</em>. 4. baskı. Addison-Wesley, 1998.</li><li>Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice Hall, 1988.</li><li>Kochan, Stephen G. <em>Programming in C</em>. 4. baskı. Pearson, 2015.</li><li>Chaudhary, Harry H. <em>C Programming: The Ultimate Way to Learn the Fundamentals of the C Language</em>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=efcc6a56e864" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C Dilinde Pointer(İşaretçiler): Bellek Adresinden Değere Ulaşmak]]></title>
            <link>https://medium.com/@osmanbalcioglu/cde-pointer-i%CC%87%C5%9Faret%C3%A7iler-bellek-adresinden-de%C4%9Fere-ula%C5%9Fmak-207d2848c3e6?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/207d2848c3e6</guid>
            <category><![CDATA[c-programming]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Sat, 14 Nov 2026 07:45:54 GMT</pubDate>
            <atom:updated>2026-11-15T12:47:40.922Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N-OdhwOx4zUINKsuz6kMdA.png" /></figure><p>C’de kullanıcıdan bir sayı alırken çoğunlukla şöyle bir satır yazarız:</p><p>scanf(“%d”, &amp;sayi);</p><p>Yeni başlayan biri &amp; işaretini bir süre kalıp olarak ezberleyebilir. İşaretçiler konusuna gelince bu işaretin neden kullanıldığı açıklık kazanır: scanf, okuyacağı değeri hangi değişkenin belleğine yazacağını bilmek için o değişkenin adresine ihtiyaç duyar.</p><p>İşaretçi (pointer), bir nesnenin bellekteki adresini tutan değişkendir. Adresi tutmak, bir değere başka bir yoldan ulaşmamızı ve o değer üzerinde bir fonksiyon içinden işlem yapmamızı sağlar. Bu yazıda önce işaretçi tanımını ve &amp; ile * operatörlerini ele alacağız; ardından işaretçi üzerinden veri okumayı, yazmayı ve işaretçiyi fonksiyon parametresi olarak kullanmayı inceleyeceğiz.</p><p><strong>1. İşaretçi nedir?</strong></p><p>Bir değişken tanımlandığında program o değişken için bellekte yer ayırır. C’de değişkenin adı, programın o nesneye erişmesini sağlar. Bu nesnenin bellekte bir adresi de vardır.</p><p>int sayi = 12;</p><p>12, sayi değişkeninde saklanan değerdir. İşaretçi ise bu değerin kendisini değil, değerin bulunduğu adresi tutar:</p><p>int *sayi_isaretcisi = &amp;sayi;</p><p>Bu tanımı şöyle okuyabiliriz: sayi_isaretcisi, int türündeki bir nesneyi gösterebilen bir işaretçidir. Başlangıç değeri olarak sayi değişkeninin adresi verilmiştir.</p><p><strong>İfade</strong></p><p><strong>Anlamı</strong></p><p>sayi</p><p>sayi değişkeninde saklanan değer</p><p>sayi_isaretcisi</p><p>sayi değişkeninin adresi</p><p>*sayi_isaretcisi</p><p>İşaretçinin gösterdiği adresteki değer</p><p>&amp;sayi_isaretcisi</p><p>İşaretçi değişkeninin kendi adresi</p><p>Burada önemli olan, sayi_isaretcisi ile &amp;sayi_isaretcisi ifadelerinin aynı şeyi göstermemesidir. İlki sayi değişkeninin adresini tutar; ikincisi ise işaretçi değişkeninin bellekteki adresidir.</p><p>İşaretçinin türü de önemlidir. int * bir int nesnesinin adresini, double * ise bir double nesnesinin adresini tutmak için kullanılır. İşaretçi, hedef nesnenin türünü derleyiciye bildirir; böylece gösterilen yerdeki veriye uygun biçimde erişilebilir.</p><p><strong>Bir bildirimdeki yıldız ne anlama gelir?</strong></p><p>int *p;</p><p>Bu bildirim, p değişkeninin bir int işaretçisi olduğunu belirtir. Bildirimdeki *, p’nin türünü açıklar. Birden fazla değişken aynı satırda tanımlandığında yıldız her işaretçi değişkeninin önünde yazılmalıdır:</p><p>int *p, *q;</p><p>Bu satırda hem p hem de q işaretçidir. Şu satırda ise yalnızca p işaretçidir:</p><p>int *p, q;</p><p><strong>2. Adres operatörü &amp; ve içerik operatörü *</strong></p><p>İşaretçilerle çalışırken &amp; ve * operatörlerini doğru ayırt etmek gerekir.</p><p><strong>Adres operatörü: &amp;</strong></p><p>Bir değişkenin adresini almak için değişken adının önüne &amp; koyarız:</p><p>int sayi = 12;</p><p>int *p = &amp;sayi;</p><p>&amp;sayi, sayi değişkeninin adresini üretir. Bu adres p işaretçisine atanır. Artık p, sayi değişkenini gösterir.</p><p><strong>İçerik operatörü: *</strong></p><p>Bir işaretçinin gösterdiği nesneye erişmek için işaretçinin önünde * kullanırız:</p><p>printf(“%d\n”, *p);</p><p>Burada *p, p’nin tuttuğu adresteki int değeridir. p’nin gösterdiği değeri değiştirmek için de aynı gösterimi kullanabiliriz:</p><p>*p = 20;</p><p>Bu satır, p hangi int değişkenini gösteriyorsa o değişkene 20 değerini yazar. Örneğimizde p, sayi değişkenini gösterdiğinden sayi artık 20 olur.</p><p>Yıldızın iki kullanımını bağlamından ayıralım:</p><p>int *p = &amp;sayi; /* Bildirim: p, int işaretçisidir. */</p><p>*p = 20; /* İfade: p’nin gösterdiği değere 20 yazılır. */</p><p><strong>3. İşaretçi üzerinden veri okumak ve yazmak</strong></p><p>İşaretçinin sakladığı adresle, gösterdiği değeri birbirine karıştırmamak gerekir. Aşağıdaki örnekte:</p><p>int sayi = 12;</p><p>int *p = &amp;sayi;</p><ul><li>p, sayi değişkeninin adresidir.</li><li>*p, o adresteki int değeridir.</li><li>*p = 25; ifadesi sayi değerini 25 yapar.</li></ul><p>Bir adresi ekrana yazdırmak için printf içinde %p kullanılır. C’de %p ile kullanılan argüman void * türünde olmalıdır; bu nedenle nesne işaretçisini (void *) ile dönüştürürüz. Burada küçük bir detayı açıklamak istiyorum. Sadece &amp;p yazarsak da adresi görüntüleyebilirdik. Modern derleyicilerde bir sorun yaşamazdık ancak yine de arka planda bir uyarı verebilirdi ayrıca eski ya da farklı mimarilerdeki bir derleyicide bu şekilde yazıyor olsaydık bir sorun ile karşılaşabilirdik. (void *)&amp;p şeklinde yazmak ise C dilinin resmi kurallarına tam uygun, hatasız, güvenli ve profesyonel yazım şeklidir.</p><p>printf(“%p\n”, (void *)p);</p><p>p’nin gösterdiği değeri yazdırmak içinse değer türüne uygun biçim belirtecini kullanırız:</p><p>printf(“%d\n”, *p);</p><p>Adresin görünümü sisteme ve programın çalıştırıldığı ortama göre değişebilir. Bu yüzden örnek çıktıda belirli bir adresi beklememek ve adresi normal bir tamsayıymış gibi %d ile yazdırmamak gerekir.</p><p><strong>scanf ile işaretçinin gösterdiği yere değer okumak</strong></p><p>scanf’e bir değişkenin adresini verdiğimizi önceki konulardan biliyoruz:</p><p>int sayi;</p><p>scanf(“%d”, &amp;sayi);</p><p>Bir işaretçi geçerli bir int değişkenini gösteriyorsa, o adresi doğrudan scanf’e verebiliriz:</p><p>int sayi = 0;</p><p>int *p = &amp;sayi;</p><p>scanf(“%d”, p);</p><p>Burada p, sayi değişkeninin adresini tutar. scanf, okuduğu tamsayıyı bu adrese yazar.</p><p><strong>4. İşaretçileri fonksiyon parametresi olarak kullanmak</strong></p><p>Fonksiyonlara normal bir int değeri gönderdiğimizde fonksiyon bu değerin bir kopyasıyla çalışır. Parametre değişse de çağıran fonksiyondaki değişken değişmez.</p><p>Bir fonksiyonun çağıran taraftaki bir değişkeni değiştirmesi gerekiyorsa o değişkenin adresini işaretçi parametresi üzerinden gönderebiliriz:</p><p>void bir_artir(int *deger)</p><p>{</p><p>if (deger == NULL) {</p><p>return;</p><p>}</p><p>(*deger)++;</p><p>}</p><p>Fonksiyon şöyle çağrılır:</p><p>int sayi = 4;</p><p>bir_artir(&amp;sayi);</p><p>Çağrı sırasında &amp;sayi, sayi değişkeninin adresini gönderir. Fonksiyon içindeki deger parametresi bu adresi tutar. (*deger)++ ise o adresteki tamsayıyı artırır. Bu nedenle çağrıdan sonra sayi değeri 5 olur.</p><p>Buradaki parantezler önemlidir. (*deger)++, işaretçinin gösterdiği tamsayıyı artırır. *deger++ ise işlem önceliği nedeniyle işaretçiyi ilerletmeye çalışır; bu başlangıç örneğinde istenen işlem değildir.</p><p>Küçük bir detay:</p><ul><li>*deger = 10; işaretçinin gösterdiği nesneyi değiştirir.</li><li>deger = NULL; yalnızca fonksiyon içindeki yerel işaretçi parametresini değiştirir; çağıranın işaretçi değişkenini değiştirmez.</li></ul><p>İşaretçi parametreleri, bir fonksiyonun çağıran taraftaki veriyi değiştirmesini veya birden fazla sonucu çağırana aktarmasını sağlayabilir.</p><p><strong>5. Örnek 1: İşaretçi üzerinden sayı okumak ve yazdırmak</strong></p><p>Bu program bir tamsayıyı scanf ile işaretçinin gösterdiği değişkene okur. Ardından değişkenin adresini, işaretçinin tuttuğu adresi ve gösterilen değeri yazdırır.</p><p>#include &lt;stdio.h&gt;</p><p>int main(void)</p><p>{</p><p>int sayi = 0;</p><p>int *sayi_isaretcisi = &amp;sayi;</p><p>printf(“Bir tamsayi girin: “);</p><p>if (scanf(“%d”, sayi_isaretcisi) != 1) {</p><p>printf(“Gecerli bir tamsayi girilmedi.\n”);</p><p>return 1;</p><p>}</p><p>printf(“Degiskenin adresi: %p\n”, (void *)&amp;sayi);</p><p>printf(“Isaretcinin tuttugu adres: %p\n”, (void *)sayi_isaretcisi);</p><p>printf(“Degiskenin degeri: %d\n”, sayi);</p><p>printf(“Isaretci uzerinden okunan deger: %d\n”, *sayi_isaretcisi);</p><p>*sayi_isaretcisi = *sayi_isaretcisi + 1;</p><p>printf(“Isaretci uzerinden bir artirilmis deger: %d\n”, sayi);</p><p>return 0;</p><p>}</p><p>&amp;sayi ile sayi_isaretcisi aynı adresi gösterir. İşaretçi üzerinden yapılan son atama sayi değişkeninin değerini de değiştirir; çünkü sayi_isaretcisi o değişkeni göstermektedir. Adreslerin ekranda görünecek biçimi her sistemde aynı olmak zorunda değildir.</p><p><strong>6. Örnek 2: İşaretçi parametreleriyle iki değerin yerini değiştirmek</strong></p><p>İki sayıyı yer değiştiren fonksiyonun yalnızca sayıların değerlerini alması yeterli değildir. Değerlerin kopyaları gönderilirse fonksiyon içindeki değişiklikler main içindeki değişkenlere yansımaz. Bu örnekte fonksiyona iki değişkenin adresini gönderiyoruz.</p><p>#include &lt;stdio.h&gt;</p><p>void yer_degistir(int *ilk, int *ikinci);</p><p>int main(void)</p><p>{</p><p>int a = 12;</p><p>int b = 35;</p><p>printf(“Degisimden once: a = %d, b = %d\n”, a, b);</p><p>yer_degistir(&amp;a, &amp;b);</p><p>printf(“Degisimden sonra: a = %d, b = %d\n”, a, b);</p><p>return 0;</p><p>}</p><p>void yer_degistir(int *ilk, int *ikinci)</p><p>{</p><p>int gecici;</p><p>if (ilk == NULL || ikinci == NULL) {</p><p>return;</p><p>}</p><p>gecici = *ilk;</p><p>*ilk = *ikinci;</p><p>*ikinci = gecici;</p><p>}</p><p>yer_degistir fonksiyonunun parametreleri int * türündedir; yani iki tamsayının adresini bekler. Çağrıda &amp;a ve &amp;b gönderilir. Fonksiyon içindeki *ilk ve *ikinci ifadeleri bu adreslerdeki değerlere erişir. Sonuçta main içindeki a ve b değerleri yer değiştirir.</p><p><strong>Kaynakça</strong></p><ul><li>Çağıltay, Nergiz Ercil, Fügen C. Selbes, Gül Tokdemir ve Çiğdem Turhan. <em>C Dersi: Programlamaya Giriş</em>. 6. baskı. Ankara, 2014.</li><li>Deitel, Paul ve Harvey Deitel. <em>C ile Programlama</em>. 7. baskıdan çeviri. Palme Yayınları.</li><li>Kelley, Al ve Ira Pohl. <em>A Book on C: Programming in C</em>. 4. baskı. Addison-Wesley, 1998.</li><li>Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice Hall, 1988.</li><li>Kochan, Stephen G. <em>Programming in C</em>. 4. baskı. Pearson, 2015.</li><li>Chaudhary, Harry H. <em>C Programming: The Ultimate Way to Learn the Fundamentals of the C Language</em>.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=207d2848c3e6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C Dilinde Fonksiyonlar: Kod Satırlarından Modüler Programa]]></title>
            <link>https://medium.com/@osmanbalcioglu/cde-fonksiyonlar-kod-sat%C4%B1rlar%C4%B1ndan-mod%C3%BCler-programa-dbb2c2c92acf?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/dbb2c2c92acf</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[c-programming]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 06:20:55 GMT</pubDate>
            <atom:updated>2026-11-15T12:51:03.790Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*36yVO85Xr78L8k02tRZouw.png" /></figure><p>Bir programın ilk sürümünü yazarken her şeyi main içine yerleştirmek kolay görünür: kullanıcıdan veri alır, hesap yapar, sonucu ekrana yazdırırız. Program büyüdükçe aynı bölümde giriş işlemleri, hesaplamalar, kontroller ve çıktılar birikir. Bu durumda kod çalışsa bile neyin nerede yapıldığını takip etmek zorlaşır.</p><p>C’de fonksiyonlar, programı daha küçük ve belirli sorumlulukları olan parçalara ayırmamızı sağlar. Bir fonksiyon bir hesaplamayı yapabilir, ekrana bilgi yazabilir, kullanıcıdan veri alabilir veya başka bir fonksiyonu çağırabilir. Böylece main programın bütün ayrıntılarını taşımak yerine, ana akışı düzenler.</p><p>Bu yazıda fonksiyon tanımından başlayıp parametresiz ve parametreli fonksiyonlara, değer döndüren ve döndürmeyen yapılara, değişken kapsamına ve çok fonksiyonlu programlara ilerleyeceğiz.</p><p><strong>1. Fonksiyon nedir?</strong></p><p>Fonksiyon, belirli bir işi yerine getiren, adı olan bir program parçasıdır. Bir fonksiyonun işi çoğu zaman üç soruyla anlatılabilir:</p><ol><li>Hangi girdileri alıyor?</li><li>Bu girdiler üzerinde ne yapıyor?</li><li>Çağıran bölüme bir sonuç döndürüyor mu, yoksa yalnızca bir işlem mi gerçekleştiriyor?</li></ol><p>Örneğin bir dairenin alanını hesaplayan fonksiyon, yarıçapı girdi olarak alır, alan hesabını yapar ve sayısal sonucu geri döndürür. Ekrana başlık yazan bir fonksiyon ise dışarıdan veri almayabilir ve çağıran koda bir hesaplama sonucu döndürmeyebilir.</p><p>Bu ayrımın amacı yalnızca kodu kısaltmak değildir. Bir fonksiyonun görevi netse:</p><ul><li>programın ana akışı daha rahat okunur,</li><li>aynı iş gerektiğinde yeniden çağrılabilir,</li><li>bir hesaplamayı diğer işlemlerden bağımsız incelemek kolaylaşır,</li><li>hata ararken sorunun hangi bölümde olduğunu bulmak kolaylaşır.</li></ul><p>Bu yaklaşım modüler programlama olarak anılır. Bir problemi önce alt görevlere ayırmak, daha sonra her görevi uygun bir fonksiyonda ifade etmek, programın yapısını görünür kılar.</p><p><strong>2. Bir fonksiyonun üç görünümü: prototip, tanım ve çağrı</strong></p><p>Bir fonksiyonla çalışırken üç farklı ifadeyi ayırt etmek gerekir: fonksiyonun prototipi, fonksiyonun tanımı ve fonksiyonun çağrılması.</p><p><strong>2.1. Fonksiyon prototipi</strong></p><p>Prototip, derleyiciye bir fonksiyonun adı, dönüş türü ve parametre türleri hakkında bilgi verir:</p><p>double circle_area(double radius);</p><p>Bu prototip, circle_area adlı fonksiyonun double türünde bir değer döndürdüğünü ve double türünde bir parametre aldığını bildirir. Satırın sonundaki noktalı virgül, bunun bir bildirim olduğunu gösterir; burada fonksiyonun gövdesi henüz yoktur.</p><p>Parametre adını prototipte yazmak açıklayıcıdır, ancak parametre türünü belirtmek asıl bilgidir. Örneğin şu prototip de geçerlidir:</p><p>double circle_area(double);</p><p><strong>2.2. Fonksiyon tanımı</strong></p><p>Tanımda, fonksiyonun nasıl çalışacağı yazılır:</p><p>double circle_area(double radius)</p><p>{</p><p>const double pi = 3.14;</p><p>return pi * radius * radius;</p><p>}</p><p>Bu tanımda:</p><ul><li>double: fonksiyonun dönüş türüdür,</li><li>circle_area: fonksiyonun adıdır,</li><li>double radius: parametre bildiriminin bir parçasıdır,</li><li>süslü parantezler arasındaki komutlar: fonksiyon gövdesidir,</li><li>return: hesaplanan sonucu çağıran koda gönderir.</li></ul><p>Bir fonksiyonun başlığı, parametreleri ve dönüş türüyle birlikte onun hangi işi yapabileceğini anlatan bir arayüz oluşturur. Gövde ise bu işin nasıl yapıldığını belirtir.</p><p><strong>2.3. Fonksiyon çağrısı</strong></p><p>Fonksiyonun yaptığı işi başlatmak için onu çağırırız:</p><p>double area;</p><p>area = circle_area(2.0);</p><p>Burada circle_area fonksiyonuna 2.0 değeri gönderilir. Fonksiyon alanı hesaplar ve return ile sonucu geri verir. Dönen değer area değişkenine atanır.</p><p>Bir C programının yürütülmesi main fonksiyonundan başlar. main başka bir fonksiyonu çağırdığında kontrol o fonksiyona geçer; fonksiyon tamamlanıp değer döndürdüğünde program çağrıdan sonraki satırdan devam eder. Çağıran fonksiyon ve çağrılan fonksiyon ifadeleri bu ilişkiyi anlatmak için kullanılır.</p><p><strong>3. Parametre almak ve değer döndürmek ayrı konulardır</strong></p><p>Sıkça karıştırılan nokta şudur: parametre alıp almamak ile değer döndürüp döndürmemek birbirinden bağımsız iki özelliktir.</p><p><strong>Parametre durumu</strong></p><p><strong>Dönüş durumu</strong></p><p><strong>Prototip örneği</strong></p><p><strong>Tipik görev</strong></p><p>Parametresiz</p><p>Değer döndürmez</p><p>void print_header(void);</p><p>Başlık yazdırmak</p><p>Parametreli</p><p>Değer döndürmez</p><p>void print_symbol(char symbol, int count);</p><p>Bir karakteri belli sayıda yazdırmak</p><p>Parametresiz</p><p>Değer döndürür</p><p>int read_menu_choice(void);</p><p>Girdi okuyup sonucu döndürmek</p><p>Parametreli</p><p>Değer döndürür</p><p>double circle_area(double radius);</p><p>Verilen yarıçapın alanını hesaplamak</p><p>Parametresiz olmak, fonksiyonun hiçbir veriyle çalışamayacağı anlamına gelmez. Örneğin read_menu_choice(void) kullanıcıdan klavyeyle veri okuyabilir; ancak çağrılırken ona parantez içinde bir argüman gönderilmez. Fonksiyonun dış dünyayla etkileşim biçimi ile çağrı sırasında parametre alması farklı konulardır.</p><p>Benzer biçimde, parametre alan bir fonksiyon mutlaka değer döndürmek zorunda değildir. print_symbol karakter ve tekrar sayısını alıp ekrana yazabilir; ancak hesaplanmış bir sonucu çağırana aktarması gerekmeyebilir.</p><p><strong>Not:</strong> Bu yazıda parametresiz fonksiyonları function_name(void) biçiminde yazıyorum. Örneğin void print_header(void); ifadesi, fonksiyonun açıkça parametre almadığını gösterir.</p><p><strong>4. Değer döndürmeyen fonksiyonlar: void</strong></p><p>Bir fonksiyon çağıran koda hesaplanmış bir değer vermeyecekse dönüş türü void olarak bildirilir:</p><p>void print_header(void)</p><p>{</p><p>printf(“Daire alani hesaplama\n”);</p><p>}</p><p>Fonksiyon çağrısı:</p><p>print_header();</p><p>print_header ekrana yazı yazdırır; ancak main içinde kullanılabilecek bir alan değeri döndürmez. Bu nedenle şu kullanım uygun değildir:</p><p>double result = print_header(); /* Hatalı kullanım */</p><p>Burada print_header fonksiyonunun dönüş değeri olmadığı halde bir değişkene atanmak istenmiştir.</p><p>printf ve return ifadelerini de birbirinden ayırmak gerekir:</p><ul><li>printf, bilgiyi ekrana yazar.</li><li>return, değeri fonksiyonun çağrıldığı yere gönderir.</li></ul><p>Örneğin aşağıdaki iki fonksiyon farklı işler yapar:</p><p>void print_sum(int a, int b)</p><p>{</p><p>printf(“%d\n”, a + b);</p><p>}</p><p>int sum(int a, int b)</p><p>{</p><p>return a + b;</p><p>}</p><p>İlki sonucu ekrana yazdırır; ikincisi sonucu başka bir hesaplamada kullanılmak üzere döndürür:</p><p>int total = sum(4, 7);</p><p>void fonksiyonun değersiz olması, hiçbir işlem yapmadığı anlamına gelmez. Ekrana yazma, dosyaya yazma veya başka bir durumu değiştirme gibi etkiler üretebilir. Bu yüzden hesaplamayı döndüren bir fonksiyonla çıktı üreten bir fonksiyonu ayrı tasarlamak, kodu yeniden kullanmayı kolaylaştırır.</p><p><strong>5. Değer döndüren fonksiyonlar ve return</strong></p><p>Bir fonksiyon hesaplama yapıp sonucunu çağıran bölüme aktaracaksa dönüş türü sonucu ifade etmelidir:</p><p>double square(double number)</p><p>{</p><p>return number * number;</p><p>}</p><p>Çağrı:</p><p>double result = square(3.5);</p><p>return number * number; önce ifadeyi hesaplar, ardından çıkan değeri çağırana döndürür. return çalıştığında fonksiyonun yürütülmesi sona erer. Bu nedenle bir fonksiyonun farklı koşullarda birden fazla return satırı olabilir; ancak programın gerçekleşebilecek her yolunda uygun bir değer döndürüldüğünden emin olunmalıdır.</p><p>int sign_of(double number)</p><p>{</p><p>if (number &lt; 0.0) {</p><p>return -1;</p><p>}</p><p>if (number &gt; 0.0) {</p><p>return 1;</p><p>}</p><p>return 0;</p><p>}</p><p>Bu fonksiyon negatif sayı için -1, pozitif sayı için 1, sıfır için 0 döndürür. Her olasılık bir dönüş değeriyle karşılandığı için çağıran bölüm hangi sonucu alacağını bilir.</p><p><strong>Dikkat:</strong> void fonksiyonda değer döndüren return ifade; kullanılamaz. Fonksiyonun çalışmasını erken bitirmek için gerekirse yalnızca return; yazılabilir.</p><p><strong>6. Parametreli fonksiyonlar</strong></p><p>Parametre, fonksiyonun çağrıldığı yerden veri almasını sağlar. Örneğin:</p><p>int sum_to(int limit)</p><p>{</p><p>int i;</p><p>int total = 0;</p><p>for (i = 1; i &lt;= limit; i++) {</p><p>total += i;</p><p>}</p><p>return total;</p><p>}</p><p>sum_to bir tam sayı parametresi alır ve 1 ile bu değer arasındaki sayıların toplamını döndürür:</p><p>int result = sum_to(5);</p><p>Çağrı sırasında gönderilen 5, fonksiyona argüman olarak verilir. Fonksiyon tanımındaki limit ise parametredir. Başka bir deyişle:</p><ul><li>argüman, çağrı sırasında gönderilen değerdir;</li><li>parametre, fonksiyon tanımında bu değeri karşılayan değişkendir.</li></ul><p>Birden çok parametre olduğunda, her parametrenin türü ayrı ayrı yazılır ve parametreler virgülle ayrılır:</p><p>double rectangle_area(double width, double height)</p><p>{</p><p>return width * height;</p><p>}</p><p>Çağrı:</p><p>double area = rectangle_area(4.0, 2.5);</p><p>İlk argüman width, ikinci argüman height parametresine karşılık gelir. Sayı ve sıra önemlidir. İki parametrenin de double olması, çağrı sırasını önemsiz hale getirmez: genişlik ve yükseklik ters geçirilirse çoğu dikdörtgen örneğinde çarpım aynı çıksa bile, farklı iş yapan fonksiyonlarda sıra sonucu değiştirebilir. Parametre türleri de prototiple uyumlu olmalıdır.</p><p><strong>6.1. C’de parametreler değer olarak aktarılır</strong></p><p>C’de fonksiyonlara argümanlar değer olarak aktarılır. Basit bir int ya da double argümanında fonksiyon, çağıran değişkenin kendisini değil, değerinin bir kopyasını alır:</p><p>void add_one(int value)</p><p>{</p><p>value++;</p><p>}</p><p>int main(void)</p><p>{</p><p>int number = 4;</p><p>add_one(number);</p><p>printf(“%d\n”, number);</p><p>return 0;</p><p>}</p><p>Ekrana 4 yazılır. add_one içindeki value değişkeni artırılmıştır; ancak main içindeki number değişkeni değişmemiştir. Bunlar farklı fonksiyonlara ait ayrı değişkenlerdir.</p><p>Bir fonksiyonun çağıranın değişkenini değiştirmesi gerekiyorsa bunun için C’de adres ve pointer kullanımı gibi başka teknikler bulunur.</p><p><strong>7. Değişken kapsamı: Bir isim nerede geçerlidir?</strong></p><p>Bir değişkenin kapsamı, o değişken adının programın hangi bölümünden görülebileceğini ve kullanılabileceğini anlatır.</p><p><strong>7.1. Yerel değişkenler ve parametreler</strong></p><p>Bir fonksiyonun gövdesinde tanımlanan değişkenler, normal koşullarda yalnızca o fonksiyonun gövdesinde kullanılabilir:</p><p>int sum_to(int limit)</p><p>{</p><p>int i;</p><p>int total = 0;</p><p>for (i = 1; i &lt;= limit; i++) {</p><p>total += i;</p><p>}</p><p>return total;</p><p>}</p><p>Burada limit, parametredir; i ve total yerel değişkenlerdir. main fonksiyonu bu isimlere doğrudan erişemez. main ile sum_to arasındaki veri aktarımı, parametreler ve dönüş değeri aracılığıyla yapılır.</p><p>Aynı isim farklı fonksiyonlarda kullanılabilir:</p><p>int main(void)</p><p>{</p><p>int value = 10;</p><p>/* … */</p><p>}</p><p>void display(void)</p><p>{</p><p>int value = 20;</p><p>/* … */</p><p>}</p><p>İki value, isimleri aynı olsa da farklı fonksiyonların yerel değişkenleridir. Her fonksiyon kendi yerel alanında çalışır.</p><p>Yerel değişkenlerle ilgili önemli bir tuzak da başlangıç değeridir:</p><p>int calculate(void)</p><p>{</p><p>int result;</p><p>return result; /* Hatalı yaklaşım: result’a değer atanmadı */</p><p>}</p><p>Normal yerel değişkenler kendiliğinden sıfırlanmaz. Değer atanmadan okunmaları hatalı sonuçlara ve tanımsız davranışa yol açabilir. Kullanılmadan önce değer verin:</p><p>int result = 0;</p><p><strong>7.2. Dosya kapsamındaki değişkenler</strong></p><p>Fonksiyonların dışında tanımlanan değişkenlere başlangıç derslerinde çoğu zaman genel (global) değişken denir:</p><p>int default_limit = 100;</p><p>void display_limit(void)</p><p>{</p><p>printf(“%d\n”, default_limit);</p><p>}</p><p><strong>8. Çok fonksiyonlu programlar</strong></p><p>Bir program birden fazla fonksiyondan oluşabilir. Bu durumda main genellikle ana akışı yönetir; hesaplamayı ve çıktıyı ayrı fonksiyonlara bırakır. Aşağıdaki program üç farklı görevi ayrı fonksiyonlarda toplar:</p><p>#include &lt;stdio.h&gt;</p><p>void print_heading(void);</p><p>double circle_area(double radius);</p><p>void print_result(double radius, double area);</p><p>int main(void)</p><p>{</p><p>double radius;</p><p>double area;</p><p>print_heading();</p><p>printf(“Yaricapi girin: “);</p><p>if (scanf(“%lf”, &amp;radius) != 1) {</p><p>printf(“Gecerli bir sayi girilmedi.\n”);</p><p>return 1;</p><p>}</p><p>if (radius &lt; 0.0) {</p><p>printf(“Yaricap negatif olamaz.\n”);</p><p>return 1;</p><p>}</p><p>area = circle_area(radius);</p><p>print_result(radius, area);</p><p>return 0;</p><p>}</p><p>void print_heading(void)</p><p>{</p><p>printf(“Daire alani hesaplama\n”);</p><p>}</p><p>double circle_area(double radius)</p><p>{</p><p>const double pi = 3.141592653589793;</p><p>return pi * radius * radius;</p><p>}</p><p>void print_result(double radius, double area)</p><p>{</p><p>printf(“Yaricap: %.2f\n”, radius);</p><p>printf(“Alan: %.2f\n”, area);</p><p>}</p><p>Bu programın çalışmasını adım adım izleyelim:</p><ol><li>Program main fonksiyonundan başlar.</li><li>main, parametresiz ve değer döndürmeyen print_heading fonksiyonunu çağırır.</li><li>Kullanıcıdan yarıçap alınır; girişin sayısal olup olmadığı denetlenir.</li><li>Yarıçap negatif değilse circle_area fonksiyonu çağrılır. Fonksiyon double türünde alan değeri döndürür.</li><li>Dönen değer area değişkenine atanır.</li><li>print_result fonksiyonu iki parametre alır ve sonuçları ekrana yazar.</li></ol><p>Burada main işlemlerin sırasını yönetirken, diğer fonksiyonların sorumlulukları belirgindir. circle_area hesaplama yapar; ekrana yazdırmaz. print_result çıktı üretir; alanı yeniden hesaplamaz. Bu ayrım, hesaplamayı farklı bir programda da kullanmayı kolaylaştırır.</p><p>Fonksiyon prototiplerinin main öncesinde yazılması, tanımların dosyanın devamında yer almasına imkân verir. Fonksiyon tanımını çağrıdan önce yazmak da mümkündür; bu durumda çağrı noktasında fonksiyonun bildirimi zaten görülmüş olur. Başlangıçta prototipleri başta, tanımları main sonrasında toplamak, arayüz ile uygulama kodunu ayırt etmeyi kolaylaştırır.</p><p><strong>Kaynakça</strong></p><ul><li>Çağıltay, Nergiz Ercil, Fügen C. Selbes, Gül Tokdemir ve Çiğdem Turhan. <em>C Dersi: Programlamaya Giriş</em>. 6. baskı, Ankara, 2014.</li><li>Selbes, C. Fügen, Gül Tokdemir, Çiğdem Turhan ve Nergiz Ercil Çağıltay. <em>C Dersi: Çözümlü Problem Kitabı</em>. 4. baskı, Ankara, 2015.</li><li>Deitel, Paul ve Harvey Deitel. <em>C ile Programlama</em>. 7. baskıdan çeviri. Palme Yayınları.</li><li>Kelley, Al ve Ira Pohl. <em>A Book on C: Programming in C</em>. 4. baskı. Addison-Wesley, 1998.</li><li>Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice Hall, 1988.</li><li>Kochan, Stephen G. <em>Programming in C</em>. 4. baskı. Pearson, 2015.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dbb2c2c92acf" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C Dilinde İlk Adımlar: Temellerden Döngülere]]></title>
            <link>https://medium.com/@osmanbalcioglu/cde-i%CC%87lk-ad%C4%B1mlar-temellerden-d%C3%B6ng%C3%BClere-039132758ba2?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/039132758ba2</guid>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[c-programming]]></category>
            <category><![CDATA[programming-languages]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Thu, 12 Nov 2026 03:10:40 GMT</pubDate>
            <atom:updated>2026-11-15T12:57:17.767Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sfppwT3xrtNybGa3_67R6w.png" /></figure><p>Bir programı anlamak, önce kodu ezberlemekle değil, çözülmesi gereken problemi netleştirmekle başlar. Örneğin kullanıcıdan birkaç not alıp ortalamayı hesaplayan bir program düşünelim. Program hangi bilgileri alacak? Hatalı bir not girilirse ne yapacak? Ortalama nasıl hesaplanacak? Sonuç hangi aralığa düşerse ne gösterecek? Bu soruların yanıtlarını kurduktan sonra C kodunu yazmak kolaylaşır. Bu çalışma, C dilinin temellerini ve atama, girdi-çıktı, seçim ve döngü konularını bu problem çözme akışı içinde ele alıyor.</p><p><strong>1. Başlangıç: Algoritmadan programa</strong></p><p>Algoritma, bir problemi çözmek için izlenen sıralı ve açık adımlar bütünüdür. Programlama dili ise bu adımları bilgisayarın çalıştırabileceği biçimde ifade etmemizi sağlar. Bu yüzden önce “hangi C komutunu kullanacağım?” diye değil, “problemi hangi adımlarla çözerim?” diye düşünmek yararlıdır.</p><p>Not ortalaması örneğini sözel olarak şöyle tarif edebiliriz:</p><ol><li>Kullanıcıdan bir not al.</li><li>Kullanıcı çıkış işareti girene kadar notları işlemeye devam et.</li><li>Her notun geçerli aralıkta olup olmadığını kontrol et.</li><li>Geçerliyse toplamı ve not sayısını güncelle.</li><li>Giriş bittiğinde hiç geçerli not girilmemişse bunu bildir.</li><li>Aksi durumda ortalamayı hesapla ve sonucu göster.</li></ol><p>Bu anlatımı koda geçmeden önce kısa sözde kodla da gösterebiliriz:</p><p>toplam = 0</p><p>sayi = 0</p><p>not oku</p><p>not çıkış işareti değilken:</p><p>not geçerliyse:</p><p>toplamı güncelle</p><p>sayı değerini artır</p><p>değilse:</p><p>kullanıcıyı uyar</p><p>yeni not oku</p><p>sayı sıfırsa:</p><p>“Hesaplanacak not yok” yaz</p><p>değilse:</p><p>ortalamayı hesapla</p><p>sonucu yaz</p><p>Buradaki adımlar, daha sonra göreceğimiz değişkenlere, koşullara ve döngülere karşılık gelir. Algoritmanın sınırlarını belirlemeden doğrudan kod yazmak, özellikle giriş değerleri ve döngünün ne zaman biteceği konusunda hatalara yol açabilir.</p><p><strong>2. C Dilinin Temelleri</strong></p><p><strong>2.1. İlk C programını okumak</strong></p><p>Başlangıçta yazılan programların çoğu ekrana kısa bir mesaj basar:</p><p>#include &lt;stdio.h&gt;</p><p>int main(void)</p><p>{</p><p>printf(“Merhaba, C!\n”);</p><p>return 0;</p><p>}</p><p>Bu programın her satırı farklı bir görevi yerine getirir:</p><ul><li>#include &lt;stdio.h&gt;, standart girdi-çıktı işlevlerinin bildirimlerini programa ekler. Bu örnekte printf işlevini kullanabilmemizi sağlar.</li><li>int main(void), programın çalışmaya başladığı main işlevini tanımlar.</li><li>Süslü parantezler { }, işlevin gövdesini ve bu gövdedeki komutların sınırlarını gösterir.</li><li>printf, metni ekrana yazar. \n, yazıdan sonra yeni satıra geçilmesini sağlar.</li><li>return 0;, programın normal biçimde sona erdiğini bildirir.</li></ul><p>C kaynak kodu bir dosyada yazılır; derleyici bu kaynak kodu çalıştırılabilir programa dönüştürür. Bu süreçte kodun dil kurallarına uygun olup olmadığı da denetlenir. Derleyici ile çalışma ortamının verdiği uyarıları okumak, hataları daha program çalışmadan yakalamaya yardımcı olur.</p><p><strong>2.2. Sözdizimi, ifadeler ve okunabilirlik</strong></p><p>C’de küçük noktalama işaretleri önemlidir. Örneğin çoğu komutun sonunda noktalı virgül bulunur:</p><p>int age = 19;</p><p>printf(“%d\n”, age);</p><p>Noktalı virgül unutulursa derleyici hata verebilir. Fazladan veya yanlış yere konan noktalı virgül de programın anlamını değiştirebilir; özellikle if ve döngü örneklerinde bunu göreceğiz.</p><p>Kodun çalışması tek ölçüt değildir. Birkaç ay sonra aynı kodu tekrar açtığımızda ne yaptığını anlayabilmemiz de gerekir. Anlamlı değişken adları, uygun girintileme ve gerekli yerlerde kısa açıklamalar bu nedenle önemlidir.</p><p>double exam_average;</p><p>x gibi kısa adlar matematiksel bir formülde yeterli olabilir; ancak exam_average, değişkenin neyi tuttuğunu daha açık gösterir.</p><p><strong>Not:</strong> Yorum satırları kodun amacını açıklamak için kullanılır. Yorumlar programın işleyişini değiştirmez; bu yüzden her satırı değil, kodun amacı hemen anlaşılmayan bölümleri açıklamak daha faydalıdır.</p><p><strong>2.3. Tanımlayıcılar, değişkenler ve temel veri türleri</strong></p><p>Değişken, program çalışırken değer saklamak için kullandığımız isimlendirilmiş alandır. Bir değişkeni kullanmadan önce türünü ve adını bildiririz:</p><p>int student_count;</p><p>double average;</p><p>char letter;</p><p>Başlangıç değerini bildirirken de atayabiliriz:</p><p>int student_count = 3;</p><p>double average = 82.5;</p><p>char letter = ‘A’;</p><p>Başlangıç konularında sık karşılaşılan türler şunlardır:</p><ul><li>int: tam sayı değerleri,</li><li>float: ondalıklı sayılar,</li><li>double: daha yüksek duyarlıkla temsil edilen ondalıklı sayılar,</li><li>char: tek bir karakter.</li></ul><p>Karakterler tek tırnakla yazılır: ‘A’. Metinler ise çift tırnakla yazılır: “Merhaba”. Bunlar aynı türde ifade değildir; karakter ile karakter dizisini karıştırmamak gerekir.</p><p>Bir değişken adı harf veya alt çizgiyle başlayabilir; rakamla başlayamaz. Büyük-küçük harf ayrımı da vardır: puan ve Puan farklı tanımlayıcılardır. C’nin ayrılmış sözcükleri, örneğin int ve while, değişken adı olarak kullanılamaz.</p><p><strong>Uyarı — Her bilgisayarda int aynı boyutta değildir-</strong><br> Bir veri türünün bellekte kapladığı alan ve temsil edebildiği değer aralığı kullanılan derleyiciye ve platforma bağlı olabilir. “int her sistemde kesin olarak şu kadar bayttır” gibi ezberler taşınabilir C kodu yazarken yanıltıcıdır.</p><p>Program boyunca değişmemesi gereken bir değeri const ile tanımlayabiliriz:</p><p>const double tax_rate = 0.20;</p><p>Bu bildirimin amacı, değerin sonradan yanlışlıkla değiştirilmesini önlemektir. Sabitleri ve değişkenleri başlangıçta açık biçimde tanımlamak, kodu takip etmeyi kolaylaştırır.</p><p><strong>3. Atama ve Girdi-Çıktı Komutları</strong></p><p><strong>3.1. Atama operatörü ile eşitlik karşılaştırması</strong></p><p>C’de = işareti <strong>atama</strong> yapar: sağ taraftaki değeri sol taraftaki değişkene yerleştirir.</p><p>int score;</p><p>score = 75;</p><p>Bu ifade “score, 75’e eşittir mi?” diye sormaz; score değişkenine 75 değerini yazar. Eşitlik karşılaştırması için == kullanılır:</p><p>if (score == 75) {</p><p>printf(“Puan 75.\n”);</p><p>}</p><p>Bu iki işaretin karıştırılması C’de sık görülen hatalardandır; çünkü atama işlemi bazı koşul ifadelerinde derleyici hatası olmadan kullanılabilir.</p><p><strong>Dikkat:</strong> if (score = 75) yazıldığında karşılaştırma değil, atama yapılır. “Puan 75 mi?” sorusu için score == 75 yazılmalıdır.</p><p><strong>3.2. Aritmetik işlemler ve işlem önceliği</strong></p><p>C’de temel aritmetik işlemler +, -, *, / ve % operatörleriyle yapılır. %, tam sayı işlemlerinde kalanı verir:</p><p>int remainder = 17 % 5; /* remainder değeri 2 olur */</p><p>İşlem önceliği de sonucu etkiler:</p><p>int first = 8 + 3 * 2; /* 14 */</p><p>int second = (8 + 3) * 2; /* 22 */</p><p>Çarpma, toplama işleminden önce yapılır. Okuyanın tereddüt edebileceği ifadelerde parantez kullanmak, işlem sırasını görünür kılar.</p><p>Tamsayılarla yapılan bölmede sonuç da tamsayı olur:</p><p>int result = 7 / 2; /* result değeri 3 olur */</p><p>Ondalıklı sonuç istiyorsak bölme işlemine katılan değerlerden en az biri ondalıklı olmalıdır:</p><p>double result = 7.0 / 2; /* result değeri 3.5 olur */</p><p><strong>Dikkat — Değişkeni double yapmak tek başına yetmeyebilir.</strong><br> double result = 7 / 2; ifadesinde önce 7 / 2 tamsayı bölmesi yapılır ve sonuç 3 olur. Sonra bu değer double türüne çevrilir. Ondalıklı bölme için 7.0 / 2 yazabilir ya da tür dönüşümü kullanabilirsiniz: (double)7 / 2.</p><p>Tür dönüşümleri bazen örtük olarak, bazen programcı tarafından açıkça yapılır. Örneğin bir tam sayı ile bir double aynı işlemde kullanıldığında C, işlemi uygun ortak türe taşır. Ancak özellikle bölme ve atamalarda hangi türde işlem yapıldığını bilmek gerekir.</p><p><strong>3.3. printf ile çıktı üretmek</strong></p><p>printf, biçimlendirilmiş çıktı üretir. Biçim belirteci, ekrana yazılacak değerin türünü ve gösterim biçimini belirtir:</p><p>int count = 4;</p><p>double average = 82.456;</p><p>printf(“Not sayisi: %d\n”, count);</p><p>printf(“Ortalama: %.2f\n”, average);</p><p>Yaygın biçim belirteçlerinden bazıları:</p><p><strong>Belirteç</strong></p><p><strong>Kullanım</strong></p><p>%d</p><p>int değer</p><p>%c</p><p>karakter</p><p>%f</p><p>printf içinde ondalıklı değer</p><p>%.2f</p><p>virgülden sonra iki basamaklı gösterim</p><p>%s</p><p>metin</p><p>Biçim belirteci ile verilen değerin türü uyuşmalıdır.</p><p><strong>3.4. scanf ile kullanıcıdan veri almak</strong></p><p>scanf, klavyeden veya standart girdiden değer okumak için kullanılır. Tek bir double değeri için:</p><p>double width;</p><p>printf(“Genisligi girin: “);</p><p>if (scanf(“%lf”, &amp;width) != 1) {</p><p>printf(“Gecerli bir sayi girilmedi.\n”);</p><p>return 1;</p><p>}</p><p>Burada iki ayrıntı önemlidir:</p><ol><li>double için scanf biçim belirteci %lf’dir.</li><li>&amp;width, scanf işlevine değerin yazılacağı değişkenin adresini verir.</li></ol><p>scanf dönüş değerini denetlemek, kullanıcının beklenen türde veri girip girmediğini anlamamızı sağlar. Bir değer bekliyorsak dönüş değerinin 1 olup olmadığını kontrol edebiliriz. İki değer bekleniyorsa beklenen dönüş değeri 2 olur.</p><p><strong>4. Seçme Komutları</strong></p><p>Programın her durumda aynı işlemi yapması gerekmez. Bir koşul doğruysa bir grup komut, yanlışsa başka bir grup çalıştırılabilir. C’de bunun temel aracı if yapısıdır.</p><p><strong>4.1. if ve if-else</strong></p><p>if (score &gt;= 60) {</p><p>printf(“Basarili.\n”);</p><p>} else {</p><p>printf(“Tekrar calis.\n”);</p><p>}</p><p>Koşul score &gt;= 60 doğruysa ilk blok, yanlışsa else bloğu çalışır. Süslü parantezler birden fazla komutu aynı dala bağlar. Tek komut olsa bile parantezleri kullanmak, sonraki değişikliklerde yanlışlıkla yalnızca bir satırın koşula bağlanması riskini azaltır.</p><p>Koşullarda kullanılan karşılaştırma operatörleri:</p><ul><li>&lt;, &lt;=, &gt;, &gt;=</li><li>==, !=</li></ul><p>Birden fazla şartı mantıksal operatörlerle birleştirebiliriz:</p><p>if (score &gt;= 0 &amp;&amp; score &lt;= 100) {</p><p>printf(“Puan gecerli aralikta.\n”);</p><p>}</p><p>&amp;&amp; “ve”, || “veya”, ! ise mantıksal “değil” anlamında kullanılır. Parantezler, özellikle birden fazla mantıksal işlemin bulunduğu ifadelerde niyeti açık eder.</p><p><strong>Uyarı -Matematikteki zincirli karşılaştırma C’de aynı anlama gelmez-</strong><br> 0 &lt; x &lt; 100 ifadesi “x, 0 ile 100 arasında mı?” demek değildir. C önce 0 &lt; x karşılaştırmasını yapar; bu karşılaştırma 0 veya 1 üretir. Sonra çıkan değer 100 ile karşılaştırılır. İstenen koşul şu şekilde kurulmalıdır: x &gt; 0 &amp;&amp; x &lt; 100.</p><p><strong>4.2. Birden fazla durum: else-if</strong></p><p>Bir değeri birkaç aralığa göre sınıflandırmak için else-if zinciri kullanılabilir:</p><p>if (average &gt;= 90.0) {</p><p>printf(“A araligi\n”);</p><p>} else if (average &gt;= 80.0) {</p><p>printf(“B araligi\n”);</p><p>} else if (average &gt;= 70.0) {</p><p>printf(“C araligi\n”);</p><p>} else {</p><p>printf(“Diger aralik\n”);</p><p>}</p><p>Koşullar yukarıdan aşağıya değerlendirilir. İlk doğru koşulun bloğu çalıştıktan sonra zincirin geri kalanı atlanır. Bu nedenle aralıkları doğru sıraya koymak önemlidir.</p><p>Bu örnekteki puan sınırları yalnızca anlatım içindir; gerçek not sistemlerinde geçme sınırı ve harf notu aralıkları kuruma göre değişebilir.</p><p><strong>4.3. İç içe koşullar ve “dangling else” riski</strong></p><p>Bir koşulun içinde başka bir koşul bulunabilir:</p><p>if (score &gt;= 0) {</p><p>if (score &lt;= 100) {</p><p>printf(“Gecerli puan.\n”);</p><p>}</p><p>}</p><p>İç içe yapılar gerektiğinde kullanılabilir; ancak çok katmanlı koşulların takibi zorlaşır. Ayrıca süslü parantezler kullanılmadığında else ifadesinin hangi if ile eşleştiği belirsizleşebilir. Bu nedenle blok sınırlarını açıkça yazmak, doğru eşleşmeyi görünür kılar.</p><p><strong>4.4. Kısa koşul ifadesi ve switch</strong></p><p>Tek bir değere göre iki kısa sonuçtan birini seçmek için üçlü koşul operatörü kullanılabilir:</p><p>status = (score &gt;= 60) ? 1 : 0;</p><p>Bir değişkenin belirli sabit değerlerine göre farklı davranışlar tanımlamak için switch kullanılabilir:</p><p>switch (menu_choice) {</p><p>case 1:</p><p>printf(“Yeni kayit\n”);</p><p>break;</p><p>case 2:</p><p>printf(“Kayitlari listele\n”);</p><p>break;</p><p>case 0:</p><p>printf(“Cikis\n”);</p><p>break;</p><p>default:</p><p>printf(“Gecersiz secim\n”);</p><p>}</p><p>break, ilgili case çalıştıktan sonra switch yapısından çıkmayı sağlar. break unutulursa program sonraki case bölümünü de çalıştırabilir. Bu davranış bazı özel durumlarda bilerek kullanılır; başlangıç örneklerinde ise genellikle istenmeyen bir hatadır. default, hiçbir case eşleşmediğinde çalışır.</p><p><strong>4.5.Akış Kontrol İfadeleri: break, continue ve return</strong></p><p>Bu üç ifade de programın normal akış sırasını değiştirmek için kullanılır; ancak etki alanları ve amaçları birbirinden tamamen farklıdır:</p><p>1. <strong>break </strong>(Döngüyü veya Switch’i Kır/Çık):</p><p>o Amacı: İçinde bulunduğu en yakın döngüyü (for, while, do-while) veya switch bloğunu derhal sonlandırır.</p><p>o Sonrası: Program akışı, kırılan döngünün veya yapının hemen dışındaki ilk satırdan devam eder.</p><p>2. <strong>continue </strong>(Atla ve Devam Et):</p><p>o Amacı: Sadece döngülerde (for, while, do-while) geçerlidir. Döngünün o anki adımını (iterasyonunu) yarım bırakarak döngünün başına (artım veya koşul kontrolüne) geri döner.</p><p>o Sonrası: Döngü bitmez, sadece o turdaki alt satırlarda kalan kodlar atlanır ve bir sonraki turdan devam edilir.</p><p>3. <strong>return </strong>(Fonksiyondan Çık / Değer Döndür):</p><p>o Amacı: İçinde bulunulan fonksiyonu tamamen sonlandırır. Eğer fonksiyon bir değer döndürmesi gerekiyorsa (int, float vb.), return ile bu değer çağrıldığı yere verilir. Fonksiyon void ise sadece return; şeklinde fonksiyonu erken bitirmek için kullanılır.</p><p>o Sonrası: Akış, o fonksiyonu hangi satır ve hangi fonksiyon çağırdıysa doğrudan oraya geri döner.</p><p><strong>5. Döngü Komutları</strong></p><p>Döngüler, bir komut grubunu belirli bir koşul sürdüğü müddetçe tekrar çalıştırır. Döngüyü yazmadan önce üç soruya cevap vermek gerekir:</p><ol><li>Döngü değişkeni veya başlangıç durumu nedir?</li><li>Döngü hangi koşul doğru olduğu sürece devam eder?</li><li>Her turda bu durumu nasıl güncelleriz?</li></ol><p><strong>5.1. while: Koşul doğru olduğu sürece</strong></p><p>while, önce koşulu denetler; koşul doğruysa gövdeyi çalıştırır:</p><p>int i = 1;</p><p>int total = 0;</p><p>while (i &lt;= 5) {</p><p>total = total + i;</p><p>i++;</p><p>}</p><p>printf(“Toplam: %d\n”, total);</p><p>Bu program 1’den 5’e kadar olan tam sayıları toplar. Her turda önce i değeri toplama eklenir, ardından i artırılır. Son turda i değeri 6’ya çıktığında i &lt;= 5 koşulu yanlış olur ve döngü biter. Sonuç 15’tir.</p><p><strong>Tur başındaki i</strong></p><p><strong>Tur sonunda total</strong></p><p>1</p><p>1</p><p>2</p><p>3</p><p>3</p><p>6</p><p>4</p><p>10</p><p>5</p><p>15</p><p><strong>Uyarı -Güncelleme adımı unutulursa sonsuz döngü oluşabilir.-</strong><br> i değişkeni artırılmazsa i &lt;= 5 koşulu hep doğru kalır. Döngü tasarlarken güncelleme adımının gerçekten çalıştığını kontrol edin.</p><p><strong>5.2. Sayaç kontrollü ve işaret kontrollü döngüler</strong></p><p>Bir döngü kaç kez çalışacağı önceden biliniyorsa sayaç kontrollü kullanım uygundur. Örneğin bir dizinin ilk beş elemanını işlemek veya 1’den 10’a kadar sayıları toplamak.</p><p>Giriş sayısı önceden belli değilse, kullanıcıya ait özel bir bitiş işareti kullanılabilir. Buna işaret kontrollü (sentinel) yaklaşım denir. Not örneğinde -1, “giriş bitti” anlamına gelebilir. -1 geçerli not aralığının dışında seçildiği için bir not değeriyle karışmaz.</p><p><strong>5.3. for: Sayacı döngüyle birlikte yönetmek</strong></p><p>Sayaç kontrollü döngülerde for, başlangıç değerini, devam koşulunu ve güncellemeyi tek satırda toplar:</p><p>int i;</p><p>int total = 0;</p><p>for (i = 1; i &lt;= 5; i++) {</p><p>total += i;</p><p>}</p><p>Bu ifade, önceki while örneğiyle aynı toplamı hesaplar. for yapısında:</p><ul><li>i = 1: başlangıç değeri,</li><li>i &lt;= 5: devam koşulu,</li><li>i++: her turun sonundaki güncelleme.</li></ul><p>total += i ifadesi, total = total + i ile aynı işi yapar. Benzer biçimde -=, *=, /= gibi bileşik atama operatörleri de bulunur.</p><p><strong>5.4. do-while: Gövdeyi en az bir kez çalıştırmak</strong></p><p>do-while yapısında önce gövde çalışır, koşul sonra değerlendirilir:</p><p>int choice;</p><p>do {</p><p>printf(“Devam etmek icin 1, cikmak icin 0 girin: “);</p><p>scanf(“%d”, &amp;choice);</p><p>} while (choice != 0);</p><p>Bu nedenle gövde en az bir kez çalışır. Kullanıcıdan en az bir seçim alınması gereken menülerde bu davranış yararlı olabilir.</p><p><strong>Dikkat:</strong> do-while yapısının sonunda noktalı virgül bulunur: } while (koşul);</p><p><strong>5.5. İç içe döngüler</strong></p><p>Bir döngünün içinde başka bir döngü çalıştırılabilir. Örneğin üç satır ve dört sütundan oluşan bir yıldız deseni:</p><p>int row;</p><p>int column;</p><p>for (row = 1; row &lt;= 3; row++) {</p><p>for (column = 1; column &lt;= 4; column++) {</p><p>printf(“* “);</p><p>}</p><p>printf(“\n”);</p><p>}</p><p>Dış döngü satırları, iç döngü her satırda yazdırılacak yıldızları yönetir.</p><p><strong>Kaynakça</strong></p><ul><li>Aslan, Kaan. <em>Sistem Programlama ve İleri C Uygulamaları</em>. Ders notları, 2008.</li><li>Çağıltay, Nergiz Ercil, Fügen C. Selbes, Gül Tokdemir ve Çiğdem Turhan. <em>C Dersi: Programlamaya Giriş</em>. 6. baskı, 2014.</li><li>Çağıltay, Nergiz Ercil, Fügen C. Selbes, Gül Tokdemir ve Çiğdem Turhan. <em>C Dersi: Çözümlü Problem Kitabı</em>. 4. baskı, 2015.</li><li>Deitel, Paul ve Harvey Deitel. <em>C ile Programlama</em>. 7. baskıdan çeviri. Palme Yayınları.</li><li>Kelley, Al ve Ira Pohl. <em>A Book on C: Programming in C</em>. 4. baskı. Addison-Wesley, 1998.</li><li>Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice Hall, 1988.</li><li>Kochan, Stephen G. <em>Programming in C</em>. 4. baskı. Pearson, 2015.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=039132758ba2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[C Dilinin Hikayesi: UNIX’ten Bugüne Bir Dil Nasıl Yaşar?]]></title>
            <link>https://medium.com/@osmanbalcioglu/cnin-hikayesi-unix-ten-bug%C3%BCne-bir-dil-nas%C4%B1l-ya%C5%9Far-2de1e07d80e9?source=rss-3e96a6e798ed------2</link>
            <guid isPermaLink="false">https://medium.com/p/2de1e07d80e9</guid>
            <category><![CDATA[computer-science]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[c-programming]]></category>
            <category><![CDATA[operating-systems]]></category>
            <category><![CDATA[algorithms]]></category>
            <dc:creator><![CDATA[Osman Balcıoglu]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 09:46:00 GMT</pubDate>
            <atom:updated>2026-11-15T13:00:24.899Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rnx5hdA80yWcexGAlT_dJQ.png" /></figure><p><em>Bir işletim sistemini yazma ihtiyacından doğan C, aradan geçen yarım yüzyılı aşkın zamanda neden hâlâ bilgisayarların en temel katmanlarında karşımıza çıkıyor?</em></p><p>Bir bilgisayara bir işi yaptırmak istiyoruz. Fakat bilgisayar, bizim gündelik dilimizi değil, kendi işlemcisinin anlayabildiği makine talimatlarını izliyor. Bugün bu çeviri süreci çoğu zaman görünmez; kodumuzu yazar, derleyiciye verir ve sonucu çalıştırırız. 1960’ların sonlarında ise bilgisayara yakın çalışan yazılımlar geliştirmek çok daha zahmetliydi.</p><p>C’nin hikâyesi, bu güçlüğü aşmaya çalışan Bell Labs araştırmacılarının hikâyesinin içinde başladı.</p><h3>C, UNIX’in yanında gelişti</h3><p>1969’da Bell Labs, Multics adlı büyük işletim sistemi projesinden ayrılıyordu. Projenin vaatlerinin çok geç ve yüksek maliyetle gerçekleşebileceği düşünülüyordu. Araştırmacılar eldeki makinelerle daha küçük bir işletim sistemi geliştirmeye yöneldi. UNIX’in ilk sürümleri, PDP-7 adlı bilgisayar için büyük ölçüde assembly diliyle yazıldı. Bu dil donanıma doğrudan komut vermeyi sağlıyordu; ancak sistem büyüdükçe yazılımı geliştirmek ve başka makinelere uyarlamak zorlaşıyordu.</p><p>Ken Thompson, BCPL’den etkilenerek B adlı dili geliştirdi ve UNIX’in ilk sürümlerinde kullandı. Dennis Ritchie’nin C dilinin gelişimini anlattığı makale de bu yolu BCPL’den B’ye, B’den C’ye uzanan bir gelişim olarak açıklar. C’nin ortaya çıkışını tek bir güne bağlamak doğru olmaz: Ritchie, gelişimi 1969–1973 aralığına yerleştirir ve 1972’yi özellikle yoğun bir dönem olarak belirtir. C, B’nin devamı olarak gelişirken yeni özellikler kazandı.</p><p>Bu gelişimin önemli bir dönüm noktası 1973’te UNIX çekirdeğinin C ile yeniden yazılmasıydı. Böylece sistem yazılımı, yalnızca belirli bir işlemciye özgü komutlarla anlatılmak yerine C gibi daha genel bir dille yazılabilir hâle geldi. Bu, yazılımın başka makinelerde çalıştırılmasını kolaylaştırdı; elbette her programın hiçbir değişiklik yapmadan her makinede çalışacağı anlamına gelmiyordu.</p><h3>C dili nedir?</h3><p>C, farklı türde problemleri çözmek için kullanılabilen genel amaçlı bir programlama dilidir. Sistem yazılımlarında önemli bir yeri olsa da yalnızca işletim sistemi yazmak için tasarlanmamıştır. C dili için belirli bir donanıma ya da işletim sistemine bağlı olmadığını; dikkatle yazılan programların farklı sistemlere taşınabileceğini ifade edebiliriz.</p><p>İnsanların yazdığı C programı kaynak koddur. Derleyici bu kodu, işlemcinin çalıştırabileceği makine talimatlarına dönüştürür. C’nin bilgisayar mühendisliği açısından öğretici taraflarından biri de budur: İnsan için yazılmış bir çözüm ile donanımın çalıştıracağı talimatlar arasındaki bağı görünür kılar.</p><h3>Algoritma, programlama dilinden önce gelir</h3><p>C’yi öğrenmeye başlarken önce dilin kurallarına değil, çözmeye çalıştığımız probleme bakmak gerekir. Önce problemi çözme yöntemini, ardından bu yöntemi uygulayan programı düşünme yaklaşımını izlemeliyiz. Ayrıca algoritmik çözüm kurulurken verinin ne olduğu ve nasıl düzenlendiğinin de dikkate alınmasını vurgulayabiliriz.</p><p>Bir kâğıttaki isimler arasından belirli bir kişiyi aradığımızı düşünelim:</p><p>1. Listenin başındaki isimden başla.</p><p>2. Bu ismin aradığımız kişi olup olmadığını kontrol et.</p><p>3. Eşleşiyorsa aramayı bitir.</p><p>4. Eşleşmiyorsa sıradaki isme geç.</p><p>5. Listenin sonuna geldiysen kişinin listede olmadığını bildir.</p><p>Bu adımlar basit bir arama algoritmasıdır. Algoritma çözümün hangi adımlarla ilerleyeceğini anlatır; C ise bu çözümü bilgisayara aktarabileceğimiz dillerden biridir.</p><p>Burada küçük ama yararlı bir ayrım var: Algoritma, hangi adımları izleyeceğimizi; veri yapısı ise üzerinde çalıştığımız verilerin nasıl düzenlendiğini anlatır. Örneğimizde isimlerin listede tutulma biçimi verinin düzenidir; isimleri sırayla kontrol etme planı ise algoritmadır. Bu iki kavramın ayrıntıları sonraki konuların konusu, ama daha ilk günden aralarındaki farkı görmek programlamayı anlamayı kolaylaştırır.</p><h3>C nasıl yayıldı?</h3><p>1970’lerin başında geliştirilen C programlama dilinin akademik ve endüstriyel çevrelerde kabul görmesi, başlangıçta belirli kısıtlar nedeniyle yavaş bir süreç izlemiştir. Stephen Kochan’ın da vurguladığı gibi, 1970’lerin sonuna kadar Bell Labs dışındaki ticari C derleyicilerine erişimin sınırlı olması, dilin erken dönemdeki yayılımını daraltan temel etkenlerden biriydi. Buna karşın, UNIX işletim sisteminin kullanım alanının genişlemesi C’nin görünürlüğünü artıran en önemli katalizör oldu.</p><p>Dönüm noktası ise 1978 yılında Brian Kernighan ve Dennis Ritchie kaleme aldığı <em>The C Programming Language</em> kitabının yayımlanmasıyla gerçekleşti; bu eser, geniş kitleler için ilk yetkin başvuru kaynağını oluşturdu. Dennis Ritchie’nin aktardığı tarihsel süreç de C’nin ilk yıllarında UNIX ekosistemiyle sıkı bir bağ kurduğunu, zaman içinde farklı sistem mimarilerine uyarlanarak evrensel bir boyuta ulaştığını açıkça ortaya koymaktadır.</p><p>C’nin 1980’lerde ortaya çıktığı sıkça sanılabilir; oysa dil daha önce geliştirilmişti. 1980’ler, C’nin farklı sistemlerde yaygınlaştığı ve standartlaştırma çalışmalarının tamamlandığı dönemdi. ANSI standardı 1989’da onaylandı; ISO/IEC 9899:1990 standardı ise 1990’da yayımlandı.</p><h3>Yeni diller varken neden C kullanılıyor?</h3><p>C’nin önemi, her projede en iyi seçenek olmasından gelmiyor. Farklı diller farklı ihtiyaçlara göre seçiliyor. C’nin güçlü olduğu yerlerden biri, yazılımın işlemciye ve donanıma yakın çalışmasının gerektiği sistemler. Uzun yıllardır kullanılan C kodları, derleyiciler ve kütüphaneler de dili birçok proje için pratik bir seçenek hâline getiriyor. İşletim sistemleri ve gömülü sistemler, C’nin performans ve taşınabilirlik özelliklerinin önem kazandığı alanlar arasında sayılıyor.</p><p>Bu kullanım bugün de sürüyor. Linux çekirdeğinin C ile yazıldığı Linux belgelerinde açıkça belirtiliyor. Zephyr adlı gömülü sistem işletim sistemi ağırlıklı olarak C ile yazılmış ve C uygulamalarını destekliyor. SQLite veritabanı motoru da C ile geliştirilmiş.</p><p>C’nin donanıma yakınlığı geliştiriciye daha fazla kontrol sağlar; bunun karşılığında ayrıntılara daha fazla dikkat etmek gerekir. Bu nedenle “C her zaman daha hızlıdır” ya da “her proje C ile yazılmalıdır” demek doğru olmaz. Daha yararlı soru şudur: Projenin donanıma erişim, kaynak kullanımı, mevcut kod ve bakım ihtiyaçları nelerdir?</p><h3>C’yi bugün öğrenmek ne kazandırır?</h3><p>Bir bilgisayar mühendisi için C’nin değeri, her projeyi C ile yazma zorunluluğunda değil; yazılımın donanımla nasıl buluştuğunu daha görünür kılmasında yatar. Algoritmadan başlayıp derleyiciye, oradan işlemcinin çalıştırdığı talimatlara uzanan zinciri anlamaya yardımcı olur.</p><p>C’nin hikâyesi, yeni programlama dillerinin ortaya çıkmasının eskilerini otomatik olarak gereksiz kılmadığını gösteriyor. Bir dil, çözdüğü probleme uyduğu ve üzerine kurulan yazılım birikimi sürdüğü için yaşamaya devam edebilir. C’nin elli yılı aşan yolculuğu da böyle başladı: Önce bir problemi çözmek için, sonra çok daha geniş bir bilgisayar dünyasının parçası olarak.</p><h3>Kaynakça</h3><h3>Kitaplar</h3><p>· Kelley, Al ve Ira Pohl. <em>A Book on C: Programming in C</em>. 4. baskı. Addison-Wesley, 1998.</p><p>· Deitel, Paul ve Harvey Deitel. <em>C How to Program: With an Introduction to C++</em>. 8. Global baskı. Pearson, 2016.</p><p>· Kernighan, Brian W. ve Dennis M. Ritchie. <em>The C Programming Language</em>. 2. baskı. Prentice-Hall, 1988.</p><p>· Kochan, Stephen G. <em>Programming in C</em>. 4. baskı. Pearson, 2014.</p><p>· Çölkesen, Toros Rıfat. <em>Veri Yapıları ve Algoritmalar</em>. 13. basım. Papatya Bilim, 2023.</p><h3>Makaleler ve çevrimiçi kaynaklar</h3><p>· Ritchie, Dennis M. “The Development of the C Language.” 1993. <a href="https://www.nokia.com/bell-labs/about/dennis-m-ritchie/chist.html">Bell Labs</a></p><p>· Ritchie, Dennis M. “The Evolution of the Unix Time-sharing System.” 1979’da sunuldu; <em>AT&amp;T Bell Laboratories Technical Journal</em>’da 1984’te yayımlandı. <a href="https://www.nokia.com/bell-labs/about/dennis-m-ritchie/hist.html">Makale</a></p><p>· American National Standards Institute. “The Origin of ANSI C and ISO C.” <a href="https://blog.ansi.org/ansi/origin-ansi-c-iso-c/?amp=1">ANSI Blog</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2de1e07d80e9" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>