<?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 Ismet Erdogan on Medium]]></title>
        <description><![CDATA[Stories by Ismet Erdogan on Medium]]></description>
        <link>https://medium.com/@ismet.erdogn?source=rss-98778f2a90e3------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*MoGj_89uG8fhqTICggZ9fA.jpeg</url>
            <title>Stories by Ismet Erdogan on Medium</title>
            <link>https://medium.com/@ismet.erdogn?source=rss-98778f2a90e3------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 08:50:30 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@ismet.erdogn/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[LaTeX ile Blok Diyagram Çizimi]]></title>
            <link>https://medium.com/@ismet.erdogn/latex-ile-blok-diyagram-cizimi-218bec61c3fa?source=rss-98778f2a90e3------2</link>
            <guid isPermaLink="false">https://medium.com/p/218bec61c3fa</guid>
            <category><![CDATA[control-theory]]></category>
            <category><![CDATA[kontrol-mühendisliği]]></category>
            <category><![CDATA[kontrol-sistemleri]]></category>
            <category><![CDATA[control-system]]></category>
            <category><![CDATA[block-diagram]]></category>
            <dc:creator><![CDATA[Ismet Erdogan]]></dc:creator>
            <pubDate>Mon, 10 Feb 2025 21:02:14 GMT</pubDate>
            <atom:updated>2025-02-10T21:02:14.314Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F1Fy2fw74ISbeH_g6Raqmw.jpeg" /></figure><p><strong><em>Sinyaller ve Sistemler</em></strong><em>, </em><strong><em>Otomatik Kontrol Sistemleri</em></strong><em> vb. dersleri alan çoğu mühendislik öğrencisi </em><strong><em>blok diyagramlar</em></strong><em> ile karşılaşmıştır. Alt sistemleri bir blok olarak ele alıp birçok farklı alt sistemin birbiri ile nasıl etkileşime girdiğini gösteren </em><strong><em>bu görsel araç, basit olmasının yanı sıra oldukça etkilidir</em></strong><em>. Belki bu dersleri alırken, ödevlerini yaparken, blok diyagram çizmek istediniz ancak başvurduğunuz ilk çözümler sizi tatmin etmedi veyahut kitaplarda yer alan güzel ve kaliteli blok diyagramların nasıl yapıldığını merak ettiniz. İşte bu yazı </em><strong><em>kendi blok diyagramlarını basit bir şekilde LaTeX‘ten faydalanarak üretmek </em></strong><em>isteyenlere yardımcı olmak amacı ile yazıldı. Bu blok diyagramların çiziminde </em><strong><em>LaTeX </em></strong><em>ile çizim yapmaya olanak sağlayan </em><strong><em>TikZ </em></strong><em>paketi kullanılmaktadır..</em></p><h3>Başlarken</h3><p>Bu yazıda konunun bütünlüğünün sağlanmasının için konunun aşağıdaki sıra ile anlatılmasının uygun olduğu düşünülmüştür:</p><ul><li><strong>Blok Diyagramı Nedir?</strong></li><li><strong>Kısaca LaTeX</strong></li><li><strong>Çizim Yapmaya Olanak Sağlayan LaTeX Paketi: TikZ</strong></li><li><strong>TikZ ile Blok Diyagram Çizimi</strong></li><li><strong>Çeşitli Blok Diyagram Örnekleri</strong></li><li><strong>LaTeX ile Çizilen Blok Diyagramını Resim Formatına Dönüştürmek</strong></li><li><strong>Kapanış</strong></li></ul><p>Doğrudan çizimin nasıl yapıldığına bakmak isterseniz ilk başlıkları atlayıp okumaya gelişme bölümünden başlayabilirsiniz. Umarım bu yazı kitap kalitesinde blok diyagram çizimini size iyi bir şekilde anlatabilir ve kendi blok diyagramlarınızı çizmeniz için sizi cesaretlendirir!</p><p><em>“Un livre n’est excusable qu’autant qu’il apprend quelque chose.”,</em> Voltaire</p><p>Keyifli okumalar!</p><h3>Blok Diyagramı Nedir?</h3><p>Bu bölümde blok diyagramlar, kontrol mühendisliği perspektifi bakımından incelenecektir. Bu durumda bloklar aslında bir sistemi dolayısıyla onun matematiksel modelini temsil etmiş olacaktır.</p><figure><img alt="En basit blok diyagram örneği." src="https://cdn-images-1.medium.com/max/1024/1*ZPamBu8eAqU82o_0StgGNw.png" /></figure><p><strong>Newton’un Hareket Yasaları</strong>, <strong>Kirchoff’un Gerilim ve Akım Yasaları</strong> gibi fiziksel yasalar mekanik veya elektriksel sistemleri matematiksel olarak modellemeye <strong>(diferansiyel denklem olarak sistemi modellemeye)</strong> olanak verir. Bu sayede sisteme uygulanacak giriş işareti ve sistemin bu giriş işaretine karşılık üreteceği çıkış işareti yani sistem cevabı arasındaki ilişki bulunmuş olur (Diferansiyel denklemler dersinde doğal (öz) ve zorlanmış çözümü hatırladınız mı?). Lisans düzeyinde Otomatik Kontrol Sistemleri gibi derslerde genellikle doğrusal, zamanla değişmeyen, tek giriş-tek çıkış sistemlerle <em>“LTI System”</em> ilgilenilir, bu yazıda da bu tarz sistemlerle ilgilenilecektir.. Bu durumda sistemi modelleyen diferansiyel denklem de doğrusal, zamanla değişmeyen diferansiyel denklem olur. Bir dipnot geçmek gerekirse gerçek hayatta çoğu sistem böyle nitelendirilemez bu durumda doğrusallaştırma ve yapılabiliyorsa uygun basitleştirmelerle bu duruma indirgenebilir.</p><p>Bir önceki paragrafta sistemin diferansiyel denklemler ile modellenmesi anlatıldı. Sistemi matematiksel modelini ifade etmek için kullanılan bir başka yöntem ise <strong>Transfer Fonksiyonlarıdır</strong>. Doğrusal, zamanla değişmeyen bir diferansiyel denkleme<strong> Laplace Dönüşümü</strong> uygulanarak kolayca transfer fonksiyonuna dönüştürülebilir. Transfer fonksiyonları, sistem hakkında yorum yapmaya olanak verir bu bakımdan bir önceki matematiksel gösterime göre daha güçlüdür. Blok diyagramları ile transfer fonksiyonlarının birbiri ile ilişkisi oldukça yakındır. Her bir blok aslında bir transfer fonksiyonunu içerir. Transfer fonksiyonlarının özellikleri sayesinde blok diyagram kullanımı oldukça avantajlı bir hale gelir.</p><p>Bir diğer matematiksel model gösterimi ise <strong>Durum-Uzay Gösterimidir</strong>. Oldukça kuvvetli olan bu yöntemin kendisi ayrı bir ders hatta dersler dizisi olarak işlenen bir konu olduğundan ve bu yazının amacıyla çok örtüşmediğinden burada anlatılması tercih edilmemiştir.</p><p>Aşağıdaki şekilde sistem <strong><em>G(s)</em></strong> transfer fonksiyonu ile ifade edilmiştir. Kendisine <strong><em>u(t)</em></strong> giriş işareti uygulanmış ve <strong><em>y(t)</em></strong> çıkış işareti elde edilmiştir. Alttaki blok diyagramda ise <strong><em>G(s)</em></strong> transfer fonksiyonunun kendisi yazılmıştır. Bu haliyle iki türlü de gösterilebilir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AHrXAZk174zc8k7eXE6Y1g.png" /></figure><p>Aşağıda ise tipik bir kapalı çevrim kontrol sisteminin blok diyagramı yer almaktadır. 3 farklı alt sistemi 3 blok temsil etmektedir ve birbiri ile ilişkisi de aşağıdaki gibidir. Kontrol sistemlerine yabancı olanlar aşağıdaki açıklamalar yeterli olacaktır.</p><ul><li><strong><em>r(t)</em></strong>: Sistemin girişine uygulanan referans işaretini (sinyali) temsil eder.</li><li><strong><em>y(t)</em></strong>: Sistemin çıkış işaretini temsil eder.</li><li><strong>Kontrolör</strong>: İngilizcesi <em>“controller”</em> olan ve Türkçeye kontrolcü, kontrolör veya denetleyici gibi çevrilmekte olan bu sistem kontrol edilecek sistemin (tesisin) davranışını istenen davranışa dönüşmesini sağlayan dinamikleri ekleyen kısımdır. Kontrol mühendisliğinin amacı da bir sistemin davranışını istenilen hale (çeşitli performans isterlerini karşılamak, sistemi kararlı hale getirmek, kararlılığı artırmak vb.) getirmektir. Kontrol mühendisleri, kontrol edilecek sisteme ve performans isterlerine göre bu kontrolörleri tasarlar</li><li><strong>Tesis</strong>: İngilizcesi <em>“plant”</em> olan ve Türkçeye tesis olarak çevrilen bu sistem, <strong>kontrol edilecek sistemi</strong> temsil eder. Eyleyici<em> “actuator”</em> ile süreci <em>“process”</em> kendi içinde barındıran bu sistemin davranışı kontrolör ile istenen tarafa çekilir.</li><li><strong>Algılayıcı</strong>: Geri besleme yolunda yer alan bu sistem çıkış işaretini ölçen algılayıcının İngilizcesi ile “sensor” dinamiklerini temsil eder.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fFOOKiKA1QgUmm5FmsWOQA.png" /></figure><p>Aşağıda ise gündelik hayattan kapalı çevrim kontrol sistemlerinin blok diyagramlarına yer verilmiştir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s6cEua1kkPulImNv-utAaA.png" /><figcaption>Uçağın Yunuslama Açısının Kontrolüne ait bir Çevrim</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qe4MXdOt4vmDtOeyLIziEg.png" /><figcaption>Otomobillerde Yer Alan Seyir Kontrol Sisteminin Basitçe İfade Edilişi</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7Juihqzjm7Tl_UpLDAb8rg.png" /><figcaption>Kimyasal Bir Sürecin Sıcaklık Kontrolüne İlişkin bir Blok Diyagram</figcaption></figure><p>Bu konuda örnekler sınırsız, ancak vakit sınırlı olduğundan bir sonraki bölüme geçelim.</p><h3>Kısaca LaTeX</h3><p><a href="https://ctan.org/tex-archive/info/lshort/turkish?lang=en">Buradaki bağlantıdan</a> da indirilebilen <strong>Bekir Karaoğlu</strong> hocamız tarafından Türkçeleştirilmiş olan<em> “A (Not So) Short Introduction to LaTeX2e”</em> Türkçe adıyla <strong><em>“İnce bir LaTeX2e Elkitabı”</em></strong>nda <strong>LaTeX</strong> şöyle tanımlanmıştır: <em>“LaTeX yüksek baskı kalitesinde bilimsel ve matematiksel dokümanlar hazırlamaya çok uygun bir dizgi programıdır. Ayrıca, basit bir mektuptan komple bir kitaba kadar, diğer her türlü belge yazımında da kolaylık sağlar. LATEX dokümana biçim verirken daha kapsamlı olan TeX programını kullanır.”</em></p><p><strong>TeX</strong>, dijital bir dizgi programıdır, metin ve formülleri dizmeye yarar. Özellikle bilimsel ve teknik dokümantasyonlarda sayfa düzeni, yazı tipleri, dil ve metin yapısı gibi doküman ile ilgili tüm parametreleri yönetebilen bir programdır.</p><p><strong>LaTeX</strong> ise makale, konferans bildirileri, teknik raporlar, kitaplar hatta mektuplar için profesyonelce hazırlanmış şablonlar bulunduran bir makro paketidir.</p><p><strong><em>“İnce bir LaTeX2e Elkitabı”</em></strong>nda da ise <strong>TeX </strong>dizgiciye, <strong>LaTeX </strong>ise tasarımcıya benzetilmiştir. Ancak bunlar bir bilgisayar programı olduğundan yol gösterilmeye muhtaç olduğu da unutulmalıdır!</p><p><strong>LaTeX </strong>ile doküman yazımının kendisi de kendi içinde çok detaylı olduğundan ilgilenenler <strong><em>“İnce bir LaTeX2e Elkitabı”</em></strong><em>na</em><strong><em> </em></strong>başvurulabilir. Daha sonra çeşitli kaynaklara da yönelip kendi dokümanlarınızı yazmaya başlayabilirsiniz. Bu bölümde blok diyagram çiziminde de standart olarak kullanıldığı için çok az sayıda <strong>LaTeX </strong>komutu ile örnek bir doküman oluşturulacaktır.</p><p>LaTeX yazımına hızlıca başlamak için tarayıcı üzerinde çalışan <a href="https://www.overleaf.com/learn/how-to/Creating_a_document_in_Overleaf"><strong>Overleaf</strong> </a>kullanılabilir. Bilgisayarınızda tarayıcıya girmeksizin bi metin editörü, kod editörü gibi araçlarla doküman oluşturmak isterseniz ise <a href="https://www.latex-project.org/get/"><strong>bu bağlantıdan</strong></a> işletim sisteminize uygun bir <strong>TeX </strong>dağıtımını (<em>Live TeX</em>, <em>MiKTeX</em> vb.) indirebilir ve bilgisayarınızdan <strong>LaTeX </strong>komutları ile doküman oluşturmaya başlayabilirsiniz.</p><p>Örnek doküman oluşturma yolunda adım adım ilerleyecek olursak ilk örnek için en az sayıda <strong>LaTeX </strong>komutu ile doküman oluşturmamızı yarayan <strong><em>“İnce bir LaTeX2e Elkitabı”</em></strong>nda yer alan aşağıdaki örnek ile başlanabilir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/eabe20d99e809dfa27bcc1141e1cf376/href">https://medium.com/media/eabe20d99e809dfa27bcc1141e1cf376/href</a></iframe><p>Yukarıdaki programın komutlarını inceleyelim:</p><ul><li><strong>\documentclass{doküman tipi}</strong>: Ne tür bir doküman yazılacağı bu komut ile belirtilir. Burada makale<em> “article”</em> tipinde bir doküman yazılacağı belirtilmiş.</li><li><strong>\begin{document}</strong>: Artık dokümanının içeriği burada yazılmaya başlanmış olur. Doküman yazımında bu kısmın içinde <strong>LaTeX </strong>komutları kullanılır.</li><li><strong>\end{document}</strong>: Bu komut doküman yazımının bittiğini LaTeX’e bildirir.</li></ul><p>Buradaki 3 komut ile basit bir yazı bir sayfaya yazılabildi. Ancak makaleler, raporlar, kitaplar birçok kısımdan, bölümden, başlıktan, formülden ve sayfadan oluşurlar. Tüm bunları dizebilmek için daha fazla <strong>LaTeX </strong>komutuna ihtiyaç duyulur. Bu durumda bazı paketler kullanılması için çağrılabilir, içlerinden kullanılacak faydalı <strong>LaTeX </strong>komutları ile baskı kalitesinde, okunabilirliği yüksek dokümanlar yazılabilir.</p><p>Şimdi daha gerçekçi bir .tex dosyası örneğini inceleyelim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/befb66c5219be15e51777f27f3ccc270/href">https://medium.com/media/befb66c5219be15e51777f27f3ccc270/href</a></iframe><p>Bu sefer oluşturulan makale tipindeki doküman; yazar, başlık tanımlamaları, bölümlerinin belirtilmesi ve yazılması ile anlam kazandı. İşte <strong>LaTeX </strong>ile oluşturulan dokümanlar bu tipik yapı üzerinde LaTeX komutları ve metinler eklenerek oluşturulmaktadır. İlgili LateX komutunun ne iş yaptığı yorum satırı olarak bir üst satırına eklenmiştir.</p><p>Belki öncekinden farklı olarak <strong>\documentclass</strong> komutunun hemen sağına eklenmiş köşeli parantez dikkatinizi çekmiştir. Köşeli parantez içine eklenen parametreler ile ilgili doküman sınıfında değişiklik yapmaya olanak sağlamaktadır, bu kısma <strong><em>“İnce bir LaTeX2e Elkitabı”</em></strong>nda <strong>opsiyonlar </strong>ismi verilmiştir.</p><p>Yazının asıl konusu ile ilgili olan anlatılmadan geçilmemesi gereken bir diğer kısım ise <strong>paketlerdir</strong>. Temel <strong>LaTeX </strong>programının altından kalkamayacağı bazı istekleri ilgili paketleri kullanarak karşılayabilirsiniz. Bu işlere örnek vermek gerekirse farklı bir dil kullanımı, renkli yazı yazmak, grafik oluşturmak, <strong>şekil çizmek</strong> gibi işler örnek olarak verilebilir. Bir <strong>LaTeX </strong>paketi aşağıdaki komut ile çağrılır.</p><ul><li><strong>\usepackage[opsiyonlar]{paket}</strong></li></ul><p>Yazının asıl konusuna geçmeden Türkçe doküman yazımı ile alakalı örnek bir .tex dosyası yazmadan geçmemek faydalı olacaktır. Türkçe doküman yazımında bazı paketlerin kullanılması gerekecektir. Doğrudan aşağıdaki programı inceleyelim:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/011330ad7a910a19abe421a559747901/href">https://medium.com/media/011330ad7a910a19abe421a559747901/href</a></iframe><p>Bu dosya ile bir önceki dosya karşılaştırıldığında paket kullanımı göze çarpmaktadır. Bu paketler ile Türkçe doküman yazmak mümkün hale gelmiştir, şimdi sırasıyla paketlerin işlevine bakalım:</p><ul><li><strong>\usepackage[turkish]{babel}</strong>: <strong>LaTeX’</strong>in otomatik olarak ürettiği başlıkları (İçindekiler başlığı, tarih yazısı vb.) Türkçeştirilir.</li><li><strong>\usepackage[utf8]{inputenc}</strong>: Türkçe’deki aksanlı ve kuyruklu harfleri dizebilmeye olanak sağlar.</li><li><strong>\usepackage[T1]{fontenc}</strong>: Dokümandaki Türkçe hecelemenin doğru yapılabilmesi için kullanılır bu sayede uygun noktalarda yeni satıra geçer.</li></ul><p>Dosyanın diğer kısımları bir önceki dosya ile benzer yapıdadır, yalnızca içerik değişmiştir ve bölümler yeni bir sayfada başlatılmıştır.</p><p><strong>LaTeX </strong>ile doküman yazımı derya deniz ancak yazının asıl konusu için şimdilik bu kadarı yeterli. Artık bir sonraki bölüme ilerlenebilir!</p><h3>Çizim Yapmaya Olanak Sağlayan LaTeX Paketi: TikZ</h3><p><a href="https://tikz.dev/"><strong>TikZ Paketi</strong></a>, yazmış olduğunuz dokümanda çeşitli şekilleri (çizgi, üçgen, dikdörtgen, daire veya sizin kendi tanımlamış olduğunuz şekil) çizmenize olanak sağlayan <strong>TeX </strong>komutlarını kullanıcıya sunar.</p><p><strong>TikZ </strong>ismini ise GNU<em> “GNU’s Not Unix”</em> isminin isimlendirmesine benzer bir şekilde Almanca <em>“</em><strong><em>TikZ </em></strong><em>ist kein Zeichenprogramm”</em> kelime grubunun baş harflerinden almıştır. Türkçesi <em>“</em><strong><em>TikZ, </em></strong><em>bir çizim programı değildir”</em> olan bu cümle aslında kendi çalışma mantığını açıklamaktadır: <em>Microsoft Paint</em> veya <em>Adobe Illustrator</em> gibi bir çizim programı olmadığını sadece kod yazarak (programlanarak) çizim yaptığına vurgu yapılmaktadır.</p><p><strong>Öğretmenler</strong>, <strong>TikZ </strong>ile kaliteli şekiller içeren geometri, trigonometri, veri yapıları, istatistik veya optik gibi görselliğin yoğun olduğu konularda ders notları, ödevler ve sınavlar hazırlayabilir. <strong>Yazarlar</strong>, kitaplarında ilgili konularda şeklin gerektiği her noktada <strong>TikZ</strong>’den faydalanabilir. <strong>LaTeX </strong>kullanarak ödev/laboratuvar raporu veya bitirme tezlerini yazan <strong>öğrenciler, TikZ</strong>’i kullanarak kendi şekillerini istedikleri gibi çizebilirler. Konu ile alakalı araştırma yaparken karşılaştığım bir başka paketten de burada bahsetmek istiyorum: <a href="https://ctan.org/pkg/circuitikz?lang=en"><strong>CircuiTikZ</strong></a>. Bu paketi de özellikle <strong>elektrik-elektronik vb. mühendisliklerde okuyan öğrenciler</strong>, dokümanlarına çeşitli elektrik devrelerini çizmek amacı ile kullanabilir (dipnot olarak <strong>TikZ </strong>paketi içinde <a href="https://tikz.dev/library-circuits"><strong>circuits </strong></a>kütüphanesi de bu işlevle kullanılabilir. Ancak ikisi arasında bir karşılaştırma yapmam doğru olmayacaktır.).</p><p><strong>TikZ </strong>birçok şeyi yapmaya olanak sağladığından öğrenme süreci de uzun sürebilir ancak çizmek istediğiniz spesifik şeyin nasıl çizildiğini kavrayıp kendi dokümanlarınızda kullanabilirsiniz. Bu yazı, <strong>TikZ </strong>ile blok diyagram çizimi üzerinedir ve bunu sağlayan kodları açıklamaya çalışacaktır. <strong>TikZ </strong>ile ilgili <a href="https://tikz.dev/tutorials-guidelines"><strong>öğretici rehberlere</strong></a> kendi sitesinden ulaşılabilir.</p><h3>TikZ ile Blok Diyagram Çizimi</h3><p>Artık bu yazının da asıl konusu olan blok diyagram çizimine burada başlayabiliriz.</p><p>Bu bölümde çizilecek blok diyagramlar münferit olarak çizilecektir. Yani amaç; <strong>LaTeX </strong>ile yazılan bir makale, rapor gibi yazıların içine yerleştirir gibi değil sadece blok diyagramı elde etmektir. Daha sonraki bölümlerde elde edilen blok diyagramın arkası ister şeffaf ister renkli biçimde resim olarak çıktısının nasıl alınacağı da gösterilecektir (<strong>LaTeX</strong> ile yazılan doküman <em>.pdf</em> formatında olduğundan çizilen blok diyagramın resim formatına çevrilmesi daha uygun olacaktır.).</p><p>Yukarıdaki sebepten dolayı doküman oluştururken doküman tipini ayarlayan komut öncekilerden farklı olarak <strong>\</strong><a href="https://ctan.org/pkg/standalone?lang=en"><strong>documentclass{standalone}</strong></a> olarak ayarlanacaktır. <a href="https://github.com/MartinScharrer/standalone">standalone paketinin kendi GitHub sayfasında</a> da işlevi şu şekilde anlatılmıştır: <em>“A class and package is provided which allows TeX diagrams or other TEX code to be compiled standalone or as part of a main document.”. </em>Bu doküman tipi sayesinde oluşturulan belgenin boyutu çizilecek blok diyagramın boyutunda (bunun üzerinde bir de eklenmek istenen kenar boşluğu boyutunda) olacaktır. Yani oluşan belge, sadece blok diyagram için oluşmuş olacaktır. Oluşturulan blok diyagramı bu halden kolayca resim formatına çevirebilir; başka bir belgenize (<em>Microsoft Word</em> vb.), sunumlarınıza ekleyebilirsiniz. Bu yazıda şu ana kadar görmüş olduğunuz blok diyagramlar bu yolla elde edilmiştir.</p><p>Aşağıdaki girişi <strong><em>u(t)</em></strong>, çıkışı <strong><em>y(t)</em></strong> olan <strong><em>G(s)</em></strong> transfer fonksiyonu ile temsil edilen sisteme ait bir blok diyagramının kendisi ve onu çizen <strong>LaTeX</strong> dosyası yer almaktadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Z7REnGicwZBjj9r6hh5E4w.png" /><figcaption>latex_4.tex dosyası ile oluşturulmuş blok diyagram</figcaption></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3b7905f3c372dc7432836d4532d1558a/href">https://medium.com/media/3b7905f3c372dc7432836d4532d1558a/href</a></iframe><p>Şimdi latex_4.tex dosyasında ilk 3 <strong>TikZ </strong>komutunu inceleyelim:</p><ul><li><strong>\usepackage{tikz}: TikZ </strong>paketinin çağrılmasını ve komutlarının kullanılmasını sağlar.</li><li><strong>\usetikzlibrary{shapes,arrows}: </strong>TikZ kütüphanelerini çağırır.<br>- <a href="https://tikz.dev/library-shapes"><strong>shapes</strong></a>: Aslında çağrılmasına gerek yoktur, çünkü blok diyagram çiziminde kullanılan dökdörtgen <em>“rectangle”</em>, çember <em>“circle”</em> ve koordinat <em>“coordinate”</em> gibi şekiller her zaman tanımlıdır.<br>- <a href="https://tikz.dev/tikz-arrows"><strong>arrows</strong></a>: Bloklar arası oklar için gereklidir. İçinde bir çok farklı ok mevcuttur ve birçok parametre değiştirilebilmektedir.</li></ul><p>Şimdi ise <strong>\tikzstyle{}</strong> komutları incelenecektir. Bu komut TikZ’de özel stiller/şekiller tanımlar. Daha sonra birçok kez kullanılarak kod tekrarından kaçınılmış olur.</p><ul><li><strong>\tikzstyle{block} = [draw, fill=blue!20, rectangle, <br> minimum height=3em, minimum width=6em]: <br></strong>- Dikdörtgen şeklinde şekil çizer.<br>- İçini %20 doygunlukta mavi rengi ile doldurur.<br>- Şeklin boyutlandırması ise <em>em </em>ölçü birimi ile yapılmıştır bu ölçü birimi font büyüklüğünü ifade eder. Bu sayede kullanılan fonta uyarlı bir şekilde boyutlandırma yapılabilmektedir. Font yüksekliğinin 3 katında bir yüksekliğe, font genişliğinin 6 katında bir genişliğe sahip dikdörtgen oluşturulacaktır. Eğer içine yazılacak yazı bu ölçüleri geçerse dikdörtgen genişlemeye başlayacaktır. Bu girilen ölçüler minimum büyüklüğü ifade eder.</li><li><strong>\tikzstyle{input} = [coordinate]: </strong>Koordinat “coordinate” tipinde “input” isminde bir stil tanımlar. Koordinat tipi görünmez bir düğümdür <em>“node”</em>, bir şekil değildir, bir noktayı temsil eder.</li><li><strong>tikzstyle{output} = [coordinate]: </strong>Koordinat “coordinate” tipinde “output” isminde bir stil tanımlar.</li></ul><p>Buraya kadar çizimin yapılması için gerekli paket ve kütüphaneler çağrıldı, çizimde kullanılacak stiller tanımlandı.</p><ul><li><strong>\begin{tikzpicture}[auto, node distance=2cm, &gt;=latex’]: </strong>Bu komut ile TikZ çizim ortamı başlatılır.<strong><br>- auto: </strong>Bağlantı çizgisi (ok) üzerine eklenen metinlerin otomatik olarak uygun konuma yerleşmesini sağlar.<strong><br>- node distance=2cm: </strong>Varsayılan düğüm <em>“node”</em> mesafesini 2cm yapar. Yani belirtilmediği takdirde bloklar ve ok başlangıç noktaları arasındaki mesafe 2cm olacaktır.<strong><br>- &gt;=latex’: </strong>Bu komut, ok uçlarının <strong>LaTeX’e </strong>özgü görünümünü kullanır</li></ul><p>Çizim ortamı başlatıldı, artık blok diyagram çizimi başlayacaktır.</p><p><strong>\node</strong> komutu ile öğelerin (metin, şekil, görünmeyen öğeler <em>“coordinate”</em>) eklenmesini sağlar. Daha önce tanımlanan stiller (blok, giriş, çıkış) bu komut yardımı ile eklenecektir. Oluşturmak istediğiniz blok diyagramda kaç tane düğüm kullanacağınızı öğrenme aşamasında kestiremiyor olabilirsiniz. Çizge<em> “graph” </em>teorisinde çizgeleri düşünebilirsiniz, sisteminizde işaretler <em>“signals”</em> bir bloktan bir bloğa ok yardımı ile akıyor; çizgede ise bir düğümden bir düğüme kenar (bağıntı) üzerinden gidiliyor. Bu durumda her bir bloğunuz bir düğüm olacaktır. <strong>Peki bizim blok diyagramımızda tek bir bloktan oluşuyor neden 3 düğüm kullanıyoruz?</strong> Bu sorunun cevabı ise çizimi yapacak komutların sizden çok şey beklemesidir. Bu durumda bloğun girişine uygulanan işareti gösteren okun başlangıç noktasının da bir düğüm olarak tanımlanması gerekir; çıkış okunun ise sonlanacağı kısmın düğüm olarak belirtilmesi gerekir. Kafanız karıştı ise (bu benim suçum) üzülmeyin; bu yazıdaki örneklerle ve kendiniz çizdikçe daha iyi anlayacaksınız.</p><ul><li><strong>\node [input] (giriş) {}: giriş </strong>isminde nokta (boş bir koordinat noktası) oluşturur.</li><li><strong>\node [block, right of=giriş, node distance=3cm] (sistem) {$G(s)$}: sistem </strong>isminde, <strong>giriş </strong>noktasının 3 cm sağında, içinde <em>“G(s)” </em>yazan blok oluşturur.</li><li><strong>\node [output, right of=sistem, node distance=3cm] (çıkış) {}: çıkış </strong>isminde, <strong>sistem </strong>bloğunun 3 cm sağında<strong> </strong>nokta (boş bir koordinat noktası) oluşturur.</li></ul><p>Düğümler (koordinat noktaları ve blok) oluşturuldu. Şimdi bunların <strong>\draw</strong> komutu ile bağlanması gerekmektedir. <strong>[-&gt;]</strong> kısmı ok tipini belirler; bu tip bir ucu küt bir ucu ok şeklini temsil eder.</p><ul><li><strong>\draw [-&gt;] (giriş) -- node {$u(t)$} (sistem); </strong>Aslında <strong>\draw [-&gt;] (giriş) — (sistem)</strong> kodu <strong>giriş </strong>noktasından <strong>sistem </strong>bloğuna okun çizilmesi için yeterlidir. <strong>node {$u(t)$}</strong> kısmı ile ok üzerine <em>“u(t)”</em> metni girilmiş olur.</li><li><strong>\draw [-&gt;] (sistem) -- node {$y(t)$} (çıkış); sistem </strong>bloğundan çıkış noktasına üzerinde <em>“y(t)”</em> yazan bir ok çizer.</li></ul><p>Blok diyagramın tasarımı bitirildi, artık çizim ortamının paydos etmesi gerek!</p><ul><li><strong>\end{tikzpicture}:</strong> Çizim ortamını sonlandırır.</li></ul><p>İlk blok diyagram çizimi başarıyla tamamlandı!</p><p>Bir blok içeren bir diyagramı artık çizebiliyoruz, ancak bizim blok diyagramlarımız birden fazla bloktan oluşmakta ve kapalı çevrim kontrol sistemlerinde geri besleme hattı üzerinden işaretlerin farkının alınması yaygındır.</p><p>Aşağıda tipik bir kapalı çevrim sistemi gösteren blok diyagramın kendisi ve onu çizen <strong>LaTeX </strong>komutları yer almaktadır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C7T2kb0oL0A5wvD2Jo0LsQ.png" /></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5226593493840a7c25f2a4bc05d7457a/href">https://medium.com/media/5226593493840a7c25f2a4bc05d7457a/href</a></iframe><p>Kapalı çevrim kontrol sistemin blok diyagramını çizen bu dosyaya bakıldığında bir önceki dosyaya göre satır sayısında büyük bir artış olmadığı gözlemlenebilir.</p><p>Bu blok diyagramı çizmek için yapılan ilk şey <strong>\tikzstyle{sum} = [draw, fill=blue!20, circle]</strong> komutu ile blok diyagramların vazgeçilmezi toplam elemanını <em>“summing point” </em><strong><em>tanımlamak oldu.</em></strong></p><p>Bu toplam elemanı, <strong>\node [sum, right of=giriş, node distance=1.5cm] (toplam) {}</strong> komutu ile <strong>giriş</strong> noktasının 1.5 cm sağına eklenerek blok diyagrama dahil oldu.</p><p>Ardından eklenen <strong>kontrolör </strong>(<strong>toplam </strong>elemanının sağına) ve sistem (<strong>kontrolör </strong>bloğunun sağına) blokları art arda diyagrama dahil edilmiştir. Mesafeler blok diyagramı çizen kodu yazan kişi tarafından estetik sebeplere göre değiştirilebilir.</p><p>Aşağıdaki komutlar ile <strong>toplam </strong>elemanına giren işaretlerin toplanacağını veya çıkarılacağını belirtmek amacıyla eklenmiştir. İçindeki mesafe, yazı tipi büyüklüğü vb. şeyler tasarımcı tarafından değiştirilebilir.</p><ul><li><strong>\node at ([yshift=0.2cm]toplam.west) {\tiny $+$}</strong></li><li><strong>\node at ([yshift=-0.2cm]toplam.east) {\tiny $-$}</strong></li></ul><p>Öncekine göre farklı olan ve bahsedilmesi gereken<strong> \draw</strong> komutlarını da inceleyelim:</p><ul><li><strong>\draw [-&gt;] (sistem) -- node [name=y]{$y(t)$} (çıkış)</strong>: Bu komutta farklı olan kısım <strong>node [name=y]{$y(t)$} </strong>kısmıdır, köşeli parantez içine <em>name </em>parametresi ile düğüme isim atanmıştır. <strong>y </strong>ismindeki bu düğüm geri besleme hattının çıkış noktası olarak kullanılacaktır. Yani bu düğüm blok diyagramların bir diğer öğesi olan <strong>dallanma noktası</strong> <em>“pick-off point”</em> temsil etmektedir.</li><li><strong>\draw [-&gt;] (y) -- ++(0,-2) -| (toplam)</strong>: Bu komut ile dallanma noktasından (<strong>y </strong>ismindeki düğüm) <strong>toplam </strong>elemanına giden geri besleme hattının çizilmesini sağlar. Ancak bunun yapılabilmesi için okun önce aşağıya indirilmesi gerekir: <strong>++(0,-2) </strong>kısmı oku 2 cm aşağı indirir. Ardından bu kısımdan <strong>toplam</strong> elemanına hat devam eder. Ancak standart iki tire işareti (--) ile ok çekilirse köşeli görünüme sahip olmaz bu sebeple <strong>-| </strong>ile <strong>toplam </strong>elemanına gitmesi sağlanır. — ile önce yatay, | işareti ile sonrasında dikey olarak <strong>toplam </strong>elemanına geri besleme hattı ulaştırılır.</li></ul><p>Bu sayede tipik bir kapalı çevrim sistemin blok diyagram çizimi de tanımlandı! Bu başlığı daha fazla uzatmayalım ve farklı blok diyagramları ve onların kodlarını inceleyelim.</p><h3>Çeşitli Blok Diyagram Örnekleri</h3><p><strong>Köklerin geometrik yer eğrisi</strong> konusu anlatılırken aşağıdaki blok diyagram mutlaka karşılaşmışsınızdır. Sorusu ise şöyle olabilir: <em>K kazancına bağlı kapalı çevrim sistemin köklerinin geometrik yer eğrisini çiziniz…</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VSCHwxnzr1UNGxOuPzfCkw.png" /><figcaption>Tipik Bir Köklerin Geometrik Yer Eğrisi Sorusunun Blok Diyagramı</figcaption></figure><p>Önceki bölümde çizilen blok diyagramında sadece blokların ve giriş ,çıkış işaretlerinin üzerindeki içindeki yazıyı değiştirerek bu blok diyagramı elde edebiliriz. Bu blok diyagramı çizen <strong>LaTeX </strong>komutları aşağıdaki gibidir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/98793abc3b1e2a51def5247deb523743/href">https://medium.com/media/98793abc3b1e2a51def5247deb523743/href</a></iframe><p><strong>kontrolör</strong> bloğunun blok diyagrama eklendiği <strong>\node [block, right of=kontrolör, node distance=3cm] (sistem) {$\frac{1}{s(s+1)(s+2)}$}</strong> komutunda <strong>\frac{1}{s(s+1)(s+2)</strong> komutu sayesinde kesirli biçimde matematiksel ifade yazılabilmektedir.</p><p>Bu sefer geri besleme hattında <strong><em>H(s)</em></strong> transfer fonksiyonu ile gösterilen bir algılayıcı dinamiğine sahip bir sistemin blok diyagramını çizecek <strong>LaTeX </strong>komutlarını yazalım. Blok diyagram ve kodlar aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7-B_oj93QPOVt0uh8ejclA.png" /><figcaption>Geri Besleme Hattında Algılayıcı Dinamiğine Sahip Bir Kapalı Çevrim Sistemin Blok Diyagramı</figcaption></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dee0bc33ada7a547ca94611990361d0b/href">https://medium.com/media/dee0bc33ada7a547ca94611990361d0b/href</a></iframe><p><strong>algılayıcı </strong>bloğu blok diyagrama <strong>\node [block, below of=sistem, node distance=1.5cm] (algılayıcı) {$H(s)$}</strong> kodu ile dahil edilmiştir. Öncekilerden farklı olarak <em>“below of”</em> parametresi ile sistem bloğunun (<em>“distance”</em> parametresi ile 1.5 cm) altına konumlandırılmıştır.</p><p>Daha sonra aşağıdaki komutlar ile geri besleme hattı tamamlanmıştır. Dikkat edilirse bu sefer geri besleme hattını 2 komut ile oluşturduk.</p><ul><li><strong>\draw [-&gt;] (y) |- (algılayıcı)</strong></li><li><strong>\draw [-&gt;] (algılayıcı) -| (toplam)</strong></li></ul><p>Peki <strong>algılayıcı </strong>bloğunu geri besleme hattının tam ortasına yerleştirmek istersek neler yapılabilir? Birçok yöntem kullanılabilir tabii ki! Bir tanesini burada inceleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*65ky9Xobbx2WhmUdr2F7dw.png" /><figcaption>Geri Besleme Hattında Algılayıcı Dinamiğine Sahip Bir Kapalı Çevrim Sistemin Blok Diyagramı (Algılayıcı Ortalanmış)</figcaption></figure><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/6932551e9b61ba4ed7c16158fdcc3f0b/href">https://medium.com/media/6932551e9b61ba4ed7c16158fdcc3f0b/href</a></iframe><p>Bu ortalama işlemini yapmak için kritik bir kullanılan kritik komutu inceleyelim:</p><ul><li><strong>\node [coordinate, right of=kontrolör, node distance=1.5cm] (orta_nokta) {}</strong>: <strong>orta_nokta </strong>isminde, koordinat <em>“coordinate” </em>tipinde bir düğüm oluştrur ve onu kontrolör bloğunun 1.5 cm sağına yerleştirir. Bu düğümü bir <strong>yardımcı düğüm</strong> <em>“dummy node”</em> olarak düşünebilirsiniz. Çıktıda görülmeyecek ama <strong>algılayıcı </strong>bloğu bu düğüm sayesinde hizalanacaktır.</li><li><strong>\node [block, right of=orta_nokta, node distance=1.5cm] (sistem) {$G(s)$}</strong>: <strong>sistem </strong>bloğunu <strong>orta_nokta </strong>düğümünün 1.5 cm sağına yerleştirir.</li><li><strong>\node [block, below of=orta_nokta, node distance=1.5cm] (algılayıcı) {$H(s)$}</strong>: <strong>algılayıcı </strong>bloğunu <strong>orta_nokta </strong>düğümünün 1.5 cm altına yerleştirir.</li></ul><p>Diğer komutlar ise okların çizildiği komutlardır.</p><p>Şimdi ise <strong>İç Model Kontrol</strong> <em>“Internal Model Control”</em> yapısına ait bir blok diyagram çizelim. İç model kontrol yapısı ismini kontrolörde süreç modelinin tersinin yer almasından dolayı gelir. Süreç kontrolü uygulamalarında sıklıkla kullanılır. Biz burada bu kontrol tekniği ile değil onun blok diyagramı ve çizimi ile ilgileneceğiz.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PB0z7M4g6ZZqmInka-v9kg.png" /><figcaption>İç Model Kontrol Yapısı</figcaption></figure><p>Bu diyagramı çizen <strong>LaTeX</strong> komutları ise aşağıdaki gibidir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/07b11c3aeb5cfe358c509da2bd598804/href">https://medium.com/media/07b11c3aeb5cfe358c509da2bd598804/href</a></iframe><p>Bu sefer oluşturulan <strong>orta_nokta </strong>düğümü bir yardımcı düğüm <em>“dummy point” </em>olarak kullanılmadı, bir <strong>dallanma noktası</strong> olarak kullanıldı. Kodun kalan kısımları önceki bölümlerle aynı mantıkla geliştirilmiştir.</p><p>Bu kısımda ise <strong>Smith Öngörücüsü</strong> yapısına ait bir blok diyagram ve onu çizen <strong>LaTeX</strong> komularına yer verilecektir. <strong>Smith Öngörücüsü</strong>, ölü zaman içeren sistemlerin ölü zamanına dikkate almaksızın kontrolör tasarlanmasına imkan verir. Ölü zamanlı sistemlerin kontrolünde kullanılan yöntemlerden biridir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VupLiX57Jy43Ve0UFuCdxQ.png" /><figcaption>Smith Öngörücüsü Yapısı</figcaption></figure><p>Bu diyagramı çizen <strong>LaTeX</strong> komutları ise aşağıdaki gibidir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/4186b8f711ba0e7dd677b237122e9bf9/href">https://medium.com/media/4186b8f711ba0e7dd677b237122e9bf9/href</a></iframe><p>Son bir örnek olarak <strong>bozucu ve gürültünün de dahil edildiği tipik bir kapalı çevrim kontrol sisteminin</strong> blok diyagramını inceleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*spFZsOO_u-W9V_p6JHm_tw.png" /><figcaption>Kapalı Çevrim Sisteme Etki Eden Bozucular ve Gürültünün Blok Diyagram Gösterilmesi</figcaption></figure><p>Görüldüğü üzere artan toplam elemanları, metinler (bozucu, gürültüler, toplam elemanlarının işaretleri) koddaki düğüm sayısını artıracaktır. Bu diyagramı çizen <strong>LaTeX </strong>komutları aşağıdaki gibidir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/85e73afe3f38a3d7cc3f3d61f61f4343/href">https://medium.com/media/85e73afe3f38a3d7cc3f3d61f61f4343/href</a></iframe><p>Görüldüğü üzere uzun bir kod bizi karşılamaktadır. Bu kadar uzun olmasının sebebi benim bu çizime olan yaklaşımımdan kaynaklanabilir. Kendi yaklaşımlarınızı yorumlarda paylaşmaktan çekinmeyin!</p><p>Aşağıdaki kod parçasında da gösterildiği gibi bozucuları <em>“input” </em>stilinde <em>“coordinate” </em>tipinde düğümü olarak düşündüm ve toplama bloklarının yukarısına yerleştirdim. O düğümlerin üzerine de metin eklemek amacıyla düğümler yerleştirilmiştir.</p><pre>% Bozucuların ok kısmı ve metin kısmı için düğümleri oluştur ve yerleştir<br>\node [input, above of=toplam2, node distance=1cm] (giriş_bozucusu) {};<br>\node [above of=giriş_bozucusu, node distance=0.3cm] {\scriptsize{giriş bozucusu}};<br>\node [input, above of=toplam3, node distance=1cm] (çıkış_bozucusu) {};<br>\node [above of=çıkış_bozucusu, node distance=0.3cm] {\scriptsize{çıkış bozucusu}};</pre><p>Bu noktada gürültüyü ekleyecek toplam elemanını neden yerleştirilmediği aklınıza gelebilir. Açıkçası kodu yazarken çıkışa yeni bir düğüm <em>“dummy node”</em> ekleyip onun bağlantılarını yapmanın daha uğraştırıcı olduğunu düşündüm. Bu sebeple aşağıdaki özellikten faydalandım:</p><pre> \draw [-&gt;] (toplam3) -- node [name=y]{$y(t)$} (çıkış);</pre><p>Daha önce de bahsedilmiş olan bu komutta y ismi verilmiş olan düğümden faydalandım. Ancak bu düğüme göre gürültüyü toplayan toplam elemanını yerleştirebilmek için komutun bu <strong>\draw </strong>komutundan sonra çağrılması gereklidir, aksi takdirde y düğümünü tanıyamayacaktır. Bu yüzden gürültüyü ekleyen toplam bloğu ve gürültüyle alakalı işlemler <em>latex_11.tex</em> dosyasında en son yapıldı.</p><p>Kodun kalan kısımları önceki yapılan örneklerden çok da farklı değildir, bu komutlar ile bir blok diyagramını daha başarıyla çizdik!</p><p>Örnekler çoğaltılabilir, diyagramlar geliştirilebilir: ayrık zamanlı sistemlerde çalışmak için farklı stiller tanımlanabilir (örnekleyici, tutucu, dönüştürücü vs.), renklerle alakalı oynamalar yapılabilir, veya bu yazıda kullanılan stiller (blok, toplam elemanı vb.) geliştirilebilir. Ancak şimdiye kadar verilen örnekler de yazının amacı bakımından yeterli olacaktır, o yüzden burada duralım ve bir sonraki başlık ile devam edelim.</p><h3><strong>LaTeX ile Çizilen Blok Diyagramını Resim Formatına Dönüştürmek</strong></h3><p><strong>TikZ </strong>paketinin sağlamış olduğu <strong>LaTeX </strong>komutları ile çizilen bu blok diyagramlar (başka şekiller de olabilir) <strong>LaTeX</strong> ile yazdığınız dokümanınızda kalmak zorunda değil, çizilen bu blok diyagramlar resim formatında dışarıya aktarılabilir. Bu sayede herhangi bir sunumda, internet sitesinde, Microsoft Word belgesinde vb. platformlarda kullanılabilir bir hale gelir. Bu yazıda da görmüş olduğunuz tüm blok diyagramlar <strong>LaTeX </strong>ile oluşturulan .<em>pdf</em> formatındaki dokümanın resim formatında (.<em>png</em>) dışarı aktarılması/dönüştürülmesi ile oluşturuldu.</p><p>Oluşan .pdf formatındaki dokümanı .png formatında bir resme dönüştürmek için <a href="https://imagemagick.org/index.php"><strong>ImageMagick</strong></a> isminde açık kaynaklı bir yazılım kullanılır: <em>Linux</em>, <em>Windows </em>ve <em>macOS </em>gibi işletim sistemlerinde çalışan bu yazılım kullanıcılara sunduğu komut satırı arayüzü <em>“command-line interface” </em>ile resim düzenleme, dönüştürme gibi işleri gerçekleştirmektedir.</p><p>Sunulan komut satırı arayüzünde <a href="https://imagemagick.org/script/convert.php"><strong>convert</strong></a> komutu ile .pdf formatındaki doküman, .png formatındaki resme dönüştürülebilmektedir. Aşağıda yer alan, terminale yazılacak kod ile bu dönüşüm işlemi gerçekleştirilir.</p><pre>convert -density 720 -background transparent -flatten output.pdf blok-diyagram.png</pre><p>Yukarıdaki kod <strong>output.pdf</strong> dosyasından<strong> blok-diyagram.png</strong> dosyasını üretir. Ayrıca 3 parametre girişmiştir:</p><ul><li><a href="https://imagemagick.org/script/command-line-options.php#density"><strong>density</strong></a>: Bu parametre ile üretilecek görüntünün çözünürlüğü ayarlanır. Birimi (eğer değiştirilmemişse) inç başına düşen nokta sayısıdır <em>“dots per inch”</em> (DPI). Bu parametre girilmezse 72 DPI olarak ayarlanır. Yüksek kaliteli resim elde etmek için 720 DPI kullanılmıştır. İsteğe göre değiştirilebilir.</li><li><a href="https://imagemagick.org/script/command-line-options.php#background"><strong>background</strong></a>: Dönüştürülecek resmin arka plan rengini ayarlamak için kullanılır. <em>“transparent”</em> argümanı ile oluşturulan blok diyagramının arka planının şeffaf olması sağlanır. Eğer bu parametre girilmezse arka plan beyaz olarak ayarlanır. Resimlerin kullanılacağı yere göre bu parametrenin girilmesi gereklidir. Örneğin bu <strong>Medium </strong>yazısında blok diyagramların arka planının beyaz olması tercih edildi, ancak bir beyaz arka plana sahip olmayan bir sunumda kullanılacak olsaydı şeffaf tercih edilebilirdi.</li><li><a href="https://imagemagick.org/script/command-line-options.php#flatten"><strong>flatten</strong></a>: Resme dönüştürme aşamasında <em>.pdf</em> dokümanındaki katmanları tek bir katmana indirir.</li></ul><p>Şu ana kadar anlatılanlar resme dönüştürme sürecinin gerçekleştiğidir. <strong>LaTeX’i</strong> kendi işletim sistemlerinde kullanan (<em>MiKTeX</em>, <em>TeX Live</em> vb. dağıtımlarla) sistemlerinde kullanan kişilerin <strong>ImageMagick </strong>programını da indirerek bu işlemi gerçekleştirebilirler.</p><p><strong>LaTeX</strong>’i <strong>Overleaf </strong>üzerinden kullananlar bu dönüştürme işlemini <strong>Overleaf </strong>ortamında kolayca halledebilir. Bunun için <em>main.tex</em> dosyasının bulunduğu klasörde uzantısız <a href="https://www.overleaf.com/learn/latex/Articles/How_to_use_latexmkrc_with_Overleaf#:~:text=What%20is%20a%20latexmkrc%20file,the%20final%20typeset%20PDF%20file."><em>latexmkrc</em></a><em> </em>isminde bir dosya oluşturulur.</p><p>Bu oluşturulan dosyanın içine aşağıdaki kod girilir.</p><pre>END {system(&#39;convert -density 720 -background transparent -flatten output.pdf blok-diyagram.png&#39;); }</pre><p>Dosyaya bu kod girilip kaydettikten sonra projenin yeniden derlenmesi gereklidir. Ancak derledikten sonra ekranınızda yine kod editörü ve .<em>pdf </em>dokümanınız olacaktır, dönüştürülen resme ulaşmak için yeniden derleme butonunun yanında yer alan <em>kayıtlar “logs” ve diğer dosyalar</em> sekmesine tıklamak ardından açılan ekranda altta yer alan <em>kayıtlar “logs” ve diğer dosyalar</em> butonuna tıklayarak <em>blok-diyagram.png</em>’yi seçmek gereklidir. Artık blok diyagramınızı resim formatında elde ettiniz!</p><p>Bu sürecin nasıl yapıldığını bir de videodan izlemek isterseniz<a href="https://www.youtube.com/watch?v=DmOml1Hl9Fo&amp;t=2s"> buradaki bağlantıyı</a> kullanabilirsiniz.</p><h3>Kapanış</h3><p>Bu yazıda <strong>TikZ </strong>paketini kullanarak <strong>LaTeX </strong>komutları ile <strong>nasıl blok diyagram çizileceğini </strong>çeşitli örneklerle de destekleyerek sizlere aktarmaya çalıştım. Hem <strong>LaTeX </strong>ortamında hem <strong>TikZ </strong>ortamında henüz çok yeni olduğumdan bilgileri doğru aktarabilmek için kaynak tarama ihtiyacı duydum ve faydalı bağlantıları (referans bağlantılar) metin üzerine eklemeye çalıştım. Yine de yanlış bir bilgi aktarımı olduysa bunu yorumlarda belirtirseniz çok sevinirim.</p><p>Özellikle <em>“kontrol mühendisliğinde sıklıkla kullanılan blok diyagramları kitaplarda olduğu gibi kaliteli bir şekilde nasıl çizebilirim”</em> motivasyonu ile başlayan bu süreçte öğrendiklerimi size sunmak istedim, umarım faydalı bir yazı olmuştur. Konuyu araştırırken ne yazık ki <strong>TikZ ile Blok Diyagram Çizimi</strong> hakkında Türkçe kaynak bulamadım (varsa lütfen paylaşın), bunun yerine <strong>TikZ </strong>paketinin kullanımı hakkında birkaç video ile karşılaştım. Dilerim, Bu kaynak bu noktadaki açığı bir nebze olsun kapatabilir.</p><p>Faydalandığım bazı kaynaklar ve ileri okumalar yapmak adına aşağıdaki kaynaklardan faydalanabilirsiniz:</p><ul><li><a href="https://tikz.dev/tutorials-guidelines">PGF/TikZ Manual/Tutorials and Guidelines</a></li><li><a href="https://ctan.org/pkg/lshort-turkish">İnce Bir LaTeX2e Elkitabı (Bekir Karaoğlu)</a></li><li><a href="https://texample.net/control-system-principles/">texample.net/Control System Principles</a></li><li><a href="https://www.latex4technics.com/?note=3JTQ">latex4technics/Drawing a Block Diagram with TiKz</a></li><li><a href="https://latexdraw.com/block-diagram-in-latex-step-by-step-tikz-tutorial/">TikZBlog/Block Diagram in LaTeX: Step-by-Step TikZ Tutorial</a></li><li><a href="https://cerden.medium.com/bilimsel-yay%C4%B1nlarda-latex-ve-r-kullan%C4%B1m%C4%B1-634b62f44a8f">Medium/Caner Erden/Bilimsel Yayınlarda LaTeX ve R Kullanımı</a>: Özellikle LaTeX’i kendi bilgisayarına kurup kullanmak isteyenler için güzel bir kaynak.</li><li><a href="https://youtu.be/DmOml1Hl9Fo?si=MQ7QWSwF_1OS4Aye">Youtube/Maths Partner/Using Tikz and PgfPlots (8 of 8: Downloading Transparent PNGs)</a></li></ul><p><strong>Önceki Yazılarımı Okumak İsterseniz</strong></p><ul><li><a href="https://medium.com/@ismet.erdogn/bircok-yonu-ile-gostericiler-pointers-f328b85fc8e7">Birçok Yönüyle Göstericiler (Pointers)</a></li><li><a href="https://medium.com/@ismet.erdogn/hanoi-kuleleri-4c353b760859">Hanoi Kuleleri ve C Programlama Dilinde Çözümü</a></li><li><a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">Fonksiyonlar ve Return İfadesi</a></li></ul><p>Görüşlerinizi, eleştirilerinizi bana bu kanal üzerinden gönderebilirsiniz.</p><p>Bir sonraki yazıda görüşmek üzere.</p><p>Sevgiler,</p><blockquote>Yazıların yayınlanma tarihleri arasındaki geçen zaman her yazı ile beraber artıyor, bu sefer azalması için bir dilekte bulunmayacağım çünkü bulundukça bu sürenin arttığını gözlemledim :) Önceki yazdığım konuların içeriği<strong> C Programlama Dili</strong>’ne dayanıyordu; ancak bu 4. yazımda konu, kontrol mühendisliğinde sıklıkla kullanılan <strong>Blok Diyagramların Çizimi</strong> oldu. Bir laboratuvar dersimiz için grup arkadaşlarımla rapor yazarken oluşan “Kitaplarda yer alan kaliteli blok diyagramlar nasıl çiziliyor?” sorusu ile bu konuyu araştırma ve öğrenme sürecim başlamıştı. Buradan (okuyorlarsa eğer) laboratuvar sürecinde birlikte zevkli bir dönem geçirdiğim grup arkadaşlarıma selamlarımı iletiyorum :)</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=218bec61c3fa" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Birçok Yönüyle Göstericiler (Pointers)]]></title>
            <link>https://medium.com/@ismet.erdogn/bircok-yonu-ile-gostericiler-pointers-f328b85fc8e7?source=rss-98778f2a90e3------2</link>
            <guid isPermaLink="false">https://medium.com/p/f328b85fc8e7</guid>
            <category><![CDATA[c-programming-language]]></category>
            <category><![CDATA[software]]></category>
            <category><![CDATA[c-programlama-dili]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[pointers]]></category>
            <dc:creator><![CDATA[Ismet Erdogan]]></dc:creator>
            <pubDate>Wed, 30 Aug 2023 21:19:14 GMT</pubDate>
            <atom:updated>2023-08-30T21:19:14.767Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Spider-Man (1967 animasyon dizisi) Sezon 1 Bölüm 19B" src="https://cdn-images-1.medium.com/max/1024/1*8bei15LrnWh_1a4NpTKeVw.jpeg" /><figcaption>Birbirini Gösteren Örümcek Adamlar (Bu resim, 1967&#39;de yayınlanmaya başlanan Örümcek Adam animasyon dizisinin 1. sezon 19B. bölümünden alınmıştır.)</figcaption></figure><p><em>İngilizcesi </em><strong><em>pointers </em></strong><em>olarak adlandırılan </em><strong><em>göstericiler</em></strong><em>, özellikle </em><strong><em>C Programlama Dili</em></strong><em> ile yeni tanışan birçok kişiye başlangıçta konsept olarak yabancı gelmektedir. </em><strong><em>Niçin göstericilere gereksinim duyulduğu, nasıl kullanıldığı, ne zaman kullanılması gerektiği </em></strong><em>ve </em><strong><em>buna benzer sorular</em></strong><em>; göstericilerle ilk kez karşılaşan birinin net olarak cevaplayamadığı sorular olarak kafasının bir köşesinde kalır. Bu yazı, yukarıda bahsetmiş olduğumuz sorulara bir nebze cevap olabilmesi için yazılmıştır. Göstericilerle ilgili anlatımlar ve kod örnekleri</em><strong><em> C Programlama Dili</em></strong><em> üzerinden olacaktır.</em></p><h3>Başlarken</h3><p>Bu yazıda birçok başlık altında göstericiler incelenecektir. Başlıklar sırasıyla aşağıdaki gibidir:</p><ul><li>Gösterici Nedir?</li><li>Göstericiler Nerelerde Kullanır?</li><li>Göstericiler ile Fonksiyonun Argümanının Kendisine (Referansına) Ulaşmak</li><li>Referans ile Aktarmaya Bir Başka Örnek</li><li>Fonksiyon Göstericileri</li><li>Gösterici ve Dizi Arasındaki İlişki ve Gösterici Aritmetiği</li><li>Gösterici ve Dizi Arasındaki İlişki — Gösterim <em>(Notation)</em></li><li>Fonksiyonlara Gösterici İletme Türleri</li></ul><p>Eğer göstericilerle yeni karşılaştıysanız veya kafanızda soru işaretleri olup bilgilerinizi yeniden tazelemek istiyorsanız başlıkları sırası ile takip etmeniz konu bütünlüğü açısından daha iyi olacaktır. Umarım bu yazı amacına hizmet eder ve (varsa) soru işaretlerini giderebilir.</p><p>Keyifli okumalar :)</p><h3>Gösterici Nedir?</h3><p>Göstericiler, temel olarak adından da anlaşılacağı üzere bir şeyi (tam sayı, karakter, virgüllü sayı, fonksiyon vb.) gösteren veyahut işaret eden bir veri tipidir.</p><p>Peki, <em>Bu gösterme veya işaret etme olgusu nasıl gerçekleşiyor? </em>sorusunu sorarsak ilk olarak <strong>adres</strong> kavramı ile karşılaşırız. Bir program çalıştırıldığında programda tanımlanan her <em>değişken</em>, <em>fonksiyon</em>, <em>dizi</em>, <em>struct </em>vb. şeyler; bilgisayarın birincil hafızasında yani <strong>RAM’</strong>de<em> (Random Access Memory)</em> daha önce başka bir şey için ayrılmamış (müsait) konumlarda saklanır. Bu konum olarak adlandırılan hafıza parçacıklarının her birinin bir <strong>adresi </strong>vardır. Eğer bu adresler biliniyorsa adres vasıtası ile saklanan değere ulaşılabilir, değiştirilebilir vb. birçok işlem yapılabilir.</p><figure><img alt="Bilginin Hafızada Saklanmasının Gösterimi" src="https://cdn-images-1.medium.com/max/1024/1*luV3Y5K4NIVSwXtKV_0_eg.png" /><figcaption>Basit Bir Bellek Gösterimi</figcaption></figure><p>Yukarıdaki resim, bir C Programı’nda tanımlamış olduğunuz 20 değerine sahip bir tam sayının bilgisayar hafızasında nasıl saklandığının basit bir gösterimidir.</p><p>Her kutucuk 1 <strong>bayt </strong>olarak düşünülmüştür ve kutucukların sol üst tarafında yer alan sayı ise o <strong>baytın </strong>adresini temsil etmektedir. Şekilde görüldüğü üzere 20 tam sayısı 4 <strong>baytlık </strong>(bir tam sayının <em>(int)</em> 4 bayt yer kapladığı göz önüne alınmıştır.) bir yer kaplamış ve hafızanın 1010. konumunda yani adresindedir.</p><p>Elbette günümüzde bilgisayarların hafıza miktarlarının çok büyük olması ve hiyerarşinin on altılı sayı tabanına daha uygun olması sebebiyle adresler on altılı sayı tabanına ait bir sayıdır. Yani bir sayı tanımladığınızda adres <em>4a0a5ffb8c </em>gibi bir sayıdır.</p><p>C Programlama Dili’nde bir değişkenin adresine ulaşmak istenildiğinde <strong>Adres Operatörü (&amp;) </strong>kullanılır. <strong>Adres operatörü</strong>, ve (<strong>&amp;</strong>) işareti ile temsil edilir.</p><p>Aşağıdaki örnek programda tanımlanan bir değişkenin adresi yazdırılmıştır:</p><pre>// ornek_1.c<br>#include &lt;stdio.h&gt;<br><br>int main(void)<br>{<br>    int a = 5;<br>    printf(&quot;%p&quot;, &amp;a);<br>    <br>    return 0;<br>}</pre><p>Yukarıdaki programın çıktısı aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/543/1*O_6GN1-kslULc192G-hCRw.png" /><figcaption><strong>ornek_1.c</strong> Programının Çıktısı</figcaption></figure><p>Çıktıda da görüldüğü üzere 5 değerine sahip <em>a</em> değişkeni hafızada 317b9ffc4c konumunda saklanmaktadır. Adres operatörü <em>printf </em>fonksiyonu içerisinde a değişkeninin soluna gelerek <strong>&amp;a, <em>printf</em> </strong>fonksiyonunun argümanı olmuştur.</p><p><strong>printf</strong> fonksiyonundaki ilk argüman olan <em>“%p” </em>içindeki <strong>%p</strong> ise biçimlendirme belirleyicisi <em>(format specifier)</em> olup on altılı sayı tabanındaki bellek adresini yazdırmak için kullanılır.</p><p>Adreslerle alakalı temel anlatımı şimdilik burada bitirilebilir. Şimdi göstericilerin kendisine daha yakından bakma vakti!</p><p>Göstericilerin değişkenleri işaret ettiği bir önceki kısımda anlatılmıştı. Gösterme veya işaret etme kısmının gizemi ise göstericinin değerinin adres olmasıdır. Göstericiler içinde adres değeri tutarak adresini tuttuğu değeri işaret etmiş olur. (Bu kısım biraz karışık olmuş olabilir. Ama birkaç örnekte ve resimde anlatılan şeyin ne demek olduğunu anlayacağınızdan eminim.)</p><p>Diyelim ki <strong>a</strong> adında bir tam sayı değişkeni tanımlanmış olsun ve değeri de 65 olsun. Artık programımızda <strong>a </strong>değişkeni 65 değerini temsil etmiş olur. Fakat bir gösterici tanımlarsak ve kendi değerini <strong>a </strong>değişkeninin adresine eşitlemiş olursak artık bu gösterici yardımı ile de 65 değerine ulaşabiliriz. Bu ulaşma yöntemine <em>“dolaylı erişim”</em> adı verilir çünkü direkt <strong>a </strong>ismi ile ulaşmaktansa bir gösterici yardımı ile 65 değerine ulaşılmaktadır <em>(indirection method).</em></p><p>Bir önceki paragrafın program hali aşağıdaki gibidir:</p><pre>// ornek_2.c<br>#include &lt;stdio.h&gt;<br><br>int main(void)<br>{<br>    int a = 67;<br>    int *aPtr = &amp;a;<br><br>    printf(&quot;a = %d\n&quot;, a);<br>    printf(&quot;a degiskeninin adresi = %p\n&quot;, &amp;a);<br>    printf(&quot;aPtr = %p\n&quot;, aPtr);<br>    printf(&quot;*aPtr = %d (dolayli erisim)&quot;, *aPtr);<br><br>    return 0;<br>}</pre><p>Görüldüğü üzere <strong>int a = 67;</strong> satırı ile <strong>a </strong>değişkeni tanımlanmış ve 67 değerine eşitlenmiş. Daha sonraki satır olan <strong>int *aPtr = &amp;a; </strong>satırı ise gösterici tanımlanmasının yapılıp <strong>a </strong>değişkeninin adresine eşitlendiği yerdir.</p><p><strong>int *</strong> ifadesi <strong>bir tam sayı göstericisi</strong>nin tanımlanacağını söyleyen kısımdır. Bir veri tipinden sonra gelen * yıldız <em>(asteriks)</em> işareti gösterici tanımlamasının yapılacağını belirten ön ektir. Görüldüğü üzere <strong>aPtr </strong>isminde bir <strong>tam sayı (int) göstericisi </strong>tanımlanmış ve <strong>a </strong>değişkeninin adresine eşitlenmiştir. Aşağıdaki 2 gösterim de aynı işi gerçekleştirir.</p><pre>int *aPtr = &amp;a;<br>\\ veya<br>int* aPtr = &amp;a; </pre><p>Şimdi <strong>sample_2.c</strong> programının çıktısını inceleyelim.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/537/1*bjitaghvTddoHkNWLKf2VQ.png" /><figcaption><strong>ornek_2.c</strong> Programının Çıktısı</figcaption></figure><p>Yukarıdaki resimde ilk 2 satırda <strong>a </strong>değişkeninin değerini ve adresi gözükmektedir. <strong>aPtr </strong>ismindeki tam sayı göstericisinin değeri de beklendiği üzere a değişkeninin adresidir. Göstericinin değeri her zaman bir adrestir ya da boştur <em>(NULL)</em>. 4. satırda <strong>yıldız (*)</strong> işaretinin farklı bir kullanımı görülmektedir.</p><p>Eğer <strong>yıldız (*) işareti</strong> bir gösterici tanımlamasında kullanılmıyorsa <strong>dolaylı erişim operatörü</strong><em> (indirection operator)</em> olarak kullanılmış olur ve gösterici içinde tuttuğu adresin kendisine giderek 67 değerine ulaşır/gösterir.</p><p>Kısacası göstericinin soluna gelen<strong> yıldız (*) işareti</strong> ile <strong>göstericin göstermiş olduğu değere</strong> ulaşılmış olur.</p><p>Aşağıdaki resimde ise bellek üzerinde bir göstericinin nasıl görülmektedir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*RDuv7symKN0bmaXos4oVMg.png" /><figcaption>Basit Bir Bellek Gösterimi — 2</figcaption></figure><p>Yukarıdaki resimde görüldüğü üzere 20 değerine sahip bir <strong>x </strong>değişkeni ve onu gösteren <strong>xPtr </strong>isminde bir işaretçi vardır. Göstericiler hafızada 8 baytlık yer kaplar (Değişiklik gösterilebilir). <strong>xPtr </strong>içinde bulundurmuş olduğu 1010 değeri, gösterici içinde bulunduğu için adres olmakla beraber <strong>x </strong>değişkeninin adresidir ve bu sayede <strong>xPtr </strong>göstericisi <strong>x </strong>değerini göstermektedir/işaret etmektedir. (Kırmızı ok gösterici-gösterilen ilişkisi için resme eklenmiştir.)</p><p>Bu ilişkiyi kurmak için aşağıdaki kodlar yeterlidir:</p><pre>// ornek_3.c<br>#include &lt;stdio.h&gt;<br><br>int main(void)<br>{<br>    int x = 67;<br>    int *xPtr = &amp;x;<br><br>    return 0;<br>}</pre><p>Bu bölümde göstericinin ne olduğu, nasıl tanımlandığı ve adres kavramına açıklık getirmeye çalıştık. Şimdi diğer bölümlere geçebiliriz.</p><h3>Göstericiler Nerelerde Kullanılır?</h3><p>Birçok C Programı’nda göstericilerden faydalanılmaktadır. Faydalanıldığı bazı yerler aşağıdaki gibidir:</p><ul><li>Fonksiyona argüman olarak değişkenin kopyası değil de kendisinin (referansının) sokulması istenildiğinde <em>(pass-by-reference)</em>,</li><li>Dinamik veri yapıları oluşturmak ve onlar ile çeşitli işlemler yapmak istenildiğinde,</li><li>Bir fonksiyona argüman olarak fonksiyon girilmek istenildiğinde,</li></ul><p>Ve benzeri zamanlarda bu işlemler için göstericilerin kullanılması gerekmektedir. Yazının ilerleyen kısımlarında veri yapıları hariç diğer kısımlar için anlatımlar mevcuttur. (Dinamik veri yapıları, <strong>bağlı liste</strong> <em>(linked list)</em>, <strong>yığın </strong><em>(stack)</em>, <strong>ağaç </strong><em>(tree)</em> gibi birçok farklı veri yapısının ve dinamik hafıza yönetiminin ele alındığı bir konu olup bu yazı kapsamını aşan bir konudur.)</p><p>Ayrıca göstericiler ve diziler birbirleri ile çok yakından ilişkilidir ve bazı dizi işlemleri de göstericiler sayesinde yapılabilir.</p><h3>Göstericiler ile Fonksiyonun Argümanının Kendisine (Referansına) Ulaşmak</h3><p>Şu özelliklere sahip basit bir fonksiyon yazalım:</p><ul><li>1 adet tam sayı bir argüman alabilsin,</li><li>Aldığı argümanı kendisi ile çarpsın,</li><li>Değer döndürmesin,</li><li>İsmi ise <strong>karesiniAl </strong>olsun.</li></ul><p>Fonksiyonumuz aşağıdaki gibi olacaktır (Eğer fonksiyonlar ile ilgili sıkıntı yaşıyorsanız <a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">buradan</a> <strong>Fonksiyonlar ve Return İfadesi</strong> isimli yazıma ulaşabilirsiniz.):</p><pre>void karesiniAl(int sayi)<br>{<br>    sayi *= sayi;<br>}</pre><p>Yukarıdaki fonksiyon tanımladığımız kriterlere göre çalışacaktır.</p><p>Şimdi C Programlama Dili’nin bir özelliğinden bahsedelim: Bir fonksiyona bir argüman girildiğinde ki bu argüman bir başka değişken olabilir. <strong>Bu değişkenin kendisi fonksiyonun içine girmez, değerinin kopyası girer. </strong>Bu kısım aşağıdaki program ile daha iyi açıklanabilir.</p><pre>// ornek_4.c<br>#include &lt;stdio.h&gt;<br><br>void karesiniAl(int sayi);<br><br>int main(void)<br>{<br>    int x = 5;<br><br>    printf(&quot;karesiniAl fonksiyonundan once x = %d\n&quot;, x);<br>    karesiniAl(x);<br>    printf(&quot;karesiniAl fonksiyonundan sonra x = %d\n&quot;, x);<br><br>    return 0;<br>}<br><br>void karesiniAl(int sayi)<br>{<br>    sayi *= sayi;<br>    printf(&quot;\tKaresiniAl fonksiyonu icerisinde x = %d\n&quot;, sayi);<br>}</pre><p>Daha anlamlı bir çıktı alabilmek adına <strong>karesiniAl </strong>fonksiyonu içerisine <em>printf()</em> ile bilgilendirme yazısı yazdırmasını sağlayan kısım eklendi. Program çıktısı ise aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/539/1*wDp9ipg8cIYiY8YJb2ePdg.png" /><figcaption><strong>ornek_4.c</strong> Programının Çıktısı</figcaption></figure><p>Beklenildiği üzere değeri 5 olarak tanımlanan <strong>x</strong> değişkeni fonksiyona argüman olarak girmiş fonksiyon içinde kendi değeri ile çarpılmış yazdırılmış fonksiyondan çıkıldıktan sonra ise <strong>x </strong>değeri yeniden yazdırılmıştır. <strong>Fonksiyon içinde 25 olan x neden fonksiyondan çıktıktan sonra fonksiyon önceki haline yani 5 değerine geri döndü?</strong></p><p>İşte bu durum birkaç önceki paragrafta anlattığımız üzere d<strong>eğişkenin kendisinin (hafızadaki hali) değil değişkenin değerinin kopyasının girmesidir</strong>. Bu duruma İngilizce hali ile <em>pass-by-value</em> denmektedir.</p><p>Peki fonksiyon içerisinden fonksiyona girilen argümanın kendisine (hafızadaki hali) ulaşmak istediğimizde yani değerinin kopyasını değil kendisi ile işlem yapmak istendiğinde <em>(pass-by-reference)</em> ne yapılması gerek?</p><p>Bu sorunun cevabı fonksiyona argüman olarak değişkenin kendisi değil adresinin girilmesidir. Bu işlemi yapmak içinse fonksiyonda ve programda birkaç değişikliğe ihtiyaç var.</p><p>Yeni program aşağıdaki gibidir:</p><pre>// ornek_5.c<br>#include &lt;stdio.h&gt;<br><br>void karesiniAl(int *sayiPtr);<br><br>int main(void)<br>{<br>    int x = 5;<br><br>    printf(&quot;karesiniAl fonksiyonundan once x = %d\n&quot;, x);<br>    karesiniAl(&amp;x);<br>    printf(&quot;karesiniAl fonksiyonundan sonra x = %d\n&quot;, x);<br><br>    return 0;<br>}<br><br>void karesiniAl(int *sayiPtr)<br>{<br>    *sayiPtr *= *sayiPtr;<br>    printf(&quot;\tKaresiniAl fonksiyonu icerisinde x = %d\n&quot;, *sayiPtr);<br>}</pre><p>Fonksiyonun yeni haline daha yakından bakacak olursak:</p><pre>void karesiniAl(int *sayiPtr)<br>{<br>    *sayiPtr *= *sayiPtr;<br>    printf(&quot;\tKaresiniAl fonksiyonu icerisinde x = %d\n&quot;, *sayiPtr);<br>}</pre><p>Görüldüğü üzere fonksiyon parametresi artık <strong>int </strong>değil <strong>int *</strong> şeklindedir yani tam sayı göstericisidir ve ismi de <strong>sayiPtr</strong>’dir. Yani fonksiyon parametre olarak bir tam sayı değeri almak yerine tam sayı göstericisi yani adres almaktadır.</p><p>Fonksiyon içerisinde de görüldüğü üzere <strong>sayiPtr</strong> değişkeninin önüne <strong>* </strong>yani <strong>dolaylı erişim operatörü</strong> kullanılarak bellekte adresin yerine gidilerek değerin kendisine ulaşılmış ve kendisi ile çarpılmıştır. Sonrasında elde edilen değer yine aynı şekilde ulaşılarak yazdırılmıştır.</p><p><strong>main </strong>fonksiyonu içerisindeki değişikliğe de yakından bakalım:</p><pre>karesiniAl(&amp;x);</pre><p>Görüldüğü üzere fonksiyona <strong>x </strong>değişkeni değil (Eğer fonksiyona argüman olarak x değişkeni girilseydi derleyici hata verirdi. Çünkü fonksiyon bildiriminde <em>(function declaration)</em> parametre olarak <strong>int *</strong> yani <strong>tamsayı göstericisi</strong> aldığı yazmaktadır.). Bu yüzden <strong>&amp; </strong>yani <strong>adres operatörü</strong> ile <strong>x </strong>değişkeninin bulunduğu adres fonksiyona girilmiştir. Bu fonksiyona <strong>x </strong>değişkenini gösteren tam sayı işaretçisi ile aynı anlama gelmektedir. Sonuçta ikisi de adrestir. Yani programımız şu şekilde de olabilirdi.</p><pre>// ornek_6.c<br>#include &lt;stdio.h&gt;<br><br>void karesiniAl(int *sayiPtr);<br><br>int main(void)<br>{<br>    int x = 5;<br>    int *xPtr = &amp;x;<br><br>    printf(&quot;karesiniAl fonksiyonundan once x = %d\n&quot;, x);<br>    karesiniAl(xPtr);<br>    printf(&quot;karesiniAl fonksiyonundan sonra x = %d\n&quot;, x);<br><br>    return 0;<br>}<br><br>void karesiniAl(int *sayiPtr)<br>{<br>    *sayiPtr *= *sayiPtr;<br>    printf(&quot;\tKaresiniAl fonksiyonu icerisinde x = %d\n&quot;, *sayiPtr);<br>}</pre><p>Bu sefer görüldüğü üzere en başta <strong>xPtr </strong>isminde bir işaretçi tanımlanıp x değişkeninin adresine eşitlenmiş. Fonksiyona ise <strong>xPtr </strong>girilmiştir. Yani yine <strong>x </strong>değişkeninin adresi girmiş oldu. Yani <strong>ornek_5.c</strong> ve <strong>ornek_6.c</strong> arasında işlevsel olarak bir fark yoktur. <strong>ornek_5.c</strong> daha sade bir programdır ve ekstra gösterici tanımlanmamıştır.</p><p>2 programın çıktısı da aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*KvHldaKH2nu8Jvh-DtMsKg.png" /><figcaption><strong>ornek_5.c </strong>ve <strong>ornek_6.c </strong>Programının Çıktısı</figcaption></figure><p>Yukarıdaki çıktıda görüldüğü üzere fonksiyon içinde yapılan işlemin değişkenin kendisini değiştirdiği görülebilir. İşte göstericiler kullanarak yapabildiğimiz şeylerden biri budur! Bu işleme İngilizcede <em>pass-by-reference</em> adı verilmiştir!</p><p><strong>ChatGPT</strong>, <em>“pass-by-reference” </em>kavramına <strong>referans ile aktarma</strong> çevirisini önerdi. O halde sonraki örnekte bu çeviriden devam edelim.</p><h3>Referans ile Aktarmaya Bir Başka Örnek</h3><p>Yine göstericilerin fonksiyonlar içerisine referans ile değer geçirmesi özelliğini kullanarak bir fonksiyon yazalım.</p><p>Fonksiyon şu özelliklere sahip olacaktır:</p><ul><li>2 adet<strong> karakter göstericisi</strong> parametreye sahip olacak.</li><li>Kendisini argüman olarak girilen 2 karakteri birbirleri ile değiştirecek.</li><li>Değer döndürmeyecek.</li><li>İsmi ise <strong>birbiriIleDegistir </strong>olacak.</li></ul><p>Fonksiyonun tanımlanması aşağıdaki gibidir:</p><pre>void birbiriIleDegistir(char *karakter1, char *karakter2)<br>{<br>    char geciciKarakter = *karakter1;<br>    *karakter1 = *karakter2;<br>    *karakter2 = geciciKarakter;<br>}</pre><p>Fonksiyonu adım adım inceleyelim:</p><ul><li>Yukarıdaki fonksiyonda görüldüğü üzere 2 adet karakter göstericisi parametre vardır. Bu göstericiler sayesinde fonksiyon içerisine referanslar sokulmuş olacaktır.</li><li>Daha sonrasında karakter değiştirme işlemini yapabilmek için gerekli kodlar yer almaktadır.</li><li>Tanımlanan <strong>geciciKarakter </strong>karakteri, karakter1&#39;in solunda yer alan <strong>* </strong>işaret yani <strong>dolaylı erişim operatörü</strong> ile <strong>karakter1</strong>&#39;in tutmuş olduğu adreste yer alan değere ulaşılmasını sağlar ve bu <strong>geciciKarakter </strong>değişkenine eşitlenir.</li><li>Daha sonra <strong>karakter1</strong>&#39;in tuttuğu adreste yer alan değer, <strong>karakter2</strong>&#39;nin tuttuğu adreste yer alan değere eşitlenir.</li><li>Son olarak <strong>karakter1</strong>&#39;in tuttuğu adreste yer alan değer, <strong>geciciKarakter’</strong>in<strong> </strong>değerine eşitlenir.</li><li>Ve bu şekilde değişkenlerin birbirlerinin değerleri ile değiş tokuşu tamamlanmış olur.</li></ul><p>Şimdi bu fonksiyon kullanılarak yazılmış programı inceleyelim:</p><pre>// ornek_7.c<br>#include &lt;stdio.h&gt;<br><br>void birbiriIleDegistir(char *karakter1, char *karakter2);<br><br>int main(void)<br>{<br>    char karakter1 = &#39;s&#39;;<br>    char karakter2 = &#39;u&#39;;<br><br>    puts(&quot;birbiriIleDegistir fonksiyonu oncesi:&quot;);<br>    printf(&quot;karakter1 = %c\nkarakter2 = %c\n\n&quot;, karakter1, karakter2);<br>    birbiriIleDegistir(&amp;karakter1, &amp;karakter2);<br>    puts(&quot;birbiriIleDegistir fonksiyon sonrasi:&quot;);<br>    printf(&quot;karakter1 = %c\nkarakter2 = %c\n&quot;, karakter1, karakter2);<br><br>    return 0;<br>}<br><br>void birbiriIleDegistir(char *karakter1, char *karakter2)<br>{<br>    char geciciKarakter = *karakter1;<br>    *karakter1 = *karakter2;<br>    *karakter2 = geciciKarakter;<br>}</pre><p>Görüldüğü üzere 2 karakter tanımlanmış, yazdırılmış. Adresleri (<strong>&amp; adres operatörü</strong> sayesinde) <strong>birbiriIleDegistir </strong>argüman olarak girilmiş ve karakterler yeniden yazdırılmış.</p><p>Programın çıktısı aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/535/1*-JrsKlBh9tFdhT02SVA9Rg.png" /><figcaption><strong>ornek_7.c </strong>Programının Çıktısı</figcaption></figure><p>Çıktıda görüldüğü üzere değişkenlerin değerleri başarı ile değiştirilmiştir.</p><h3>Fonksiyon Göstericileri</h3><p>Fonksiyon gösteren göstericiler ya da kısaca fonksiyon göstericileri; <strong>bir fonksiyonun başka bir fonksiyona argüman olarak girilmesi</strong>,<strong> bir fonksiyonun bir fonksiyondan değer döndürülmesini </strong>ve <strong>fonksiyonların dizi içinde saklanması</strong> gibi tekniklerin gerçekleşmesi sağlayan önemli yapılardan biridir.</p><p>Fonksiyonlar da tıpkı yazılan programda tanımlanan veri tipleri gibi (tam sayı, virgüllü sayı, karakter vb.) hafızada belirli bir konumda saklanır ve fonksiyon göstericileri de bu konumun başlangıç adresini tutar. Bu adrese ulaşılarak tanımlanan fonksiyonun işlevleri gerçekleştirilebilir.</p><p>Şimdi basit bir program yazalım:</p><ul><li><strong>trigonometrikHesapla </strong>isminde genel bir fonksiyon yer alsın ve bu fonksiyon parametre olarak alacağı fonksiyon göstericisi ile içine fonksiyon adresi girilebilsin.</li><li>İçine fonksiyon olarak girilebilecek fonksiyonlar da <strong>sinüs</strong>, <strong>kosinüs </strong>ve <strong>tanjant </strong>gibi<strong> tek parametreli</strong> yine kendimiz tarafından tanımlanan fonksiyonlar olsun.</li><li>Yapılmak istenen işlem için kullanıcı seçimini yapıp <strong>trigonometrikHesapla </strong>fonksiyonuna gerekli argümanlar girilerek değer döndürülsün ve sonuç yazdırılsın.</li></ul><p>Program aşağıdaki gibi yazılabilir:</p><pre>// ornek_8.c<br>#include &lt;stdio.h&gt;<br>#include &lt;math.h&gt;<br><br>void bilgilendirme();<br>double sinus(double sayi);<br>double kosinus(double sayi);<br>double tanjant(double sayi);<br>double trigonometrikHesapla(double (*fonksiyon)(double), double sayi);<br><br>int main(void)<br>{<br>    unsigned hesapSecimi;<br>    double sayi;<br><br>    bilgilendirme();<br>    printf(&quot;\n# Giris seciniz (numara):&quot;);<br>    scanf(&quot;%u&quot;, &amp;hesapSecimi);<br><br>    while (hesapSecimi != 4)<br>    {<br>        switch (hesapSecimi) {<br>            case 1:<br>                printf(&quot;Sinus degerini hesaplamak istediginiz sayiyi giriniz:&quot;);<br>                scanf(&quot;%lf&quot;, &amp;sayi);<br>                printf(&quot;sin(%.2lf) = %.2lf\n&quot;, sayi, trigonometrikHesapla(sinus, sayi));<br>                break;<br>            case 2:<br>                printf(&quot;Kosinus degerini hesaplamak istediginiz sayiyi giriniz:&quot;);<br>                scanf(&quot;%lf&quot;, &amp;sayi);<br>                printf(&quot;cos(%.2lf) = %.2lf\n&quot;, sayi, trigonometrikHesapla(kosinus, sayi));<br>                break;<br>            case 3:<br>                printf(&quot;Tanjant degerini hesaplamak istediginiz sayiyi giriniz:&quot;);<br>                scanf(&quot;%lf&quot;, &amp;sayi);<br>                printf(&quot;tan(%.2lf) = %.2lf\n&quot;, sayi, trigonometrikHesapla(tanjant, sayi));<br>                break;<br>            default:<br>                puts(&quot;Gecersiz secim.&quot;);<br>                bilgilendirme();<br>                break;<br>        }<br>        printf(&quot;\n# Giris seciniz (numara):&quot;);<br>        scanf(&quot;%u&quot;, &amp;hesapSecimi);<br>    }<br>    puts(&quot;Program sonu.&quot;);<br>    return 0;<br>}<br><br>void bilgilendirme()<br>{<br>    printf(&quot;\nHesaplamalar:\n&quot;<br>         &quot;1 - Sinus Fonksiyonu\n&quot;<br>         &quot;2 - Kosinus Fonksiyonu\n&quot;<br>         &quot;3 - Tanjant Fonksiyonu\n&quot;<br>         &quot;4 - Program sonu\n&quot;);<br>}<br>double sinus(double sayi)<br>{<br>    return sin(sayi);<br>}<br>double kosinus(double sayi)<br>{<br>    return cos(sayi);<br>}<br>double tanjant(double sayi)<br>{<br>    return tan(sayi);<br>}<br>double trigonometrikHesapla(double (*fonksiyon)(double), double sayi)<br>{<br>    return (*fonksiyon)(sayi);<br>}</pre><p>Fonksiyon göstericilerini kullanmış olduğumuz <strong>trigonometrikHesapla </strong>fonksiyonuna daha yakından bakalım:</p><pre>double trigonometrikHesapla(double (*fonksiyon)(double), double sayi)<br>{<br>    return (*fonksiyon)(sayi);<br>}</pre><p>Yukarıdaki fonksiyonda görüldüğü üzere ilk parametresinde <strong>* </strong>sayesinde bir fonksiyon isminde <strong>gösterici tanımlanması</strong> yapılmıştır ve <strong>*fonksiyon</strong> deyimi parantezlerle kapatılmıştır. Solunda yer alan <strong>double</strong>, <strong>göstericinin gösterdiği fonksiyonun dönüş değerinin tipini</strong>, sağında parantez içinde yer alan bir adet <strong>double </strong>deyimi <strong>göstericinin göstermiş olduğu fonksiyonun bir adet double tipinde argüman aldığını</strong> söyler.</p><p>Bu sayede fonksiyon içine başka bir fonksiyon sokulabilir.</p><p>Fonksiyonun içine bakıldığında ise <strong>return </strong>deyiminden sonra gelen <em>(*fonksiyon)(sayi)</em> kısmı fonksiyona argüman olarak girilen göstericiye <strong>*</strong> yani <strong>dolaylı erişim operatörü</strong> kullanılarak gösterdiği fonksiyona ulaşılmış ve parantez içine alındıktan sonra sağındaki parantezin içinde <strong>trigonometrikHesapla </strong>fonksiyonunun ikinci parametresi olan <strong>sayi, </strong>argüman olarak göstericinin gösterdiği fonksiyona girilmiştir.</p><p>Burada şunu da söylemeden geçmemeliyiz. Fonksiyon aşağıdaki gibi de olabilirdi.</p><pre>double trigonometrikHesapla(double (*fonksiyon)(double), double sayi)<br>{<br>    return fonksiyon(sayi);<br>}</pre><p>Yani dolaylı erişim operatörü kullanmadan da fonksiyon aynı şekilde çalışabilirdi. Ancak ilk yöntemde <strong>dolaylı erişim operatörü</strong> ile gösterilen fonksiyona ulaşıldığı açıkça gösterildiği için daha okunabilir bir kod yazılmış olur.</p><p>Bu programın örnek bir çıktısı aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/679/1*ijN7CkRracIlUTIhpfn6ig.png" /><figcaption><strong>ornek_8.c </strong>Programının Çıktısı</figcaption></figure><p>Program çıktısında görüldüğü üzere girilen farklı değerler için farklı fonksiyonlar çalıştırılmıştır fakat bu fonksiyonlar çağırılarak değil <strong>trigonometrikHesapla </strong>fonksiyonunun içine argüman olarak girilmiştir ve program bu şekilde kurgulanmıştır.</p><p>Fonksiyon göstericilerini basit olarak anlatmak amacıyla basit bir örnek program gösterilmiştir. Fonksiyon göstericileri ile çok çeşitli programlar yazılabilir.</p><h3>Gösterici ve Dizi Arasındaki İlişki ve Gösterici Aritmetiği</h3><p>C Programlama Dili’nde <strong>6</strong> elemanlı,<strong> tam sayı </strong>tipinde değer tutan, <strong>liste </strong>isminde bir dizi şu şekilde tanımlanabilir:</p><pre>int liste[6];</pre><p>Ön tanımlı bir dizi oluşturmak içinse tanımlama şu şekilde yapılabilir:</p><pre>int liste[6] = {10, 20, 30, 40, 50, 60};</pre><p>Bu dizinin hafızada gösterimi basit bir şekilde şöyle olabilir (Diziler hafızada <strong>sırasıyla toplu</strong> olarak saklanır.):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*rC0n6HWPbTN8EtR4_E7kWQ.png" /><figcaption>Dizi için Basit Hafıza Gösterimi — 1</figcaption></figure><p>Yukarıdaki gösterimin daha açık hali (daha donanıma yakın hali) ise aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/541/1*7c-YZZVPzXhviENy83e-bw.png" /><figcaption>Dizi için Basit Hafıza Gösterimi — 2</figcaption></figure><p>Diziler aslında göstericiler ile çok yakından ilişkilidir.</p><p>Aşağıdaki örneği ve çıktıyı inceleyelim.</p><pre>// ornek_9.c<br>#include &lt;stdio.h&gt;<br><br>int main(void)<br>{<br>    int liste[6] = {10, 20, 30, 40, 50, 60};<br><br>    printf(&quot;liste = %p\n&quot;, liste);<br>    printf(&quot;&amp;liste[0] = %p\n&quot;, &amp;liste[0]);<br><br>    return 0;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/539/1*mTWrMs8LkIdqh9Pi8Cw5kQ.png" /><figcaption><strong>ornek_9.c </strong>Programının Çıktısı</figcaption></figure><p>Çıktıda görüldüğü üzere <strong>&amp;liste[0]</strong> yani <strong>liste </strong>adlı <strong>dizinin başlangıç değerinin bulunduğu adres</strong> ile <strong>liste değişkenin tutmuş olduğu adres</strong> yazdırıldığında ikisinin de aynı yeri yazdırmıştır.</p><p><strong>liste</strong>’nin kendi başına neden adres tutmuş olduğu sorusu ilk başta aklınıza gelebilir. Bu sorunun cevabı ise aslında <strong>liste</strong>’nin <strong>dizinin başlangıç adresini gösteren bir tam sayı göstericisi</strong> olmasıdır. (Hatta dizi isimleri <strong>sabit olmayan değer gösteren sabit gösterici</strong>dir. Bu konuya ileride değineceğiz.)</p><p>Dizi çok bilinen şekli ile aşağıdaki gibi dizinin tüm elemanları dolaşılabilir:</p><pre>// ornek_10.c<br>#include &lt;stdio.h&gt;<br><br><br>int main(void)<br>{<br>    int liste[6] = {10, 20, 30, 40, 50, 60};<br><br>    for (int i = 0; i &lt; 6; ++i) {<br>        printf(&quot;liste[%d] = %d\n&quot;, i, liste[i]);<br>        printf(&quot;&amp;liste[%d] = %p\n\n&quot;, i, &amp;liste[i]);<br>    }<br><br>    return 0;<br>}</pre><p>Çıktısı ise şu şekildedir (<strong>ornek_9.c’</strong>deki adresin yeni derleme esnasında değişmiş olması gayet normaldir.):</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*jMAaLVz_ecvib1Y-TzNZ9w.png" /><figcaption><strong>ornek_10.c </strong>Programının Çıktısı</figcaption></figure><p>Peki, bir tam sayı göstericisi tanımlanıp değeri <strong>liste</strong>’nin değeri yani dizinin başlangıç adresine eşitlenmiş olsaydı ve yeni tanımlanan bu gösterici ile dizi dolaşılmak istenseydi ne yapılabilirdi?</p><p>Aşağıdaki programı ve çıktısını inceleyelim:</p><pre>// ornek_11.c<br>#include &lt;stdio.h&gt;<br><br>int main(void)<br>{<br>    int liste[6] = {10, 20, 30, 40, 50, 60};<br>    int *listePtr = liste;<br><br>    for (int i = 0; i &lt; 6; ++i) {<br>        printf(&quot;liste[%d] = %d\n&quot;, i, *(listePtr + i));<br>        printf(&quot;&amp;liste[%d] = %p\n\n&quot;, i, (listePtr + i));<br>    }<br><br>    return 0;<br>}</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/544/1*tdA5CGfjEbgupHhvT5spkg.png" /><figcaption><strong>ornek_11.c </strong>Programının Çıktısı</figcaption></figure><p>Görüldüğü üzere yeni program da istenildiği gibi diziyi dolaşmıştır.</p><p>Şimdi sırası ile değişikliklere yakından bakalım:</p><ul><li><strong>listePtr </strong>adında bir tam sayı göstericisi tanımlanıp liste dizisinin (göstericisinin) değerine yani dizinin başlangıç adresine eşitlenmiştir.</li><li><em>For Döngüsü</em> içinde 2 adet değişiklik yapılmıştır.</li><li><strong>liste[i]</strong> yerine <strong>*(listePtr + i)</strong>,</li><li><strong>&amp;liste[i]</strong> yerine <strong>(listePtr + i) </strong>ifadeleri yazılmıştır.</li></ul><p><strong>liste </strong>dizisinin elemanlarına <strong>köşeli parantez içinde ulaşmak istenilen elemanın sırasını girme yöntemi ile ulaşmak</strong> şimdiye kadar alışılmış bir yöntemdir ve gayet doğal gelmektedir.</p><p>Peki tamsayı değer tutan (0, 1, 2, 3, 4, 5, 6) <strong>i</strong> değişkeni bir göstericiye yani adrese eklendiğinde nasıl teker teker yine bu değerleri gösterebilmiştir?</p><p>Çıktıda görüldüğü üzere</p><ul><li><strong>(listePtr + 0)</strong> = 000000e5db7ffbc0</li><li><strong>(listePtr + 1)</strong> = 000000e5db7ffbc4</li><li><strong>(listePtr + 2)</strong> = 000000e5db7ffbc8</li><li><strong>(listePtr + 3)</strong> = 000000e5db7ffbcc</li><li><strong>(listePtr + 4)</strong> = 000000e5db7ffbd0</li><li><strong>(listePtr + 5)</strong> = 000000e5db7ffbd4</li></ul><p>Adreslerine eşit olarak başarılı bir şekilde diziyi dolaşmıştır.</p><p>İşte bu aritmetiğe <strong>Gösterici Aritmetiği</strong> adı verilmektedir.</p><p>Bu aritmetiğe göre göstericiye bir tam sayı değeri <strong>eklenirse veya çıkarılırsa </strong>adresten çıkarılacak değer o tam sayı değerinin kendisi değildir, göstericinin ne göstericisiyse (tam sayı, virgüllü sayı, karakter) gösterdiği veri tipinin hafızada kapladığı alan kadar gösterici adresine ekleme veya çıkarma yapılabilir.</p><p>Bu aritmetikten faydalanarak dizi içinde başarı ile dolaşılmıştır ve <strong>listePtr </strong>örneğinde de görüldüğü üzere <strong>bir tam sayı göstericisine 1 değeri eklendiğinde tuttuğu adres 4 değer kadar artmıştır</strong>. Bu 4 değeri de bir tam sayının (<strong>int</strong>) hafızada kaplamış olduğu alan (<strong>bayt</strong>) miktarıdır.</p><p><strong>Gösterici Aritmetiği</strong>’nde toplama ve çıkarma işlemlerine izin verilir:</p><ul><li>gösterici +/- (tam sayı değeri)</li><li>gösterici++/- -;</li><li>gösterici += (tam sayı değeri)</li><li>(tam sayı değeri) = gösterici1 — gösterici2</li></ul><p>Son madde aynı diziyi gösteren göstericiler için anlamlıdır.</p><p>Bir sonraki bölümde anlatılacaklar bu bilgiler ışığında anlatılacaktır.</p><h3>Gösterici ve Dizi Arasındaki İlişki —Gösterim (Notation)</h3><p>Dizilerin de aslında bir <strong>gösterici </strong>olduğundan bir önceki bölümden bahsetmiştik. Bu bölümde <strong>diziler </strong>ve <strong>göstericiler </strong>arasındaki ilişkiye ifade etme yöntemleri <em>(notation) </em>bakımından incelenecek.</p><p><strong>10 elemanlı bir tam sayı dizisi</strong> ve ve<strong> bu dizinin ilk elemanının adresini tutan bir tam sayı göstericisi</strong> tanımlayalım. (Dizi isimlerinin de bir gösterici olduğu unutulmamalı! Bu sayede tanımlanan göstericiye eşitleme yapılabildi.)</p><pre>int dizi[10];<br>int *diziPtr = dizi;</pre><h4>Gösterici/Ofset Gösterimi (Pointer/Offset Notation)</h4><p>Bir önceki bölümde dizinin elemanlarına normalde dizi[2] deyimi ile basit bir şekilde ulaşılabileceğinden fakat gösterici ile ulaşırken farklı bir yöntem ile dizi elemanlarına ulaşmıştık.</p><p>Eğer dizinin üçüncü elemanına ulaşılacaksa dizi[2] deyimi ile basit bir şekilde ulaşılabilir, fakat dizi adresine bir gösterici tanımlandıysa şu şekilde de dizi elemanına ulaşılabilir (Bu gösterim önceki bölümde de kullanıldı).</p><p><strong>(diziPtr + 2)</strong> deyimi de <strong>dizi[2]</strong> deyimi ile aynı işlevi görmektedir. <strong>*(diziPtr + 2)</strong> deyiminde gösterici kullanıldığından toplama veya çıkarma operatöründen sonra bir ofset/öteleme işlevi gören bir tam sayı kullanıldığından bu gösterime <strong>Gösterici/Ofset Gösterimi</strong> veya <strong>İngilizcesi ile Pointer/Offset Notation</strong> adı verilmiştir.</p><p>Gösterici aritmetiği sayesinde tam sayı adres üzerinde öteleme/ofset yapar ve parantez dışındaki <strong>*</strong> yani <strong>dolaylı erişim operatörü</strong> ile adresteki değere ulaşılmış olur.</p><pre>dizi[2];<br>// veya<br>*(diziPtr + 2)</pre><h4>Gösterici/İndeks Gösterimi (Pointer/Index Notation)</h4><p>Bu gösterim tipi, daha önce bu yazıda hiç kullanmadığımız bir gösterim tipidir.</p><p>Yine aşağıdaki tanımlamalar geçerli olsun.</p><pre>int dizi[10];<br>int *diziPtr = dizi;</pre><p>Nasıl dizi elemanlarına indeksler sayesinde (<strong>dizi[2] </strong>gibi) ulaşılabiliyorsa bir diziyi gösteren göstericide de aynı gösterim kullanılıp dizi elemanlarına ulaşılabilir.</p><p>Aşağıdaki koda bakalım:</p><pre>dizi[2];<br>// veya<br>diziPtr[2];</pre><p><strong>diziPtr[2]</strong> deyimi de dizi[2] ile aynı işlevi görecektir.</p><p>Gösterici ve indeks aynı anda kullanıldığından dolayı bu gösterime <strong>Gösterici/İndeks Gösterimi</strong> veya İngilizcesi ile <strong>Pointer/Index Notation</strong> denir.</p><p>Şimdi önceden kullandığımız gösterimler ve bu bölümde anlatılan gösterimleri tek bir programda kullanalım:</p><pre>// ornek_12.c<br>#include &lt;stdio.h&gt;<br><br>int main(void)<br>{<br>    int liste[5] = {10, 20, 30, 40, 50};<br>    int *listePtr = liste;<br><br>    puts(&quot;Dizi/Indeks Gosterimi (Array/Index Notation):&quot;);<br>    for (int i = 0; i &lt; 5; ++i) {<br>        printf(&quot;liste[%d] = %d\n&quot;, i, liste[i]);<br>    }<br><br>    puts(&quot;\nGosterici/Ofset Gosterimi (Pointer/Offset Notation):&quot;);<br>    for (int i = 0; i &lt; 5; ++i) {<br>        printf(&quot;*(listePtr + %d) = %d\n&quot;, i, *(listePtr + i));<br>    }<br><br>    puts(&quot;\nGosterici/Indeks Gosterimi (Pointer/Index Notation):&quot;);<br>    for (int i = 0; i &lt; 5; ++i) {<br>        printf(&quot;listePtr[%d] = %d\n&quot;, i, listePtr[i]);<br>    }<br>    <br>    return 0;<br>}</pre><p>Çıktı ise aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/538/1*3cs047P6hLmBuPiLP_a_zQ.png" /><figcaption><strong>ornek_12.c </strong>Programının Çıktısı</figcaption></figure><h3>Fonksiyonlara Gösterici İletme Türleri</h3><p><strong>C Programlama Dili</strong>’nde fonksiyonlara argüman girildiğinde girilen değişkenin kendisi değil bir kopyasının girildiği <em>(pass-by-value)</em> önceki bölümlerde bahsedilmişti. Eğer bir değişkenin kendisini fonksiyon içine sokmak istiyorsak girilecek değişkenin adresini tutan gösterici ile sokulması <em>(pass-by-reference)</em> gerektiğini önceki bölümlerden artık biliyoruz.</p><p>Bu bölümde fonksiyonlara parametre olarak gösterici tanımlamanın 4 farklı çeşidinden bahsedilecektir. Her çeşit farklı bir amaç için kullanılmaktadır.</p><p>Bu çeşitlere geçmeden önce C Programlama Dili’nde yer alan <strong>const </strong>anahtar kelimesi <em>(keyword) </em>bahsetmek gerekir. Çoğu kişinin yakından bildiği <strong>const </strong>anahtar kelimesi tanımlanan bir değişkenin değerinin programın çalışması esnasında hep aynı değerde kalması (<strong>const </strong>ile tanımlanan değişkenlerin değerleri değiştirilemez.) gerekiyorsa programcı tarafından tercih edilir.</p><p>Aşağıdaki programı inceleyelim:</p><pre>// ornek_13.c<br>#include &lt;stdio.h&gt;<br><br>int main(void)<br>{<br>    double sayi1 = 5;<br>    const double pi = 3.14;<br><br>    sayi1 = 10;<br>    pi = 3;<br><br>    return 0;<br>}</pre><p>Yukarıdaki programda görüldüğü üzere</p><ul><li><strong>double </strong>tipinde <strong>sayi1 </strong>değişkeni tanımlanıp 5 değerine eşitlenmiştir.</li><li><strong>const </strong>anahtar kelimesi ile birlikte <strong>double </strong>tipinde <strong>pi </strong>değişkeni tanımlanıp 3.14 değerine eşitlenmiştir.</li></ul><p>Daha sonra,</p><ul><li><strong>sayi1</strong>&#39;in değeri 10&#39;a eşitlenmiş.</li><li><strong>pi </strong>ise 3&#39;e eşitlenmeye çalışılmıştır. Ancak derleyici bu satırda hata verir çünkü <strong>const </strong>anahtar kelimesi ile birlikte tanımlanan bir değişken değiştirilmeye çalışılmıştır.</li></ul><p>Eğer program derlenmeye çalışırsa hata ile karşılaşılır. Hata mesajı ise aşağıdaki gibidir.</p><pre>error: assignment of read-only variable &#39;pi&#39;<br>   10 |     pi = 3;</pre><p><strong>const </strong>anahtar kelimesi fonksiyon parametrelerinde sık bir şekilde kullanılabilir. Ne zaman kullanıp kullanmayacağınıza <strong>En Az Ayrıcalık İlkesi </strong><em>(Principle of Least Privilege)</em><strong> </strong>ışığında karar vermelisiniz.</p><p><strong>En Az Ayrıcalık İlkesi</strong>’ne göre parametreye eriştiğinizde onunla ne yapacaksanız o parametreye erişiminizi ancak o kadar vermelisiniz. Daha fazla erişim hakkı vermeniz demek yazdığınız programın daha hataya açık bir program olmasına sebep olur.</p><p>Örnek vermek gerekirse fonksiyon içinde bir sabit gibi kullanacağınız veya sadece yazdırmak için kullanacağınız parametreleri <strong>const </strong>ile beraber tanımlamak her zaman daha güvenlidir ve programcıya daha az hata yaptırır. Ancak alınan parametre çeşitli işlemlere tabi tutulacaksa bu sefer tabiki <strong>const </strong>anahtar kelimesi kullanılmamalıdır.</p><p>Şimdi, fonksiyonlara referans ile değer geçirmenin 4 farklı türünü görelim ve tek tek inceleyelim:</p><ul><li>Sabit olmayan değeri gösteren sabit olmayan gösterici veya <em>non-constant pointer to non-constant data</em></li><li>Sabit olmayan değeri gösteren sabit gösterici veya <em>a constant pointer to nonconstant data</em></li><li>Sabit değeri gösteren sabit olmayan gösterici veya<em> a non-constant pointer to constant data</em></li><li>Sabit değer gösteren sabit gösterici veya<em> a constant pointer to constant data</em></li></ul><h4>1- Sabit Olmayan Değeri Gösteren Sabit Olmayan Gösterici</h4><pre>void fonksiyon(int *parametre);</pre><p>Bu tür aşağıdaki işlemlere izin verir:</p><ul><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adres <strong>değiştirilebilir</strong>.</li><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adreste yer alan veri <strong>değiştirilebilir</strong>. (Gösterdiği değer değiştirilebilir.)</li></ul><p>Görüldüğü üzere gösterici üzerinde en fazla işlem iznini veren tip budur.</p><p>Aşağıdaki örneği inceleyelim:</p><pre>// ornek_14.c<br>#include &lt;stdio.h&gt;<br><br>void elemanlarinKaresiniAl(int *diziPtr, const int uzunluk);<br>void diziyiYazdir(const int * const diziPtr, const int uzunluk);<br><br>int main(void)<br>{<br>    int dizi[] = {1, 2, 3, 4, 5, 6, 7 ,8, 9, 10};<br>    int *diziPtr = dizi;<br><br>    diziyiYazdir(diziPtr, 10);<br>    elemanlarinKaresiniAl(diziPtr, 10);<br>    puts(&quot;&quot;);<br>    diziyiYazdir(diziPtr, 10);<br><br>    return 0;<br>}<br><br>void elemanlarinKaresiniAl(int *diziPtr, const int uzunluk) {<br>    for (int i = 0; i &lt; uzunluk; ++i)<br>    {<br>        *diziPtr *= *diziPtr;<br>        diziPtr += 1;<br>    }<br>}<br><br>void diziyiYazdir(const int * const diziPtr, const int uzunluk)<br>{<br>    for (int i = 0; i &lt; uzunluk; ++i)<br>    {<br>        printf(&quot;diziPtr[%d] = %d\n&quot;, i, diziPtr[i]);<br>    }<br>}</pre><p><strong>elemanlarinKaresiniAl </strong>fonksiyonuna daha yakından bakalım (<strong>diziyiYazdir </strong>fonksiyonu ile 4. alt başlıkta ilgileneceğiz.):</p><pre>void elemanlarinKaresiniAl(int *diziPtr, const int uzunluk) {<br>    for (int i = 0; i &lt; uzunluk; ++i)<br>    {<br>        *diziPtr *= *diziPtr;<br>        diziPtr += 1;<br>    }<br>}</pre><p>Görüldüğü üzere fonksiyon,</p><ul><li>2 parametreye sahiptir.</li><li>İlk parametre, sabit olmayan değeri gösteren sabit olmayan göstericidir.</li><li>İkinci parametre, içine girilen dizinin eleman sayısını ifade eden <strong>uzunluk </strong>parametresidir. Değişmemesi/Değişmeyeceği için <strong>const </strong>anahtar kelimesi ile parametre tanımlanmıştır.</li></ul><p>Asıl konumuz olan ilk parametreyi inceleyelim:</p><ul><li>For döngüsü içinde ilk satır, göstericinin gösterdiği <em>(derefenced pointer)</em> değerin karesini alan satırdır. Bu kısım sabit olmayan değer erişimi sayesinde yapılabilmektedir.</li><li>İkinci satır ise göstericinin dizide göstermiş olduğu yeri bir sonraki yere kaydıran <strong>gösterici aritmetiği</strong> işlemidir. Eğer göstericimiz sabit olsaydı bu işlem yapılamazdı.</li></ul><p><strong>Not:</strong> Bu konular daha yaratıcı örneklerle tabiki desteklenebilirdi fakat basit örneklerle daha anlaşılır olması ve yazının daha fazla uzamaması için düzey ve kapsam basit tutulmuştur.</p><h4>2- Sabit Olmayan Değeri Gösteren Sabit Gösterici</h4><pre>void fonksiyon(int * const parametre);</pre><p>Bu tür aşağıdaki işleme izin verir:</p><ul><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adreste yer alan veri <strong>değiştirilebilir</strong>. (Gösterdiği değer değiştirilebilir.)</li></ul><p>Bu tür aşağıdaki işleme izin vermez:</p><ul><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adres <strong>değiştirilemez</strong>.</li></ul><p>Aslında dizi isimleri, sabit olmayan değeri gösteren bir sabit göstericidir.</p><pre>int liste[];</pre><p>Şeklinde bir tanımlama yapıldığında <strong>liste </strong>ismi bu gösterici türündedir.</p><p>Eğer fonksiyon içinde göstericinin tuttuğu adres yani göstermiş olduğu yerin hiç değişmemesi gerekiyorsa bu şekilde parametre tanımlanması en doğrusu olur.</p><p>Bu şekilde fonksiyon içine gönderilen göstericide gösterici aritmetiği işlemleri uygulanamaz.</p><p><strong>ornek_14.c </strong>programında <strong>elemanlarinKaresiniAl </strong>fonksiyonu bu şekilde de yazılabilirdi.</p><pre>void elemanlarinKaresiniAl(int * const diziPtr, const int uzunluk) {<br>    for (int i = 0; i &lt; uzunluk; ++i)<br>    {<br>        diziPtr[i] *=  diziPtr[i];<br>    }<br>}</pre><p>Gösterici/indeks gösterimi ile gösterici adresi yani gösterdiği yer hiç değiştirilmeden (Farklı gösterimler de kullanılabilirdi.) işaret edilen adreslerin değerlerinde değişiklikler yapılabilirdi.</p><h4>3- Sabit Değeri Gösteren Sabit Olmayan Gösterici</h4><pre>void fonksiyon(const int *parametre);</pre><p>Bu tür aşağıdaki işleme izin verir:</p><ul><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adres <strong>değiştirilebilir</strong>.</li></ul><p>Bu tür aşağıdaki işleme izin vermez:</p><ul><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adreste yer alan veri <strong>değiştirilemez</strong>. (Gösterdiği değer değiştirilebilir.)</li></ul><p>Bu tip gösterici bir dizi üzerinde gezinme imkanı (gösterici aritmetiğinin uygulanabilir olması) ancak dizi elemanları üzerinde bir değişiklik yapılmasına izin verilmemesi gerektiğinde kullanılır.</p><p>Genelde dizi yazdırma gibi işler için uygundur.</p><h4>4- Sabit Değeri Gösteren Sabit Gösterici</h4><pre>void fonksiyon(const int *const parametre);</pre><p>Bu tür aşağıdaki işlemlere izin vermez:</p><ul><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adres <strong>değiştirilemez</strong>.</li><li>Fonksiyona argüman olarak giren göstericinin tuttuğu adreste yer alan veri <strong>değiştirilemez</strong>. (Gösterdiği değer değiştirilebilir.)</li></ul><p>Parametre üzerinde en az hatta hiç işlem yapılmamasını sağlayan gösterici tipi bu tiptir.</p><p>Salt yazdırma veya bir sabit gibi kullanma işlemleri için idealdir. <strong>ornek_14.c </strong>programında <strong>diziyiYazdir </strong>fonksiyonu içindeki ilk parametre de bunun örneğidir.</p><pre>void diziyiYazdir(const int * const diziPtr, const int uzunluk)<br>{<br>    for (int i = 0; i &lt; uzunluk; ++i)<br>    {<br>        printf(&quot;diziPtr[%d] = %d\n&quot;, i, diziPtr[i]);<br>    }<br>}</pre><p>Son olarak, <strong>ornek_14.c </strong>programının çıktısını inceleyelim:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/536/1*-VMl0aZfaNoIYGYC2Id7qA.png" /><figcaption><strong>ornek_14.c </strong>Programının Çıktısı</figcaption></figure><h3>Kapanış</h3><p>Bu yazıda sizlere <strong>C Programlama Dili</strong>’nde ustalaşması zaman isteyen ve benim de ustalaşmak için kat etmem gereken uzun bir yolu olan <strong>göstericiler </strong>İngilizcesi ile <strong>pointers </strong>konusunun temelini ve çeşitli yönlerini gerek görsellerle gerek program örnekleri ile aktarmaya çalıştım.</p><p>Kendi öğrenme yolculuğumda faydasını gördüğüm kısımları vurgulamaya çalıştım. Örnek düzeylerini ise uzamaması ve konu özüne odaklanması için basit tutmaya çalıştım. Umarım bu yaklaşımla beraber bu yazı; konuya ilgi duyan, yeni başlayanlar veya daha önce başlayıp bir şekilde unutmuş olanlar için yararlı bir yazı olmuştur.</p><p>Konuyu daha iyi anlamak ve daha kaliteli örneklerle karşılaşmak için aşağıdaki kaynaklardan faydalanabilirsiniz:</p><ul><li><a href="https://deitel.com/c-how-to-program-9-e/"><strong>C: How to Program (8–9th Edition)</strong></a><strong><em> — </em>Chapter 7: Pointers</strong></li><li><a href="https://www.youtube.com/watch?v=nvO1sq_b_zI&amp;list=PLhQjrBD2T383f9scHRNYJkior2VvYjpSL&amp;index=6"><strong>YouTube/CS50/CS50 2021 in HDR — Lecture 4 — Memory</strong></a></li><li><a href="https://www.youtube.com/watch?v=zuegQmMdy8M&amp;t=17s"><strong>YouTube/freeCodeCamp.org/Pointers in C / C++ [Full Course]</strong></a></li><li><a href="https://necatiergin2019.medium.com/list/c-yazlar-2dbdfa366c2e"><strong>Medium/Necati Ergin/C Yazıları</strong></a></li></ul><p><strong>Önceki Yazılarımı Okumak İstersiniz</strong></p><ul><li><a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">Fonksiyonlar ve Return İfadesi</a></li><li><a href="https://medium.com/@ismet.erdogn/hanoi-kuleleri-4c353b760859">Hanoi Kuleleri ve C Programlama Dilinde Çözümü</a></li></ul><p>Görüşlerinizi, eleştirilerinizi bana bu kanal üzerinden gönderebilirsiniz.</p><p>Bir sonraki yazıda görüşmek üzere.</p><p>Sevgiler,</p><blockquote>Uzun bir aradan sonra yeniden merhaba! Bu uzun aralar bu hesapta bir normal bir hale gelmeye başladı. Umarım bu durum anormal bir hale gelir :) Başlangıçta <a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">Fonksiyonlar</a> sonrasında <a href="https://medium.com/@ismet.erdogn/hanoi-kuleleri-4c353b760859">Hanoi Kuleleri</a> şimdi ise Göstericiler (Pointers), umarım bu üç yazı da amaçlarına ulaşabilmiştir. Göstericiler konusu da tıpkı Hanoi Kuleleri gibi yazmaya ilk başladığımdan aklımda olan konulardan biriydi, sonunda bu konuyu da aklımdan çıkarabildim :) Bu yazının yayınlanacağı tarih olan bir ihtimal 30 Ağustos’ta (veya yüksek ihtimal 31 Ağustos tarihinde dünden) bayramımız olan <strong>30 Ağustos Zafer Bayramı’mızı kutlarım. Vatanımız için canlarını feda eden askerlerimize, onları yetiştiren şanlı milletimize ve Mustafa Kemal Atatürk’e minnet ve şükranla…</strong></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f328b85fc8e7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hanoi Kuleleri ve C Programlama Dilinde Çözümü]]></title>
            <link>https://medium.com/@ismet.erdogn/hanoi-kuleleri-4c353b760859?source=rss-98778f2a90e3------2</link>
            <guid isPermaLink="false">https://medium.com/p/4c353b760859</guid>
            <category><![CDATA[matematik]]></category>
            <category><![CDATA[c-programlama]]></category>
            <category><![CDATA[algoritma]]></category>
            <category><![CDATA[algoritmalar]]></category>
            <category><![CDATA[recursion-in-c]]></category>
            <dc:creator><![CDATA[Ismet Erdogan]]></dc:creator>
            <pubDate>Sun, 06 Nov 2022 00:25:03 GMT</pubDate>
            <atom:updated>2022-11-06T00:25:03.420Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Hanoi Kuleleri ve C Programlama Dilinde Çözümü — Kapak Resmi" src="https://cdn-images-1.medium.com/max/972/1*EZia5ibVU1If9ky36yF8hA.png" /><figcaption>Kashi Vishwanath Tapınağı (Tapınağın resmi <a href="https://medium.com/@shantanualshi/picking-apart-towers-of-hanoi-89e7f528ae5a">bu bağlantıdaki</a> Medium yazısından alınıp çeşitli değişikliler uygulanıp kullanılmıştır.)</figcaption></figure><p><em>Efsaneye göre Uzak Doğu’daki bir tapınakta rahipler belli bir sayıda olan diskleri bir kazıktan diğerine geçiriyorlardı. Toplamda 3 adet kazık vardı ve ilk kazıkta 64 adet disk yukarıya doğru küçülecek şekilde dizilmişti. İlk başta sadece ilk kazıkta diskler vardı ve diğer 2 kazığa geçirilmiş bir disk yoktu. Rahipler her bir seferde sadece bir diski hareket ettirerek ve bunu yaparken de küçük diskin daha büyük diskin üstüne konulma kısıtlaması ile birinci kazıktan ikinci kazığa diskleri taşımaya çalışıyorlardı. Ayrıca bu taşıma işlemlerini gerçekleştirmek için de üçüncü kazığı yardımcı kazık olarak kullanıyorlardı. Ve yine bu efsaneye göre bu hareketlerin sonuncusu tamamlandığında yani en küçük disk de ikinci kazığın en üstüne yerleştirildiğinde dünyanın sonu gelecektir.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/348/1*mjnMh1fGK1V3ptQnJvJEsw.jpeg" /><figcaption>Hanoi Kuleleri ve Bileşenleri (Resim <a href="https://www.tutorialspoint.com/data_structures_algorithms/images/tower_of_hanoi.jpg">bu bağlantıdan</a> alınmıştır.)</figcaption></figure><h3>Bir Matematik Oyunu: Hanoi Kuleleri</h3><p><strong>Hanoi Kuleleri’nin</strong> bir bulmaca olarak tanıtılması 1883&#39;te Fransız matematikçi <a href="https://en.wikipedia.org/wiki/%C3%89douard_Lucas">Édouard Lucas</a> sayesinde gerçekleşmiştir. Aynı bulmacayı <em>Brahma Kuleleri, Benares Tapınağı’nın Problemi </em>veya<em> Lucas’ın Kulesi </em>adı ile bulmak da mümkündür. Yazının ilk kısmındaki efsane de bu problemin dayandığı birçok efsaneden sadece biri.</p><p>İsterseniz oyunun detaylarına gitmeden önce kısaca yukarıdaki efsanemizi gözden geçirelim: Rahipler 64 adet diski bir kazıktan diğerine üçüncü bir yardımcı kazık kullanarak kurallara bağlı şekilde dizmek istiyorlar. Bildiğimiz şey ise H<strong>anoi Kuleleri’nin</strong> disk sayısına bağlı olarak en az kaç adımda başka bir kazığa dizilebildiğidir. En az adım sayısı şu şekilde formülize edilmiştir:</p><pre>- x değişkeni disk sayısını temsil ederse,<br>- y değişkeni ise disklerin tamamını ikinci kazığa götürmek için gereken adım sayısını temsil ederse formül şu şekilde olur:</pre><pre>y = 2^x - 1</pre><figure><img alt="y = x² — 1 Grafiği" src="https://cdn-images-1.medium.com/max/1024/1*84mbB6Xary5INtLLxuOChQ.png" /><figcaption>En az adım sayısının, disk sayısına bağlı değişimi</figcaption></figure><p>Yukarıdaki formülde ve grafiğinde de görüldüğü üzere tüm diskleri başka bir kazığa geçirmek için gereken en az adım sayısı üstel zamanda artmaktadır.</p><p>Efsanedeki rahiplerin işine dönersek 64 adet diski diğer kazığa geçirmek için gerekli adımları gerçekleştirmekle meşguller. Peki bu 64 adet disk için ne en az ne kadar adım gerçekleştirmek gerekir diye düşünürsek formüle dayanarak bu sayının 18446744073709551615 olduğunu söyleyebiliriz. (Söyleyebilir miyiz gerçekten diye düşünürken 18 446 744 073 709 551 615 şeklinde sayıyı ayırmam gerekti ve bu sayı 18 kentilyon 446 katrilyon 744 trilyon 73 milyar 709 milyon 551 bin 615 oldu. İşte şimdi söyleyebildim :) )</p><p>Sayı o kadar büyük oldu ki 4 hane daha eklesek <a href="https://en.wikipedia.org/wiki/Avogadro_constant"><em>Avagadro Sayısı</em></a>’na basamak sayısı olarak ulaşmış oluyoruz ki bu sayıyı hayal etmek gerçekten zor! Konudan bağımsız bu sayıyı biraz olsun hayal edebilmek için <a href="https://www.youtube.com/c/Bar%C4%B1%C5%9F%C3%96zcan"><em>Barış Özcan</em></a>’ın <a href="https://www.youtube.com/watch?v=7AW4dTcgyRk"><strong>bu videosunu</strong></a> izleyebilirsiniz.</p><p>Diyelim ki her bir adım bir saniye gibi çok küçük bir süre içinde gerçekleşsin. Bu adımları gerçekleştirmek için gereken yıl sayısı en az <strong>584 942 417 355</strong> olurdu. <a href="https://en.wikipedia.org/wiki/Age_of_Earth">Dünyanın yaşının</a> 4 milyar küsür olduğunu düşünürsek, efsane doğruysa dünyanın sonunun gelmesine çok uzun bir vakit var diyebiliriz.</p><h3>Şimdi Daha Yakından İnceleyelim</h3><p>Görüldüğü üzere Hanoi Kuleleri’nin <strong>2 tane önemli bileşeni</strong> vardır:</p><ul><li>Diskler</li><li>Kazıklar veya çubuklar</li></ul><p>İstenilen sayıda disk ile bu bulmaca kurgulanıp çözülebilir. (yeteri kadar zamanınız varsa)</p><p>Kazık veya çubuk denilen bileşende ise sayı bellidir ve bu sayı 3 tür. Başlangıç durumunda tüm diskler herhangi bir çubukta yukarıya doğru küçülen sırada dizilmiştir bu çubuk <em>başlangıç çubuğu’dur</em>, ikinci çubuk ise tüm disklerin yerleştirilmek istendiği <em>hedef çubuğu’dur, </em>geriye kalan üçüncü çubuğu ise adımlar gerçekleştirilirken geçici disk koyma bölgesi olarak kullanılan <em>geçici disk tutma çubuğu </em>’dur.</p><figure><img alt="Hanoi Kulelerinin Gösterimi" src="https://cdn-images-1.medium.com/max/728/1*ZPMjyr3TQqIx0kRAbuu4LQ.png" /><figcaption>Hanoi Kulelerinin Örnek Bir Modeli (Bu resim <a href="https://deitel.com/c-how-to-program-9-e/">C:How to Program (9th Edition)</a>’dan alınmıştır.)</figcaption></figure><p>Yukarıdaki resimde gördüğünüz üzere <strong>3 tane çubuk</strong> ve <strong>4 tane disk</strong> vardır. Diskler başlangıç pozisyonundadır ve ikinci veya üçüncü çubuklardan biri seçilerek o çubuğa dizilmeye hazır bir şekilde beklemektedir. 2 farklı senaryoda oyunu oynayabiliriz:</p><ul><li>2. çubuğu <em>geçiçi disk tutma çubuğu</em> olarak seçip 3. çubuğu olarak <em>hedef çubuğu</em> belirlemek.</li><li>3. çubuğu <em>geçiçi disk tutma çubuğu</em> olarak seçip 2. çubuğu olarak <em>hedef çubuğu</em> belirlemek.</li></ul><p>Sizin de bu oyunu oynamanız için aşağıya bağlantı bırakıyorum. Tamamlamak için yaptığınız hamle sayısı ile gereken en az hamle sayısını karşılaştırmayı unutmayın. :)</p><p><a href="https://www.mathsisfun.com/games/towerofhanoi.html">Tower of Hanoi</a></p><p>Oyunu biraz kurcaladıysanız en az hamle ile oyunu nasıl bitirebileceğinizi az çok anlamış olabilirsiniz. Şimdi 3 diskten oluşan bir oyunu da en az hamle ile nasıl bitirebileceğimizi düşünmeye çalışalım.</p><figure><img alt="3 Diskli Hanoi Kuleleri — İlk Durum" src="https://cdn-images-1.medium.com/max/690/1*XrfQraj87OgoG6rWADT0Mw.png" /><figcaption>Başlangıç Durumu</figcaption></figure><p>Yukarıdaki resimde gördüğünüz üzere <strong>3 diskli Hanoi Kuleleri</strong> oyunu bizi karşılamaktadır ve oyun görevi tüm disklerin 3. diske yerleştirilmesi olarak tanımlanmıştır.</p><p>Şu şekilde düşünebiliriz: Görev, 3 diski de 3. çubuğa taşımak ise olayı şu şekilde 3 parçaya ayırabiliriz.</p><ul><li>Tüm diskleri 3. çubuğa dizmek için öncelikle en büyük diskin 3. çubuğa yerleştirilmesi gerekir (Kurallar gereği). O halde <strong>ilk aşama</strong> olarak büyük diskin üstünde <strong>2 disk (küçük ve orta boyutta) 2. çubuğa yerleştirilmeli</strong> (Bu parça kendi için de aşamaları olan bir ana parça olarak düşünülebilir.).</li><li>İlk kısım yapıldığında <strong>en büyük diskin üstü boşaldığı için rahatlıkla 3. çubuğa yerleştirilir</strong>.</li><li>Şimdi sırada <strong>ortanca çubukta kalan 2 diski 3. çubuğa taşımak</strong> kaldı. Bu da tamamlandığında oyunumuz bitmiş olacak (Bu parça da kendi için de aşamaları olan bir ana parça olarak düşünülebilir.).</li></ul><p>Bu sefer sadelik açısından yaptıklarımızı biraz daha sadeleştirelim:</p><ul><li><strong>İlk çubuktaki 2 disk, 2. çubuğa taşınır</strong>. (Kendi içinde aşamaları vardır.)</li><li><strong>İlk çubukta kalan en büyük disk, 3. çubuğa taşınır</strong>. (Tek bir hamlede yapılabilir)</li><li>İlk aşamada <strong>2. çubuğa yerleştirilen 2 disk, 3. çubuğa taşınır</strong>. (Kendi içinde aşamaları vardır.)</li></ul><p>Görüldüğü üzere <strong>birinci </strong>ve <strong>üçüncü </strong>kısımlar kendi içinde de aşamaları olan kısımlardır. Çünkü 2 diski aynı anda hareket ettirilmesine oyun kuralları izin vermez. Şimdi biraz daha detaylı bir sıralı görev listesi yapalım.</p><p><strong>Ana Görev</strong>: 1. çubuktaki 3 diski 3. çubuğa yerleştirmek. (2. çubuk, geçici çubuk olarak kullanılacak)</p><ul><li><strong>1. çubuktaki 2 diski 2. çubuğa taşı</strong>. (3. çubuk: <em>geçici çubuk</em>)<br><em>1-)</em> 1. çubuktaki en küçük diski 3. çubuğa taşı.<br><em>2-)</em> 1. çubuktaki ortanca diski 2. çubuğa taşı.<br><em>3-)</em> 3. çubuktaki en küçük diski 2. çubuğa taşı.</li><li><em>4-)</em> 1. çubuktaki en büyük diski 3. çubuğa taşı.</li><li><strong>2. çubuktaki 2 diski 3. çubuğa taşı. </strong>(1. çubuk: <em>geçici çubuk</em>)<strong><br></strong><em>5-)</em> 2. çubuktaki en küçük diski 1. çubuğa taşı.<br><em>6-)</em> 2. çubuktaki ortanca diski 3. çubuğa taşı.<br><em>7-)</em> 1. çubuktaki en küçük diski 3. çubuğa taşı.</li></ul><p>Yukarıdaki liste ile sanki bazı görevlerin bir aşamaya kadar tekrar ettiğini: ana görevin temelde 3 alt göreve bölündüğü ve o alt görevlerde de disk sayısının 1 den fazla olduğu durumlarda yine 3 alt göreve bölündüğü fark etmiş olabilirsiniz.</p><p>Bir işlevin yine kendi işlevlerini çağırması <a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">önceki yazımda</a> bahsettiğim <a href="https://en.wikipedia.org/wiki/Recursion_(computer_science)"><em>özyinelemeli fonksiyonların</em></a> yaptığı işin ta kendisidir. Burada <em>özyinelemeli fonksyionun</em> temel durumu (<em>base case</em>) ise sadece bir diski bir çubuktan bir çubuğa taşımaktır: Görüldüğü üzere de sadece bir diskin taşındığı durumlarda alt görevler çağrılmamış ve tek bir adımda görev tamamlanmıştır. Bu kısım eğer kafanızda tam olarak canlanmadıysa yapacağımız kod örneği ile kafanızda daha da iyi canlanacaktır.</p><p>Ayrıca yukarıda tamamladığımız oyunun 3 disk için 7 adımda bittiğini görmekteyiz. Bu en başta anlattığımız formüle göre de 3 disk için yapabileceğimiz <strong>en az adımda</strong> oyunu tamamladığımızı göstermektedir. (2³ -1 = 7)</p><p><strong>Sırasıyla adımlar:</strong></p><figure><img alt="Hanoi Kuleleri Oynanış" src="https://cdn-images-1.medium.com/max/524/1*1iAj1vBFG7PpqDXBWxEvLg.png" /><figcaption>Adım 1</figcaption></figure><figure><img alt="Hanoi Kuleleri Oynanış" src="https://cdn-images-1.medium.com/max/521/1*NaQ4aIu_C6Jy4nNf92hYGg.png" /><figcaption>Adım 2</figcaption></figure><figure><img alt="Hanoi Kuleleri Oynanış" src="https://cdn-images-1.medium.com/max/520/1*gR0G8TszoXjcKuO055P73g.png" /><figcaption>Adım 3</figcaption></figure><figure><img alt="Hanoi Kuleleri Oynanış" src="https://cdn-images-1.medium.com/max/518/1*JUht6S-B-oibQEIdcoAdCA.png" /><figcaption>Adım 4</figcaption></figure><figure><img alt="Hanoi Kuleleri Oynanış" src="https://cdn-images-1.medium.com/max/518/1*esEaOILhlq87fGmU-xm6QA.png" /><figcaption>Adım 5</figcaption></figure><figure><img alt="Hanoi Kuleleri Oynanış" src="https://cdn-images-1.medium.com/max/521/1*NCu3gymnhK6KeEHOjLi0AA.png" /><figcaption>Adım 6</figcaption></figure><figure><img alt="Hanoi Kuleleri Oynanış" src="https://cdn-images-1.medium.com/max/519/1*PFTM0S32cCkgvtA205F-6w.png" /><figcaption>Adım 7 ve son!</figcaption></figure><h3>Hanoi Kuleleri’ni C Programlama Dili ile Çözmek</h3><p>Bir önceki başlık altında 3 diskli <em>Hanoi Kuleleri</em>’ ni çözerken ana amacımıza ulaşmak için temelde 3 görevi yerine getirmemiz ve bu 3 temel görevin birincisi ve sonuncusunun da yine birden fazla dikin taşınması gerektiği için yine 3 alt göreve ayrıldığını görmüştük. Ayrıca bu sebeple <em>3 * 1 + 1 + 3 * 1 = 7</em> olmak üzere bu problemin 7 hareket ile çözüldüğünü görmüştük. Bunları görürken bu tip bir davranışın <strong>özyinelemeli fonksiyonlara</strong> çok benzediğinden de bahsetmiştik.</p><p>Bu başlık altında bu problemi <strong>C Programlama Dili</strong>’nde <strong>özyinelemeli yaklaşım</strong> ile çözeceğiz. Yani diski hareket ettirmeyi bir <strong>özyinelemeli fonksiyon (recursive function) </strong>olarak tanımlayacağız.</p><p>Eğer <strong>özyinelemeli fonksiyon</strong> nedir tam anlamıyla bilmiyorsanız <a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">bir önceki yazıma</a> göz atabilirsiniz.</p><p>Şimdi fonksiyonumuzu türetmeye çalışalım.</p><ul><li>Fonksiyon öncelikle özyinelemeli bir fonksiyon olacak.</li><li>Fonksiyon ismi <em>diskiHareketEttir(…) </em>olsun.</li><li>Parametre olarak:<br>- Toplam disk sayısı: <em>(int toplamDiskSayisi)</em><br>- Disklerin halihazırda durduğu çubuk: <em>(int baslangicCubugu)</em><br>- Disklerin hareket ettirileceği çubuk: <em>(int hedefCubugu)</em><br>- Disklerin geçici olarak yerleştirileceği çubuk: <em>(int geciciCubuk) </em>alacak<em>.</em></li><li><strong>Özyinelemeli fonksiyonun</strong> sonsuz özyineleme yapmasını engellemek için yazmamız gereken<strong> temel durum</strong> (<em>base case</em>) ise <em>toplamDiskSayisi, </em>1&#39;e eşit olduğunda bir diski hareket ettirerek ve <strong>boş değer döndürerek </strong><em>(return;) </em><strong>özyineleme zincirinin </strong>sonuna ulaşılmış olacak.</li></ul><p>Şimdi bu yazdıklarımızı <strong>C Programlama Dili’nde</strong> fonksiyonun kendisini (<em>function header</em> ve <em>function body</em>) kısımlarını yazarak ifade edelim.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/e8509c6016b03471edbab9379a121573/href">https://medium.com/media/e8509c6016b03471edbab9379a121573/href</a></iframe><p>Adım adım <a href="https://gist.github.com/ismeterd/f1e0091379e1680f29fc404e3b2d4cee">hanoi_recursive1.c</a> içindeki fonksiyon tanımıza bakalım:</p><ul><li><em>Function header</em> denilen kısımı incelediğimizde <em>void </em>yani <em>değer döndürmeyen bir fonksiyon</em> olduğunu anlamış oluruz. Daha sonra <em>parametrelerine </em>bakacak olursak da bunların bizim fonksiyon türetirken oluşturduğumuz isim ve tanımlamalarla uygun olduğunu görürürüz.</li><li>Asıl işlerin döndüğü fonksiyonun içi yani <em>function body</em> denilen kısmı incelediğimizde ilk başta temel durum yani <em>base case </em>ile karşılaşırız. Burada eğer <strong>disk sayısı 1&#39;e eşitse</strong> sadece tek bi işlemin gerçekleşeceği yani <strong>1 diskin başlangıç çubuğundan hedef çubuğuna</strong> aktarılacağı yazdırılmıştır. Ayrıca bu bu kısım <em>özyineleme zincirinin</em> son kısmını ifade ettiği için yazdırma işleminden sonra <em>return; </em>ifadesi kullanılmıştır. Burada <em>return</em> hiçbir değer döndürmemektedir, sadece fonksiyon işlevini sonlandırmaktadır.</li><li><strong>if bloğu</strong> dışında kalan kısım ise disk sayısının 1&#39;den büyük olması durumunda gerçekleşecek görev bölümünü temsil etmektedir. Bu kısım bir önceki başlıkta incelenen özyinelemeli yakaşımı esas almaktadır. Yapılmak istenen ana görevi yapmak için yapılması gereken alt görevleri temsil eder.</li><li>Şu şekilde açıklanabilir:<br><strong>n adet diski 1&#39;den 3&#39;e hareket ettirmek istiyorsan:</strong><br>1. Öncelikle (n-1) adet diski 1&#39;den 2&#39;ye hareket ettir.<br>2. Sonra 1&#39;de kalan son diski (en büyük disk) 3&#39;e hareket ettir.<br>3. Son olarak (n-1) adet diski 2&#39;den 3&#39;e hareket ettir.</li><li>Fonksiyondan anladığımız üzere (n-1) sayısı da 1&#39;e eşit olmadığında yine 3 alt göreve doğru dallanma olmaktadır ve disk sayısı alt görevlerde 1&#39;e ulaşana kadar bu dallanma devam etmektedir.</li></ul><p>Aşağıdaki görsel bu durumu 4 diskli için güzel bir şekilde özetlemektedir:</p><figure><img alt="4 Diskli Hanoi Kulelerinin Özyinelemeli Yaklaşımla Görselleştirilmesi" src="https://cdn-images-1.medium.com/max/1024/1*yEvNbtYbvRSu4KPt0fv_bQ.png" /><figcaption>4 diskli Hanoi Kuleleri’nin özyinelemeli yaklaşımla görselleştirilmesi.</figcaption></figure><p>Ana programımız ise aşağıdaki gibidir:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3fa67d79a3325657c01689db76f155c5/href">https://medium.com/media/3fa67d79a3325657c01689db76f155c5/href</a></iframe><p>Yukarıdaki programda görüldüğü üzere <em>diskiHareketEttir(…) </em>fonksiyonu içine sırasıyla <strong>3, 1, 3, 2 argümanları girilerek yapılmak istenenin 3 diskin 1. çubuktan 3. çubuğa (2. çubuğu geçiçi disk tutma çubuğu kullanarak)</strong> belirtilmiştir.</p><p>Ve çıktımız aşağıdaki gibidir.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/511/1*F_NQK_LTpoceuTSdT96r7w.png" /><figcaption><a href="https://gist.github.com/ismeterd/a12490bccbc0130c7d3a16ecde42d7a4">hanoi_recursive2.c</a> programının çıktısı.</figcaption></figure><p>Görüldüğü üzere resimdeki adımlarla ilk başta yaptığımız adımlarla uyuşmaktadır.</p><blockquote>Ek olarak bu başlık altında karşınıza kalın harflerle çıkmış olan kavramlara tam olarak hakim değilseniz <a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">bu bağlantıdan</a> bir önceki yazıma ulaşabilirsiniz.</blockquote><h3>Kapanış</h3><p>Bu yazıda sizlere <strong>Hanoi Kuleleri</strong>’nin ne olduğuna ve çözümünü <strong>özyinelemeli yaklaşımla</strong> <strong>C Programlama Dili</strong>’nde nasıl çözebiliriz? sorusuna yanıt vermeye çalıştım. Çeşitli örneklerle, resimlerle ve programlarla desteklemeye çalıştım.</p><p>Bu konuda yazı yazmadan önce birçok kaynaktan, videodan ve kitaptan yararlanarak anladıklarımı bir sentezle sizlere anlatmaya çalıştım. Umarım yukarıda saydığım amaçlarıma bir nebze ulaşabilip kafanızda en az soru işareti kalacak şekilde aktarabilmişimdir.</p><p><strong>Belki daha sonraki yazılarda</strong> farklı yaklaşımlarla çeşitli veri yapıları kullanarak Hanoi Kuleleri’ne yeni çözümler getirebiliriz.</p><p><strong>Çeşitli Kaynaklar</strong></p><ul><li><a href="https://deitel.com/c-how-to-program-9-e/"><em>C: How to Program (8-9th Edition)</em></a><em> — </em>Chapter 5: Functions (Exercises) (Problemle ilk tanıştığım yer :) )</li><li>Hanoi Kuleleri oyununu oynamak için <a href="https://www.mathsisfun.com/games/towerofhanoi.html">bu bağlantı</a>.</li><li><a href="https://en.wikipedia.org/wiki/Tower_of_Hanoi">Wikipedia/Tower of Hanoi</a></li><li><a href="https://en.wikipedia.org/wiki/Kashi_Vishwanath_Temple">Wikipedia/Kashi Vishwanath Temple</a></li><li><a href="https://en.wikipedia.org/wiki/%C3%89douard_Lucas">Wikipedia/Édouard Lucas</a></li><li><a href="https://medium.com/algorithms-data-structures/hanoi-kuleleri-1-a74bf4e7a48f">Medium/Onur Dayıbaşı/Hanoi Kuleleri</a></li><li><a href="https://medium.com/devopstr/hanoi-kuleleri-algoritmas%C4%B1-7d7324df229b">Medium/Peker Mert Oksuz/Hanoi Kuleleri Algoritması</a></li><li><a href="https://medium.com/@shantanualshi/picking-apart-towers-of-hanoi-89e7f528ae5a">Medium/shantanu alshi/Picking apart Towers of Hanoi</a></li><li><a href="https://www.geeksforgeeks.org/c-program-for-tower-of-hanoi-2/">GeeksForGeeks/C Program for Tower of Hanoi</a></li><li><a href="https://www.youtube.com/watch?v=2SUvWfNJSsM">Youtube/3Blue1Brown/Binary, Hanoi and Sierpinski, part 1</a><br><em>İkilik tabanda sayma</em> ile Hanoi Kuleleri’ni çözerken kullandığımız <em>özyinelemeli yaklaşımın</em> birbirleriyle olan ilişkişini açıklayan <strong>harika </strong>bir video.</li></ul><p><strong>Önceki Yazımı Okumak İstersiniz</strong></p><p><a href="https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1">Fonksiyonlar ve Return İfadesi</a></p><p>Görüşlerinizi, eleştirilerinizi bana bu kanal üzerinden gönderebilirsiniz.</p><p>Bir sonraki yazıda görüşmek üzere.</p><p>Sevgiler,</p><blockquote>Ufak bir vize döneminden sonra yeniden merhaba! İlk yazımı yayınlamamın ardından yaklaşık 4 ay geçtiğini düşününce zaman gerçekten hızlı geçiyor. Bu yazıdaki konu olan <strong>Hanoi Kuleleri;</strong> aklımda geçen yazdan beri olan, ilgimi çok çeken ve sizlerin de ilgisini çekecebileceğini düşündüğüm bir konu. Bu sebeple hazır önceki yazımda fonksiyonlardan bahsetmişken bu yazıda hem fonksiyonları kullanmamız hem eğlenceli bir problemi çözüme kavuşturmamız açısından bu konunun güzel denk geldiğini düşünüyorum. Umarım sizler de bu yazıya bu açıdan bakınca benimle benzer düşünceleri paylaşıyorsunuzdur ve yazıyı okumak hem bilgilendirici hem keyifli olmuştur :) Teşekkürler.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4c353b760859" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fonksiyonlar ve Return İfadesi]]></title>
            <link>https://medium.com/@ismet.erdogn/fonksiyonlar-ve-return-ifadesi-be25eeef7ec1?source=rss-98778f2a90e3------2</link>
            <guid isPermaLink="false">https://medium.com/p/be25eeef7ec1</guid>
            <category><![CDATA[c-programlama-dili]]></category>
            <category><![CDATA[yazılım]]></category>
            <category><![CDATA[structured-programming]]></category>
            <category><![CDATA[yazilim-gelistirme]]></category>
            <category><![CDATA[fonksiyonlar]]></category>
            <dc:creator><![CDATA[Ismet Erdogan]]></dc:creator>
            <pubDate>Fri, 08 Jul 2022 08:11:32 GMT</pubDate>
            <atom:updated>2022-07-08T08:11:32.282Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/416/1*d5-Ok7GAyzKjlyW7oD3lig.png" /></figure><p><strong><em>Fonksiyonlar</em></strong><em>, yazılım öğrenmeye başlayan birinin çoğunlukla koşullu durumlar ve döngülerden sonra karşılaştığı bir konudur. Fonksiyonların tam olarak ne için kullanıldığı, yazılan programlar içinde nasıl yer aldığı ve fonksiyonun ayrılmaz parçası denebilecek </em><strong><em>return </em></strong><em>ifadesinin ne işe yaradığı gibi şeylerse yeni başlayan biri için kafasında bazı soru işaretlerine yol açmaktadır. Bu yazı bu soru işaretlerini bir nebze giderebilmesi için yazılmıştır. Fonksiyon anlatımı ve örnekleri </em><strong><em>C Programlama Dili</em></strong><em> üzerinden olacaktır.</em></p><h3>Fonksiyon Nedir?</h3><p>Aslında çoğumuzun fonksiyon kavramı ile tanışması lise veya daha önceki yıllara uzanmaktadır. Lisede bu konuya genellikle şu klişe örnek ile başlanır: <em>Fonksiyonu bir makine gibi hayal edin. İlk başta içine bir şeyler vermeniz gerekiyor, sonrasında ise makine içine giren maddeye bir takım işlemler uyguluyor ve makineden ilk baştaki maddeden farklı bir madde çıkıyor</em>. Bu örnek çok klişe olsa da konuya ilk adımı attırmak da başarılı. Hatta bu örnek yazılım içinde gördüğümüz fonksiyonları anlamlandırmak konusunda da gayet iyi. O zaman fonksiyonları şu 3 parçada özetleyebiliriz:</p><ul><li>Girdi</li><li>Girdi üzerine yapılan çeşitli işlemler</li><li>Çıktı</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/226/1*MeBsUybbl2WKhAUMtz3w1A.png" /><figcaption><a href="https://courses.p2pu.org/en/courses/1079/content/2281/">Yukarıdaki anlatımın görselleştirilmiş hali</a></figcaption></figure><p>Ek olarak daha önce hiç fonksiyon tanımlamamış olabilirsiniz ama herhangi bir dilde kod yazarken aslında önceden tanımlanmış fonksiyonları kullanıyorsunuz. Bunun örneğini C Programlama Dili’nde örnek vermek gerekirse <em>printf()</em>, <em>scanf()</em>, <em>getchar()</em>, <em>sizeof() </em>ve daha sınırsız sayıda fonksiyonu programlarımızda kullanmaktayız.</p><p>Bu kadar sözün ardından bir örnek ile yazılanları somutlaştırabiliriz.</p><h3>Bir Fonksiyon Örneği ve Return İfadesi</h3><p>Şöyle bir fonksiyon düşünelim: Fonksiyonun amacı dikdörtgenin alanını çıktı olarak vermesi.</p><p>Fonksiyonun izleyeceği adımlar:</p><ul><li>Dikdörtgenin alanın hesabı için 2 farklı kenarın bilinmesi gerekir. O halde bu fonksiyonun içine uzun kenar ve kısa kenarın girilmesi gerekir.</li><li>Bu alan hesabını fonksiyonun yapabilmesi için alanın nasıl bulunacağı fonksiyon içinde belirtilmelidir. Fonksiyonun bu aşamada yapması gereken uzun kenar ve kısa kenarı çarpmasıdır.</li><li>Daha sonra elde edilen bu alan değeri fonksiyonun dışına çıkarılmalıdır. Yani çıktı olarak verilmesi gerekmektedir. Burada ilk kez değineceğimiz kavram olan değer döndürme (<em>return </em>ifadesi) ortaya çıkmaktadır. Değer döndürme sayesinde fonksiyon artık döndüreceği değere eşit olmuştur. Bu örneğimizde alanı çıktı olarak vermemiz gerekmektedir. O zaman fonksiyonumuzun döndüreceği değer alanın ta kendisidir.</li></ul><p>Şimdi bu yazdıklarımızı kod üzerinde gerçekleştirelim ve ilk fonksiyonumu tanımlayalım.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/740bf5f0e3ec766d9387476e20eb0d7f/href">https://medium.com/media/740bf5f0e3ec766d9387476e20eb0d7f/href</a></iframe><p>Şimdi ise sırasıyla kodu inceleyelim:</p><ul><li><em>unsigned int DikdortgenAlani</em>: Bu kısımda <em>DikdortgenAlanı </em>şeklinde yazılan kısım fonksiyonun ismini temsil etmektedir. Başında yazan <em>unsigned int</em> ise bu fonksiyonun döndüreceği değerin veri tipini ifade etmektedir. Döndürülecek değer pozitif tam sayı şeklinde düşünüldüğü için <em>unsigned int</em> veri tipi kullanılmıştır.</li><li>İlk kısımdan hemen sonra <em>(unsigned int kenar1, unsigned int kenar2)</em> kısmı gelmektedir. Bu kısım fonksiyonun alacağı parametrelerin belirlendiği kısımdır. Parametre diye bahsettiğimiz şey aslında fonksiyonun içine girecek olarak girdi’leri ifade eder. Görüldüğü üzere burada <em>kenar1 </em>ve <em>kenar2 </em>olmak üzere 2 parametre vardır. Ve bu parametreler pozitif tam sayı olarak alınacağı için <em>unsigned int</em> veri tipi tanımlayıcısı kullanılmıştır. Bu kısım ile <em>function header</em> denilen kısım bitmiş olur.</li><li>Şimdi <em>function body</em> denilen kısma geçebiliriz. Burada fonksiyonun yapacağı işlemler yer alır. Ve yukarıda görüldüğü üzere <em>return alan</em> ifadesi ile de son bulur. Öncelikle <em>unsigned int</em> veri tipinde alan değişkeni oluşturulmuştur ve başlangıç değeri olarak sıfıra eşitlenmiştir. Daha sonra alan değeri, parametrelerin tuttuğu değerlerin çarpımı olduğu için <em>alan = kenar1 * kenar2 </em>satırı yazılmıştır. Fonksiyonun içindeki son satır olan <em>return alan</em> satırı ile birlikte alan değeri döndürülmüştür. <em>return </em>ifadesi değeri döndüren deyimdir ve yukarıdaki gibi kullanılır.</li></ul><p>Şimdi ise bu fonksiyonumuzu kullanarak şöyle bir program yazalım:</p><ul><li>Kullanıcıdan sırasıyla dikdörtgenin kenarları alınsın.</li><li><em>dikdortgenAlan</em> adinda bir değişken oluşturalım ve yazdığımız fonksiyona eşitşeyelim.</li><li>Daha sonra kenarları ve dikdörtgenin alanını yazalım.</li></ul><p>Programımız:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/8dc6d80070f2097a1f1368e1c4551fc4/href">https://medium.com/media/8dc6d80070f2097a1f1368e1c4551fc4/href</a></iframe><p>Programımızın çıktısı aşağıdaki gibidir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*3V2ZqEGRZsyangTUK1_WFA.png" /><figcaption><a href="https://gist.github.com/ismeterd/7acb1e42837ee87fd74a977d3cd2e9b0">function2.c</a> output</figcaption></figure><p>Şimdi programımızı detaylıca anlamaya çalışalım:</p><ul><li>C Programlama Dili’nde <em>#include</em> gibi <em>preprocessor </em>ifadeleri dışında genel olarak programımız <em>main()</em> fonksiyonu içinde çalışılır. Ama özelleşmiş bir fonksiyon diyebiliriz. C programımız çalıştırıldığında programımız otomatik olarak <em>main()</em> fonksiyonunu çağırır. Bizim yazdığımız fonksiyonlar gibi çağırmak zorunda değiliz. En önemli farklardan biri budur. Ayrıca görüldüğü üzere <em>main()</em> fonksiyonu başındaki <em>int</em> veri tipi ile döndüreceği değerin tam sayı tipinde olacağını bize söylemektedir. <em>main()</em> fonksiyonu <em>return</em> edildiğinde yani değer döndürdüğünde programımız sonlanır. Geleneksel olarak programlar, <em>main()</em> fonksiyonu <em>return 0</em> ile sonlanır. Buradaki 0 değeri programda herhangi ölümcül hata olmadan programın sonlandığını ifade eder. Eğer <em>main()</em> fonksiyonu içinde <em>return</em> ifadesi kullanmazsanız <strong>C</strong> otomatik olarak yine 0 argümanı ile programı sonlandıracaktır. Programın hangi kod ile sonlandığını terminalde görebilirsiniz. Örneğin yukarıdaki çıktıda <em>“Process finished with exit code 0”</em> yazmaktadır. Bu programın 0 argümanı ile sonladığını, anlamsal olarak da kritik bir hata olmadan programın tamamlandığını söylemektedir. 0&#39;dan başka argümanlar genel olarak hata durumlarında kullanılır.</li><li><em>DikdortgenAlani(…)</em> fonkiyonunu tanımladığımız satırlar <em>main()</em> fonksiyonun dışında yer almaktadır. Fonksiyon tanımlamaları başka fonksiyonlardan bağımsız şekilde yapılır ve bir başka fonksiyon içinde yapılmaz. Ve programların okunabilirliği açısından genellikle <em>main()</em> fonksiyonunun bitişinden sonra yapılır. Ayrıca fonksiyon tanımlamasının yapıldığı bu bölüm <em>function definition</em> olarak adalandırılmaktadır.</li><li>Programımızda görüldüğü üzere <em>main()</em> fonksiyonu üzerinde oluşturduğumuz fonksiyonumuz yer almaktadır. Bu kısma <em>“Function Prototype”</em> denir. Bu kısım sayesinde fonksiyonumuz derleyici tarafından tanınabilir hale gelmektedir. Derleyici bu prototipi kullanarak fonksiyonun <em>return (döndürülecek değerin) </em>veri tipini, alacağı parametrelerin sayısını ve tipini kontrol eder. Kısacası bu kısım da fonksiyon kullandığımız programlarımızda yer almalıdır. Yukarıda da olduğu gibi <em>“Function Header”</em> kısmını aynı şekilde yazarak prototipi yazabilirsiniz. Sonunda noktalı virgülü unutmayarak tabii ki :)</li><li><em>main()</em> fonksiyonunun içinde yani programımız asıl döndüğü kısımda <em>dkenar1 </em>ve <em>dkenar2 </em>adında 2 tane <em>unsigned int</em> veri tipinde değişken tanımladık ve başlangıç değer olarak 0 değerini atadık. Daha sonra kullanıcıdan 1. ve 2. kenarın değerlerini <em>scanf(…)</em> fonksiyonunu kullanarak aldık. Daha sonra <em>unsigned int</em> veri tipinde <em>dikdortgenAlan</em> isminde bir değişken tanımladık ve bunu yazdığımız fonksiyon olan <em>DikdortgenAlani </em>fonksiyonuna eşitledik. Fonksiyonumuza bu eşitlemeyi yaparken argümanlar olarak kullanıcıdan girdiğimiz değerleri girdik ( <em>DikdortgenAlani(dkenar1, dkenar2)</em> şeklinde). Burada <em>dkenar1</em> argümanı fonksiyon tanımını yaptığımız yerdeki <em>kenar1</em> parametresi, <em>dkenar2</em> argümanı ise <em>kenar2</em> parametresi olarak fonksiyon içinde kullanılmaktadır. Daha sonra fonksiyon gerekli işlemleri yapıp alanı hesaplamakta ve alan değerini döndürmektedir. Bu kısım şu şekilde düşünülebilir: diyelim ki kullanıcı <em>dkenar1</em>’ i 5, <em>dkenar2</em>’yi 4 olarak girsin. <em>unsigned int dikdortgenAlan = DikdortgenAlani(dkenar1, dkenar2)</em>; kısmı artık u<em>nsigned int dikdortgenAlan = 20 </em>olarak düşünülebilir<em>.</em> Çünkü bu fonksiyon 4 ve 5 değerlerini girdi olarak aldı gerekli işlemleri yaparak 20 değerini döndürdü. Yani fonksiyon artık 20 değerine eşit oldu. Artık istediğimiz yerde kullanabiliriz.</li><li>Sonra aldığımız bu <em>DikdortgenAlan</em> değerini <em>printf(…)</em> fonksiyonu ile konsola yazdırarak alanın kaç olduğunu öğrenmiş olduk.</li></ul><p>Yukarıdaki yaptığımız örnek temel bir örnek olsa da fonksiyonun temelde ne olduğunu ve nasıl çalıştığını anlamak adına önemli bir örnek olmaya adaydır.</p><p>Bu bölümü kapatmadan önce fonksiyon tanımlamayı genelleştirirsek şöyle bir formül ortaya çıkar:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/5bca5aa7bcbbfee131c2c2daee43ce39/href">https://medium.com/media/5bca5aa7bcbbfee131c2c2daee43ce39/href</a></iframe><h3>Değer Döndüren Fonksiyonlara Ek Olarak</h3><p>Fonksiyonları yeni öğrenen biri genellikle fonksiyonların yaptığı işe odaklanıp döndüreceği değeri ihmal edebiliyor. <em>return</em> ifadesine gerek yokmuş gibi düşünmek ilk başta çok mantıklı gelebiliyor. Bir toplama fonksiyonu yazarak bu durumu örnekleyebiliriz.</p><p>Toplama fonksiyonun yapması gerekenler:</p><ul><li>Toplayacağı iki sayıyı parametre olarak alacak.</li><li>İki sayıyı toplayacak.</li><li>Çıktı olarak verecek.</li></ul><p>Yeni başlayan biri olarak programı böyle veya daha farklı bir şekilde yazmak yaygın olabilmektedir.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/81e5f43d6a25113176530e0a433718cf/href">https://medium.com/media/81e5f43d6a25113176530e0a433718cf/href</a></iframe><p>Programın çıktısı ise şu şekildedir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/639/1*IZ_rngyo9EXdRCRQBSn-Gw.png" /><figcaption><a href="https://gist.github.com/ismeterd/b89bd63b5fdfcf1f60f4b14d2193cd64">funtion4.c</a> output</figcaption></figure><p>Çıktımız fonksiyonun yapması gereken işi doğru bir şekilde yaptığını göstermektedir. Ama fonksiyon içinde herhangi bir <em>return </em>ifadesi bulunmaması dikkatinizi çekmiş olabilir. Bu durumda fonksiyonumuz herhangi bir değer döndürmemektedir. Daha doğrusu <em>integer </em>veri tipinde değer döndüreceği fonksiyon tanımlamasında belirtilmiş (void kullanarak değer döndürmeyeceği de ifade edilebilirdi. İleride değineceğiz.). Fakat <em>return </em>kullanarak hangi değerin döndürülmesi gerektiği belirtilmemiştir. Aşağıdaki kod ile durumu açıklamaya çalışırsak:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/3d1ea8facf7a83630506fca866fc14cc/href">https://medium.com/media/3d1ea8facf7a83630506fca866fc14cc/href</a></iframe><p>Çıktı ise şu şekildedir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/637/1*O_o-fzLERoMUp4gyV3frxA.png" /><figcaption><a href="https://gist.github.com/ismeterd/94a74675349869df23f174f9c7dc6b3c">function5.c</a> output</figcaption></figure><p>Ne olduğunu anlamaya çalışırsak,</p><p>Öncelikle toplam adında <em>integer </em>veri tipinde değişken oluşturulup<em> topla(3, 5)</em> fonksiyonuna eşitlenmiş. Burada fonksiyon çağrıldığı için fonksiyon içindeki ifadeler de çalışarak toplam → 8 demekte ve doğru gözükmektedir.</p><p>Fakat bir alt satıra indiğimizde toplam değişkenin değerini konsola yazdırmak istediğimizde konsolda çıkan 12 sayısı gibi yanlış bir sonuç ile karşılaşmaktayız.</p><p>Bunun sebebi fonksiyonda bir değer döndürmemizin sonucu olarak bilgisayarın <em>integer </em>tipinde rastgele bir sayıyı fonksiyonun değer döndürtmesi şeklinde düşünebiliriz.</p><p>Peki nasıl değer döndüren (projelerimizde bu fonksiyonu bir çok yerde kullanıp sonuçlarını başka yerlere girdi olarak verebileceğimiz) bir topla fonksiyonu yazabiliriz.</p><p>En basit şekilde:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/f75d5c3e0194ad5181efad0ac51856aa/href">https://medium.com/media/f75d5c3e0194ad5181efad0ac51856aa/href</a></iframe><p>Şeklinde bir program yazarsak sorunun çözüldüğünü değer döndüren, değeri her yerde kullanabileceğimiz bir toplama fonksiyonu elde etmiş oluruz.</p><p>Örnek kolay olması dolayısıyla ben bu fonksiyonu zaten bir artı işareti ile ifade edebiliyorum diyebilirsiniz. Burada sadece kavramı basit bir şekilde anlatmak için böyle bir fonksiyon kullandık. Ayrıca programlar görece daha da büyüdükçe çeşitli girdilerden çeşitli çıktılar daha sonra onları yine başka girdiler olarak kullanacaksınız ve burada değer döndürmenin gücü çok daha kolay anlaşılacaktır.</p><h3>Başka bir Örnek Olarak Faktöriyel Fonksiyonu</h3><p>Fonksiyonlar sayesinde birçok matematiksel işlemleri, operatörleri ve fonksiyonları; fonksiyonun içinde gerekli işlemleri yaptırarak yazılım içinde kullandığımız bir fonksiyon olarak ifade edebilir ve bu fonksiyonları ihtiyacımız olan yerlerde kullanabiliriz. Örnek olarak kullanıcı tarafından girilen bir sayının faktöriyelini hesaplayan bir fonksiyon yazalım.</p><p>Bu fonksiyonun yapması gerekenler şu şekilde olacaktır.</p><ul><li>Girdi olarak bir tamsayı alması</li><li>Fonksiyonun içinde çeşitli işlemler ile faktöriyelin sonucunu hesaplaması</li><li>Ve son olarak elde edilen sonucun çıktı değer döndürmesi (sonucun <em>return</em> edilmesi)</li></ul><p>O halde şöyle bir fonksiyon yazabiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/dfd1ddf5076d183027ec07cca456a56e/href">https://medium.com/media/dfd1ddf5076d183027ec07cca456a56e/href</a></iframe><p>Şimdi yukarıdaki fonksiyonu anlamaya çalışalım:</p><ul><li>Öncelikle <em>Faktoriyel(...)</em> fonksiyonunun döndüreceği değer, pozitif bir tam sayı (işaretsiz tam sayı) olacağı için <em>unsigned int Faktoriyel(…) </em>şeklinde yazıldı (<em>int </em>olarak da yazılabilirdi).</li><li>Daha sonra sadece pozitif tam sayılar ve 0’ın faktöriyeli alınabildiği için fonksiyon girdisi (parametresi) <em>Faktoriyel(unsigned int sayi) </em>olarak yazıldı (<em>int </em>olarak da yazılabilirdi). Bu kısımla birlikte <em>function header</em> kısmı tamamlanmış oldu.</li><li><em>Function body</em> kısmına geçecek olursak bloğumuz <em>if </em>ile başlamakta. 0! = 1 olduğu için başlangıçta <em>if </em>ile bunu kontrol etmemiz gerekti. Eğer sayi parametresine 0 argümanı verilirse bu <em>if </em>ifadesi aktif olacak ve fonksiyon 1 değerini döndürerek (<em>return</em>) fonksiyonun işi tamamlanmış olacak ve fonksiyondan <em>return </em>ile çıkılacaktır (Eğer fonksiyon <em>return </em>edilmişse ve kendisinde sonra satırlar varsa o satırlar çalışmaz çünkü fonksiyon değerini döndürmüş ve fonksiyondan çıkılmıştır).</li><li>Eğer <em>sayi</em>, 0’ a eşit değilse sonraki satırlar çalışacaktır. Burada <em>carpim </em>adında <em>unsigned int</em> bir değişken oluşturulmuş ve 1’ e eşitlenmiştir. Daha sonra <em>for </em>döngüsünde <em>i</em> adında bir değişken oluşturulmuş ve <em>i</em> değeri fonksiyon içine girilen sayi değerinden küçük veya eşit olduğu sürece döngü dönmeye devam edecek şeklinde <em>for </em>döngüsü yazılmıştır. Döngü her döndüğünde <em>carpim </em>değişkeni, <em>i </em>ile çarpılarak yeni bir değer elde edilmektedir. Diyelim ki fonksiyonun içine 3 argümanını verdik. Yani <em>sayi </em>= 3 oldu. 3 olduğu için <em>if </em>bloğuna girmez ve sonraki kodlar çalışmaya başlar. <em>For </em>döngüsüne girince sırası ile şöyle olmaya başlar:</li><li><em>i </em>= 1 → <em>carpim </em>= <em>carpim * i</em> → <em>carpim </em>* 1 → <em>carpim </em>= 1 olur</li><li><em>i </em>= 2 → <em>carpim </em>= <em>carpim * i</em> → <em>carpim </em>* 2 → <em>carpim </em>= 2 olur</li><li><em>i </em>= 3 → <em>carpim </em>= <em>carpim * i </em>→ <em>carpim </em>= 3 → <em>carpim </em>= 6 olur</li><li>Daha sonra i değeri <em>sayi </em>değerinden büyük olduğu için döngüye girmez ve döngüden çıkılır. Ardından <em>carpim </em>değeri <em>return </em>edilerek. Faktöriyel hesaplanmış olur.</li></ul><p>Yukarıdaki <em>for </em>döngüsü ile faktöriyelin kaç olduğunu hesaplamış olduk. Bu mantığı farklı kodlarla yazmak sizin elinizde.</p><p>Şimdi şöyle bir program yazalım:</p><ul><li>Kullanıcı bir sayı girsin.</li><li>Daha sonra o sayının faktöriyel değeri ekrana yazdırılsın.</li></ul><p>O halde şöyle bir program yazabiliriz.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/65badf7837d8d402d23a5b85a4ef4011/href">https://medium.com/media/65badf7837d8d402d23a5b85a4ef4011/href</a></iframe><p>Kullanıcının girdiği 5 sayısı için çıktımız:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/452/1*QySHXjPjQZr08tKcnzxxgA.png" /><figcaption><a href="https://gist.github.com/ismeterd/3b0a4df6bd3fdd712e61220552de220d">function9.c </a>output</figcaption></figure><p>Yukarıdaki programda ise</p><ul><li>main fonksiyonu altında fonksiyonumu tanımladık. <em>(Function Definition)</em></li><li>main fonksiyonu üstünde fonksiyonumuzun prototipini yazdık.<em> (Function Protoype — Function Declaration)</em></li><li>Daha sonra <em>main()</em> fonksiyonu içinde ana programımızı yazdık.</li><li>Kullanıcıdan sayı aldık.</li><li>Daha sonra bu sayıyı <em>Faktoriyel </em>fonksiyonunun içine girdi olarak verdik ve printf(…) fonksiyonu içinde kullanarak sonucu yazdırdık.</li></ul><p>Yazdığımız bu fonksiyonu geliştirebilirsiniz. Örnek olarak biz bu fonksiyon için her zaman pozitif veya 0 sayılarının girdi olarak alınacağını düşündüğümüz için fonksiyonumuzu bu şekilde yazdık. Ama kullanıcı negatif bir sayı girebilir bu durumda fonksiyonun bunu algılayıp bir hata mesajı verdirmesi veya -1 gibi bir değeri döndürerek bu değerin anlamının negatif sayı girilmek olduğunu programınızda ifade edebilirsiniz.</p><p>Bu bölümü bitirmeden önce farklı bir yaklaşımla faktöriyel fonksiyonunu ifade etmek istiyorum. Bu yaklaşımı kullanan fonksiyonlara <em>recursive </em>(özyinelemeli) fonksiyon denir.</p><p>Fonksiyonun değer döndürdüğü şey yine kendi fonksiyonu ise o fonksiyona <em>recursive </em>(özyinelemeli) fonksiyon denir.</p><p>Görselle ifade etmek daha anlaşılır olacaktır.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0sqh3IN1FtVNMp16M1VMww.png" /><figcaption>Özyinelemeli (Recursive) Fonksiyonun Görselleştirilmesi</figcaption></figure><p>Şimdi bu yaklaşımı kodlarla ifade etmeye çalışalım. Yani faktöriyel fonksiyonumuzu yeniden yazalım.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/9f89896b4b9f913efd0e60daf1b61720/href">https://medium.com/media/9f89896b4b9f913efd0e60daf1b61720/href</a></iframe><p>Yeni fonksiyonumuzu anlamaya çalışırsak aslında görselde ifade edilmeye çalışan şeyi koda indirgemiş olduğumuzu anlarız.</p><ul><li><em>sayi </em>1 veya 0 ‘ a eşit olursa fonksiyonun 1 değerini döndürmesi gereken <em>if </em>bloğumuz var. <em>Recursive </em>fonksiyonlarda bu kısım bilinen en küçük durum ya da <em>base </em>adı verilen kavramla ifade edilir.</li><li><em>if </em>dışındaki yer ise değer döndüren kısımdır. <em>girdi * Faktoriyel(girdi — 1)</em> yaparak sonuç için bir merdiven aşağı gitmemizi sağlar. (Bilinen en küçük durum (<em>base</em>)’a kadar)</li></ul><p>Bu fonksiyonu az önce yazdığımız programa ekleyerek deneyebilirsiniz.</p><p><em>Recursive</em> fonksiyonlar üzerine çokça konuşulabilecek bir konu ama bu bölümdeki amacımız gereği bu kısmı sadece bir alternatif olarak anlatmış olalım ve yolumuza devam edelim. Dilerseniz <em>recursive </em>fonksiyonlar ile ilgili daha çok araştırma yapabilir ve daha çok örnekle karşılaşabilirsiniz. Hatta <em>tail recursive</em> gibi farklı <em>recursive </em>yaklaşımlarını araştırıp birbirleriyle karşılaştırabilirsiniz.</p><h3>Değer Döndürmeyen Fonksiyonlar</h3><p>Şu ana kadar fonksiyonları anlatırken <em>return </em>ifadesi ile birlikte değer döndürmenin ne olduğunu, kullanımını ve gücünü gördük. Yalnız her fonksiyon değer döndürmek zorunda değil, yani <em>return </em>ifadesi içermeyebilir.</p><p>Bu tür fonksiyonlara değer döndürmeyen (<em>void</em>) fonksiyonlar denir.</p><p>Bir örnekle daha iyi anlamaya çalışalım. Hatta bu örneğimiz yazımızın ilk resmindeki fonksiyon olsun.</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/a9adb70041913de46a64b11aeb556045/href">https://medium.com/media/a9adb70041913de46a64b11aeb556045/href</a></iframe><p><em>Selamla(…) </em>fonksiyonunu anlamaya çalışalım.</p><ul><li>Öncelikle<em> void Selamla(…)</em> kısmındaki <em>void </em>kısmı dikkatinizi çekmiş olabilir. <em>void </em>ile ilk kez karşılaşıyoruz. Hatırlarsanız fonksiyon tanımlarken <em>void </em>yazılan kısımda döndürülecek değerin veri tipini yazıyorduk (<em>int</em>, <em>double </em>vs.). Ama burada <em>void </em>yazıyor, daha önce gördüğümüz bir tip değil. <em>void</em>’ in Türkçe karşılığı boş, geçersiz vb. anlamlarına gelmektedir. Burada da aynen bu anlamla kullanılmaktadır. Eğer bir değer döndürülmeyecekse fonksiyonlar <em>void </em>ile tanımlanmaya başlanır.</li><li>Parametre olarak da <em>char pointer</em>’ i almaktadır : <em>(char *string)</em> . Bu sayede içine <em>string </em>(karakter dizisi) yazmak mümkün olmaktadır. Ve bu kısımla birlikte <em>function header</em> kısmı bitmiştir.</li><li><em>Function body</em> ksımında ise alınan <em>string’ </em>i başına Merhaba, koyarak yazdırmakta ve fonksiyon sonlamaktadır. Görüldüğü üzere <em>return </em>kullanılmamıştır ve değer dönmemiştir.</li></ul><p>Örnek bir programda bu fonksiyonu şu şekilde kullanabiliriz:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/1715fc4a068deb78fe813cee4b6721b5/href">https://medium.com/media/1715fc4a068deb78fe813cee4b6721b5/href</a></iframe><p>Ve şöyle bir çıktı ile karşılaşırız.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/331/1*qOwj5XeWTa3LBW6lhuyXJA.png" /><figcaption><a href="https://gist.github.com/ismeterd/ee827e8c8d2e11ad800da31b9b10f744">function11.c</a> output</figcaption></figure><h3>Değer Döndürmeyen Fonksiyonlara Başka Bir Örnek</h3><p>Değer döndürmeyen fonksiyon bölümünü tamamlamadan önce başka bir değer döndürmeyen fonksiyon örneği görmek konuyu pekiştirecektir.</p><p>Değer döndürmeyen fonksiyon kullanarak oluşturduğumuz 2 boyutlu herhangi bir matrisi konsola yazdırabilir ve matrisin ne olduğunu görebiliriz.</p><p>O zaman bu fonksiyonun yapacağı işi özetleyelim:</p><ul><li>Matrisin (2 boyutlu dizinin) ilk adresini gösteren pointer’ i (işaretçi) (ipucu: dizilerin ismi aslında dizinin ilk elemanını gösteren pointer (işaretçi)’ dir), matrisin satır sayısını ve matrisin sütun sayısını parametre alması gerekmektedir.</li><li>Ve sırasıyla satırları yazdırmalıdır.</li><li>Herhangi bir değer döndürmeyeceğiz :)</li></ul><p>Şu şekilde bir fonksiyon yazabiliriz:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/37f7752341f6a771db27efeb9a19292a/href">https://medium.com/media/37f7752341f6a771db27efeb9a19292a/href</a></iframe><p>Şimdi fonksiyonu anlamaya çalışalım:</p><ul><li>Öncelikle fonksiyon <em>void </em>yani değer döndürmeyen bir fonksiyon olarak tanımlanmış.</li><li>Ardından fonksiyon ismi <em>MatrisYazdir </em>olarak belirlenmiş.</li><li>Daha sonra 3 tane parametre alacağı belirtilmiş. Bunlar sırasıyla 2 boyutlu dizinin ilk adresini tutacak olan tamsayı işaretçisi <em>(integer pointer)</em>, satır sayısını tutan tamsayı ve sütun sayısını tutan tamsayıdır.</li><li>Fonksiyon içinde ise sırasıyla matrisin elemanlarını bastıracak <em>for </em>döngüleri yer almaktadır.</li><li><em>printf(…)</em> fonksiyonun içindeki <em>*(matrisPointer + (i * sutun_sayisi + j))</em> kısmı ise <em>pointer arithmetic</em> denilen kısımdır. <em>Pointer arithmetic</em>’ in ne olduğuna amaçtan sapmamak için burada değinmeyeceğim. Bu kısım sayesinde <em>for </em>döngülerindeki her adım için sırasıyla matrisin elemanlarını yazdırılmaktadır. <em>Ek bilgi: Parantez dışındaki * işareti dereference operatörü denilen adresin tuttuğu değeri yazdıran operatördür.</em></li><li>Daha sonra ilk satır yazdırılınca bir alt satıra inmek için <em>printf(“%s”, “\n”);</em> satırı yer almaktadır.</li></ul><p>Şimdi bu fonksiyonu bir programda kullanalım ve konsolumuzdaki çıktımıza bakalım:</p><iframe src="" width="0" height="0" frameborder="0" scrolling="no"><a href="https://medium.com/media/617bbc98167928548b42eb4e169f2616/href">https://medium.com/media/617bbc98167928548b42eb4e169f2616/href</a></iframe><p>Çıktımız ise şu şekildedir:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/635/1*ttICXln7-hMHx1cQTItLWQ.png" /><figcaption><a href="https://gist.github.com/ismeterd/a1d6afc09cf5d2070c2d101f65fe243a">function13.c</a> output</figcaption></figure><ul><li>Programımızda önce 2 boyutlu bir dizi şeklinde matrisimizi oluşturduk ve değerlerini girdik.</li><li>Daha sonra fonksiyonumuzun içine matrisin ismi (matrisin ilk elemanını gösteren <em>işaretçi (pointer)</em>), satır sayısı ve sütun sayısını yazdık.</li><li>Ve konsolumuzda matrisimizi bu şekilde görüntüleyebildik.</li></ul><h3>Kapanış</h3><p>Bu yazıda sizlere fonksiyonların ne olduğunu, <em>return </em>ifadesinin nasıl kullanıldığını, değer döndürmeyen fonksiyonları ve bunların daha iyi anlaşılması için örnek programlarla bu konuları anlatmaya çalıştım.</p><p>Tabii ki daha komplike örnekler de burada yer alabilirdi. Veya adres (<em>pointer) </em>döndüren fonksiyon örnekleri yapılabilirdi. Ama konunun özünün anlaşılması için zor olmayan, anlaşılması daha kolay örneklerle konuyu anlatmaya çalıştım.</p><p>Fonksiyonlar gibi büyük kapsamlı ve birçok örneği olan bir konuyu, tüm yönleriyle anlatmak sanırım imkansız gibi bir şey olurdu. Bu yazı böyle bir iddia taşımasa da bu konuya yeni başlayanların, ya da başlamış ama bazı kavramlarda takılmış olanların kafalarındaki soru işaretlerini bir nebze giderebilmek için yazıldı ve umarım bu amacına ulaşabilmiştir.</p><p>Ayrıca konuyu daha detaylıca anlamak, çalışmak ve birçok örnek görmek isteyenler</p><ul><li><a href="https://faculty.ksu.edu.sa/sites/default/files/c_how_to_program_with_an_introduction_to_c_global_edition_8th_edition.pdf">C: How to Program → Chapter 5: Functions</a> ,</li><li><a href="https://python-istihza.yazbel.com/fonksiyonlar.html">YazBel → Fonksiyonlar</a> (Konuyu Python dilinde anlatsa da konuda ilerlemek isteyen herkes faydalanabilir)</li><li>vb. online kaynaklardan faydalanabilir.</li></ul><p>Görüşlerinizi, eleştirilerinizi bana bu kanal üzerinden gönderebilirsiniz.</p><p>Bir sonraki yazıda görüşmek üzere.</p><p>Sevgiler,</p><blockquote>Konudan bağımsız bir şekilde buraya da birkaç cümle yazmak istiyorum. Yaklaşık bir sene önce Medium’ a okuyucu olarak giriş yaptım ve bu süreç içerisinde yazarların sunduğu bilgi ve tecrübesinden faydalanarak kendi yaşamıma ve işlerime katkı sağladım. Ve benim durumumda olan daha binlercesine ulaşan tüm kişiler adına Medium yazarlarına teşekkür etmek istiyorum. Ben de artık öğrendiklerimi bu yazı ile platformda paylaşmaya başlamış bulunmaktayım. Umarım yazdıklarım konu ile ilgili araştırma yapanlar için faydalı olur :) Teşekkürler.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=be25eeef7ec1" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>