TEMEL BİLGİSAYAR BİLİMLERİ C/C++ WxÜá aéàätüð Doç.Dr. Kaan Erarslan Dumlupınar Üniversitesi, Mühendislik Fakültesi

Transkript

1 TEMEL BİLGİSAYAR BİLİMLERİ C/C++ WxÜá aéàätüð DoçDr Kaan Erarslan Dumlupınar Üniversitesi, Mühendislik Fakültesi

2 ÖNSÖZ 2 Günümüz programlama dilleri içinde C/C++ kadar işletim sistemlerinin, yazım editörlerinin, tablo ve grafik paketlerinin, sunum yazılımlarının, veri taban yönetim sistemlerinin, teknik çizim ve görüntü işleme paketlerinin kendisiyle yazıldığı bir dil daha yoktur Öyleyse öğrencisine, çok iyi bir dil öğrendiğini söyleyebiliriz C/C++ ders notları, klasik bir kitaptan farklı olarak, çok geniş içeriği olan bir programlama dilinden süzülmüş temel bilgileri vermeyi amaçlamaktadır Öğrencinin, bir dönemlik kısa süre içerisinde, kullanamayacağı birçok teorik bilgiye boğulması yerine, öğrendikleriyle dönem sonunda belli işlemleri yapabilecek niteliğe ulaşmasını hedeflemektedir Öğrencinin gerek DOS, gerekse Windows çevresinde, temel veri alış-verişini, belli matematik ve istatistik işlem kodlamalarını ekran ve dosya ortamından yapabilmesi ve pratiğe dökebilmesini amaçlamaktadır Notlar, standart C/C++ temel bilgilerinden ve günlük hayatta giderek artan kullanımıyla, görsel C++ yazılımcılık bilgilerinden oluşmaktadır Notlarda yöntem olarak, teorik bilgilerin öğrenciye pratikuygulamalarla anlatımı benimsenmiştir Yani teori, genellikle örnek kodlar üzerinden anlatılmıştır C/C++ programlamada ilerlemek isteyen akademisyen ve araştırmacılara, yetkin programcıların hazırladığı kaynak kitapları almaları, internette programlama sitelerini takip etmeleri ve örnek kodları incelemeleri önerilir C/C++ öğrencileri için hayati bir uyarı: Programlama en iyi, derste anlaşılır 2006 Şubat ayında kaleme alınan, 2007 ve 2008 yıllarında güncellenen ders notlarının öğrencilerimize ve yararlanmak isteyen bütün akademisyenlere faydalı olması dileğiyle Ocak 2008 Dumlupınar Üniversitesi, Mühendislik Fakültesi, Kütahya DoçDr Kaan Erarslan

3 1 GENEL BĐLGĐLER 3 YAZILIM VE PROGRAMLAMA Bilgisayar, donanım ve yazılım olarak iki ana başlık altında incelenebilir Donanım, elektronik ve fiziksel bütün cihazlara verilen genel isimdir Yazılım, bu donanımın kullanımı ve yönetilmesini sağlayan, program ve yan dökümanlarını içeren bir terimdir Đkisi bir arada, bir bilgisayarı meydana getirirler Program ise, bir programlayıcının belli bir amaca yönelik olarak geliştirdiği kodlardır PROGRAMCILIK Bilgisayar kullanıcılığı iki türlüdür; operatörlük (hazır program kullanıcılığı) ve programcılık Programcı, kod geliştireceği konuya hâkim ve bu konuyu kodlayacak düzeyde belli bir programlama dil bilgisine sahip kişidir Programcılık, işletim sistemi ve veritabanı yönetiminden, görüntü işleme ve grafik tasarımına, internet ve oyundan, mühendislik hesaplamalarına kadar çok geniş bir alana sahiptir Temel programcılık yöntemleri aynı da olsa, her alan, kendine ait kodlama dili, tekniği ve özelliği yönünden farklılaşmalar göstermiş ve ayrı birer uzmanlık dalı haline gelmiştir Programlama dilleri, belli gramer yapıları ve kelime hazineleri olan yabancı dillere benzetilebilir Programcı, bu kelimeleri (komutlar), gramere (kodlama kuralları) uygun olarak, amacına uygun bir şekilde tasarlayarak (algoritma) dizecektir Anlamlı bir cümle kurmanın, gerekli kelimelerin kuralına uygun olarak dizilmesiyle elde edilmesi gibi, yazılmak istenen program da, zihinde yapılan bir sistematiğe göre komutların art arda dizilmesiyle elde edilecektir Programcılık, yüksek öğretimde mesleki alan gözetmeksizin, üniversite mezunu formasyonunda yer alan bir bilgi türüdür Programlama bilgisi ve bir programlama dili öğrenmek, yüksek öğrenim öğrencisinde ne tür bir gelişimi amaçlamaktadır? 1 Matematik, istatistik ve yöneylem türü bilimler, yüksek öğrenim görenlerde nasıl bir düşünme vizyonu ve gelişimi sağlamaktaysa, programlama da, öğrenciye tasarım ve planlama yönünde bir düşünce gelişimi sağlamaktadır 2 Öğrencinin, belli kurallar çerçevesinde, kendi içinde anlamlı parçaları dizerek, anlamlı bir bütün elde etme kabiliyeti geliştirilmektedir 3 Öğrencinin, zihninde bir probleme yönelik çözüm üretmesi ve bir iş planı çerçevesinde kademe kademe çözümünü gerçeklemesi sağlanmaktadır 4 Her meslek, çalışabilir ve anlamlı programlar yapmayı gerektirir Bu ise, kurallara uygun ve değişik şartlarda yapılabilecek işlerin tasarlanmasına ihtiyaç duyar Programcı, aynı zamanda bir tasarımcıdır Programlama, öğrencinin tasarım gücünü geliştirmektedir 5 Đş planlaması, işin her kademesinde yapılacak olan iş parçalarını, başından sonuna kadar kusursuz planlamayı gerektirir Programlama, öğrencinin iş planlama kabiliyetine yeni bir ufuk (vizyon) katmaktadır 6 Günümüzde, her meslek dalında yer alan yazılımlar mevcuttur Dolayısıyla, yüksek öğretim mezunu, iş hayatında bizzat bu alanda da çalışabilecektir Yazılım, yüz milyarlarca dolarlık bir iş hacmine sahiptir

4 PROGRAMLAMA DĐLLERĐ 4 Her program kodu, belli bir dilde geliştirilmiştir Program kodları da, yine belli programlar içinde yazılırlar Programlama dilleri seviyelerine göre sınıflandırılabilirler Seviye, bir dilin insan diline yakınlığıyla, bilgisayar diline yakınlığı arasındaki durumunu anlatmaktadır Buna göre; Đnsan dili PROGRAMLAMA DĐLLERĐ Makine dili Çok yüksek seviyeli Access, Visual Basic Yüksek seviyeli Basic, Fortran, Pascal, Cobol Orta seviyeli C, ADA Alçak seviyeli Sembolik makine dilleri (Assembly) Makine dilleri 1-0 kodlu doğal makine dili Dillerin gelişimi, makine dillerinden, çok yüksek seviyeli dillerin gelişimine doğru olmuştur Makine dili bilmek, bilgisayara tam bir hakimiyeti, yüksek seviye dili bilmek ise, hızlı, kolay ve etkili programlar yazmayı sağlar Yüksek öğretim zorunlu müfredatında, orta ve üstü seviyeleri bilmek yeterli olmaktadır Programlama dilleri, kullanım alanlarına, uygulama veya sistem programlama amaçlı oluşlarına göre de sınıflandırılabilirler Kullanım alanlarına göre sınıflandırmada başlıca yazılımlar; genel amaçlı, teknik ve mühendislik, veritabanı yönetimi, yapay zeka, ağ tabanlı ve sistem programlama yazılımlarıdır Sistem programlama yazılımları, bilgisayar donanımına kumanda edebilen, uygulama yazılımlarına destek veren veya kendi ortamlarında çalışır kılan yazılımlardır Editör ve derleyiciler bu sınıftadır C PROGRAMLAMA DĐLĐ C, 1972 yılında, Dennis Ritchie tarafından AT&T Bell Laboratuarlarında geliştirilen orta seviyeli bir dildir Sistem programlamada kullanılabilirlik ve nesne tabanlı kodlanabilirlik, C dilinin en önemli özelliklerindendir Görsel olan derleyicileriyle Çok Yüksek Seviye dili gibi davranabilirken, sistem programlama özellikleriyle, Makine diline yakın kodlama imkanı sunmaktadır Bugün dünyada kullanılan birçok uygulama yazılımının kodlandığı dildir C ile, başta Windows ve UNIX gibi işletim sistemleri, OFFICE paketleri (Word, Access, Excel, Power Point), AutoCAD gibi teknik çizim paketlerinin büyük bir kısmı geliştirilmiştir C, bugün bilgisayar dünyasının en gelişmiş ve en tercih edilen dili olmuştur DERLEYĐCĐ (COMPILER) VE BAĞLAYICI (LINKER) Programlama dilleri, editör, derleyici ve bağlayıcı olarak adlandırılan işlevleri olan yazılımlardır Diğer bir ifadeyle, içinde program geliştirilen programlardır Geliştirilecek programlar, kodlayıcı tarafından ASCII kodlarıyla yazılırlar Kodların yazıldığı bu ortama Editör adı verilir Bu haliyle kodlar, her hangi bir yazı metninden farksızdır ve Kaynak Kod adını alır Kodun çalışabilmesi için önce bilgisayar diline, sonra da, uygulama formuna dönüştürülmeleri gereklidir Bu dönüştürme işlemini yapacak yazılımlara Derleyici (Compiler) ve Bağlayıcı (Linker) adı verilir Aşağıdaki şekilde, bir programın makine diline çevriliş safhaları görülmektedir Kaynak kod ( C ) Editör Amaç kod ( OBJ ) Derleyici (Compiler) Uygulama kodu ( EXE ) Bağlayıcı (Linker)

5 5 Bu dönüşümler olmadığı sürece kaynak kod sadece bir yazı metnidir Ancak unutulmamalıdır ki, ticari yazılımların sır olarak saklandığı kısmı da, kaynak kodlardır Programcının beyin ürünü, kaynak kodudur C DERLEYĐCĐLERĐ DOS altında çalışan Tümleşik Çevreli Uyarlama (integrated environment version) ve Komut satırlı uyarlama (command line version) adı verilen iki versiyon bulunmaktadır Tümleşik paketlerde editör ve diğer işlevler aynı çevrededir (Örnek: Turbo C) Komut satırlı versiyonda ise, kodlar bir editörde yazılıp, DOS ortamında verilecek komutlarla derlenir ve bağlanır (Örnek: GMac) Windows altında çalışan versiyonlar, görsel paketlerdir; yani, Visual C++ Gerek DOS, gerekse Windows altında geliştirilen derleyicilerde başı Microsoft ve Borland firmaları çekmektedir C VE C++ Standart C ve C++ birbirinden kısmen farklı komutları olan iki C versiyonudur Ancak, C++ da Standart C den farklı olan sadece bazı komutlar değil, bizzat program mantığı ve mimarisidir C++, nesne tabanlı programlama (object oriented programming) olarak adlandırılan modüler programlama yapısı üzerine bina edilmektedir Bu yapı, daha gelişmiş olan görsel C++ paketlerinde de kullanılmaktadır

6 2 C DĐLĐNE GĐRĐŞ VE GENEL BĐLGĐLER 6 C DĐLĐNĐN GENEL YAPISI Bir C programı, genelde dört ana kısımdan oluşur; Başlık Dosyaları, Bildirim ve Tanımlar, Fonksiyonlar ve Ana Fonksiyon En yalın haliyle bir programın çalışması için ilk ve son kısım yeterliyken, büyük bir yazılım, her dört öğeyi de içerecektir Başlık dosyaları (header files) Bildirim ve Tanımlar Fonksiyonlar Ana Fonksiyon Yukarıdaki gösterim daha geniş şekliyle aşağıda verilmiş, sonrasında anlamları açıklanmıştır #include < h > #include < h > int float fonksiyon1 ( ) fonksiyon2 ( ) void main( )

7 Başlık Dosyaları (Header files) 7 Kodlar her zaman, kod içinde yer alacak prototiplerin yer aldığı başlık dosyalarının programa dahil edilmesi ile başlar Bu işlem örnekleri aşağıda görüldüğü şekilde yapılır: #include <stdioh> #include <iostreamh> #include conioh #include mathh Bunlar ne anlama gelmektedir? #include bir C komutudur include kelimesinin Türkçe anlamı, dahil etmektir Peki, dahil etmek ne demektir ve dahil edilen nedir? Başlangıç için daha rahat anlaşılması açısından şu şekilde cevap verilebilir: C kütüphanelerinde kodlayıcı için önceden hazırlanmış birçok komut vardır Bu komutlar, ortak temalı kütüphanelerde kümelenmiştir Mesela, matematik komutları, bunlarla ilgili bir kütüphanede toplanmıştır Programcı, bir C komutunu kullanmak için, program yapısı gereği, mutlaka onunla ilgili başlık dosyasını programa dahil etmelidir Aksi takdirde, komut, derleme sırasında tanınmayacaktır Yani bu işlemle, C de komutlar kullanılmadan önce onlar için, bir tür kullanım izni alınır veya komutun tanınması sağlanır Daha teknik bir ifadeyle; Standart C içinde prototip adı verilen ve komutları (fonksiyonları) çağıran tanımlar vardır Bunlar, C de daha önce hazırlanan komutların türleri hakkında bilgiler içermekte ve uzantısı h olan dosyalarda yer almaktadır C kütüphanelerinde yer alan komutların geliştirilen kod içinde kullanılması, ancak bunların programa dahil edilmesi (include) ile mümkün olmaktadır Kullanacağımız komutların tanınmasını sağladıktan, diğer bir ifadeyle kullanım izni aldıktan sonra, program içinde programlayıcı tarafından kullanılacak değişkenler tanımlanmalıdır Bildirimler ve Tanımlar Programcı, program akışı sırasında değerler alacak değişkenler tanımlamak isteyecektir Bunların isimlerini kendisi koyacak ve ne tür bir değişken tanımladığını derleyiciye anlatacaktır Burada iki kavramı netleştirmek yararlı olacaktır; değişken ve tanımlama Değişken ile ne kastediliyor? y = x + 5 gibi bir doğru denklemi ve grafiği düşünelim y y=x+5 x

8 8 Burada x ve y nedir? Birer değişkendir Peki, bu ne anlama gelmektedir? Her x için karşılık gelen bir y değeri vardır Sıfırdan başlayıp x e değer verdiğimizi düşünelim x=0 için y=0+5, yani y=5 olacaktır x=1 için y=6, x=20 için y=25 değerini alacaktır Burada dikkat edilmesi gereken x ve y nin ne olduğudur x ve y birer değişkendir Yani, x ve y birer sabit sayı olmayıp, değişen sayıları taşıyan ifadelerdir Diğer bir ifadeyle, x ve y birer sayı olmayıp, sayı taşıyıcısıdırlar ve taşıdıkları sayı değişmektedir C kodlarında da, benzer şekilde değişkenler kullanılacaktır Bunlar matematikteki gibi sadece sayı değil, sözel değerler de taşıyabilecektir O halde, programcı bilgisayara şu mesajı vermelidir Biraz sonra bir değişken adı göreceksin, onun türü şudur Tanım satırları bu amacı taşır Tanımlanmadan bir değişken kullanılamaz Değişken türleri, giriş düzeyi için önce sayısal ve sözel olarak ikiye, sayısal değişkenlerse kendi içinde tamsayı ve reel sayı olmak üzere ikiye ayrılacaktır Değişkenler ve tür bildirimleri aşağıda verilmiştir Değişkenler Sayısal Sözel char Tamsayı int Reel sayı float double Programcı, önce tür bildirimini, arkasından da değişken ad(lar)ını listeler int a, b, toplam=0; float x=125, y, z=0; char c; Örnekler incelendiğinde, tür bildirisini değişken adının takip ettiği görülür Değişken tanımlandığında ilk değeri de verilebilir Her tanım satırı, her komut ve aritmetik işlem satırı mutlaka ; işaretiyle bitirilmelidir Değişken tanımı, Standart C de global olarak veya fonksiyon başında, C++ ise kullanılacağı ilk yerde yapılabilir Değişken tanımlarında ismi programcı belirler Bu isimde Đngilizce de geçen harfler kullanılabilir Yani, ç, ş, ğ, ö, Đ, ı, ü gibi Türkçe de yer alan bazı harfler kullanılamaz Değişken tanımında birden fazla kelime kullanılacaksa kelimelerin arasına boşluk bırakılamaz Mesela, int ogr toplami; yanlış bir bildiridir Doğrusu, int ogr_toplami; int OgrToplami; olabilir

9 Fonksiyonlar 9 C programları, nesneler oluşturmak amacıyla fonksiyon bloklarına bölünür Bunların bir tür program modülü olduğu düşünülebilir Program içinde aynı işlem satırlarının tekrar tekrar yazılması yerine, bir defa yazılıp tekrar tekrar kullanılması gibi bir amaç taşımaktadır Genel görünüş olarak; bir fonksiyonun ismi, parantezleri ve ona ait sınırları gösteren küme parantezleri vardır fonksiyon_ismi ( ) fonksiyon bloğu C komut satırları hiçbir zaman açığa yazılamaz Mutlaka bir fonksiyonun içinde yazılmaları gerekmektedir Fonksiyon bloklarının ismini kodlayıcı belirler Đsim verme kuralları, değişken isimlerinde geçerli olan kurallarıdır Yani, sadece Đngiliz alfabesindeki harfler kullanılmalıdır, birden fazla kelime varsa boşluk bırakılmamalıdır Ana Fonksiyon - main( ) Ana fonksiyon, ismini kodlayıcının belirleyemediği ve her programda mutlaka olması gereken bir fonksiyondur Görsel olmayan C derleyicilerinde mutlaka tanımlanmalıdır void main ( ) veya int main( ) return 0; Görsel C derleyicilerinde (Visiual C++) ana fonksiyon yazılmasa da, ana fonksiyon tanımını derleyici WinMain adı ile otomatik olarak yapmaktadır

10 3 DEĞĐŞKEN VE FONKSĐYONLAR; C DE ĐLK KODLAR 10 C ye ait teorik bilgiler, en kolay uygulamalarla öğrenilmekte ve anlaşılmaktadır Genel program yapısı 2 Konu da ele alındı Fonksiyon oluşturma ve değişken tanımlama da bu konu içinde ele alınacak ve uygulama kodlarına bağlı olarak açıklanacaktır Örnek kodlar satır satır incelenecektir ĐLK PROGRAM; EKRANA MESAJ GÖNDERMEK Programlar, genellikle kullanıcı ile diyalog içinde ve veri işlemeye yöneliktirler Bir diyaloğun iki yönlü olduğundan yola çıkacak olunursa, programın kullanıcıya hem mesaj vermesi, hem de kullanıcıdan gelecek mesajları okuyabilmesi gerekir Yani, sorular sorup, cevapları okumalıdır Đlk program, kullanıcı ile diyaloğa yönelik olacak ve ekrana bir mesaj yazacaktır /* Đlk program */ #include <iostreamh> void main ( ) cout << Merhaba ; Bu kısa ama, ilk bilgileri içermesi açısından önemli program, DOS ekranına Merhaba ifadesini yazdırmaktadır Şimdi, satır satır programı inceleyelim Program girişinde yer alan; /* Đlk program */ satırı, bir tür yorum satırıdır ve program çalışırken atlanır Yani, kullanıcının kod kısmına düştüğü bir not kaydından ibarettir /* ifadesiyle başlar ve aynı satırda veya birçok satırdan sonra */ ifadesiyle kapatılır Bu arada yazılan kısımlar, programın bir parçası değişmiş gibi işlem görür #include < iostreamh > satırı, biraz sonra kullanılacak olan komutun yer aldığı başlık dosyasının, programa dahil edilmesini sağlar Bu sayede, ekrana mesaj yazan cout komutu sorunsuz kullanılabilecektir void main ( ) satırları, ana fonksiyona girildiğini göstermektedir Programın amacı sadece ekrana bir mesaj göndermek olduğundan, ne değişken tanımına, ne de fonksiyon bloklarına ihtiyaç vardır ve bu program başlık dosyası ve ana fonksiyondan ibarettir Programdaki komutlar açığa yazılamaz; mutlaka bir fonksiyon içinde yazılmalıdır Buradaki fonksiyon ise, main ( ) fonksiyonudur

11 void ifadesi ne demektir? 11 C de her fonksiyon küme parantezleriyle sınırlandırılmış, diğer bir ifadeyle blok içine alınmıştır Fonksiyon bloğunun kapandığını bildiren görülünce, C program yapısı gereği bir değer üreterek bunu döndürmelidir Eğer döndürülecek bir değer olmayacaksa, main( ) ifadesinin başına void şeklinde bir ön ek getirilebilir Alternatif bir işlem ise, main( ) ifadesinin önüne int, yani tamsayı tür bildirisi eklemek ve parantez kapanmadan return 0; komutuyla sıfır değerini döndürmektir Değer döndürmenin ne anlama geldiği, ileride yer alan programlarda daha iyi anlaşılacaktır cout << Merhaba ; satırı, ekrana Merhaba yazısının çıkmasını sağlayacak komut satırıdır Ekrana mesaj gönderen komutlardan birisi cout<< komutudur Bu ifadeden sonra çift tırnaklar arasına yazılan ifade, program çalıştırıldığında ekranda belirecektir Bütün tanım, komut ve aritmetik işlem satırlarında olduğu gibi, bu satır da ; işaretiyle bitmektedir Program tek komut satırlı olup, paranteziyle hem main( ) fonksiyonu, hem de program kapatılmış olur Bu satırlar nereye yazılıyor ve nasıl çalıştırılıyor? Turbo C gibi bir tümleşik çevreli uyarlama (integrated environment version) derleyicisi kullanıldığı farz edilirse, bu satırlar Turbo C nin editörüne yazılacaktır Sonrasında, menüde yer alan Run alt menüsündeki, Run opsiyonu seçilecektir Run, execute veya implement etmek tabirleri, programı çalıştırmak anlamına gelmektedir Program çalıştığında, ekrana Merhaba yazısını yazacak ve editöre geri dönecektir Programı File menüsündeki Save komutuyla kaydettikten sonra yapılan bir Run işlemi, adını verdiğimiz dosyanın EXE uzantılı bir kopyasının da üretilmesini sağlayacaktır Yani, program artık makine dilindedir EXE türü dosyaların her ortamda çalıştığı bilindiğine göre, artık ilk program, editörden bağımsız olarak EXE dosyasıyla çalıştırılabilir Merhaba Đlk program, kısa olmakla birlikte, C ye yeni başlayanlar için temel teşkil edecek pek çok bilgi içermektedir Turbo C dışında birçok derleyicide de bu program kodlanabilir Derleyiciler arasında bazı farklılıklar olabilmekte ve derleyici özelliklerine göre kodlarda değişiklik yapmak gerekebilmektedir Bu kodların çalışabileceği bir başka derleyici de, yine Turbo C yi geliştiren Borland ın bir başka ürünü olan C++Builder dır Görsel programlama yapılabilen bir ortam olan C++Builder da bu kodların Turbo C de olduğu gibi DOS ekranında çalışması için Console yapısında kullanılması gerekmektedir Bu amaçla yapılacak işlemler şöyle sıralanabilir:

12 1 Öncelikle C++Builder açılır 12 2 Ekrana aşağıda görülen ekran gelecektir Ara yüz adı da verilen bir Form ve arka planda ise bir kod sayfası yer almaktadır 3 Sol üst köşede bulunan New butonuna basılır

13 13 4 Karşımıza aşağıdaki pencere açılacaktır Burada Console Wizard seçilir 5 Console uygulamasının seçenekleri görülen pencereyle karşımıza gelecektir Burada, aşağıdaki tercihlerle yeni bir console uygulama sayfası açılabilir 6 Karşımıza aşağıdaki kod sayfası açılacaktır Sayfanın kod yazmamız için tamamen boş olmadığı ve hazır bazı satırların yer aldığı görülüyor C++Builder, ister console uygulaması olsun, ister görsel programlama olsun, programcıya kolaylık sağlamak amacıyla her zaman kullanılacağı düşünülen bazı kod satırlarını ekrana önceden yerleştirir Aşağıdaki ekranda, void main( ) yerine int main( ) geldiğini görüyoruz #pragma hdrstop komutu, önceden derlenmiş header dosyalarından uygun olanları temizleyerek, programın diskte daha az yer almasını sağlar #pragma argsused ise, kullaılmayan bir parametre için uyarı almamızı engeller

14 14 7 Ders kapsamındaki uygulamalar için bize hazır sunulan bu kodları silerek, ders notlarında yer alan kodları doğrudan yazabiliriz

15 8 Kodları yazdıktan sonra, tuşuna, veya Run menüsünden Run seçeneğine veya F9 tuşuna basılarak program çalıştırılır 15 9 Programın çalışmasını takiben siyah zeminli bir pencerenin kısa süreli açılıp kapandığı görülecek Bu süre zarfında Merhaba mesajı ekrana gelmesine rağmen, hızla kapanmasından dolayı görülmeyecektir Yazıyı ekranda tutmak için program şu şekilde kodlanabilir: #include iostreamh #include conioh void main() cout<< Merhaba ; getch( ); getch( ); komutu program akışını herhangi bir tuşlama yapılıncaya kadar durdurur Bu özelliğini, ekran mesajlarını dondurmak için kullanmak mümkündür getch( ); komutunun çalışması için prototipinin yer aldığı conioh dosyası programa #include conioh şeklinde eklenmelidir

16 ĐKĐNCĐ PROGRAM; DEĞĐŞKEN TANIMI, EKRANDAN SAYI OKUMA VE YAZMA 16 Programların sıklıkla kullanıcısına soru sorması ve cevap alması gerektiği belirtilmişti Đkinci örnek kod, ekrandan okuduğu iki sayının toplamını alıp, sonucu ekrana yazsın Birinci örnekte olduğu gibi ekrana mesaj gönderme işlemi yapılarak kullanıcıdan sayı girmesi talep edilecek, ilaveten, kullanıcının klavyeden girdiği ve ekranda görülen cevap, programa alınacaktır Bu programda, ilkinde olmayan değişken tanımı ve kullanımı da görülecektir // Đkinci program; ekrandan okunan iki sayının toplamı #include < iostreamh > #include < conioh > int a,b,c; void main( ) clrscr( ); cout << Đlk sayı = ; cin >> a; cout << \n Đkinci sayı = ; cin >> b; c= a + b; cout << \n\n Toplam = << c; getch( ); Đlk programdan farklı olan satırlar ele alınırsa, ilk olarak // ifadesi göze çarpar // ifadesi de, /* ve */ gibi yorum satırı oluşturmada kullanılır Ancak //, sadece bir satırın, // ifadesinin sağında kalan kısmını yorum bölgesi haline getirir #include < conioh > komutu, ana fonksiyon içindeki clrscr( ); ve getch( ); komutlarının kullanılabilmesi için programa dahil edilmiştir int a,b,c; Burada üç tamsayı değişkeni tanımlanmaktadır Hafızada her biri için 2 byte lık yer ayrılmıştır ve henüz sayısal bir değer taşımamaktadırlar clrscr( ); komutu, DOS komutlarından cls nin yaptığı işi yapar; yani, ekranı temizler cout << Đlk sayı = ; komutu, ekrana Đlk sayı = ifadesinin yazdırılmasını sağlar Program kullanıcısı bu mesaja karşılık bir sayı girecektir Bu sayının okunması için yeni bir komuta ihtiyaç vardır;

17 cin >> a; 17 cin >> komutu, ekrana klavyeyle yazılan bilgileri okumaya yarar ve iostreamh içinde tanımlıdır Komut, değişken adının yazılması ve ; işaretiyle tamamlanır Burada, a değişkeni, ekrandan girilen sayısal değeri alacaktır Aynı şekilde, cout << \n Đkinci sayı = ; komutu da, ekrana Đkinci sayı = mesajını gönderecektir Bu komutta bir de \n ifadesi bulunmaktadır Çift tırnak içinde yer alan bazı özel işaretler C de anlam taşımaktadır \n, bir satır atlatmayı sağlar Birden fazla kullanılırsa, her biri için bir satır boşluk bırakılacaktır Kullanılmaması durumunda, yazılar aynı satırda görünecektir cin >> b; komutuyla b değişkenine ekrandan girilen sayısal değer atanır Böylece, başlangıçta tamsayı olarak tanımlanan ve değer taşımayan a ve b değişkenleri, bizzat program kullanıcısının verdiği değerleri taşımaktadır c = a + b; işlem satırı sonunda, c değişkeni, a ve b nin değerlerinin toplamına eşitlenir C de, aritmetik eşitliğin sağ tarafındaki işlem tamamlanarak, sol taraftaki değişkene atanır Bundan sonrası, toplam sonucunu ekrana yazdırmaktır cout << \n\n Toplam = << c; işlem satırı bu amaçla yazılmıştır Ekrana toplam sonucunun yer aldığı bir mesaj gönderilmektedir Tırnak içinde bulunan \n\n ifadesi, iki satır ara verilmesini sağlar Toplam = ifadesi ekrana aynen yansır Bundan sonra toplam değeri ekrana gelmelidir Bu değer, c değişkeni tarafından taşınmaktadır Metnin yer aldığı tırnak kapatıldıktan sonra c değişkeninin değeri yazılacaktır Bunun için tırnak sonrası << işareti konur ve akabinde c değişkeni yazılır getch( ); komutu, ekrandan bir tuşlama bilgisi okur Buradaki kullanım amacı, her hangi bir tuşa basılana kadar ekrandaki yazıları dondurmaktır Örnek çalışma: Đlk sayı = 15 Đkinci sayı = 75 Toplam = 90 Sembolik bellek: a 15 b 75 c 90

18 ALTERNATĐFLER 18 1 C/C++ programlama dili, derleyiciden derleyiciye küçük farklılıklar gösterebilir Şimdiye kadar verilen örnekler, Turbo C derleyicisi göz önüne alınarak hazırlanmıştır Bir başka yaygın kullanımlı derleyici olan Development Studio da (DEV-CPP), ikinci örnek programda neler değişecekti görelim: // DEV-CPP derleyicisinde ekrandan okunan iki sayının toplamı #include <iostream> #include <stdlibh> using namespace std; int main(int argc, char *argv[]) int a,b,c; system("cls"); cout << " Đlk sayı = "; cin >> a; cout << " \n Đkinci sayı = "; cin >> b; c= a + b; cout << "\n\n Toplam = " << c; system("pause"); return 0; #include <iostream > komutunda, <iostreamh> yerine, <iostream> kullanıldığını fark ediniz Buna ilaveten, using namespace std; ifadesinin eklendiği görülmektedir Ana fonksiyonun, ileride detayıyla izah edilecek olan fonksiyonların değer döndürmesi kuralına göre bir tamsayı değeri döndürmesi gereklidir ve bunun için ana fonksiyon girişi int main(int argc, char *argv[]) şekline dönüşmekte ve son satırı return 0; komutuyla bitmektedir Dev-Cpp içindeki conioh da clrscr(); komutu olmadığından, programda aynı işi görecek olan system( cls ); komutu kullanılmıştır Bu komut, tırnak içine DOS komutlarını yazarak kullanabilme imkanı vermekte ve #include <stdlibh> komutuyla kullanılabilir hale gelmektedir #include <conioh> satırı eklenerek, getch(); komutu, Dev-Cpp ile de kullanılabilmektedir Ancak, buna alternatif olarak system( pause ); komutu yer almıştır

19 19 Derleyicinin DEV-CPP olması durumunda temelde değişecek komut yapıları şunlardır; #include< >, using namespace std;, int main(int argc, char *argv[]) ve bazı komutlar Ders notlarının genelinde Turbo C derleyicisi baz alınmakla birlikte, serbest ve ücretsiz bir yazılım olan DEV- CPP ye (Development Studio) dönüşüm yapmak ve kullanmak da, verilen bilgiler ışığında hızlı ve kolay olacaktır 2 Derleyicinin yine Turbo C olduğu örneği göz önüne alarak ekrana mesaj gönderme ve cevap alma komutlarının da alternatifini görelim Bundan amaç, yazılı ve elektronik literatürde bu komutlara çokça rastlanacak olması ve C/C++ öğrencisinin yazılı veya internet ortamındaki örnekleri incelerken sıkça karşılarına çıkacak olmasıdır Farklılık, cout<< ve cin>> komutlarının yerine printf( ) ve scanf( ) komutlarının kullanımıdır Şimdi yine ikinci örneği, bir de printf( ) ve scanf( ) komutuyla yeniden yazalım: // Đkinci program; printf() ve scanf() komutlarıyla #include <stdioh> #include <conioh> int a,b,c; void main( ) clrscr( ); printf( Đlk sayı = ); scanf( %d,&a); printf( \n Đkinci sayı = ); scanf( %d,&b); c= a + b; printf( \n\n Toplam = %d, c); getch( ); printf( ); ve scanf( ); komutlarının kullanımı için studioh dosyasının programa dahil edilmesi gereklidir printf(); komutu ekrana mesaj göndermek için kullanılır Bu işlem, iki tırnak arasına mesaj yazılarak gerçekleştirilir scanf( ); komutu ise, örneğimizde de görüldüğü gibi virgülle ayrılmış iki kısımdan oluşur; %d ve &a Burada tırnak içine yazılmış olan %d ifadesi, ekrandan okunacak değişkenin bir tamsayı olduğunu, &a ise, okunacak sayının a değişkeninin adresine kaydedileceğini gösterir %d, okunacak ifadenin türünü gösteren bir formattır ve anlamı (int) tamsayıdır %f float ve %s char tipi değişkenler okunacağını gösteren formatlardır Her format için, o türden bir değişkenin virgül sonrasında sıralanmış olması gereklidir printf( ); ve scanf( ); komutlarına kaynaklarda, cout<< ve cin>> komutlarından daha önce kullanıldığı için çokça rastlanılacaktır Görüldüğü gibi, cout<< ve cin>> komutları format kullanımını ortadan kaldırmış ve veri okuma yazma işlemlerini kolaylaştırmıştır Bu nedenle, ders notlarında cout<< ve cin>> komutları tercih edilmiştir

20 ÜÇÜNCÜ PROGRAM; FONKSĐYON ÇAĞIRMA VE DEĞER DÖNDÜRME 20 C fonksiyonlarının, program yapısı gereği bir değer döndürmesi gerektiğinden bahsedildi Üçüncü kodlama, bunun anlamının tam olarak vurgulanabileceği bir örnek olacak Program, bir dikdörtgene ait en ve boy değerlerinin ekrandan okutulması ve dikdörtgen alanının hesaplanması için kodlanacak Ekrandan en ve boy değerlerinin alınışı ikinci örnekte olduğu gibi main( ) fonksiyonunda gerçekleşecek Ancak, alan hesabı için, buna özel bir fonksiyon tanımlanacak En ve boy değerleri bu fonksiyona argüman olarak taşınacak ve fonksiyon kapanırken hesaplanan alan değerini return edecek, yani döndürecek // Üçüncü program; ekrandan en ve boy değeri okuyarak alan bulma // Fonksiyon kullanımı ve değer döndürme #include <iostreamh> #include <conioh> float x,y,z; float alan (float a, float b) float c; c= a * b; return c; void main( ) clrscr( ); cout << Eni = ; cin >> x; cout << \n Boyu = ; cin >> y; z= alan (x, y) ; cout << \n\n Dikdörtgen alanı = << z<< m2 ; getch( ); Programda, float x, y, z; şeklinde üç reel sayı değişkeni tanımlanmış Bununla, hafızada her bir değişken için dörder byte lık alan tahsis edilmiştir Daha sonra sırasıyla float alan ve void main( ) fonksiyon blokları görülüyor C programları çalışırken, değişken tanımından sonra main( ) fonksiyonuna yönelir Daha sonraki çalışma sırasını, bu fonksiyondan diğer fonksiyonlara olan çağrılar belirler main( ) incelendiğinde, clrscr( ); komutu ile ekranın temizlendiği görülür Sonra, x ve y değişkenleri üzerine dikdörtgenin eni ve boyu cout<< komutları ile sorularak, cin>> ile alınan sayısal değerler aktarılıyor Buraya kadar olan diyalog işlemleri, ikinci programda da vardı Farklı olarak, z = alan (x, y); ifadesi görülüyor

21 z = alan (x, y); ne demek? 21 Bu satırda, bir fonksiyon çağırma işlemi var z değişkeninin değerinin, alan fonksiyonundan dönecek (return edecek) değere eşit olduğu görülüyor Bir başka önemli nokta; program akışı burada alan fonksiyonuna yönlenecek Yani bundan sonraki işlemler için alan fonksiyonu bulunarak, program seyri oradan devam edecek Bir diğer husus ise, alan fonksiyonuna giderken, x ve y değişken değerlerinin oraya gönderilecek olması alan fonksiyonuna gelen bu veri değerlerine, argüman terimi kullanılmaktadır alan fonksiyonu incelendiğinde, void olan main( ) fonksiyonundan bazı farkları olduğu görülüyor: Birincisi, alan bir void değil Başında float türü var Yani bu, alan fonksiyonu bir reel sayı üretecek ve Döndürecek anlamına gelmektedir Đkincisi, alan(float a, float b) yapısında, parantez içinde tanımlanmış iki değişken görülüyor Eğer bir fonksiyona çağrıldığı noktadan değer gönderiliyorsa, bu değerleri birebir karşılamak için aynı sayıda ve aynı türde değişken tanımlanmalıdır alan(float a, float b) ifadesine göre, birer reel sayı olarak tanımlanan a ve b, çağrılırken değerleri gönderilen x ve y nin değerlerine otomatik olarak eşitlenir Yani, x=a ve y=b olacaktır alan fonksiyonuna girerken a ve b değişkenleri transfer edilen değerleri aldılar Fonksiyon içindeki ilk satırda, float c; şeklinde yeni değişken daha tanımlanmış durumda Ancak bu değişkenin henüz değeri yok Bir alt satıra inildiğinde, c = a * b; aritmetik işlemi görülüyor Bununla, c değişkeni de, en ve boy değerlerinin transfer edildiği a ve b değişkenlerinin çarpımına eşitleniyor Yani alan, c üzerinde hesaplanıyor return c; komut satırıyla, hem alan fonksiyonu kapatılmış, hem de dikdörtgen alan bilgisini taşıyan c değişkeninin değeri, bu fonksiyonun çağrıldığı noktaya geri döndürülmüş oldu Geri döndürme işlemiyle tekrar, main( ) içindeki z = alan (x, y); satırına gelinir Ancak, artık z değişkeni, return edilen değere eşitlenmiştir Yani, z = c olmuştur Diğer bir ifadeyle z, dikdörtgen alan değerini taşımaktadır Son işlem, hesaplanan alanın ilanıdır cout << \n\n Dikdörtgen alanı = << z; komutuyla, ekrana bu bilgi gönderilmiş olur getch( ); komutuyla, her hangi bir tuşlamaya kadar bilgiler ekranda tutulur a ve b değişkenleriyle, x ve y değişkeninin bir farkı var mıdır? #include komut satırlarından sonra gelen değişken tanımlarıyla, fonksiyon bloklarında yapılan tanımlamalar arasında bir fark vardır Her hangi bir fonksiyona bağlı olmadan tanımı yapılan değişkenlere global değişken, bir fonksiyon bloğu dahilinde tanımlanan değişkenlere ise lokal değişken denir Global değişkenler her fonksiyon bloğunda tanınır ve değeri bilinirken, lokal değişkenler sadece fonksiyon içinde tanınır ve değerleri bilinir Yani, alan fonksiyonunda tanımlanan a ve b değişkenleri lokaldir ve sadece bu blok içinde tanınırlar Fonksiyon blokları, genelde tekrar tekrar çalıştırılması gereken işlemlerde, bir tür modül olarak kullanılır Mesela, bir program içinde sık sık bir formül hesabı yapılacaksa, formül parametrelerinin değerleri buraya gönderilerek, sonuç return edilebilir Fonksiyon blokları, nesne tabanlı programlamanın da temelini teşkil eder Đlaveten, başlık dosya yazımı, struct ve class yapıları, ileri düzey modüler programlamada kullanılacaktır Program Run edildiğinde, sırasıyla en ve boy bilgileri sorulacak ve cevap ekranda belirecektir En ve boy sorguları main( ) fonksiyonunda, alan hesabı alan fonksiyonunda ve deklarasyon, yani sonuç bildirisi, yine main( ) içinde olacaktır

22 Örnek çalışma: Eni = 50 Boyu = 100 Dikdörtgen alanı = 5000 m2 Sembolik bellek: x 50 y 100 z 5000 a 50 b 100 c VERĐ TĐPĐ BĐLDĐRĐLERĐ Burada, veri tipleri hakkında biraz daha teorik bilgi eklemekte fayda var Değişken tanımlamaları int, float, double ve char şeklinde olabilir Ancak, bir verinin sayısal sınırları, onun için bellekte ayrılacak yer uzunluğu, işaretli olup olmaması, değişken tanımlamalarında ön bildiri eklemlemeleriyle belirtilir Tablodaki sınırlar Turbo C göz önüne alınarak hazırlanmıştır C++Builder da sınırlar büyümektedir Bildiri Uzunluk (byte) Minimum Değer Maksimum Değer char int unsigned long unsigned long float 4-34 x x double 8-34 x x long double x x short, long, signed ve unsigned ön bildirileriyle ne kastedildiği aşağıdaki tabloda görülmektedir Bildiri short long signed unsigned long Bildirilen özellik Kısa bellek alanı Uzun bellek alanı Đşaretli değişken (pozitif/negatif değerli) Đşaretsiz değişken (sadece pozitif değerli) Aşağıdaki tabloda, hangi veri bildirisinin, hangi ön ekleri alabileceği görülmektedir char int float double short + long + + signed + + unsigned + + Bunların dışında, auto, register, extern ve static gibi saklama bildirileri, struct, union ve enum gibi özel veri tipi bildirileri ve typedef gibi özel tip bildirileri bulunmaktadır

23 4 ARĐTMETĐK ĐŞLEMLER 23 Aritmetik işlemlerin kodlanması, bütün programlama dillerinde benzerlik gösterir Bu benzerlik hem işlem operatörleri, hem de işlem mantığı açısındandır Temelde dört işlem için aynı operatörler kullanılır C de ise, biraz sonra görülecek bazı özel operatörler de mevcuttur ĐŞLEM OPERATÖRLERĐ C de kullanılan aritmetik operatörler ve matematik işlem karşılıkları şöyledir: Operatör Matematik Đşlemi Örnek Đşlem + Toplama x = x + 5; - Çıkarma y = y z ; * Çarpma a = a * 2 ; / Bölme j = j / k ; ++ Bir artırma x ++ ; veya ++x; - - Bir eksiltme y - - ; veya - -y; % Mod (Bölüm kalanı) k = 10 % 3 ; (k=1 olur) Dört işlem operatörü, günlük hayatta kullanılan operatörlerden farksızdır Ancak, çarpma operatörü her dilde * karakteridir x = x + 5; satırında, eşitliğin hem sağında, hem de solunda x var Bu ne anlama geliyor? Matematik işlem mantığıyla yaklaşıldığında, böyle bir eşitlik yazma imkanı yoktur Ama programlama dillerinde bu mümkündür Şöyle ki, böyle bir satırda önce eşitliğin sağ tarafındaki işlem yapılır ve sonuç bulunur Sonra, bu sonuç, eşitliğin sol tarafındaki değişkene eşitlenir Bundan dolayı eşitliğin sağında da, solunda da aynı değişken kullanılabilir x = x + 5; satırında nasıl bir işlem yapmış oluyoruz ve nasıl sonuç bulunur? Bu işlem, x in üzerine 5 değerini eklemek anlamı taşımaktadır Bu satırın doğru çalışması için, x değişkeninin buraya gelene kadar bir değerinin olması gerekir ki, onun üzerine 5 sayısı eklenebilsin Mesela, program akışı içinde x değişkeni 10 gibi bir değer taşıyorsa, eşitliğin sağ tarafında 10+5 işlemi yapılır ve bu değer x e eşitlenir; yani, x=15 olur C de aynı işlem, x += 5; şeklinde de yazılabilir Sonuç aynı olacaktır Benzer bir yapıya, y = y z;, a = a * 2; ve j = j / k; örnekleri de sahiptir Önce eşitliğin sağ tarafındaki işlem yapılarak, sol taraftaki değişkene bu değer atanacaktır [ a = a * 2; ile a *= 2; ] [ y = y - z; ile y - = z; ] ve [ j = j / k; ile j /= k; ] işlemleri denktir Eşitliğin sol tarafında yalnızca bir değişken yer alabilir Asla, işlem sol tarafta yer almaz (Mesela, x + y = z; yanlış bir yazımdır)

24 x = x ++; veya y = y - -; ifadeleri ne anlama geliyor? ve - - operatörleri C ye özel iki operatördür x++ ; komut satırı, x değişkeninin mevcut değerinin 1 sayı artırılmasını sağlar Örneğin, bu işleme gelmeden önce x in değeri 22 ise, x++ ; sonrası, 23 e çıkar Benzer şekilde, - - operatörü, değişken değerini bir azaltmaya yarar x++; ile ++x; ve y- -; ile - -y; aynı anlama gelir Eğer, değişken değeri 2 veya daha fazla artırılmak isteniyorsa, o zaman, x = x + 2; şeklinde yazmak gerekecektir [ x=x+2; ile x+=2; denktir] ARĐTMETĐK ĐŞLEM MANTIĞI Denklem yazarken, C de geçerli olan aritmetik mantığını anlamak ve kullanmak gerekir Uzun denklemlerin doğru yazılması veya okunabilmesi buna bağlıdır Temelde bilinmesi gereken üç kural aşağıda yer almaktadır: i Çarpma ve bölme işlemleri, toplama ve bölme işlemlerinden önce yapılır int a=12, b=4, c=4, d= 2, e; e= b a / c + c * d ; Örnek kod satırları incelendiğinde, klasik işlem sırasını gözeten matematik yaklaşım ve program yaklaşımı aşağıdaki gibi farklı sonuçlar verecektir e = b a / c + c * d; -8 / e= 4 sonucu YANLIŞ! 2 * 2 4 Đşlem sırasına göre yapıldığında, e=4 gibi bir sonuç beklenebilir Ama, program çalışırken bu sonucu bulmayacaktır Çünkü, işlemler yazılış sırasına göre yapılmayacaktır Programlamada, çarpma ve bölme işlemleri önce yapılacak ve sonuç aşağıdaki gibi bulunacaktır e = b a / c + c * d; e= 9 sonucu DOĞRU! 9

25 ii Parantez içindeki işlemler önce yapılır 25 float x=20, y= 5, z=6, w=15, q; q = x + ( z w / y ) / ( z ( x w ) ); işlem satırı incelendiğinde, en içteki parantezden işe başlanır; (x w) sonucunda 5 elde edilir ve onun dışındaki parantezde ( z 5) sonucu 1 olarak bulunur Diğer parantezde ( z w / y) ifadesi yer almaktadır Burada önce w / y bölme işlemi yapılıp 3 değeri bulunur ve sonuç z den çıkarılarak 3 elde edilir En sonunda x + 3 / 1 işlemi yapılarak, q= 23 sonucuna ulaşılır Unutulmaması gereken önemli bir husus, tamsayı bölümleriyle ilgili Đki tamsayının bölümü her zaman bir tamsayıdır Yani, a= 10 / 4; işlemi sonucunda a, 2 değerini alacaktır (a float tanımlı olsa bile) Bundan kaçınmanın yolu, işlem satırını a= 100 / 4; şeklinde yazmaktır Burada 10 sayısı, 100 şeklide yazılarak reel sayı haline getirilmiş ve işlem sonucunda a nın 25 değerini alması sağlanmıştır iii Fonksiyon işlemleri önce yapılır C dilinin matematik kütüphanesinde birçok hazır komut yer almaktadır #include <mathh> başlık dosyasının programa dahil edilmesini gerektiren bu fonksiyonlardan sık kullanılan bazıları ve işlevleri aşağıda verilmektedir: Fonksiyon Anlamı Örnek Đşlem Matematik karşılığı sqrt ( x ); Karekök alma y=sqrt (25); y = 25 pow (x, y ); Kuvvet alma y=pow (5, 3 ); 3 y = 5 (double y) fabs (x); Mutlak değer y=fabs (- 40); y = 40 exp (x); Eksponansiyel (üs) y=exp (x); x y= e ceil (x); En yakın büyük tamsayı y=ceil (52); y=52 => y=6 floor(x); En yakın alt tam sayı y=floor (126); y=126 <= y=12 log(x); Logaritma y=log (x); log e x log10(x); Logaritma 10 tabanı y=log10 (x); log 10 x sin(x); Sinüs y=sin (60); sin 60 cos(x); Kosinüs y=cos (30); cos 30 asin(x); Ark sinüs y=asin (60); ark sin 60 acos(x); Ark kosinüs y=acos (30); ark cos 30 tan(x); Tanjant y=tan (45); tan 45 atan(x); Ark tanjant y=atan (45); ark tan 45 Burada alınan bilgilerle, neredeyse bütün formüllerin kodlanması mümkün hale geldi Bu bilgilerin verdiği kodlama gücünü ve kodlama sınırlarındaki büyük açılımı, çeşitli örneklerle anlamaya başlayalım

26 FORMÜL KODLAMALARI 26 Aşağıdaki formülleri, C dilinde yazalım V 2 = πr h V= * r * r * h; = b 2 4ac delta = b * b 4 * a * c; nrt P= P = (n * R * T) / V; V y x z = xy 1+ z=sqrt (x*y-1) + pow (x,y) / pow (y,3); 3 y x 1 α = xy alfa=fabs (x-1) / ( y-pow (x,y) ) + pow ( 2-x*y, 1 / 3 ); y y x Bir formülün tam bir program koduyla nasıl yazılabileceği, aşağıdaki örnekte verilmiştir //************************************************** // Bir silindirin hacmini hesaplayan program //************************************************** #include <iostreamh> #include <conioh> float Pi=314159; float V,r,h; // Pi yerine doğrudan M_PI kullanılabilir void main( ) clrscr( ); cout << Silindirin yarıçapı (cm)= ; cin >> r; cout << \n Silindirin yüksekliği (cm)= ; cin >> h; V = Pi * r * r * h; cout << \n\n Silindirin hacmi = << V<< cm3 ; getch( ); Bütün formül kodlama problemlerinde, klasik bir programlama tarzı vardır Eşitliğin sağındaki değişkenlerin değerleri program kullanıcısından talep edilir ve formüle göre bilinmeyen değişken hesaplanır Sonuç ekrana yazdırılır

27 27 Aşağıda, bir öğrencinin yıl içinde aldığı vize ve ödev notlarıyla, yıl sonundaki final notunu, sırasıyla %30, %20 ve %50 ağırlıkla değerlendiren bir program geliştirilmiştir // ******************************************** // Not ortalaması // ******************************************** #include iostreamh #include conioh Vize= 60 Ödev= 100 Final= 70 Not ortalaması= 7300 float vize, odev, final, not; void main( ) clrscr( ); cout << Vize = ; cin>>vize; cout<< \n Odev = ; cin>>odev; cout<< \n Final = ; cin>> final; Sembolik bellek: vize 60 odev 100 final 70 not 7300 not = vize * 03 + odev * 02 + final * 05; coutsetf (ios::fixed); coutsetf (ios::showpoint); coutprecision( 2 ); cout<< \n\n\a\a Not ortalaması= << not; getch( ); Örnekte, coutsetf (ios::fixed);, coutsetf (ios::showpoint); ve coutprecision (2); komutları kullanıldı Bu komutlar, reel sayı giriş/çıkışında (ios), ondalık kısmın sabit (fixed) olarak gösterileceğini (showpoint) ve bunun da hassasiyetinin (precision) 2 hane olacağını ifade etmektedir Not ortalamasının deklare edildiği cout komutunda, \n formatının yanı sıra, iki tane de \a ifadesi kullanıldı \a nın anlamı zil sesidir Yani, bu komut çalışırken, kullanıcının dikkatini çekmek için, bir zil sesi çıkarmasını sağlar Diğer bazı formatlar aşağıda verilmiştir Format Anlamı \n Sonraki satır başına ilerle \a Zil sesi ver \b Bir karakterlik geri gel \f Sonraki sayfaya ilerle \r Satır başına gel \t Tab tuşu hareketi yap (8 kolon atla)

28 TRĐGONOMETRĐK ĐŞLEMLER 28 Trigonometrik işlemlerde dikkat edilmesi gereken husus, açıların radyan cinsinden olması gerektiğidir Dolayısıyla, girilen açının program içinde dereceden radyana çevrilmesi, bulunan sonuçların da, radyandan dereceye çevrilerek ekrana yazdırılması gerekir Dönüşüm formülü ve buna ilişkin bir örnek aşağıda verilmiştir θ * Pi a tan(ε ) *180 Derece Radyan tan Radyan Derece 180 Pi /***************************************************************************** Ekrandan girilen açının tanjant değerini bulan Girilen trigonometrik değerin ark tanjantını (açıyı) bulan program *****************************************************************************/ #include <iostreamh> #include <conioh> #include <mathh> float teta,aci_degeri,deger,aci; // Pi için C de M_PI sabiti kullanılır // yani, tanımlamaya gerek yoktur void main( ) // Önce açının tanjant değerini bulalım clrscr( ); cout << Tanjantı bulunacak açı= ; cin >> teta; aci_degeri=tan( teta * M_PI / 180 ); cout << \n Trigonometrik değer = <<aci_degeri; getch( ); // Şimdi girilen trigonometrik değerin ark tanjantını (açı) değerini bulalım clrscr( ); cout << Ark tanjantı alınacak değer= ; cin >> deger; aci=atan(deger) * 180 / M_PI; cout << \n Açısal değer = <<aci<< derece ; getch( ); Örnek çalışma: Sembolik bellek: Tanjantı bulunacak açı = 45 Trigonometrik değer = 1 Ark tanjantı alınacak değer = 1 Açısal değer = 45 derece Pi teta 45 aci_degeri 1 deger 1 aci 45

29 5 ŞART CÜMLELERĐ, ĐLĐŞKĐSEL VE MANTIKSAL OPERATÖRLER 29 Günlük problemlerde, belli şartlar altında farklı hareket tarzları belirlemek gerekmektedir Bunların kodlamada da belli kalıplar çerçevesinde dile getirilmesi zaruridir Şart cümleleri ve onlarla iç içe kodlanan ilişkisel ve mantıksal operatörler bu amaçla kullanılmaktadır ŞART CÜMLELERĐ; IF VE IF ELSE KALIPLARI C/C++ programı içinde, ancak belli bir şartın yerine gelmesi durumunda çalışacak kod parçaları vardır Bunlar if bloğu adı verilen kod blokları içinde yer alırlar Bu blok, bir if şart cümlesiyle kontrol edilir ve if cümlesinin doğru olması halinde çalışır Genel yapısı şu şekildedir: if ( şart ) Buradaki kalıpta bir şart ifadesi yazmak gerekmektedir Bu şart, bir veya daha fazla değişkenin birbirleriyle veya bir takım sabit değerlerle ilişkisi şeklindedir Parantez içindeki şart doğrulanıyorsa, ancak bu durumda if tarafından kontrol edilen bloğun içine girilir ve içindeki satırlar çalışmaya başlar Aksi takdirde, if bloğu atlanacak ve çalışmayacaktır if ( şart ) else Bir diğer kalıp ise şartı ve aksi durumu bir arada dikkat alır Burada if cümlesi ve ona ait bloğu, bir else bloğu takip eder else bloğu, if şart cümlesinin doğrulanmaması durumunda çalışacaktır Yani, eğer şart doğruysa if bloğu, aksi takdirde else bloğu çalışacaktır Burada dikkat edilmesi gereken nokta, birbirine if-else ilişkisiyle bağlanmış iki blok varsa, biri mutlaka çalışacak, diğeri mutlaka çalışmayacaktır Bunu ise, şartın doğru olup olmaması belirler if ( şart_1 ) else if (şart_2 ) else if (şart_3) else if (şart_4) ĐLĐŞKĐSEL OPERATÖRLER Şart kalıplarının en gelişmiş şekli, birçok şartın zincirleme kontrol edilmesini sağlar Yine bir if cümlesiyle başlayan blok zinciri, else if bloklarıyla devam eder Đlk şart cümlesinin doğru olmaması durumunda, else if kalıbına bağlı diğer şartlar sorgulanır Her hangi birinde doğrulanma gerçekleşirse, diğer if else cümlelerine bakmaya gerek kalmaz Bu kalıpta, ardıl bloklardan sadece birisi çalışacak, diğerleri çalışmayacaktır Kod yazarı, her ihtimali göz önüne almalı ve programını her şartı kapsayacak şekilde geliştirmelidir Şart cümlelerini kurmadan önce, cümle kalıplarının yanı sıra, şartları yazmak için de bilgiye ihtiyaç var Bu bilgilerin ilki ilişkisel operatörler, diğeri mantıksal operatörler

30 30 Đki değişken veya işlem neticesi arasındaki ilişkinin sorgulandığı operatörlerdir Bunlar, iki taraf arasındaki eşitlik, büyük veya küçüklük durumlarını sorgulamada kullanılır Operatör Anlamı Örnek Đşlem == Eşit if (a == b)!= Eşit değil if (x!= y) > Büyük if (d > 5) >= Büyük veya eşit if ( z >= 0 ) < Küçük if (e < - 50) <= Küçük veya eşit if ( k <= j ) Şimdi bu bilgileri, akademik hayatta sıkça kullanılan bir matematiksel örnek üzerinde uygulayalım // * Đkinci derece denklem köklerini bulan program * Bilindiği gibi, ikinci derece bir denklem, #include <iostreamh> #include <conioh> #include <mathh> float delta, a, b, c, kok1, kok2; void main( ) clrscr( ); cout<< x2 nin katsayısı= ; cin>>a; cout<< \n x in katsayısı= ; cin>>b; cout<< \n Sabit değer= ; cin>>c; delta = b * b 4 * a * c; // Đlk durum; delta sıfırdan küçük Gerçek kök yok if (delta < 0) cout<< \n\n Gerçek kök yok! \a\a ; // Đkinci durum; delta sıfıra eşit Tek gerçek kök var else if (delta == 0) kok1 = (-1 * b) / (2 * a); cout<< \n\n Tek kök var= << kok1; // Üçüncü durum, iki gerçek kök var else if (delta > 0) kok1 = (-1 * b + sqrt (delta) ) / (2 * a); kok2 = (-1 * b - sqrt (delta) ) / (2 * a); cout<< \n\n 1 kök = << kok1; cout<< \n 2 kök = << kok2; getch( ); 2 ax + bx+ c yapısında olup, kökleri, x 1,2 b± = 2a denklemiyle bulunur Burada delta, = b 2 4ac eşitliğinden hesaplanır Karekök içindeki ifadenin sıfırdan küçük, eşit veya büyük olmasına göre değişik sonuç deklarasyonu yapılmalıdır Kodlar incelendiğinde, önce katsayıların okunduğu, sonra deltanın (karekök içi) hesaplandığı ve onları takip eden üç duruma ait if-else blokları görülüyor Eğer bir şart cümlesi sadece bir komutu kontrol ediyorsa, küme parantezli bloklama yapmak gerekli değildir Ancak birden fazla işlem yapılacaksa, mutlaka kullanılmalıdırlar Nitekim, ilk if sorgusuna bağlı gerçek kök olmadığını deklare eden cout komutu, bir blok içinde değildir Ama, diğer iki şart ifadesini bloklar takip etmiştir

31 Bir başka örnek, öğrenci notlarına bağlı olarak sınıfı geçip geçemediği ile ilgilidir 31 /******************** Öğrenci notları ********************/ #include <iostreamh> #include <conioh> float vize,odev,final,not; void main( ) clrscr( ); cout<< Vize notu= ; cin>> vize; cout<< Odev notu= ; cin>> odev; cout<< \n Final notu= ; cin>>final; not = 03 * vize + 01 * odev + 06 * final; if (not >= 50) cout<< \n\n GEÇTĐ ; else cout<< \n\n KALDI ; getch( ); MANTIKSAL OPERATÖRLER Kod geliştirirken bazı durumlarda, bir işlemin yapılması birden fazla şarta bağlı olabilir Bu amaçla, şartları birbirine mantıksal bir ilişkiyle bağlayan operatörler kullanılır Operatör Anlamı Örnek Đşlem && Ve if (a == b && d!= 0) Veya if (x!= y z<100)! Değil if (!(d > 5) ) && operatörüyle bağlanan bir sorgu sonucu, bağlanan iki şartın da doğru olması halinde doğru olacaktır Ve bağlacı, konuşma dilinde de benzer bir anlamda kullanılır Mesela, öğrencinin ortalaması 3 ün üstünde ve disiplin suçu yoksa, yatay geçiş yapabilir denildiğinde, yatay geçiş yapmak için iki şartında yerine gelmesi gerektiği anlaşılır Veya böyle değildir Şartlardan sadece birinin doğru olması, işlemin yapılma onayı anlamına gelir Değil operatörü!, doğru sonuçları yanlış, yanlışları doğru algılamayı sağlar Bir şart ifadesi doğru ise 1, yanlışsa 0 değeri üretir Bu yüzden, if (a) b++; şeklindeki bir ifade anlamlıdır Eğer a değişkeninin değeri sıfırdan farklıysa, parantez içinde 1 değeri üretilir ve doğru işlemi yapılarak b++; komutu icra edilir Eğer a sıfır değeri taşıyorsa, parantez içi yanlış kabul edilerek b++; işlemi yapılmaz

32 32 Birden fazla ve farklı işlevdeki mantık operatörleriyle bağlı bir şart cümlesinde, && operatörü, operatöründen önce icra edilir Şimdi birkaç örneği inceleyelim int a=3, b= 14, c= 9, d= 6; if ( a > d / 2 && b < 2 * c ) d++; else d- -; Bu program parçasında, d değişkeni ya bir artacak, ya da bir eksilecektir Şart cümlesinde && ile bağlı iki ifade görülüyor Đlki, a > d / 2 şeklindeki ifade doğru mudur? a, 3 değerine sahip ve d / 2, 3 değerini üretiyor Peki, 3>3 müdür? Hayır! Üç üçten büyük değildir Eğer sorgu >= şeklinde olsaydı doğru olacaktı Bu durumda && bağlacının diğer tarafına bakmaya bile gerek yok else kısmı çalışır ve d- -; komutu icra olur if ( (18 36 / 2 == 0 && 3 / 2 > 0) ( * 4 > 0 && 8 * 10 < 100) ) a=100; else a= 0; ( 1 && 1 ) ( 0 && 1 ) 1 0 şart ifadesi sonucu, doğru olacaktır ve a=100; komutu icra olacaktır 1 Aşağıdaki örnek, bir öğrencinin harf notu hesabında && bağlaçlarının nasıl kullanıldığını göstermektedir /************************* Öğrenci Harf Notları *************************/ #include < iostreamh > #include < conioh > float vize,odev,final,not; void main( ) clrscr( ); cout<< Vize notu= ; cin>> vize; cout<< Odev notu= ; cin>> odev; cout<< \n Final notu= ; cin>>final; Not aralığı Harf notu 0-50 FF DD DC CC CB BB BA AA not = 03 * vize + 01 * odev + 06 * final; if (not >= 0 && not < 50) cout<< \n\n FF ; else if (not >= 50 && not < 60) cout<< \n\n DD ; else if (not >= 60 && not < 70) cout<< \n\n DC ; else if (not >= 70 && not < 75) cout<< \n\n CC ; else if (not >= 75 && not < 80) cout<< \n\n CB ; else if (not >= 80 && not < 85) cout<< \n\n BB ; else if (not >= 85 && not < 90) cout<< \n\n BA ; else if (not >= 90 && not <= 100) cout<< \n\n AA ; getch( );

33 Sözel değişkenlerle verilebilecek bir kod örneği de, bir test sorusuna verilen cevabı kontrol amaçlıdır 33 /********************************************************** Test uygulaması; if ve char değişken kullanımı **********************************************************/ #include iostreamh #include conioh char cev; void main( ) clrscr( ); cout<< Türkiye nin başkenti neresidir? ; cout<< \n a) Đstanbul b) Ankara c) Kütahya d) Antalya ; cout<< \n\n Cevabınız: ; cin>>cev; if ( cev== b cev== B ) cout<< \n\n Doğru cevap ; else cout<< \n\n Yanlış cevap ; getch( ); Türkiye nin başkenti neresidir? a)đstanbul b)ankara c)kütahya d)antalya Cevabınız: b Doğru cevap char cev; bildirisiyle, cev değişkenine bir karakterlik bilgi taşıma özelliği verilmiş oldu Sorgu cümlelerinde sözel ifade kıyaslamaları yapılırken, ifade tek tırnak içine alınır Eşitlik sorgularında hiçbir zaman = ifadesi kullanılmaz Çünkü = bir ilişkisel operatör olmayıp, aritmetik operatördür = operatörü bir değişkene değer atamasında kullanılır Oysa burada eşitlemek değil, eşit mi diye sormak istenmektedir Bunun için ilişkisel operatör olan == kullanılmıştır if cümlesinde, kullanıcının büyük veya küçük harfle soruyu cevaplama ihtimali göz önüne alınarak, her iki durumda da cevabın doğru sayılması için veya mantıksal operatörü kullanılmıştır Sözel değişkenlere birden fazla karakter içeren bilgiler de kaydedilebilir Bununla ilgili bilgiler, dizi değişkenlerle ilgili konuda ele alınacaktır #include <iostreamh> #include "conioh" void basamak ( int n ) if( n > 9 ) basamak (n/10); cout<< n%10<<"\n"; void main( ) clrscr(); int sayi; cout<<" Sayıyı giriniz= "; cin>>sayi; basamak ( sayi ); getch(); Yandaki program, bir sayıyı basamaklarına ayırıyor Bunu yaparken, main( ) içinde önce sayı okunuyor, sonra okunan sayının basamaklarına ayrılması için basamak(sayi); fonksiyonu çağrılıyor Bu fonksiyona sayi değeri taşınıyor Fonksiyon, sayi değişken değerini int n; bildirisiyle karşılıyor Daha sonraki if cümlesinde, sayı 9 dan büyükse, sayının 10 a bölümü ile tekrar basamak fonksiyonu çağrılıyor Yani, kendini çağıran bir fonksiyon! Bu işlemler devam ederken, eğer sayı 9 dan küçükse, sayının 10 a bölümünden kalan değer ekrana yazdırılıyor; cout<< n%10 << ; Girdi: 2783 Çıktı:

34 6 ÇEVRĐMLER (DÖNGÜLER) 34 Kod geliştirirken, zaman zaman aynı komut satırlarının tekrar tekrar çalıştırılmasına ihtiyaç duyulur Bu tür durumlarda, çevrim veya döngü olarak adlandırılan yapılar kullanılır Bu yapılarda aynı kod satırlarının tekrar tekrar yazılması yerine bir defa yazılıp, tekrar tekrar çalıştırılması sağlanmaktadır Tekrar edecek olan kodlar küme parantezleriyle blok içine alınır ve çevrim türlerinden biriyle kontrol edilir Bir çevrim (loop) elde edebilmek için kullanılacak birkaç kalıp bulunmaktadır Bunlar for, while ve do-while çevrim türleridir Bu konuda, bahsi geçen çevrim türleri hakkında bilgi ve örnekler verilecektir FOR ÇEVRĐMLERĐ (DÖNGÜLERĐ) for çevrim yapısı, ilk ve son şart ifadeleriyle, ilkten sona nasıl gidileceğinin yer aldığı kontrol kısmıyla, tekrar edecek komutların yer aldığı bloktan oluşur Çevrime girilirken kontrol değişkeni ilk değeri alır ve blok içindeki komutlar çalıştırılır Blok sonunda artma/azalma ifadesine gidilir Kontrol değişkeni yeni değerini aldıktan sonra son şartın sağlanıp sağlanmadığı test edilir Şart sağlanıyorsa tekrar bloğa girilerek aynı satırlar yine çalıştırılır Çevrim hareketi, son şart ihlal edilene kadar sürer for çevriminin teorik ve şematik genel yapısı aşağıdaki gibidir: for ( ilk şart ; son şart ; artma/azalma ifadesi ) ❶ for ( ilk şart ; son şart ; artma/azalma ifadesi ) ❹ ❷ ❺ ❸ for ( i=1; i<=5; i++ ) cout<< \n Sayı= << i ; Sayı= 1 Sayı= 2 Sayı= 3 Sayı= 4 Sayı= 5 Sembolik bellek: i 1 i 2 i 3 i 4 i 5 i değişkeni ilk değer olarak 1 sayısını alır Bloğun içine girilir cout komutu çalışır ve ekrana Sayı=1 ifadesi gönderilir Bloğun sonuna gelindiğinden dolayı artma/azalma ifadesine gidilir Buradaki i++ çalışır ve i nin yeni değeri 2 olur Son şart olan i<=5 kontrol edilir i, halen 5 ten küçüktür ve son şart sağlanmaktadır Tekrar blok içine girilir ve cout komutu yine çalışır Ama, i bu defa 2 değerini taşımaktadır Ekranda Sayı= 2 mesajı belirir Blok sonu olduğundan dolayı i++ ifadesine gidilir ve i nin yeni değeri 3 olur i<=5 şartı halen sağlandığından dolayı çevrim yeniden döner Bu işlemler i++ işlemiyle i nin değeri 6 olana kadar sürer i, 6 olduğunda i<=5 şartı artık sağlanmamaktadır Program, for bloğundan sonraki akışına devam eder

35 for çevrim bloklarının kontrolünü sağlayan paranteze bakıldığında bloğun kaç defa döneceği anlaşılır 35 for (i=1; i<=10; i++) kontrol kısmına bakıldığında, i kontrol değişkeninin ilk değer olarak 1 sayısını alacağı ve 10 olana kadar birer birer artacağı görülmektedir Yani, bu çevrim 10 defa dönecektir for (j=0; j<=20; j=j+5) yapısı incelendiğinde, j kontrol değişkeninin 0 değerini alacağı, daha sonra beşer beşer artacağı görülmektedir Bu durumda j=0, j=5, j=10, j=15 ve j=20 için çevrim 5 defa dönecektir for (j=10; j>0; j=j-2) yapısına bakıldığında, j nin ilk değer olarak 10 sayısını aldığı görülür Azalan bir çevrim yapısında, j ikişer ikişer küçülecektir Sırasıyla j=10, j=8, j=6, j=4, j=2 değerlerini alarak 5 defa dönüş yapar j=0 değerini aldığında çevrimden çıkılır Eğer son şart j>=0 olsaydı, altıncı bir dönüş daha yapılacaktı Çevrim (döngü) bilgisi, programcı için çok geniş uygulama alanlarının kapısını açmaktadır Bu konuda çok sayıda örnek kod bulunabilir ve geliştirilebilir /*********************************************************************** n adet sayının aritmetik ortalaması; for çevrim uygulaması ***********************************************************************/ #include iostreamh #include conioh float x, pay=0, orta; int i, n; void main( ) clrscr( ); cout<< Kaç sayının ortalaması alınacak? ; cin>> n; for (i=1; i<=n; i++) cout<< \n Sayı girin= ; cin>> x; pay = pay + x; Aritmetik ortalama, n adet sayının toplamının n e bölünmesi işlemidir Matematiksel olarak n x i i= x = 1 n şeklinde gösterilebilir Görüldüğü gibi işlemde bir pay ve bir de payda kısmı bulunmaktadır Bu tür işlemlerde pay ve paydayı ayrı hesaplatmak işi kolaylaştırabilir Buradan yola çıkarak önce kaç sayının okunacağı öğreniliyor, daha sonra, n defa dönecek bir çevrim içinde hem teker teker sayılar okunuyor, hem de ilk değeri sıfır olan pay adındaki değişkene ekleniyor Paydaki kümülatif işlemi bu şekilde gerçekleştirilmiş oluyor orta = pay / n; cout<< \n\n Ortalama= << orta ; getch( ); Çevrim sonunda yapılacak tek işlem, sayıların toplamlarının yer aldığı pay değerini n e bölmek ve deklare etmek Kaç sayının ortalaması alınacak? 4 Sayı girin= 8 Sayı girin= 10 Sayı girin= 7 Sayı girin= 11 Ortalama = 9 Sembolik bellek: n 4 i x pay orta 9

36 WHILE ÇEVRĐMĐ 36 while çevrim yapısında, çevrimi kontrol eden değişkenin ilk değeri, çevrim öncesinde atanır ve son alabileceği değer, while ifadesinin kontrol kısmında yer alır Artma/azalma işlemi while tarafından kontrol edilen blok içinde yer alır ve bu genelde bloğun son komutudur Genel yapısı ve çalışma şeması aşağıda verilmiştir while ( şart ) int i; ❶ while ( i<=10 ) ❷ ❹ ❸ i++; Yukarıdaki örnek incelendiğinde, i değişkeninin ilk değer olarak 1 sayısını aldığı ve çevrime bu şekilde başlandığı görülüyor Bloğun sonundaki i++; komutuyla i, 2 değerini alır ve while (i<=10) şartı kontrol edilir Bu çevrim i 10 dan küçük veya eşit olduğu sürece çalışacaktır ve 10 defa dönecektir i 11 olduğunda şart sağlanamadığından dolayı çevrim dışına çıkılarak program akışına devam edilecektir Konuyla ilgili bir örnek, aşağıda verilmiştir /**************************************************** while ile faktöriyel işlemi ****************************************************/ #include iostreamh #include conioh long double faktor=1; int n; void main( ) clrscr( ); cout<< Sayı giriniz= ; cin>> n; while (n>0) faktor = faktor * n; n--; cout<< \n\n Faktöriyel= << faktor ; getch( ); Yapılan işlem; faktor = n ( n 1) ( n 2) 1 faktor adındaki değişken long double tanımlanmıştır Bunun sebebi bu tür değişkenlerin çok büyük sayısal değerler taşıyabilmesidir n hem faktöriyeli alınacak sayıyı taşıyan, hem de çevrimi kontrol eden değişken olarak kullanılmıştır Okunan sayının faktöriyeli, sıfıra kadar küçülen bir çevrim yapısı içinde, her sayının faktor üzerinde çarpılmasıyla bulunmuştur Sayı giriniz= 4 Faktöriyel= 24 Sembolik bellek: faktor n

37 DO-WHILE YAPISI 37 Bu çevrim türü, while yapısıyla hemen hemen aynıdır Tek fark, while çevrimlerinde şart önce kontrol edilir, doğrulanıyorsa bloğa girilir do-while yapısında ise, blok her ne olursa olsun ilk çalışmasını yapar, şart doğruluğu bloğun sonunda kontrol edilir do-while çevrimleri, bloğun kontrol edilmeksizin bir defa çalışması gereken, menü ile kontrol edilen tür programlarda tercih edilir Genel yapısı aşağıda yer almaktadır do while ( şart ); int i; ❶ do ❷ ❹ ❸ i++; while ( i<=10 ); /*********************************************************** do-while; maksimum ve minimum bulma örneği ***********************************************************/ #include "iostreamh" #include "conioh" float maks,minm, x; int n; void main( ) clrscr( ); cout<< "Kaç sayı okunacak? "; cin>> n; cout<< "\n\n Đlk sayı= "; cin>>x; minm=maks=x; // Đlk sayı hem minm, hem maks n--; // Đlk sayı okunduğundan n eksiltiliyor do cout<< "\n Sayı giriniz= "; cin>>x; if ( x > maks) maks = x; if ( x < minm) minm = x; n--; while (n>0); cout<< "\n\n Maksimum= "<< maks << " \n Minimum= "<<minm; getch( ); Burada n adet sayı içinde, en küçük ve en büyük olanlarını bulan bir kod görülüyor Đlk değer okunduktan sonra bu değer minm ve maks değişkenine eşitleniyor Đlk sayı okunduğundan dolayı n - -; işlemiyle bir azaltılıyor Daha sonra, n-1 defa dönecek bir do-while mekanizması içinde, diğer sayılar okunuyor ve okunur okunmaz minm ve maks ile kıyaslanıyor Girilen x sayısı minm den küçükse yeni minm o oluyor Aynı şekilde, yeni girilen x, maks dan büyükse yeni maks o oluyor Kodlama algoritmaları programcıdan programcıya değişir Her programcı aynı işi yapan farklı kodlar geliştirebilir Kaç sayı okunacak= 4 Đlk sayı= 24 Sayı giriniz= 12 Sayı giriniz= 45 Sayı giriniz= 33 Maksimum= 45 Minimum= 12

38 IF-GOTO ĐLE ÇEVRĐM 38 C de satırlara birer etiket, yani satır adı verilebilir etiket: formatındaki etiketler, programın çalışmasına bir komut gibi etki etmezler Ancak goto komutuyla programın akışını değiştirecek bir anlam taşırlar Bu yapı, çevrim oluşturmada da kullanılabilir /************************************************ if-goto çevrimi; okunan sayı asal mı? ************************************************/ #include iostreamh #include conioh int n, i=1; void main( ) clrscr( ); cout<< Sayıyı giriniz= ; cin>> n; s1: i++; if ( n % i == 0 ) goto s2 ; if (i <n-1) goto s1 ; cout<< \n\n Asal sayı ; goto s3 ; s2: cout<< \n\n Asal değil ; s3: getch( ); Asal sayılar, 1 ve kendinden başka sayılara kalansız bölünemeyen sayılardır (3,5,7,11,13,15, gibi) O halde, ekrandan okunan sayının, 2 den başlayarak n-1 e kadar bütün sayılarla kalansız bölünüp bölünmediği test edilmelidir Örnek kodlarda, yukarıdaki bilgilerle if-goto yapısı birleştiriliyor s1: i++; satırında i nin değeri artırılıyor ve if (i<n) goto s1; komutuyla bu satıra i, n den küçük olduğu sürece yönlendirme yapılıyor Ayrıca, if (n%i == 0) goto s2; satırıyla, kalansız bölme olması durumunda sayının asal olmadığı anlaşılıyor ve çevrim kesilip s2: etiketli satıra yönlendirme yapılıyor Bu tekrarlar, i, n e eşitlenene kadar sürerse if (i<n-1) goto s1; komutu çalışmayıp alt satıra inecektir ve hala kalansız bölme gerçekleşmediğinden, alt satırdaki cout<< \n\n Asal sayı ; goto s3; satırları çalışacaktır Mod (%) operatörü, bölme işlemi yapar Ancak bölümü değil, kalanı bulur Đşlemde, if cümlesinde sıfıra eşitlik sorgulanıyor Eğer bölme işlemlerinin birinin kalanı sıfırsa, n sayısının asal olmadığı anlaşılır Aynı işlem for, while ve do-while yapılarıyla da kodlanabilir Algoritmadaki küçük bir farkla, aynı işi for çevrimiyle yapan program şöyle olabilirdi: #include iostreamh #include conioh int n,i, j=0; void main( ) clrscr( ); cout<< Sayıyı giriniz= ; cin>>n; for(i=2; i<n; i++) if ( n%i == 0) j++; if (j==0) cout<< \n\n Asal sayı ; else cout<< \n\n Asal değil ; getch( ); Bu algoritmada, j adlı değişkene başlangıçta sıfır değeri veriliyor for çevrimi sırasında bir if sorgusuyla kalansız bölme yapılıp yapılamadığı kontrol ediliyor Kalansız bölme olması halinde, if şartına bağlı j++; komutu çalışıyor ve başlangıçta sıfır değeri verilen j nin değeri bir artıyor Böyle bir durumda, test edilen sayının asal olmadığı anlaşılıyor j nin çevrim sonrası sıfır olarak kalması halinde de girilen sayının asal olduğuna hükmediliyor

39 ĐÇ ĐÇE ÇEVRĐMLER (NESTED LOOPS) 39 Çevrimler, bazı problem türlerinin bir gereği olarak, iç içe (yuvalı) bir yapıda kodlanabilir Genel görünümleri for, while ve do-while için aşağıda verilmiştir for ( ; ; ) for( ; ; ) while ( ) while( ) do do while ( ); while ( ); Bu yapıları ve nasıl çalıştığını değişik örnekler üzerinde görelim for ( i=1; i<=5; i++ ) for( j=1; j<=5; j++ ) cout<< \n Ι= << i << J= << j ; Örnekte iç içe iki for çevrimi görülüyor Normal bir çevrimin nasıl çalıştığını hatırlayalım Đlk değer atamasıyla blok içine girilerek çevrime başlanır Artma/azalma işlemi sonrasında, son şart kontrol edilir Eğer şart sağlanıyorsa tekrar bloğa girilerek aynı işlemler tekrarlanır Burada, dış for yapısının her bir yeni değeri için, içerdeki çevrim tam çalışmasını yapacaktır Yani, i nin her bir değeri için, j ile kontrol edilen çevrim ilk değerden son şart değerine kadar bütün değerleri alarak işini bitirecek ve iki çevrim tamamlanmış olacaktır Ι= 1 J=1 Ι= 1 J=2 Ι= 1 J=3 Ι= 1 J=4 Ι= 1 J=5 Ι= 2 J=1 Ι= 2 J=2 : : : : Kodlarda, dış çevrimin parantezleri koyu renkte görülmektedir Dış çevrimde i=1 değerini aldıktan sonra, blok içine girer i nin yeni değerini artma/azalma ifadesi olan i++; komutuyla alabilmesi için bloğun sonundaki paranteze ulaşması lazımdır Bunun için de, iki parantez arasındaki işlemler tamamlanmalıdır Đçeride yapılacak işlem, j ile kontrol edilen for çevrimidir j=1 değerini alarak bu çevrim bloğuna girilir Bu bloktan, ancak son şart olan j<=5 aşıldığı zaman çıkılır Özetle i nin 1 den 5 e kadar alacağı her değer için j çevrimi 1 den 5 e kadar dönecektir Đç içe iki çevrimdeki cout<< komutu toplamda 25 defa çalışacaktır Sembolik Bellek i j

40 40 Üç veya daha fazla çevrim iç içe yazıldığında, temel mantık değişmemektedir Tekli bir çevrimde geçerli olan kurallar geçerlidir; ilk değer atanır, çevrim bloğu sonuna gelinince artma/azalma ifadesine gidilir, son şart sağlanıyorsa döngü devam eder Burada dikkat edilmesi gereken, bir çevrimin blok sınırı olan paranteze bir şekilde ulaşmadıkça, onu kontrol eden değişkenin değeri artırılamaz/azaltılamaz Bu artış/azalış ise sadece o çevrimi kontrol eden değişkende olur Dış çevrimlerin kontrol değişkenlerinde değer değişimi olmaz Onların değerlerinin değişmesi için, kontrol ettikleri çevrimin sonuna gelmek gereklidir Üçlü bir çevrimin çalışması aşağıdaki örnekte görülmektedir for ( i=1; i<=3; i++ ) for( j=1; j<=3; j++ ) for (k=1; k<=3; k++) cout<< \n Ι= << i << J= << j << K= ;<< k; Ι=1 J=1 K=1 Ι=1 J=1 K=2 Ι=1 J=1 K=3 Ι=1 J=2 K=1 Ι=1 J=2 K=2 Ι=1 J=2 K=3 Ι=1 J=3 K=1 Ι=1 J=3 K=2 Ι=1 J=3 K=3 : : : Sembolik Bellek i j k Yukarıdaki örnekte her çevrim üç defa dönecektir Ancak en dıştaki i çevrimi 3, onun her bir dönüşü için j çevrimi 3 ve onun da her bir devri için k çevrimi 3 defa dönecektir Yani, i çevrimi 3, j çevrimi 9 ve k çevrimi içinde 27 defa çalışacaktır Bu tür çevrimlere bakılınca, toplam devir her bir çevrimin dönme sayısını çarpımı olarak hesaplanabilir; 3 x 3 x 3=27 cout<< komutu 27 defa çalışacak ve ekrana mesajını gönderecektir Daha iyi anlamak için, Đç içe üç çevrimi bir gündeki saat, dakika ve saniyesinin dönüşüne benzetmek mümkündür En dış çevrim saat, sonraki çevrim dakika ve en içteki ise saniye olarak düşünülebilir Nasıl bir saat geçene kadar 60 dakika devrini tamamlıyorsa ve bir dakika için de 60 saniye geçiyorsa, üçlü döngülerde de benzer bir yapı vardır Yukarıdaki örnek, aşağıda bir günlük saat, dakika ve saniye için yazılmıştır for ( i=1; i<=24; i++ ) for( j=1; j<=60; j++ ) for (k=1; k<=60; k++) cout<< \n Ι= << i << J= << j << K= ;<< k; Bir günün 24 saat, her saatin 60 dakika ve her dakikanın 60 saniye olduğundan yola çıkarsak, en dış çevrim bir gündeki 24 saatin ilerleyişini, içindeki çevrimler de dakika ve saniyeleri göstermektedir Bu örnekte en iç çevrimde yer alan cout<< komutu, 24 x 60 x 60, yani defa çalışacaktır

41 41 /************************************************************* Ekran zemin-yazı renklerini ve sesleri için ikili bir çevrim Turbo-C için geçerli bir örnektir *************************************************************/ #include iostreamh #include conioh #include dosh int i, j, k=0; void main( ) for( i=0; i<15; i++) for ( j=0; j<15; j++) textbackground( i ); textcolor ( j ); clrscr( ); sound ( k=k+15 ); // ses gittikçe tizleşecek cout<< \n\n\n\n\t\t Zemin rengi= << i << Yazı rengi= << j ; delay (100); // 100 milisaniye gecikme sağlayacak nosound( ); Bu program, ekran zemin ve yazı renklerini değiştirirken, kalından tize doğru da ses değişimini sağlamaktadır Bu amaca yönelik ikili bir çevrim yapısı içinde, ekran renk ve seslerine yönelik komutları içermektedir Đkili çevrimin dıştakini i, iç çevrimi j kontrol etmektedir Đç çevrimde yer alan komutlar, her bir çevrim 15 er defa devir yapacağından, toplam 15 x 15= 225 defa çalışacaklardır textbackground( ); komutu ekran zemin rengini, textcolor( ); komutu yazı rengini belirlemek için kullanılır Đşlem, renklere ait 0-14 arası kodlar parantez içine yazılarak gerçekleştirilir Çevrim yapılarında sırasıyla bütün renk kombinasyonları görüntülenmiş olmaktadır Renk değişikliğinin gerçekleşmesi için, bu komutların ardından clrscr( ); komutu da kullanılmıştır Daha sonra, geçerli olan zemin ve yazı renkleri ekrana yazdırılmaktadır sound( ); komutu, sayıları arasında kalından tize doğru ses çıktısı sağlar <dosh> başlık dosyası, bütün bu yeni komutlar için programa dahil edilmiştir Çevrim blokları tamamlandıktan sonra, nosound( ); komutuyla sesin kapatılması gerekir Aksi takdirde programdan çıkılsa da ses kesilmeyecektir Đkili çevrime yönelik bir örnek kod, bilgilerin uygulamayla pekiştirilmesini de sağlayacaktır Konu: ekrandan okunan bir sayıya kadar olan asal sayıları listelemek Daha önce yapılan bir sayının asal olup olmadığına dair programdan da burada yararlanılabilir

42 /************************************************************ Bir sayıya kadar olan asal sayıları bulan program ************************************************************/ #include iostreamh #include conioh int i, j, k, sayi; void main( ) clrscr( ); cout<< Bir sayı giriniz= ; cin>> sayi; for( i=2; i<=sayi; i++) k=1; for( j=2; j< i; j++) if( i % j == 0) k=0; break; if( k == 1) cout<< \n << i ; getch( ); 42 Ekrandan okunan sayı, dış çevrimde 2 ile kendisi arasında i++ artma/azalma ifadesiyle teker teker artıyor Her bir i değeri, j kontrol değişkeniyle kontrol edilen bir iç çevrime alınarak, yine 2 den başlanarak kendisine (i ye) kadar olan bütün tamsayılara mod (%) işlemiyle bölünerek (i%j), bölümden kalanın sıfır olup olmadığı if (i%j==0) sorgusuyla kontrol ediliyor Eğer kalansız bir bölme varsa i%j işlemi sıfır olacaktır ve k kontrol değişkeni, başta 1 değeri taşırken sıfıra döndürülecektir Đçteki çevrimden çıkıldığında k değişkeni hala 1 değerini taşıyorsa, kalansız bölünebileceği bir sayı bulunamamış demektir Bu durumda dış çevrimden alınan sayının asal olduğu anlaşılır ve cout<< komutuyla ekrana yazdırılır Bir sayı giriniz= continue, break, return, goto continue, break, return ve goto, çevrimlerin rutin devirlerini etkileyebilecek dört komuttur goto komutu, program akışını bir çevrimin içinden, çevrim sonrasında gelen etiketli bir satıra, çevrim bloğu içindeki bir başka satıra veya çevrim öncesindeki bir satıra yönlendirebilir continue; komutu Türkçe devam etmek anlamına gelse de, programdaki etkisi devam etmek değildir Komutun bulunduğu yerden çevrimin son parantezine gidilmesini sağlar Yani o devir tamamlanmış gibi, artma/azalma ifadesine gidilir ve çevrimin o turunu sonlandırır break; komutu, içinde bulunulan bloktan çıkılmasını sağlar Bir for bloğu içinde kullanılırsa, çevrim sonuna kadar döndürülmeyecek ve tamamlanmış gibi dışına çıkılacaktır Çevrim sonlandırılacaktır return; komutu, fonksiyon bloğunu sonlandıran bir komuttur Bulunulan yer neresi olursa olsun, fonksiyondan çıkılarak çağrıldığı yere dönülür

43 fakulte ( ) for( j=1; j<=100; j++ ) for (k=1; k<=100; k++) if ( a * b == 0) continue; if ( a * b > 0) break; if ( a * b < 0) return ( k ); 43 Örnekte, fakulte( ) fonksiyonu içindeki bazı satırlar görülüyor Đç içe giren iki çevrimde, if cümleleriyle sorgular yapılıyor ve duruma göre continue;, break; veya return(k); komutları çalışıyor Şimdi bunların nasıl etki edeceğini görelim Eğer, if(a*b==0) doğruysa, continue; komutu çalışacak ve k ile kontrol edilen çevrimde k++ artma/azalma ifadesine gidilerek, yeni k değeri için tekrar çevrime girilecektir Eğer, if(a*b>0) ifadesi doğruysa, bu durumda break; komutu çalışarak, k ile kontrol edilen çevrimden tamamen çıkılmasını, dolayısıyla i ile kontrol edilen çevrime geçilmesini sağlayacaktır Eğer, if(a*b<0) doğruysa, bu durumda return(k); komutu çalışacak ve fakulte() fonksiyonundan çıkılmasına ve bu fonksiyonun çağrıldığı yere dönülmesine neden olacaktır OKEK ve OBEB bulan aşağıdaki örneği de inceleyelim /************************************ OKEK ve OBEB hesabı ************************************/ #include iostreamh #include conioh int i, s1, s2; void main( ) clrscr( ); cout<< Đki sayı giriniz= ; cin>> s1>>s2; for( i=1; i<=s1*s2; i++) if( i % s1 == 0 && i % s2 == 0) cout<< \n\n OKEK= << i; break; if( s1>s2) i=s1; else i=s2; for(; i>0; i--) if( s1 % i == 0 && s2 % i == 0) cout<< \n\n OBEB= << i; break; getch( ); Örnekte, okunan iki sayının ortak katlarının en küçüğü (OKEK) ve ortak bölenlerinin en büyüğü (OBEB) bulunuyor Đki sayının OKEK değeri en fazla iki sayının çarpımı olabilir Bundan dolayı ilk çevrim i<=s1*s2 ifadesiyle, iki sayının çarpımına kadar dönebilecektir OKEK, her iki sayıya da tam bölünen sayıdır Bu elde edilir edilmez ekrana mesaj gönderiliyor ve break; komutuyla ilk çevrim terk ediliyor Đkinci çevrim OBEB i bulmak için tasarlanmıştır OBEB en fazla, sayılardan büyük olanın değeri kadar olabilir Bundan dolayı ilk çevrim sonrası if-else yapısıyla büyük olan sayı bulunarak i ye eşitleniyor i ikinci çevrimde de başlangıç değerini oluşturacak ve çevrim bu sayıdan sıfıra doğru küçülecektir OBEB değeri, her iki sayıya da tam bölünebilir Bu sayı if cümlesiyle kontrol ediliyor ve ilk sağlandığı değer OBEB olarak cout<< komutuyla ilan ediliyor break; komutu, ikinci çevrimin de dışına çıkılmasını sağlıyor Đkinci çevrimde for( ; i>0; i- -) şeklindeki ifadede, ilk şartın olmadığı görülüyor Bunun anlamı, çevrime ilk değer ataması şartı aramaksızın girilebileceğidir i nin ilk değeri bir üst if yapısıyla, ya s1, ya da s2 olarak belirlenmişti for( ; i>0; ) şeklindeki bir for döngüsü, sadece son şartı olan bir döngüdür for( ; ; ) döngüsü ise, sonsuz defa dönecek bir yapıya sahiptir Çevrimden blok içindeki bir if cümlesine bağlı olan kesici bir komutla (mesela break;) döngüden çıkış sağlanabilir

44 switch-case-default 44 switch-case-default kalıbı, genellikle programın bir menü aracılığıyla kullanılması durumunda tercih edilirler ve sıklıkla do-while çevrim yapısında yer alırlar Genel yapısı aşağıdaki gibidir: switch (ifade) case etiket: komut(lar); case etiket: komut(lar); : : : case etiket: komut(lar); default: komut(lar); switch isminden de anlaşılacağı gibi bir tür anahtar vazifesi görür ve parantezler içindeki ifade, case lerden hangisine uyuyorsa, programın çalışmasını oraya yönlendirir O case e ait komut veya komutlar (ki küme parantezi olmaksızın bir sonraki case e kadar blok şeklinde) çalışırlar Bu bloğun son komutu genlikle break; olur Çünkü, break; komutuyla switch bloğunun dışına, yani do-while bloğuna çıkılır ifade, case lerden hiçbirine uymuyorsa, o zaman default a ait komut veya komutlar çalışacaktır // *** switch-case-default *** #include iostreamh #include conioh #include dosh int secim; float x, y; void sayi_oku( ) clrscr( ); cout<< \n\n Sayıları giriniz= ; cin>> x >> y; void topla ( ) sayi_oku( ); cout<< \n Toplam: << x+y; getch( ); void cikar ( ) sayi_oku( ); cout<< \n Fark: << x-y; getch( ); void carp ( ) sayi_oku( ); cout<< \n Çarpım: << x*y; getch( ); void bol ( ) sayi_oku( ); cout<< \n Bölüm: << x+y; getch( ); secim_oku( ) clrscr( ); cout<< \n 1Topla \n 2Çıkar \n 3Çarp \n 4Böl \n 5 Çıkış ; cout<< \n\n Seçiminiz: ; cin>>secim; void main( ) clrscr( ); do secim_oku( ); switch( secim ) case 1: topla( ); break; case 2: cikar( ); break; case 3: carp( ); break; case 4: bol( ); break; case 5: break; default: cout<< \n\n Hatalı giriş! \a\a\a ; while (secim!= 5); Örnek kod incelendiğinde, main( ) fonksiyon içinde bir do-while bloğu yer almaktadır Blok içinde de switch-casedefault yapısı görülüyor do-while bloğu, önce secim_oku( ) fonksiyonunu çağırıyor Burada ekrana bir menü çıkarılıyor Kullanıcının tercihi secim isimli değişkene kaydediliyor Bloğun kapanmasıyla fonksiyonun çağrıldığı noktaya dönülüyor ve switch (secim) bloğuna geliniyor secim belli olduğundan dolayı, o case e switch ediliyor (anahtar, değişim) Mesela kullanıcı toplama için 1 e bastıysa, case 1: e yöneliyor Burada topla( ); ve break; komutlarını görüyoruz Önce topla( ); fonksiyonuna gidiliyor Bu fonksiyona baktığımızda, oradan da sayi_oku( ); fonksiyonuna gitmemiz gerektiği anlaşılıyor Bu fonksiyonun içinde clrscr( ); ile ekran silme ve sonrasında iki sayıyı x ve y değişkenleri üzerine okuma işlemi yapılıyor Okuma sonrası topla( ) fonksiyonuna iki değer alınmış olarak dönülüyor Fonksiyon, ekrana iki sayının toplamını yazıyor ve geri dönüp break; i çalıştırıyor break; ile dowhile a geri dönülüyor Diğer tercihlerde de, aynı sıra ile işlemler yapılıyor Eğer kullanıcı yanlışlıkla mesela 11 sayısını girerse, switch onu default a gönderiyor Burada zil sesli bir hata mesajı bulunuyor Her durum (case) için son işlem break;, yani, dowhile a geri dön do-while a dönmek demek, secim_oku( ) nun tekrar çalışması, dolayısıyla menünün tekrar ekrana gelmesi demek Kullanıcı 5 i seçtiğinde while (secim!=5); ihlal edildiğinden dışarı çıkılıyor

45 7 DĐZĐLER 45 Diziler ve dizi değişkenleri, programcılıkta ayrı bir öneme sahiptir Birbiriyle bağlantılı birden fazla sayı veya harfin bir değişken tarafından taşınabilmesine imkan sağlayan bu yapı ile, çeşitli matematik, istatistik ve matris işlemleri, sözel veri işleme türü kodlamalar yapılabilir Dizi değişkenler, normal veri bildirimine ilaveten köşeli parantezlerle [ ] gösterilirler Parantez [ ] içerisinde eleman sayıları belirtilir Diziler, bellekte de adresleri birbirini takip eden sayı veya harf dizileri şeklinde yer alırlar Aşağıda bazı dizi değişken tanımlamaları verilmiştir int vize[20], final[30], a[5][5]; float gelir[1000], gider[10][10][10]; char ad[15], soyad[25], ilceler[80][30]; double x[10], y[3][5], z[7][7][7], w[5][5][3][3]; Görüldüğü gibi, iki, üç ve daha fazla boyutlu dizi değişken tanımlanabilir Bunları birer matris gibi düşünmek, anlamayı ve kullanmayı kolaylaştıracaktır int a[5]; tanım ifadesinin anlamı nedir? Eğer tanımı int a; şeklinde yapmış olsaydık, a değişkenine, bir tamsayı değeri taşıma özelliği vermiş olacaktık int [5]; tanımıyla, a değişkenine beş tamsayı değeri taşıma imkanı verilmiştir Bellekte a=[a1 a2 a3 a4 a5] gibi ardışık beş tamsayılık yer ayrıldığı düşünülebilir Tek bir a tamsayısı tanımlandığında ekrandan okunan değer a ya eşitleniyordu Şimdi nasıl olacak? Soruyu şu şekilde açabiliriz: int a; şeklindeki bir tanımlamada, cin>> komutuyla yapılan okumalarda, okunan değer a değişkenine bellekte ayrılan adrese yerleştiriliyordu Şimdi ise a değişkeni 5 değer okuyabilecek durumda Okunan sayı ne şekilde ve nereye yerleştirilecek? Beş elemanlı, tek boyutlu bir L matrisi düşünelim; L=[ ] Bu matrisin taşıdığı değerler nasıl birbirine karışmıyor? Çünkü, her elemanın matris içinde bir yeri var Aşağıdaki gösterim şekline göre L matrisinin elemanları şu şekilde ifade edilebilir: L[1]=4 L matrisinin birinci elemanı 4 L[2]=7 L matrisinin ikinci elemanı 7 L[3]=2 L matrisinin üçüncü elemanı 2 L[4]=6 L matrisinin dördüncü elemanı 6 L[5]=9 L matrisinin beşinci elemanı 9 C dilinde de benzer bir dizi içi adresleme vardır Şu farkla ki, C de eleman indeks değeri matematikteki gibi birden değil, sıfırdan başlar Yani aynı sıralama C için şöyledir: L[0]=4 L matrisinin sıfırıncı elemanı 4 L[1]=7 L matrisinin birinci elemanı 7 L[2]=2 L matrisinin ikinci elemanı 2 L[3]=6 L matrisinin üçüncü elemanı 6 L[4]=9 L matrisinin dördüncü elemanı 9

46 46 Benzer şekilde int a[5]; dizi değişken bildirisiyle, bellekte L matrisi gibi bir a matrisi oluşturulacaktır Bunların elemanları; a[0], a[1], a[2], a[3] ve a[4] şeklinde kullanılabilecektir Programda tanım satırı hariç a[5] şeklinde bir kullanım yanlış olacaktır Çünkü int a[5]; ifadesi, a dizisinin 5 elemanlı bir tamsayı olduğunu bildirirken, a nın kodlar içindeki en büyük elamanının indeks değeri a[4] olacaktır Đndeks değeri 4 e kadar da gelse, indeksleme sıfırdan başladığı için eleman sayısı beş olacaktır Örneği inceleyelim /************************************************* Diziler Sayı dizisi içindeki sıfırların sayımı *************************************************/ #include iostreamh #include conioh int i, n, say=0, a[50]; void main( ) clrscr( ); cout<< Okunacak sayı adeti (maks50)= ; cin>> n; for( i=0; i<n; i++) cout<< \n Sayı girin= ; cin>> a[i]; if ( a[i] == 0 ) say++; cout<< \n\n\n Sıfırların sayısı= <<say; getch( ); Örnekte, tamsayı dizi değişkeni a[50] tanımlanmakta ve bellekte a ya 50 elemanlık adres tahsisatı yapılmaktadır 50 sayısı, sabit olarak program boyunca açık tutulacak ve üstüne çıkılamayacak dizi eleman sayısının değeridir Program başında, kullanıcıdan okunacak sayı adeti istenmekte, bunun maksimum 50 olabileceği bildirilmektedir Okunan değer n değişkenine kaydedilmekte, daha sonra bir for çevrimi içinde dizi değişkenlere ne şekilde veri girişi yapılacağı görülmektedir Dikkat edilecek nokta, çevrimi kontrol eden i değişkeninin, aynı zamanda a dizisinin indis değerini de kontrol ediyor olmasıdır Bunun için for çevrimi i=0 ilk değeriyle başlatılmıştır Çevrim i<n şartına kadar çalışacaktır Sıfırdan başladığı düşünülürse, çevrim n defa dönecektir Çevrimin her devrinde, okunan değerin sıfır olup olmadığı sorgulanmakta, sıfıra eşitse, sayaç olarak kullanılan say değişkeni, say++; komutuyla bir artırılmaktadır Çevrim sonunda, say değişkeninin değeri ekrana gönderilmektedir Örnek ekran çıktısı, değişkenlerin sırayla aldıkları değerlerin yer aldığı sembolik bellekle birlikte gösterilmektedir Okunacak sayı adeti(maks50)= 5 Sayı girin= 5 Sayı girin= 0 Sayı girin= 2 Sayı girin= 8 Sayı girin= 0 Sıfırların sayısı= 2 Sembolik bellek say n 5 i a[i] a[0]=5 a[1]=0 a[2]=2 a[3]=8 a[4]=0 Bir diğer örnek, diziye girilen sayıların küçükten büyüğe doğru sıralanması ile ilgili olacak

47 /********************************* Diziler - Sayıların sıralanması *********************************/ #include iostreamh #include conioh int i, j, n, gecici, x[50]; void main( ) clrscr( ); cout<< Kaç sayı okunacak? ; cin>> n; for( i=0; i<n; i++) cout<< \n Sayı girin= ; cin>> x[i]; for( i=0; i<n; i++) for( j=i+1; j<n; j++) if (x[i]>x[j]) gecici=x[i]; x[i]=x[j]; x[j]=gecici; for(i=0; i<n; i++) cout<< x[i]<< ; getch( ); 47 Örnek kod, kısa, ama iyi tasarlanması gereken bir probleme yönelik Öncelikle, 50 elemanlı bir dizi değişken olan x tanımlamıyor Okunacak sayı adeti belirlendikten sonra, ilk çevrimde bu sayılar x[0] dan başlayıp okutuluyor Sıralama işlemi, iç içe ikili çevrim içinde yapılıyor Bunun için gerektiğinde sayıların sıralarının değiştirilmesi gerekiyor Değiştirme sırasında gecici adında geçici değeri taşıyacak bir değişken kullanılıyor Programın çalışmasının daha iyi anlaşılması, tamamen adım adım değişkenlerin değer alışı ve değiştirişini takip etmekle mümkün olacaktır Son çevrimde sıralanmış sayıların ekrana yazdırılma işlemi yapılıyor for(i=0;i<n;i++) cout<< x[i]<< ; komutu incelendiğinde, çevrime ait bir parantez kullanmadan cout komutunun kullanıldığı görülüyor Gerek for, gerekse if yapılarında, eğer şart ifadesine bağlı çalışacak komut sayısı bir tane ise, o zaman blok içine alınmasa da program normal çalışacaktır Eğer birden fazla komut kullanılacaksa, mutlaka küme parantezine alınmalıdır Bundan yola çıkarak, iç içe ikili çevrimin de aslında parantezsiz olabileceği söylenebilir Çünkü, ilk çevrime bağlı sadece bir başka for çevrimi, ona da bağlı bir if bloğu bulunmakta for( i=0; i<n; i++) for( j=i+1; j<n; j++) if (x[i]>x[j]) gecici=x[i]; x[i]=x[j]; x[j]=gecici; şeklinde de, doğru çalışacaktır Kaç sayı okunacak? 4 Sayı girin= 12 Sayı girin= 9 Sayı girin= 4 Sayı girin= Bellek takibini, çevrimin bir devri için yapalım x[0]=9, x[1]=12, x[2]=4 ve x[3]=7 değerini taşıyor Đkili çevrime girerken i=0 ve içeride j=i+1 olduğundan, j=1 değerini alacak Đç çevrimde, if(x[i]>x[j]) yani sayısal olarak if(12>9) Bu durumda, gecici=x[0];, yani, gecici=12 Alt satırda x[0]=x[1];, yani, x[0]=9 Takiben, x[j]=gecici;, yani, x[1]=12 Bu işlemle, 9, x[0] a, 12, x[1] e yerleştirildi Yani, yer değiştirdiler Çünkü, küçükten büyüğe sıralamak istiyoruz ve ikinci sıradaki 9, birinci sırada girilen 12 den daha küçük O halde birinci sıraya 9 geçmeli Çevrim algoritmasının bunu sağladığını bu şekilde sayısal değerler vererek ve çevrimleri kağıt üstünde çalıştırarak gözlemleyiniz

48 ĐKĐ BOYUTLU DĐZĐLER 48 Đki boyutlu diziler, iki boyutlu matrisler gibi satır ve sütunlardan oluşurlar Aşağıda, 5x5 lik bir dizinin (matrisin) matematiksel gösterimi ve karşılık gelen C indisleri verilmektedir a a a = a a a a 12 a 13 a 14 a15 a 55 a[0][0] a[0][1] a[0][2] a[0][3] a[0][4] a[1][0] a[1][1] a[1][2] a[1][3] a[1][4] a= a[2][0] a[2][1] a[2][2] a[2][3] a[2][4] a[3][0] a[3][1] a[3][2] a[3][3] a[3][4] a[4][0] a[4][1] a[4][2] a[4][3] a[4][4] Buna göre, bir boyutlu dizilerde olduğu gibi, iki, üç ve daha fazla boyutlu olan dizilerde de, indis değerleri sıfırdan başlar Bunun dışında, satır ve sütun mantığı aynı matematikteki matrisler gibidir Đki boyutlu iki dizinini (matrisin) toplamını alan program aşağıda verilmiştir Önce iki matrise ait değerler <stdlibh> ile kullanılabilecek rand( ); fonksiyonuyla rasgele atanacak, sonra iki dizi değerleri toplanacaklar /********************************* Đki boyutlu iki dizinin (matrisin) toplamı *********************************/ #include iostreamh #include conioh #include stdlibh #include timeh int i, j, n, a[10][10], b[10][10],c[10][10]; void main( ) clrscr( ); cout<< Matris boyutu? ; cin>> n; cout<< \n ; //satır atlatmak için srand((unsigned) time(null)); for( i=0; i<n; i++) for( j=0; j<n; j++) a[i][j]= rand( )%10 ; b[i][j]=rand( )%10; for( i=0; i<n; i++) for( j=0; j<n; j++) c[i][j]=a[i][j]+b[i][j]; cout<< c[i][j]<< ; cout<< \n ; Örnekte, a ve b dizileri, 10 satır ve 10 sütundan oluşan 100 tamsayılık bir yapıya sahipler Dizi (matris) içleri, iç içe iki for döngüsündeki, rand(); rasgele sayı üretim fonksiyonuyla dolduruluyor Daha sonra, yine iç içe for döngüleriyle c dizisi (matrisi), a ve b nin toplamı olarak bulunuyor Örnekteki indis kullanımlarına dikkat ediniz rand( ); genellikle aynı sayıları rasgele ürettiğinden, x ve y matrisleri aynı olabilir srand ( (unsigned) time(null) ); komutu, rand ( ); fonksiyonundan önce kullanılırsa, sistem zamanından alınacak bilgiye göre rasgele sayı üretilecek, böylece farklı sayılar üretilmiş olacaktır time( ); komutu için, timeh programa dahil edilmelidir rand( ) komutunun çok büyük değerler de üretebileceği göz önüne alınarak, rand( )%10 ile rasgele sayının 10 a bölümünden kalanı kullanmak daha küçük sayılar elde etmemizi sağlayacaktır getch( );

49 /***************************************** Diziler - Kare matris çarpımı *****************************************/ #include "iostreamh" #include "conioh" int i,j,k,n; int a[10][10], b[10][10], c[10][10]; int toplam; void main( ) s1: clrscr( ); cout<<"\n Matris boyutu= "; cout<< \n\n A matris değerleri \n ; cin>>n; for(i=0;i<n;i++) for(j=0;j<n;j++) cout<<i+1<<" Satır "<<j+1<< Sütun= ; cin>>a[i][j]; cout<< \n\n B matris değerleri \n ; for(i=0;i<n;i++) for(j=0;j<n;j++) cout<<i+1<<" Satır "<<j+1<< Sütun= ; cin>>b[i][j]; // Matrisler çarpılıyor for(i=0;i<n;i++) for(j=0;j<n;j++) toplam=0; for(k=0;k<n;k++) toplam += a[i][k] * b[k][j]; c[i][j]=toplam; // Sonucun ekrana yazılması for (i=0;i<n;i++) cout<< "\n"; for (j=0;j<n;j++) cout<<c[i][j]<<" "; cout<<"\n\n Tekrar ister misiniz (E/e)? "; if( getch( ) == 'e' getch( ) == E ) goto s1; // Başa dönmek için e veya E tuşlanmalı getch( ); 49 Matris çarpımı, toplama ve çıkarma işleminden farklı bir yapıya sahiptir Đlk matrisin satır elemanlarıyla, ikinci matrisin sütun eleman çarpımları toplanarak, yeni matrisin karşılık gelen eleman değeri hesaplanır a11 a12 a b b12 b13 a = a21 a22 a b = 23 b21 b22 b23 a 31 a32 a 33 b31 b32 b33 Buna göre, mesela c11 elemanı; c11=a11xb11+a12xb21+a13xb31 işlemiyle bulunacaktır Diğer c elemanları da, satır elemanlarının sütun eleman çarpımlarıyla toplamından elde edilir Programda önce, A ve B matris değerleri giriliyor cout<< i+1<< Satır <<j+1<< Sütun= ; şeklindeki komutla, ekrana i ve j nin değerinin bir fazlası olan sayılar gönderiliyor Böylece ekrana 1 Satır 1Sütun= gibi bir yazı çıkıyor Hatırlanacağı üzere, C de indis değerleri sıfırdan başlıyordu Eğer cout içinde i+1 yerine i ve j+1 yerine j yazsaydık ekrana, 0 Satır 0 Sütun= şeklinde mesaj çıkacaktı Bu ise, kullanıcıyı şaşırtacaktı Gerçekte ise, program içindeki okumalar i+1 veya j+1 kullanılarak değil, i ve j indisleri kullanılarak yapılıyor Yani; cin>>a[i][j]; şeklinde Matris çarpım işlemi üç iç içe çevrimde gerçekleşiyor Bunun kodlama mantığı, kağıt üzerinde değer takibi yapılarak anlaşılabilecektir

50 /********************************************************* Sözel Diziler - Sınıftaki en yüksek notlu öğrenci *********************************************************/ #include iostreamh #include conioh int n, i, not[100], maks=0, imaks; char isim[100][20], soyisim[100][30]; void main( ) clrscr( ); cout<< \n Öğrenci sayısı? ; cin>>n; for( i=0;i<n;i++) cout<< \n Adı= ; cin>>isim[i]; cout<< Soyadı= ; cin>>soyisim[i]; cout<< Notu= ; cin>>not[i]; if( not[i] > maks) maks=not[i]; imaks=i; cout<< \n\n En yüksek notu alan öğrenci ; cout<< \n \n ; cout<< isim[imaks]<< <<soyisim[imaks]; cout<< \n Notu= << not[imaks]; getch( ); 50 Önce karakter dizisi bir boyutlu olursa ne olur onu görelim char a[20]; tanımına göre 20 elemanlı (harfli) bir değişken tanımlıyoruz Bu değişkene okuma yapılırken doğrudan cin>>a; komutu kullanılır Böylece, girilen metin bilgisi, karakter matrisine yerleştirilir Örnek programda, karakter türü iki dizi değişkeni bulunuyor char isim[100][20], soyisim[100][30]; şeklinde tanımlanan bu değişkenlerin her birine 100 tane veriyi taşıma kapasitesi veriliyor Bu 100 verinin her biri isim değişkeninde 20, soyisim değişkeninde 30 harfli olabilecektir Karakter dizileri, tamsayı ve reel sayı değişkenlerinden farklıdır int a[100][20]; tanımına göre bellekte 100x20=2000 sayılık yer ayrılırken, aynı tanım char şeklinde yapıldığında 100 satır ve 20 sütundan oluşan bir karakter matrisi açmış oluyoruz Okuma/yazma işlemi cin>>isim[i]; şeklinde yapılıyor Bunun anlamı, girilen veriyi, isim değişkeninin i nci satırına kaydettirmektir Örnekte, en yüksek notla birlikte, en yüksek notun girildiği i değeri imaks değişkenine aktarılıyor Böylece, en yüksek notun kaçıncı sırada olduğu imaks a kaydediliyor SEMBOLĐK SABĐTLER // Diziler - Sembolik sabitler #include iostreamh #include conioh #define SATIR 3 #define SUTUN 3 int x[satir][sutun], i, j, topla=0; void main( ) clrscr( ); for(i=0;i<satir;i++) for(j=0;j<sutun;j++) cout<< \n Sayı girin: ; cin>>x[i][j] ; topla+=x[i][j]* x[i][j]; cout<< \n\n Kare toplamı: <<topla; getch( ); Sembolik sabitler, #define komutuyla tanımlanırlar #define SATIR 3 komutu, SATIR değişkeninin program boyunca 3 rakamı olarak tanımlandığını, yani, nerede SATIR ifadesi görülürse, orada 3 rakamı varmış gibi hareket edileceği anlamına gelir Aynı şekilde, #define SUTUN 3 komutunda, program SUTUN ifadesini gördüğü yerde, 3 rakamı varmış gibi çalışacaktır Dizi değişkenler tanımlanırken boyutları ya sabit sayılarla, ya da, sembolik sabitlerle tanımlanmalıdır Kullanıcının girdiği bir tamsayı değerine göre bellek alanı açılmaz

51 8 DOSYADAN OKUMA/YAZMA 51 Veri girişlerinde, ekranın yanı sıra, dosya içinden de okuma yapılabilir ve çıktılar dosyaya yazdırılabilir Bu amaçla, iki yeni değişken tipi olan ifstream ve ofstream, bunların başlık dosyası olan fstreamh kullanılacaktır Aşağıdaki örnek, dosyadan okunan bir grup sayının toplamını buluyor /************************************* Dosyadan okuma/yazma - 1 *************************************/ #include iostreamh #include conioh #include fstreamh int i, n, sayi, toplam=0; char ad[20]; ifstream oku; ofstream yaz; void main( ) clrscr( ); cout<< Okunacak dosya: ; cin>>ad; okuopen( ad ); oku>>n; for(i=1;i<=n;i++) oku>>sayi; toplam += sayi; yazopen( SonucDat ); yaz<< Toplam= <<toplam; VeriDat SonucDat cout<< \n\n SonucDat dosyasına kaydedildi ; getch( ); Toplam= 255 Örnekte, değişken tanımları içinde dosya okuma amaçlı değişken olarak oku, yazma amaçlı değişken yaz ı görüyoruz Bu değişkenlerden okuma işlemini yapacak olan ifstream oku; yazma işlemini yapacak olan ofstream yaz; şeklinde tanımlanmıştır Bu tanımlardan sonra değişkenlerimiz, dosya işlemleri için hazır hale gelmiştir Ana fonksiyon içinde önce okunacak dosya adı kullanıcıdan isteniyor Bu bilgi ad karakter değişkenine kaydediliyor Daha sonra dosya açma işlemi yapılıyor; okuopen (ad); Buna göre, oku değişkenimize open komutu eklemlenerek, dosya okuma amaçlı açılmıştır Açılan dosya adı parantezlerin içindedir; yani, ad değişkeninin taşıdığı kullanıcı tarafından girilen dosya adı; VeriDat Programın bu dosyayı okuyabilmesi için veri dosyasının önceden hazırlanmış olması gerekmektedir Daha sonra oku değişkenini, cin>> benzeri bir şekilde; oku>> komutuyla dosya okumasında kullandığımız görülüyor Đlk okunan değer n değişkeni; yani 10 olacaktır Bir for döngüsü içinde 10 sayı dosyadan okunmaktadır Okuma sonrası hemen toplam değişkeninin üstüne eklenmektedir Döngüden çıkılınca, bütün sayılar okunmuş ve toplam bulunmuştur Şimdi sonuç bir dosyaya yazdırılacaktır Bu amaçla tanımlanan değişken, çıktı dosyasını açıyor; yazopen(sonucdat); Buna göre diskte SonucDat adında bir dosya açılacak, varsa üzerine kayıt yapılacaktır Dikkat edilirse, bu defa dosya adını kullanıcıdan sormak yerine program içinde çift tırnak arasında belirledik En son işlem yaz komutunu cout<< gibi yaz<< şeklinde kullanarak SonucDat içine toplam değerini yazdırmaktır toplam += sayi; komutundaki += ifadesi, soldaki değişkenin üstüne eklenmesini sağlar ve toplam=toplam+sayi; ile aynıdır

52 /************************************* Dosyadan okuma/yazma - 2 *************************************/ #include iostreamh #include conioh #include fstreamh #include stdlibh char ulke[20], sehir[20]; char ad[20]; ifstream oku; void main( ) clrscr( ); cout<< Okunacak dosya: ; cin>>ad; okuopen(ad); if(okufail( ) ) cerr<< \n Dosya açarken hata oluştu! ; cerr<< \n Programdan çıkıyoruz ; exit(-1); oku>>ulke>>sehir; cout<< \n\n Ülke: <<ulke<< \n Şehir: <<sehir; okuclose( ); getch( ); VeriDat Türkiye Ankara Bu örnek, diğerinden farklı olarak dosyanın açılmaması durumunda nasıl hata mesajı verdirebileceğimizi gösteriyor if cümlesi içinde okufail( ) sorgulaması olumluysa, yani hata varsa, if bloğu içindeki cerr<< komutlarıyla hata mesajı ekrana gönderiliyor ve exit(-1); hatalı program çıkış komutu çalıştırılıyor Bir dosyadan iki karakter veri okuyacak program, ülke ve şehir bilgilerini daha sonra ekrana yazdırıyor Okuma işlemini takiben dosya okuclose( ); komutuyla kapatılıyor Okunacak dosya: veridat Ülke: Türkiye Şehir: Ankara 52 // *** Dosyadan okuma/yazma 3 *** #include iostreamh #include conioh #include fstreamh char ad[20]; long x[50][50]; ifstream oku; int i, j, n; void main( ) clrscr( ); cout<< Okunacak dosya: ; cin>>ad; okuopen(ad); oku>>n; // Dosyadan ilk okunan sayı n cout<<n<< satır ve sütunlu veri \n\n ; for(i=0;i<n;i++) for(j=0;j<n;j++) oku>>x[i][j]; cout<<x[i][j]<< ; cout<< \n ; okuclose( ); getch( ); Yandaki örnek kodlamada, adını kullanıcının gireceği bir dosyadan önce boyut, sonra iki boyutlu bir dizi okunup ekrana yazdırılıyor Tanım satırında yer alan long ifadesi, long int anlamına gelmektedir Đç içe iki for çevrimi içinde oku>> komutu ile yapılan veri alma işleminin hemen ardından, okunan bilgi cout<< komutuyla ekrana gönderiliyor Dosyadan okumanın, ekrandan yapılan okumadan az bir farkı olduğunu, onun dışındaki işlemlerin değişmediğini fark ediniz Okunacak dosya: verilerdat 2 satır ve sütunlu veri

53 9 YAPILAR (struct) 53 Yapılar (struct), nesne tabanlı programlamaya geçişte temel adımlardan biridir Yapılar, çeşitli değişken ve fonksiyonları altında toplayabilen çatılardır struct ne demektir? Kelime anlamı olarak struct, yapı demektir (structure) C de ise, mantık ilişkisi olan farklı türden değişkenleri ve fonksiyonları çatısı altında toplayan özel veri gruplarıdır Programcı, nasıl ve nelerden oluşan bir yapı oluşturacağına kendi karar verir struct grubunun değişkenleri, bellekte dizi değişkenler gibi tutulurlar struct nasıldır? Genel görünümleri ve üç örnek yapı aşağıda verilmiştir: struct [yapı_ismi] degisken_tanimi; degisken_tanimi; : degisken_tanimi; ; struct KOORDINAT float x; float y; int kod; char ad[20]; ; struct NOTLAR float vize; float final; float odev; ; struct OGRENCI char ad[20]; char soyad[30]; float GenelOrt; ; struct yapılarının bir [yapı_ismi], içinde veri tür tanımlarının olduğu bir bloğu, bir de bu yapıyı kullanacak olan [yapı_değişkeni] vardır Bu değişken, yapıya atanarak, alt alanlarıyla birlikte kullanılır Yapı ismi ve değişkeni ne demektir ve nasıl kullanılır? Yapıların bloklarının bir ismi ve bu bloktaki alt değişkenleri kullanacak bir üst kimlik vardır Yapı bloğunun tanımlandığı isme yapı_ismi, bu bloğu kullanacak değişkene de yapı_değişkeni denir Açık yapı formu ve yapıya değişken ataması için iki genel model ve iki kullanım örneği aşağıda görülmektedir: struct [yapı_ismi] degisken_tanimi; degisken_tanimi; : degisken_tanimi; [yapı_değişkeni]; [yapı_ismi] [yapı_değişkeni]; struct OGRENCI char ad[20]; char[ soyad[30]; float GenelOrt; insaat; KOORDINAT nokta;

54 Niye bir üst kimliğe (yapı değişkenine) ihtiyaç var? 54 Yapı isminin yanı sıra bir de yapı değişkeni tanımlanır Bu, yapıların birden çok değişken tarafından kullanılabilmesi içindir Yapı kurmaktan amaç, bir veri modülü oluşturmak ve bu modülü birçok farklı değişkenle kullanabilmektir Yani her birini defalarca tanımlamak yerine, yapıya bağlı bir değişken tanımıyla, alt alan değişkenleri de tanımlanmış olur Alt alan değişkenleri aynı da olsa, üst kimlik durumundaki değişken farklı olduğundan yapılar birbirine karışmayacaktır struct OGRENCI char ad[20]; char[ soyad[30]; float GenelOrt; ; OGRENCI maden; OGRENCI seramik; OGRENCI endustri; Burada yapı adı OGRENCI olup, blok içinde ad, soyad ve GenelOrt değişkenleri tanımlanmış durumdadır Daha sonraki satırlarda bu yapıyı kullanabilecek üç değişken tanımlanmıştır Dolayısıyla bellekte maden, seramik ve elektronik için bu üç alt değişkene yer açılacak ve hiçbiri birbirine karışmayacaktır Yapı değişkeni aynı yapıya atanabiliyor O halde nasıl karışmıyor ve nasıl gösteriliyorlar? Karışmamaları, zaten gösterim şekillerinden kaynaklanıyor Bir yapıdaki değişken, yapı değişkeni ve alt değişkenle birlikte gösterilir Đki değişkenin adları nokta () operatörüyle bağlanır Örnekleri inceleyelim madenad= Hasan ; seramiksoyad= Altan ; endustrigenelort=325; Aynı anda bütün değerler de atanabilir: struct OGRENCI maden = Hasan, Demirci, 288 ; veya OGRENCI maden = Hasan, Demirci, 288 ; Bir başka tanım ve atama: struct TARIH int gun; int ay; int yil; ; TARIH bugun; bugungun=15; bugunay=2; bugunyil=2006; struct NOT_ORTALAMASI int vize; int final; endustri; endustrivize=75; endustrifinal=71; struct ZAMAN int saat; int dakika; int saniye; saat_oku; saat_oku=13, 45, 5; Özetle, struct lar ortak kullanılabilen veri modülleridir Bu modülleri, struct değişkenleri kullanır Yeni oluşum, yapı değişkeniyle alt değişkenin, nokta operatörüyle bağlanmasıyla kullanılır

55 /******************************************************** Yapılar 1; Memur kütüğü (bir kişilik) ********************************************************/ #include iostreamh #include conioh struct MEMUR char ad[20]; char soyad[25]; char DYeri[20]; int DYili; int PersNo; ; void main( ) clrscr( ); MEMUR m; cout<< \n Adı= ; cin>> mad ; cout<< \n Soyadı= ; cin>> msoyad ; cout<< \n Doğum Yeri= ; cin>> mdyeri ; cout<< \n Doğum Yılı= ; cin>> mdyili ; cout<< \n Personel No= ; cin>> mpersno ; // Bu bilgileri yine ekrana gönderelim cout<< \n Memurun Adı= << mad ; cout<< \n Memurun Soyadı= << msoyad ; cout<< \n Doğum Yeri= << mdyeri ; cout<< \n Doğum Yılı= << mdyili ; cout<< \n Personel No= << mpersno ; getch( ); Örnek kodlar, struct ların çalışması hakkında bir fikir vermektedir Đlk örnekte, 5 alt elemanı olan MEMUR adlı bir yapı yer almaktadır Bu yapıya m adlı bir değişken atanıyor ve ekrandan alınan bilgilerin, değişkenlere nasıl yerleştirildiği görülüyor /******************************************************** Yapılar 2; Kimlik kütüğü (100 kişilik) ********************************************************/ #include iostreamh #include conioh #include fstreamh struct KIMLIK char ad[20]; char soyad[25]; int No; ofstream yaz; void main( ) int i,n; clrscr( ); m[100]; cout<< \n Kaç personel var? ; cin>>n; for(i=0;i<n;i++) cout<< \n Adı= ; cin>> m[i]ad ; cout<< \n Soyadı= ; cin>> m[i]soyad ; cout<< \n Personel No= ; cin>> m[i]no ; // Bu bilgileri dosyaya gönderelim char dos[20]; cout<< \n\n Kayıt dosyasının adı: ; cin>>dos; yazopen( dos ); for(i=0;i<n;i++) yaz<< \n Memurun Adı= << m[i]ad ; yaz<< \n Memurun Soyadı= << m[i]soyad ; yaz<< \n Personel No= << m[i]no << \n\n ; getch( ); 55 Đkinci örnekte ise, üç alt değişkeni olan KIMLIK yapısına, 100 elemanlı m[100] tanımlı bir dizi değişken atanıyor Bu, bellekte 100 tane dizi değişkene yer ayrıldığını, her bir değişkeninde KIMLIK yapısındaki alt değişken alanlarına sahip olduğunu gösteriyor Örnekte daha sonra böyle bir dizi yapıya ekrandan değer okunması ve okunan bilginin dosyaya yazılması işlemi yapılıyor

56 10 GÖSTERICILER (Pointer) 56 Göstericiler (pointer), şimdiye kadar gördüğümüz değişkenlerden farklı özelliği olan nesnelerdir Sayısal veya sözel değer taşımak yerine, bu bilgilerin kaydedildiği adres bilgisini taşırlar Dolayısıyla, bir değerin bellekteki adresine ulaşabiliyorsanız, değerine de ulaşıyorsunuz demektir Göstericilerle yapılan işlemlerde hızlı erişim sağlaması gibi bir fayda elde edilir Genel gösterimi, tür bildirisinden sonra gelen değişken isimlerine * ön ekini getirmektir int *say; float *x; char *ad[20]; /******************************* Göstericiler (Pointers) - 1 *******************************/ #include iostreamh #include conioh int a=10; int *p; void main( ) clrscr( ); p=&a; cout<< \n p= <<p<< *p= <<*p; *p=20; cout<< \n *p= <<*p<< a= <<a; a=30; cout<< \n *p= <<*p<< a= <<a; char *s= Dumlupınar ; cout<< \n << s; getch( ); p=0x8fc100aa *p=10 *p= 20 a=20 *p=30 a=30 Dumlupınar Örnek kod ve sonuç incelendiğinde, bir pointer ın (göstericinin) atandığı değişkenin bellek adresini taşıdığı anlaşılıyor Çünkü p değişkeni, cout<< komutunda kendi yalın halinde kullanıldığında, ekrana a değişkeninin adres bilgisini yansıtıyor *p şeklindeki deklarasyonlaysa, işaret ettiği adreste yer alan bilginin ekrana aksetmesini sağlıyor Daha sonra *p=20; işlemiyle göstericiye değer veriliyor Böyle bir eşitlemenin, a değişkenini de etkilediği görülüyor Demek ki, gösterici bir değişkene bağlıysa ve göstericinin değeri değiştiriliyorsa, bağ kurulan değişken de aynı değeri alıyor Çünkü bir *p=20; eşitlemesi, p nin işaret ettiği adrese de gönderiliyor ve a=20 oluyor a değişkenindeki bir değişikliğin de, otomatikman p yi etkilediği görülüyor a=30; işlemi, a nın adresine atanan p nin de aynı değeri almasını sağlıyor Sözel bir göstericinin nasıl değer aldığı ve cout<< komutuyla nasıl kullanıldığı da örnekte görülüyor

57 GÖSTERĐCĐLERLE DĐNAMĐK BOYUTLU DĐZĐLER 57 Gösterici kullanımının en büyük kolaylık sağladığı bir alan olarak, boyutunu kullanıcının belirlediği dizileri görürüz Bu amaçla, new operatörü kullanılır /************************************************ Göstericiler (Pointers) - 2 Dinamik boyutlu diziler new operatörü Not ortalaması ***********************************************/ #include "iostreamh" #include "conioh" void main( ) int *x, toplam=0, n, i; clrscr( ); cout<<" Kac ogrenci var? "; cin>>n; x=new int [n]; for(i=0;i<n;i++) cout<<"\n"<<i+1<<" not= "; cin>>x[i]; toplam+=x[i]; cout<<"\n\n Ortalama= "<<toplam/n; getch( ); C++ da, dinamik bellek işlemleri için new operatörü kullanılır Dizi boyutu önceden belirsiz olan ve kullanıcı tarafından belirlenmesi istenilen durumlarda new operatörü büyük kolaylık sağlar Đlk örnekte, tek boyutlu *x göstericisine x=new int[n]; komutuyla n elemanlık bellek alanı açılmıştır Đkinci örnekte, çiftli **y göstericisine, önce ilk boyutu y=new int *[n]; komutuyla, sonra ikinci boyutu bir for çevrimi içinde for(i=0;i<n;i++) y[i] = new int[n]; komutuyla verilmektedir Böylece nxn lik bir dizi oluşturulmuştur /************************************************************ Göstericiler (Pointers) - 3 Dinamik iki boyutlu diziler new operatörü Matris satır-sütun toplamları ************************************************************/ #include "iostreamh" #include "conioh" void main( ) int **y, i, j, n; int satir, sutun; clrscr( ); cout<<"\n Kare matris boyutu: "; cin>>n; y = new int*[n]; for( i=0;i<n;i++) y[i] = new int[n]; for(i=0;i<n;i++) for(j=0;j<n;j++) cout<<"\n"<<i+1<<" satir "<<j+1<<" sutun: "; cin>>y[i][j]; for(i=0;i<n;i++) satir=0; for(j=0;j<n;j++) satir+=y[i][j]; cout<<"\n"<<i+1<<" satir toplami= "<<satir; for(j=0;j<n;j++) sutun=0; for(i=0;i<n;i++) sutun+=y[i][j]; cout<<"\n"<<j+1<<" sutun toplami= "<<sutun; getch( ); Daha sonra, x ve y göstericileri, birer dizi değişken olarak değer okuma ve işlemede kullanılmışlardır

58 58 /************************************************************************************ Göstericiler (Pointers) - 4 Dinamik 3 boyutlu diziler new operatörü ************************************************************************************/ #include "iostreamh" #include "conioh" #include timeh #include stdlibh void main( ) clrscr(); int ***y, i, j, k, n; int satir,sutun; cout<<"\n Kare matris boyutu: "; cin>>n; y = new int**[n]; for(i=0;i<n;i++) y[i] = new int*[n]; for( i=0;i<n;i++) for( j=0;j<n;j++) y[i][j] = new int[n]; srand((unsigned) time(null)); for(i=0;i<n;i++) for(j=0;j<n;j++) for(k=0;k<n;k++) y[i][j][k]=rand( )%100; //diziye rasgele değer alınıyor for(i=0;i<n;i++) for(j=0;j<n;j++) for(k=0;k<n;k++) cout<<"\n"<<i+1<<" satir "<<j+1<<" sutun "<<k+1<<" kat= "<<y[i][j][k]; getch(); Örnekte, üç boyutlu bir dizinin dinamik bellek açılışı görülüyor ***y göstericisine, her boyut için ayrı işlem yapılıyor Đlk boyut y = new int**[n];, ikinci boyut for çevrimi içinde for(i=0;i<n;i++) y[i] = new int*[n]; ve üçüncü boyut iç içe iki çevrim içinde for((i=0;i<n;i++) for(j=0;j<n;j++) y[i][j] = new int[n]; komutlarıyla dinamik olarak atanıyor Burada boyut n değişkeni, n değişkeni ise kullanıcı tarafından belirliyor Neticede nxnxn lik bir üç boyutlu dizimiz oluyor

59 11 NESNEYE YÖNELĐK PROGRAMLAMA 59 Nesneye yönelik programlama (Object oriented programming), C++ içinde geniş ve başlangıç düzeyi haricinde özel zaman ayırmak gereken bir konudur Çünkü nesneye yönelik programlama, aynı programlama dili içinde bambaşka bir programlama mimarisi ve mantığıdır C++, yapı itibariyle fonksiyonlardan oluşan ve programcının bu mevcut fonksiyonlara kendi fonksiyonlarını eklediği bir dildir Komut olarak kullanılan hazır fonksiyonlar aslında kullanılabilir nesnelerdir Dolayısıyla programcı, nesne kullanıcısıdır Bu kısımda, programcının kendi nesnelerini oluşturması ve nesne tabanlı programlama bilgilerine kısa bir giriş yapılacaktır class ve struct Nesneye yönelik programlamanın temel öğelerinden birisi class lardır (sınıf) Daha önceki konularda struct hakkında bilgi edinmiştik class için, struct ın büyük ölçüde aynısıdır diyebiliriz class A M ; struct A private: M ; veya struct B M ; class B public: M ; şeklinde bir denklik kurulabilir Yapılar veya sınıflar içinde üye değişken tanımı yapılabildiği gibi, üye fonksiyon tanımı da yapılabilir Üyeler struct yapısında normalde public: özelliğinde, class ta ise private: özelliğindedir Üyelerin public: olması demek, yapı üyelerinin erişime açık olması, private: olması ise, üyelerin yapı veya sınıf için özel olması ve dışarıdan erişime kapalı olması demektir Nesne tabanlı programın diğer aktörleri başlık dosyalarıdır (*h) Nesneler, bu dosyalar içinde oluşturularak, tıpkı diğer C++ fonksiyonları gibi #include *h komutuyla kendilerine ulaşılabilir Konunun daha iyi anlaşılması için basit bir uygulama içeriği olan aşağıdaki örnekte, daire ve karenin çevre ve alan hesabını yapan kareh ve daireh dosyaları yazılmış, daha sonra bunları kullanan geometricpp dosyası kodlanmıştır Yani, üç dosya, uyumla çalışacaktır Başlık dosyalarında struct ve class kullanılmış, aralarındaki küçük fark gösterilmiştir Programladığımız fonksiyonların, sıkça kullanılacak işlemleri yerine getirecek şekilde kodlanması durumunda, nasıl bir C++ komutu gibi kullanılabileceği görülmüştür

60 60 /******************************* Kareh ********************************/ #include "mathh" class KARE public: double Kenar; double Cevresi(); double Alan(); ; double KARE::Cevresi() double cevre; cevre=kenar*4; return cevre; double KARE::Alan() double Alani; Alani=Kenar*Kenar; return Alani; /******************************* Daireh ********************************/ #include "mathh" struct DAIRE double Cap; double Cevresi(); double Alan(); ; double DAIRE::Cevresi() double cevre; cevre=cap*m_pi; return cevre; double DAIRE::Alan() double Alani; Alani=(Cap*Cap*M_PI)/4; return Alani; Kenar uzunlugu=10 Daire cap uzunluğu=10 Karenin cevresi=40 Karenin alani=100 Dairenin cevresi=3141 Dairenin alani= 7853 /******************************* Geometricpp ********************************/ #include "iostreamh" #include "conioh" #include "Daireh" #include "Kareh" KARE K; DAIRE D; void main() KKenar=100; DCap=100; clrscr(); cout<<"\n Kare kenar uzunlugu= "<<KKenar; cout<<"\n Daire cap uzunlugu = "<<DCap; cout<<"\n Karenin cevresi= "<<KCevresi(); cout<<"\n Karenin alani= "<<KAlan(); cout<<"\n Dairenin cevresi= "<<DCevresi(); cout<<"\n Dairenin alani= "<<DAlan(); getch(); Geometricpp dosyasına #include satırlarında Kareh ve Daireh dosyalarının da dahil edildiği görülüyor Kareh ta bir karenin kenarı bir üye değişken, Cevresi ve Alan ise üye fonksiyondur Erişime açmak için hepsi public: yapılmıştır Daireh ta, Cap yapıda üye bir değişken, Cevresi ve Alan ise fonksiyon üyedir Geometricpp içinde KARE K; ve DAIRE D; satırlarında bu sınıf ve yapıya değişken ataması yapılmıştır KKenar=100; ve DCap=100; satırlarında sınıf ve yapıdaki üye değişkenlere değer ataması yapılmıştır cout<< cümlelerinde ise, fonksiyonlar çalıştırılıp sonuçlar ekrana yazdırılmıştır struct veya class üye fonksiyonları yazılırken yapı veya sınıf adıyla fonksiyon adının :: operatörüyle bağlandığı görülmektedir Üye değişkenlerin (nokta) operatörüyle bağlandığını yapılarla ilgili konuda görmüştük Bir yapı veya sınıf değişkeni gösterici (pointer) olursa, bu değişkenler üye fonksiyonun -> operatörüyle bağlanacağını burada belirtelim Görsel programlamada bu operatör sıklıkla kullanılacaktır

61 12 GÖRSEL PROGRAMLAMA (Visual programming) 61 Şimdiye kadar gördüğümüz C/C++ bilgi ve uygulamaları DOS ortamında gerçekleşiyordu Genellikle siyah beyaz bir ekran üzerinde olan okuma yazma işlemleri, WINDOWS ekranının canlılığından uzaktı Görsel programlamayla, artık programlar yeni bir editörde ve yeni bir yüzle karşımıza çıkacak Temelde C/C++ programlamayı bilen bir öğrencinin, görsel programlamaya geçişinin daha kolay olduğu muhakkaktır Çünkü bu yeni kod dünyasına girildiğinde, her ne kadar her şey bambaşka görünse de, bir noktadan sonra yine temel C/C++ bilgilerinin kullanıldığı fark edilecektir Görsel programlamayla, programcının gündemine yeni bir konu daha girmektedir; ara yüz tasarımı Bir görsel (visual) programın iki ana unsuru olduğu söylenebilir: i Arayüz ii Motor (kodlar) Arayüz, arkasında kodların çalışacağı ekran görüntüsüdür Yani programcı, programının ekran görüntüsünü kendisi tasarlayacaktır Bunun için yeni bir editöre ihtiyacı olacaktır Aşağıda Borland C++ ekranı görülüyor Form başlığı Kontrol Çubuğu Object Inspector Nesne düzenleyicisi Form nesneleri Form Bir başka yenilik ise, daha önce tek bir CPP dosyasında oluşan programın, ara yüzün katılımıyla bir dosya gurubundan oluşur hale gelmesidir Artık ortada, kod, ara yüz ve diğer dosyalarıyla bir proje vardır

62 62 Form, programcının ekran tasarımı yapması için açılan boş bir zemindir Üstünde, nesnelerin yer aldığı ve konularına göre gruplandırıldığı Bileşen Paleti (nesne çubuğu) vardır Bu zeminin üzerine nesne çubuğundan program ihtiyaçlarına göre yazılar, metin kutuları, şekiller, seçim düğmeleri, liste kutuları gibi birçok nesne eklenecektir Gerek Form un kendisi, gerekse her bir nesne için, Object Inspector (nesne düzenleyicisi) olarak adlandırılan ve hemen formun sol tarafında bulunan nesne düzenleme penceresi kullanılacaktır Object Inspector, seçili olan nesne ile ilgili, renk, yazı tipi, büyüklük, ekran konumu gibi birçok parametreyi düzenlemek amacıyla kullanılır Büyük kolaylık sağlayan bu kontroller form üzerinde yapılabildiği gibi, programın kod satırlarında da değiştirilebilir Standart, Additional, Win32, Dialogs, vs başlıklar altında çeşitli nesnelerin olduğu görülecektir Bu nesneler, fare yardımıyla seçilerek, Form üzerinde istenilen yere yerleştirilecek, renk, büyüklük, yazı tipi, vs özellikleri Object Inspector yardımıyla düzenlenecektir Object Inspector ın (nesne düzenleyicisinin) Properties, yani nesne özelliklerini düzenleyen bir birimi olduğu gibi, bir de Events, yani Olaylar kısmı vardır Burada, nesneyle ilgili çeşitli olaylar düzenlenir Mesela, bir nesneye fareyle tıklanınca, fare üzerine gelince, kapatılınca, vs neler olacağı, kod yazılarak belirtilir Formun arkasında ise, kod sayfası, ayni projenin motor kısmı yer alır Turbo C gibi derleyicilerde geliştirilen programlar, bir yerde motor gibi düşünülebilir Tek fark, ekran düzenini artık kod içinde düşünmeye gerek kalmaması, ara yüzün ayrı bir tasarım ve çalışmayla yapılmasıdır Aşağıda, boş bir forma ait kod kısmı görünüyor C++ derleyicisi, programcıya bu satırları hazır sunuyor

63 F12 kısa yol tuşuyla form ve kod sayfası arasında geçiş yapılabilir Dosyada, #include <vclh>, Virtual Component Library (Görsel Bileşen Kütüphanesi), Unit1cpp ve #include Unit1h ifadesi, #pragma package ve #pragma resource gibi, dosyaların paketlenmesi ve kaynak kodlarıyla ilgili komutlar otomatik olarak yerleştirilmiş, ayrıca, TForm1 *Form1; satırıyla standart formun Form1 olduğu belirtilmiştir; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) Burada, TForm1 class ının (sınıfının) TForm1 üye fonksiyonu yer almaktadır Form1 üstüne gelen her nesne ve bunlara ilişkin kodların yazıldığı fonksiyonlar, TForm1 sınıfına otomatik olarak eklenen üye fonksiyonlardır Kodlayıcı, farkında bile olmadan bir class ı (sınıfı) doldurmaktadır Görsel programlamada, CPP dosyasının yanı sıra, form üzerindeki kontrollerle ilgili bilgilerin olduğu DFM, derlenmiş kaynak, resim, ikon, vs bilgilerin olduğu RES, proje dosyalarına ulaşımı sağlayan ve adını EXE dosyaya veren proje dosyası BPR ve derlenmiş birim dosyaları H bir projeyi oluşturan dosyalardır Proje dosyası BPR ile bütün bu dosyalara da ulaşılmış olur Bileşen (nesne) çubuğunda en sık kullanılan başlık Standard dır Bu başlığın en sık kullanılan nesneleri ise Label (etiket), Edit (yazım), Button (tuş), CheckBox (kontrol kutusu), ListBox (listeleme kutusu), ComboBox (seçenek liste kutusu) ve RadioButton dur (seçenek düğmesi) RadioButton ListBox ComboBox 63 Label Edit Button CheckBox Benzer şekilde Additional bileşeninde de, sıkça kullanılan nesneler bulunmaktadır Bunlar, üzerine şekil eklenebilen tür Button dan BitBtn (bitbutton) ve SpeedButton, veri girişi için tablo formu sunan StringGrid, forma şekil eklemeyi sağlayan Image, basit geometrik şekiller ekleyen Shape, gölgeli zeminde yazı ve şekil ekleyen Bevel ve grafik ekleyen Chart tır Image Shape Chart BitBtn SpeedButton StringGrid Bevel Kod yazımı, standart C den kısmen farklı olan görsel programlamayla ilgili bazı örnekler, konunun daha iyi anlaşılmasını sağlayacak, birçok detay, örnekler üzerinde adeta kendini anlatacaktır Đlk kod örneği, iki sayı için dört işlemi, yani toplama, çıkarma, çarpma ve bölmeyi yapan, basit bir hesap makinesi olsun Önce form üzerine sayıların girileceği iki Edit kutusu yerleştirilecek, üzerinde işlem bilgisinin yazılı olduğu Button lar yerleştirilecek, daha sonra, Button lara Click edilmesi (tıklanması) durumu için Event (olay) kodlanacaktır

64 ĐLK ÖRNEK; BASĐT HESAP MAKĐNESĐ (Form, Edit, Label, Button kullanımı) 64 Örnek programın ekran görüntüsü incelendiğinde, işlem yapılacak iki sayı için hazırlanmış iki Edit kutusu, dört işlem ve çıkış için beş Button, başlık ve işlem sonucunun yazılması için iki adet Label kullanıldığı görülüyor Aşağıdaki küçük resimde, form üzerindeki bu nesneler gösterilmektedir Label Edit ler Label Button lar Button Bu ekran (ara yüz) nasıl hazırlanıyor? Formun büyüklüğü, kenarlarından fareyle tutarak veya forma ait nesne düzenleyicisindeki Height (yükseklik) ve Width (genişlik) yoluyla istenilen boyuta ve ekran pozisyonuna getirilir Daha sonra, işe formun üzerindeki Form1 yazısı yerine Hesap Makinesi yazmakla başlanabilir Bunun için nesne düzenleyicisindeki Caption kısmına istenilen başlık yazılır Caption (başlık) Form başlığı Form Daha sonra, üstteki bileşenler çubuğundan Standart üstünde yer alan Label kısa yol tuşu seçilerek, form üzerinde istenilen yere konulur ve otomatik olarak Label1 adını alır Bu adın değiştirilmesi, yine ona ait Object Inspector sütununda yer alan Caption kısmından yapılır Label Label1 Gerek Label ve Form, gerekse birçok nesnenin bir Caption ı, bir de Name i vardır Bunların işlevleri de farklıdır Capiton, sadece form üzerinde görünen yazıyı değiştirmekte kullanılırken, Name, o nesnenin kod satırlarında kullanılacak ismidir Dolayısıyla, Caption yerine yanlışlıkla Name değiştirilirse, Name de kullanılan ismin kod satırlarında da kullanılması gerekecektir Bu genellikle şaşırmalara sebep verdiğinden, Name i hiç değiştirmemek daha uygun olacaktır

65 65 Edit kutuları, kullanıcıdan istenilen bilginin girilmesi için kullanılan metin kutularıdır Programda, kullanıcı iki sayıyı bu kutulara girecektir Edit kutuları forma yerleştirildiğinde, içlerinde Edit1, Edit2 gibi ifadelerin çıktığı görülür Tabii ki program çalışırken kutu içinin boş olması gerekmektedir Bunun için Edit in nesne düzenleyicisindeki Text kısmına gidilir ve bunun içi boşaltılır Edit lerde Label dan farklı olarak Caption değil, Text vardır Yani, kutu içindeki yazı Edit in Text idir, Label ın ise Caption ı Edit1 Edit Edit2 Label2 Şekilde, Label2 nin yeri gösterilmekle birlikte, formda boşluk gözüküyor Bunun sebebi, Label2 nin hesaplama sonucunun deklare edileceği yer olması ve işlem yapılmadıkça burada bir sayının gözükmemesi gereği Label2, tıpkı Edit kutuları gibi boş olmalı ve iki sayının girilip dört işlem tuşlarından birinin seçilmesi durumunda Label2 de sonuç belirmeli O halde, Label2 forma yerleştirildikten sonra, Caption kısmına gidilip, içi boşaltılmalı Biraz sonra kod satırlarında Label2 nin boşaltılan Caption ına işlem sonucunun nasıl yazdırıldığı görülecek Button lar, görsel programlamanın önemli nesnelerindendir Çünkü bir anlamda, ara yüzden kod satırlarına geçiş noktalarıdır Button ların Caption kısmına, üstlerinde belirmesi istenen yazı veya şekil eklendikten sonra, Button un esas işlevine, yani üstüne yazılacak olan kod kısmına geçilir Son bir bilgi; gerek Label gerekse Edit kutularında belirecek yazıların büyüklüğü, karakter türü, rengi vs özelliği, nesne düzenleyicisindeki Font kısmından ayarlanabilir Ara yüzü hazırladıktan sonra program nasıl yazılıyor? Görsel programlamadaki iki basamaktan ilki olan form tasarımı tamamlandıktan sonra, kod yazmaya geçilebilir Bu geçiş, genellikle Button lar üzerine Events, yani olay yazarak olur Olay demek, Button a basıldığında olması istenen işlem ve buna ait kodlamadır Mesela, Button1 in üzerinde Toplama (+) yazıyor O halde, bu tuşa fareyle tıklandığında Edit1 ve Edit2 ye girilen sayıların toplanması sağlanmalıdır Button dan kod sayfasına geçiş, Button1 seçiliyken Object Inspector daki Events kısmına geçerek, burada yer alan OnClick seçeneğinin kutusunu fareyle iki defa tıklamak veya daha kısa yolu, form üzerindeki Button1 tuşuna fareyle iki defa tıklamaktır

66 Ara yüzü ve bu ara yüze ait programın kod satırları da aşağıda verilmektedir Şimdi bunları inceleyelim 66 #include <vclh> #pragma hdrstop #include "Unit1h" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::Button1Click(TObject *Sender) Label2->Caption=FloatToStr(StrToFloat(Edit1->Text)+StrToFloat(Edit2->Text)); void fastcall TForm1::Button2Click(TObject *Sender) Label2->Caption=FloatToStr(StrToFloat(Edit1->Text)-StrToFloat(Edit2->Text)); void fastcall TForm1::Button3Click(TObject *Sender) Label2->Caption=FloatToStr(StrToFloat(Edit1->Text)*StrToFloat(Edit2->Text)); void fastcall TForm1::Button4Click(TObject *Sender) Label2->Caption=FloatToStr(StrToFloat(Edit1->Text)/StrToFloat(Edit2->Text)); void fastcall TForm1::Button5Click(TObject *Sender) Close( ); Görsel programlamada kod yazmak, derleyicinin boş form için oluşturduğu hazır satırlara, kendi satırlarımızı eklemek şeklindedir Derleyicinin hazırladığı kod satırlarını hatırlayalım:

67 67 #include <vclh> #pragma hdrstop #include "Unit1h" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) Boş forma ait kod satırları Programın bundan sonraki kısımlarını ise, Button1 den Button5 e kadar olan düğmelere kod yazarak biz geliştirmiş olduk Her bir Button için, onlara ait fonksiyon satırları programın devamında görülüyor Button fonksiyonları otomatik olarak isimlendiriliyor ve TForm1 class ına ekleniyor Bunlardan Button1 (toplama, +) için olan fonksiyonu inceleyelim Diğer Button olayları, tamamen aynı tarzda, ama farklı işlemler için (-, x, ) yazıldı void fastcall TForm1::Button1Click(TObject *Sender) Label2->Caption=FloatToStr(StrToFloat(Edit1->Text)+StrToFloat(Edit2->Text)); Bu blok, TForm1 sınıfının Button1Click fonksiyonu Yani, Button1 e Click edildiğinde (tıklandığında) yapılacak işlemi içeriyor Đçinde sadece bir işlem satırı yer alıyor Bu satıra göre, Edit1 ve Edit2 ye yazılan sayılar toplanıyor ve sonuç, Label2 de beliriyor Label2->Caption, FloatToStr, StrToFloat, Edit1->Text ne demek? Hatırlanacağı üzere, Label2 forma yerleştirildikten sonra, işlem sonucu burada deklare edileceğinden, kendisine ait Caption boşaltılmıştı Eşitliğin sol tarafında, Label2->Caption ifadesi var Yani, toplama işleminin sonucu, Label2 nin Caption ında belirecek, biraz önce Caption kısmı boşaltılan Label2 nin Caption ı kod satırlarında belirlenecek FloatToStr ve StrToFloat ifadeleri, form üzerine yazılanlarla ve kod satırlarındaki sayısal veya sözel bilgilerin aynı tür bildiri olmadığı, birbirlerine dönüştürme işlemi yapıldığı gibi bir anlam taşımaktadır Açıklayalım: Form üzerine yazılan sayı olsun, metin olsun her ifade, şimdiye kadar kullanmadığımız yeni bir değişken türüne ait; AnsiString AnsiString türü, ara yüz formuna ait olup, ne int, float, double, ne de char türü bir değişkendir O halde, kullanıcının ekrana girdiği sayıların kod satırlarında kullanılabilmesi için AnsiString ten int, float veya char gibi türlere dönüştürülmesi gerekmektedir Aynı şekilde, kod satırlarındaki bir bilginin ekranda belirmesi için de, int, float ve double dan AnsiString e çevrilmesi gerekecektir Bu amaçla kullanılacak dönüştürme komutları:

68 68 String ten tamsayıya (int), tamsayıdan(int) string e StrToInt IntToStr String ten float a, float tan string e StrToFloat FloatToStr Bu bilgiler ışığında komut satırını tekrar gözden geçirelim: Label2->Caption=FloatToStr(StrToFloat(Edit1->Text)+StrToFloat(Edit2->Text)); Önce, eşitliğin sağ tarafına bakalım: StrToFloat(Edit1->Text) Bunun anlamı, Edit1 kutusundaki Text i, float a çevir Aynı şekilde StrToFloat(Edit2->Text) in anlamı, Edit2 kutusundaki Text i, float a çevir Daha sonra float a çevrilen iki sayının toplama işlemi yapılıyor : StrToFloat(Edit1->Text)+StrToFloat(Edit2->Text) Đşlem sonucunda float a çevrilen iki değerin float olan sonucu bulunuyor Artık toplam sonucunun ekrana gönderilmesi gerekiyor Ancak, eldeki değer float türünde ve ekrana gitmeden önce string e çevrilmeli Görüldüğü üzere, bütün bu işlem bir parantez içine alınarak FloatTorStr komutuyla, float tan String e çevirme sağlanıyor Eşitliğin sol tarafında Lable2->Caption ı var Yani, sol taraf bir ekran bilgisi olacak ve String türünde O halde, eşitliğin sağ tarafı da String olmalı Nitekim, bu biraz önce gördüğümüz dönüştürmelerle sağlanmış durumda Artık ekrana girilen iki sayının toplamı, Label2-Caption üzerinde görülüyor Diğer işlemlerde de, Button lar üzerine yazılan olayların aynı olduğu, sadece işlem operatörünün farklı olduğu görülüyor Button5 programdan çıkış amaçlı kullanılacağı için, kod satırında, Close( ); komutu yer alıyor Bir formun büyüklüğü ve yeri ayarlandıktan sonra, Object Inspector üzerinde yer alan WindowsState seçeneği wsnormal de ise, ayarlandığı büyüklük ve pozisyonda belirecektir wsmaximized seçilmişse, ara yüz bütün ekrana yayılacaktır wsminimized ise, ekranın ekranın altındaki kısa yol çubuğunda kısayol olarak belirmesini sağlayacaktır Bütün bu hazırlıklardan sonra program nasıl çalıştırılacak? Çalıştırmadan önce dosyaları kaydedelim Her yeni çalışmayı ayrı bir klasör içinde kaydetmekte fayda vardır Bunu nedeni, programın artık tek bir dosyadan oluşmuyor olması ve bir dosya grubunu barındıran proje yapısında olmasıdır Derleyicinin her yeni proje için aynı dosya isimlerini önerdiği düşünülürse, bir süre sonra dosyaların üst üste yazılmaması için bu yola başvurulması ve her projenin kendine ait bir klasöre kaydedilmesi en uygun olanıdır Programı çalıştırmak için Run menüsünden Run komutu seçilebileceği gibi, doğrudan F9 fonksiyon tuşu da kullanılabilir Program çalıştığında, Edit kutularına sayılar girilerek istenilen işlem yapılabilir Çalışma sonrası, projeye verilen ismin EXE dosyasına da verildiği görülecektir Yani, makine diline çevrilen yazılıma CPP dosyasının adı değil, proje dosyasının (bpr) adı verilecektir Görsel programlamada dikkat edilirse, cout<< ve cin>> komutları ile diyalog yerine, tamamen Label ve Edit nesneleriyle bu diyalog sağlanmış oldu

69 ĐKĐNCĐ ÖRNEK; DOSYADAN OKUNAN SAYILARIN ORTALAMASI (AnsiString, ListBox, dosya işlemi) #include <vclh> #pragma hdrstop #include "Unit1h" #include "fstreamh" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::SpeedButton1Click(TObject *Sender) AnsiString Dsy; char ad[20]; ifstream oku; int i,n; float sayi, toplam=0,orta; Dsy=Edit1->Text; strcpy(ad,dsyc_str()); okuopen(ad); oku>>n; // Veri sayısı okunuyor for(i=0;i<n;i++) oku>>sayi; toplam+=sayi; ListBox1->Items->Add(FloatToStr(sayi)); orta=toplam/n; Edit2->Text=FloatToStrF(orta,ffNumber,4,2); okuclose(); void fastcall TForm1::SpeedButton2Click(TObject *Sender) Close( ); 69 Yandaki ara yüzde, kullanıcıdan dosya adının istendiği Edit1 kutusu, SpeedButton1 ve SpeedButton2, sayı ortalamasının yazılacağı Edit2 kutusu yanı sıra bir de ListBox yer alıyor ListBox, verilerin listelenebildiği pencerelerdir Veri uzunluğu pencere boyunu geçince, ScrollBar denilen kaydırma çubukları açılır ListBox içindeki veriler, ListBox ın Items olarak adlandırılan veri maddeleridir Listeye ekleme yapmak istendiğinde, ListBox->Items->Add ( ); formatında String türü bilgi Add edilir (eklenir) ListBox ile ilgili diğer komut kullanımı, bir sonraki örnekte daha detaylı bulunabilir Ara yüzden sonra, bir de motor kısmına, yani kod kısmına bakalım Dosya işlemlerinde daha önce kullandığımız kalıp burada da kullanılacağından, #include fstreamh satırı yazılıyor AnsiString Dsy; bir başka yenilik Burada string türü bir değişken tanımlanıyor Daha sonra Edit1 e girilen dosya adı doğrudan Dsy değişkenine atanıyor: Dsy=Edit1->Text; Dikkat edilirse, ekrandan girilen bir bilgi, AnsiString türü bir değişkene çevirme ihtiyacı olmaksızın atanabiliyor Ancak, dosya açma işlemi için bize char türü bilgi lazım O halde, string bilgi char a dönüştürülmeli String-char çevrimi için bu komut kullanılıyor: strcpy(ad,dsyc_str( )); Bu işlemle Dsy deki bilgi char türü ad değişkenine kopyalanıyor Daha sonra okuopen(ad); komutuyla dosya açılıyor ve ilk değer okuması n değişkenine yapılıyor Bu, dosyanın içerdiği veri sayısı for çevrimiyle sayılar dosyadan okunuyor ve toplanıyor Çevrim içinde bir de okunan sayı ListBox1 e ekleniyor Bütün sayıların okunması, listelenmesi ve toplamasından sonra, ortalama alınıyor Ekrana yazdırılmak istenen ortalama değeri float türü veri, FloatToStrF(orta,ffNumber,4,2); komutuyla Edit2 ye, ondalık kısmı 2 hane olacak şekilde formatlanarak gönderiliyor

70 ÜÇÜNCÜ ÖRNEK; PERSONEL VERĐ TABANI (ComboBox, ListBox, dosya kayıt/okuma) 70 M // void fastcall TForm1::Button1Click(TObject *Sender) ListBox1->Items->Add(Edit1->Text+" "+Edit2->Text+" "+ ComboBox1->Text+" "+ComboBox2->Text); // void fastcall TForm1::Button2Click(TObject *Sender) ListBox1->Items->Delete(ListBox1->ItemIndex); // void fastcall TForm1::Button3Click(TObject *Sender) ListBox1->Items->SaveToFile("personeldat"); void fastcall TForm1::Button4Click(TObject *Sender) ListBox1->Items->LoadFromFile("personeldat"); void fastcall TForm1::Button5Click(TObject *Sender) Close( ); Örnek ara yüzde, personel ad ve soyadı için Edit1 ve Edit2 kutuları, Meslek için ComboBox1 ve Đşe başlama tarihi için ComboBox2 yi, veri listelemek için ListBox1 i ve listeye ekleme/silme yapmak için 2 Button, dosyaya kaydetme ve dosyadan yükleme için 2 Button ve çıkış için bir Button görülüyor Mevcut duruma bakıldığında altı personel kaydı yapıldığı görülüyor Kayıt sırasında personel ad ve soyadı elle girilirken, mesleği Combox1 de yer alan, aşağıya doğru açılır listeden, işe başlama tarihi de, ComboBox2 de yer alan listeden seçiliyor Ekle tuşuyla ListBox a eklenen verilerden fareyle seçilenler, Sil tuşlamasıyla silinebiliyor Kaydet tuşuyla personeldat dosyasına ListBox1 deki veriler kaydolurken, programın bir sonraki çalışmasında Yükle komutuyla yine personeldat dosyasındaki veriler ListBox a yüklenebiliyor Yanda,derleyicinin boş formda oluşturduğu satırlara ilave edilen kodlar yer almaktadır Edit1, Edit2, ComboBox1 ve ComboBox2 Text lerinden ListBox1 e nasıl ekleme ve silme yapıldığı, Button1 ve Button2 fonksiyonlarında görülüyor Button3Click te ListBox1 deki verilerin personeldat dosyasına kaydı, Button4Click fonksiyonunda ise ListBox1 e personeldat dosyasından okunan bilginin yüklenmesi görülüyor

71 DÖRDÜNCÜ ÖRNEK; NOT ORTALAMASI (Dosya diyalogları, SpeedButton, RadioButton, CheckBox) 71 #include "Unit1h" #include "fstreamh" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; ifstream oku; ofstream yaz; char ad[300],ad2[300]; float vize,odev,final,not; AnsiString D1,D2; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::SpeedButton1Click(TObject *Sender) OpenDialog1->Title ="Dosyayı seçiniz"; OpenDialog1->Filter="Veri Tabanı Dosyaları (*dat) *DAT"; if(opendialog1->execute()) D1=OpenDialog1->FileName; strcpy(ad,d1c_str()); okuopen(ad); void fastcall TForm1::SpeedButton2Click(TObject *Sender) SaveDialog1->Title="Çıktı Dosyası"; SaveDialog1->Options<<ofOverwritePrompt; SaveDialog1->DefaultExt="dat"; if(savedialog1->execute()) D2=SaveDialog1->FileName; strcpy(ad2,d2c_str()); yazopen(ad2); void fastcall TForm1::Button1Click(TObject *Sender) oku>>vize>>odev>>final; if(radiobutton1->checked) not=04*vize+06*final; if (CheckBox1->Checked) not++; if(radiobutton2->checked) not=03*vize+02*odev+05*final; if (CheckBox1->Checked) not++; yaz<<" Not ortalaması= "<<not; Edit1->Text=FloatToStr(not); void fastcall TForm1::Button2Click(TObject *Sender) Close( ); Birçok yeni bilginin yer aldığı bu programda, açılan pencere üzerinden dosya açma ve kaydetme işlemi, elemeli seçenek düğmeleri olan RadioButton lar ve tercih belirtmek için kullanılan CheckBox bulunmaktadır Dosya ismi belirlerken Windows penceresi açmak için, yukarıdaki ara yüzde görünmeyen ve bileşenler çubuğundaki Dialogs başlığından alınan, OpenFileDialog ve SaveFileDialog nesnelerini eklememiz gerekir Bunlar, program çalışırken kaybolacaklar Ama, dosya açma ve kapama işlemlerinin yapıldığı SpeedButton1 ve SpeedButton2 nin çalışması için, diyalogların mutlaka forma eklenmesi gerekmektedir Unutmamalı ki, diyalog işlemleri sadece dosyanın adını belirlemede kullanılmakta, dosya açma işlemi yine okuopen(ad); komutuyla yapılmaktadır SpeedButton lar üstüne alınan ikonlar, Object Inspector daki Glyph seçeneğiyle belirlenmektedir Ayrıca, tuşun ne işe yaradığının anlaşılması için kullanıcıya çıkarılan bir ipucu yazısı oluşturmak da mümkündür Bu, nesne düzenleyicisindeki Hint kısmına ipucunu yazmak ve ShowHint kısmını true durumuna getirmekle mümkün olur C++Builder menüsünde Tools altında Image Editor vardır Burada kendi ikon ve küçük BMP resimlerinizi üretebilirsiniz

72 72 void fastcall TForm1::SpeedButton1Click(TObject *Sender) OpenDialog1->Title ="Dosyayı seçiniz"; OpenDialog1->Filter="Veri Tabanı Dosyaları (*dat) *DAT"; if(opendialog1->execute()) D1=OpenDialog1->FileName; strcpy(ad,d1c_str()); okuopen(ad); SpeedButton1Click de, OpenDialog1->Title= Dosyayı seçiniz ; ifadesi, diyalog penceresinin üstünde belirecektir OpenDialog1->Filter= ; ise pencerede *DAT türü dosyaların filtre edilip listelenmesini sağlayacaktır if(opendialog1->execute( )) cümlesi, dosya açmada hata yoksa doğrulanacak ve parantezlerin içine girecektir Burada, AnsiString D1 değişkenine, diyalog penceresinden gelen dosya adı eşlenmekte, bu bilgi daha sonra bir char türü değişken olan ad a strcpy komutuyla kopyalanmaktadır Sonrası, dosya açma komutunu çalıştırmaktan ibarettir void fastcall TForm1::SpeedButton2Click(TObject *Sender) SaveDialog1->Title="Çıktı Dosyası"; SaveDialog1->Options<<ofOverwritePrompt; SaveDialog1->DefaultExt="dat"; if(savedialog1->execute()) D2=SaveDialog1->FileName; strcpy(ad2,d2c_str()); yazopen(ad2); SpeedButton2Click fonksiyonu incelendiğinde, bu defa kayıt amaçlı bir pencere açma işlemi görülüyor SaveDialog1->Title= Çıktı Dosyası ; komutu, pencerenin üstündeki başlık için kullanılmıştır Belirlenen dosya ismi zaten varsa, kullanıcının uyarılması ve dosya üstüne kayıt yapmak isteyip istemediğinin sorulması için SaveDialog->Options<<ofOverwritePrompt; komutu kullanılmıştır if cümlesi doğrulandığı takdirde D2 değişkeni D2=SaveDialog1->FileName; komutuyla dosya ismini alacak, daha sonra char türü ad2 değişkenine bu bilgi kopyalanacaktır yazopen(ad2); komutuyla da kayıt dosyası açılacaktır char ad[300], ad2[300]; tanım satırlarında değişken boyutları çok büyük tutulmuştur Bunun nedeni, bir dosya adının altında bulunduğu bütün klasör isimleriyle birlikte kaydolmasıdır

73 73 void fastcall TForm1::Button1Click(TObject *Sender) oku>>vize>>odev>>final; if(radiobutton1->checked) not=04*vize+06*final; if (CheckBox1->Checked) not++; if(radiobutton2->checked) not=03*vize+02*odev+05*final; if (CheckBox1->Checked) not++; yaz<<" Not ortalaması= "<<not; Edit1->Text=FloatToStr(not); Button1Click fonksiyonu, not ortalamasının yapıldığı bloktur Önce oku>>vize>>odev>>final; komutuyla OpenDialog1 süreciyle adı belirlenen dosyadan üç veri okunmaktadır Ara yüzde kullanıcıya iki hesaplama yöntemi sunulmaktadır O halde program her iki durum içinde hazır olmalıdır Kullanıcı RadioButton1 i seçmişse ona göre, RadioButton2 yi seçmişse ona göre hesap yapmalıdır if cümleleri bu RadioButton ların Checked olup olmadığını kontrol ediyor Hangisi Checked durumundaysa, not o formüle göre hesaplanıyor Ayrıca, kullanıcı, not ilavesi için CheckBox1 i tıklamışsa, bu durumda dikkate alınmalı ve if(checkbox1->checked) cümlesiyle sorgulanmalıdır Sonuç olumluysa, not++; komutu çalışacaktır Elde edilen sonuç, fonksiyon sonunda hem ekrana Edit1->Text i olarak gönderilmekte, hem de açılan dosyaya kaydedilmektedir BEŞĐNCĐ ÖRNEK; BĐRDEN FAZLA FORM AÇMA, DOSYALARA RESĐM EKLEME (Bevel, Image) Yukarıda, Sanal Galeri adı verilen bir projeye ait, küçültülüp yan yana sıralanmış üç form görülmektedir Bütün bu sayfalar bir projenin formlarıdır Programcının her bir formu teker teker tasarlaması, sonra da birbirine bağlaması gerekmektedir Yeni bir form oluşturmak için menüdeki New opsiyonu seçilmeli, açılan pencereden Form seçilmelidir Açılan her yeni form için Unit2cpp, Unit3cpp gibi kod sayfaları da oluşturulmaktadır Form1 sayfasına, Additional dan eklenen Bevel zemin oluşturma nesnesi istenilen boyuta getirildikten sonra, Bevel üzerine, yine Additional da bulunan Image nesnesi eklenir Daha sonra Object Inspector de (nesne düzenleyici) bulunan Picture tuşlanarak, bir resim dosyası seçilir Resmin büyüklüğü, belirlediğimiz çerçeveye uymuyorsa, yine nesne düzenleyicisindeki Stretch seçeneği, true konumuna getirilir Form1 de, bir sonraki sayfaya (Form2) geçiş tuşu görülüyor Bu tuş tıklandığında, Button1Click fonksiyonuna Form2->Show( ); komutunu yazmak yeterli olacaktır Ancak, bu komutun çalışması için yapılması mutlaka gereken bir iş daha vardır: geçilmek istenen formun Unit dosyasını programa #include Unit2h komutuyla dahil etmek

74 74 Açılan formlara ait Unit#cpp dosyaları, yukarıda görüldüğü gibi sıralıdır Programcı CPP dosyalarının isimlerini değiştirebilir Ama, burada esas önemli olan, proje dosyasının ismidir Çünkü EXE dosyanın adı, aynı zamanda proje (bpr) dosyasının da adıdır Şimdi her bir Unit#cpp dosyasının içine bakalım // Unit1cpp dosyası #include <vclh> #pragma hdrstop #include "Unit1h" #include "Unit2h" #include "stdlibh" // #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; // fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) // void fastcall TForm1::Button1Click(TObject *Sender) Form2->Show(); // void fastcall TForm1::Button2Click(TObject *Sender) exit(0); // Unit3cpp dosyası #include <vclh> #pragma hdrstop #include "Unit3h" #include "Unit2h" #include "stdlibh" #pragma package(smart_init) #pragma resource "*dfm" TForm3 *Form3; fastcall TForm3::TForm3(TComponent* Owner) : TForm(Owner) void fastcall TForm3::Button1Click(TObject *Sender) Form2->Show(); - void fastcall TForm3::Button2Click(TObject *Sender) exit(0); // Unit2cpp dosyası #include <vclh> #pragma hdrstop #include "Unit2h" #include "Unit1h" #include "Unit3h" #include "stdlibh" #pragma package(smart_init) #pragma resource "*dfm" TForm2 *Form2; fastcall TForm2::TForm2(TComponent* Owner) : TForm(Owner) void fastcall TForm2::Button1Click(TObject *Sender) Form1->Show(); void fastcall TForm2::Button2Click(TObject *Sender) Form3->Show(); void fastcall TForm2::Button3Click(TObject *Sender) exit(0); Formlar arası geçişi sağlayan komut: Form1->Show( ); Form2->Show( ); veya Form3->Show( ); Komutun çalışması için, geçilmek istenen formun Unit1h, Unit2h veya Unit3h dosyaları da #include ediliyor Ayrıca, Çıkış tuşunun her formda çalışması için, Close( ); yerine, exit(0); komutu kullanılmıştır Böylece, Form2 veya Form3 ten de doğrudan çıkış olacaktır Close( ); komutu, sadece içinde bulunulan formun penceresini kapatmaya yaramaktadır exit(0); komutunu çalıştırmak için #include stdlibh programa dahil edilmiştir exit(0); komutunda parantez içine sıfırdan farklı bir sayının gelmesi, programdan hatalı bir çıkışın olduğunu gösterir Sıfır rakamı ise normal çıkış anlamı taşımaktadır

75 PROGRAMIN HER BĐLGĐSAYARDA ÇALIŞMASI 75 Şu ana kadar geliştirdiğimiz programlar bilgisayarda bir derleyici paket yüklü olduğundan sorunsuz çalıştı Halbuki, bazı programların EXE dosyaları başka bilgisayarlarda DLL dosya hataları verebilir Böyle bir durumla karşılaşmamak için, menüde yer alan Project başlığı ve açılan alt menüden Options seçilmelidir Daha sonra aşağıdaki üç işlem yapılıp, program ondan sonra Run edilmelidir 1 Compiler seçilerek, Release tuşlanmalıdır 2 Linker seçilerek, Use Dynamic RTL kutusu boşaltılmalıdır 3 Packages seçilerek, Run time packages kutusu boşaltılmalıdır Yeri gelmişken, yine Project->Options penceresinde bulunan Application seçilip, Load Icon tuşlanarak bir ikon yüklenirse, programın Windows listelemelerinde bu ikonla gözükmesi de sağlanmış olur Object Inspector da yer alan Icon seçeneği de, programın çalışması esnasında sol üst köşede belirecek ikonu belirlemede kullanılır Tercih edilen ikon (*ico) resmi burada yüklenerek, kişisel yazılım pencerelerimiz tamamlanmış olur Mesela;

76 ALTINCI ÖRNEK; MENÜLER 76 Yandaki şekillerde görülen menüler, bileşen çubuğunun Standard başlığı altındaki MainMenu seçeneğiyle eklenmiştir OpenDialog ve SaveDialog ta olduğu gibi, çalıştığında ekranda görülmeyen, ama çalışma formunda gözüken bir simgedir Bu simge çift tıklandığında, menü oluşturmamız için aşağıya ve yana doğru büyüyebilen bir tasarım penceresi açılır Gerek menü başlıkları, gerekse menü alt başlıkları burada belirlenir Menü maddeleri, üzerine SpeedButton da olduğu gibi küçük resimler alabilirler Alt başlıklardan yana doğru bir daha alt menü oluşturmak istenirse (45, 90, 180 örneğinde olduğu gibi), alt menü üstüne farenin sağ tuşu tıklanarak, Create Submenu seçilir Menüdeki her bir madde, tıpkı bir button gibi düşünülebilir Button larda nasıl Event yazılıyorsa, menü elemanları içinde kod yazılır Menüdeki herhangi bir madde çift tıklandığında, kod sayfasında ona Click fonksiyonu açılır void fastcall TForm1::CikisClick(TObject *Sender) Close(); Yukarıda, Dosya menüsü, Çıkış alt menüsüne ait kod satırları görülüyor KAYNAKÇA Kaan Aslan, A dan Z ye C Klavuzu, Pusula Yayınevi Fehmi Demiralp, C++ ile Nesneye Dayalı Programlama, Beta Yayınları Đhsan Karagülle, Zeydin Pala, C++ Builder 6, Türkmen Kitabevi Ahmet Özmen, Ders Notları, DPÜ Elektrik-Elektronik MühBöl

77 77

78 /* Dogrunun egimini bulan program ****************************************/ 78 #include "iostreamh" #include "conioh" float m,x1,x2,y1,y2; void main() clrscr(); cout<<"\n 1 noktanin x koordinati= "; cin>>x1; cout<<"\n 1 noktanin y koordinati= "; cin>>y1; cout<<"\n 2 noktanin x koordinati= "; cin>>x2; cout<<"\n 2 noktanin y koordinati= "; cin>>y2; m=(y2-y1)/(x2-x1); cout<<"\n\n Dogrunun egimi= "<<m; getch(); /* Iki nokta arasindaki mesafeyi bulan program *****************************************************/ #include "iostreamh" #include "conioh" #include "mathh" float D,x1,x2,y1,y2; void main() clrscr(); cout<<"\n 1 noktanin x koordinati= "; cin>>x1; cout<<"\n 1 noktanin y koordinati= "; cin>>y1; cout<<"\n 2 noktanin x koordinati= "; cin>>x2; cout<<"\n 2 noktanin y koordinati= "; cin>>y2; D=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); cout<<"\n\n Mesafe= "<<D; getch();

79 /* 1'den n'e kadar olan cift sayilari toplayan program ***********************************************************/ 79 #include "iostreamh" #include "conioh" #include "mathh" int i,n,x,toplam=0; void main() clrscr(); cout<<"\n Kaca kadar olan cift sayilar toplanacak? "; cin>>n; for(i=1;i<=n;i++) if(i%2==0) toplam=toplam+i; cout<<"\n "<<i; cout<<"\n\n Cift sayilar toplami= "<<toplam; getch(); /* 1'den n'e kadar olan tek sayilarin carpimi *******************************************************/ #include "iostreamh" #include "conioh" #include "mathh" int i,n; long double carpim=1; void main() clrscr(); cout<<"\n Kaca kadar olan tek sayilar toplanacak? "; cin>>n; for(i=1;i<=n;i++) if(i%2!= 0) carpim=carpim*i; cout<<"\n "<<i; cout<<"\n\n Tek sayilar carpimi= "<<carpim; getch();

80 /* n adet rakam icindeki pozitifleri sayan program *********************************************************/ 80 #include "iostreamh" #include "conioh" float i,n,x,say=0; void main() clrscr(); cout<<"\n Kac sayi okunacak? "; cin>>n; for(i=1;i<=n;i++) cout<<"\n Sayi girin= "; cin>>x; if(x>=0) say++; cout<<"\n\n "<<say<<" adet pozitif sayi girildi"; getch(); /* n adet rakam icindeki negatifleri sayan program *********************************************************/ #include "iostreamh" #include "conioh" float i,n,x,say=0; void main() clrscr(); cout<<"\n Kac sayi okunacak? "; cin>>n; for(i=1;i<=n;i++) cout<<"\n Sayi girin= "; cin>>x; if(x<0) say++; cout<<"\n\n "<<say<<" adet negatif sayi girildi"; getch();

81 /* n adet sayiyi tek-cift seklinde ayiran program **********************************************************/ 81 #include "iostreamh" #include "conioh" int i,n,x,tek=0,cift=0; void main() clrscr(); cout<<"\n Kac sayi okunacak? "; cin>>n; for(i=0;i<n;i++) cout<<"\n Sayi girin= "; cin>>x; if(x%2==0) cift++; else tek++; cout<<"\n\n "<<tek<<" adet tek sayi girildi"; cout<<"\n\n "<<cift<<" adet cift sayi girildi"; getch(); /* n adet sayiyi tek-cift seklinde listeleyen program **********************************************************/ #include "iostreamh" #include "conioh" int i,n,x[100],tek=0,cift=0; void main() clrscr(); cout<<"\n Kac sayi okunacak? "; cin>>n; for(i=0;i<n;i++) cout<<"\n Sayi girin= "; cin>>x[i]; cout<<"\n\n Cift sayilar:"; for(i=0;i<n;i++) if(x[i]%2==0) cout<<" "<<x[i]; cout<<"\n\n Tek sayilar:"; for(i=0;i<n;i++) if(x[i]%2!=0) cout<<" "<<x[i]; getch();

82 /* n adet sayi icindeki en kucuk ve en buyugu sira numarasi ile bulan program ************************************************************/ 82 #include "iostreamh" #include "conioh" float i,n,x[100],min=0,max=0,imax=0,imin=0; void main() clrscr(); cout<<"\n Kac sayi okunacak? "; cin>>n; for(i=0;i<n;i++) cout<<"\n Sayi girin= "; cin>>x[i]; min=max=x[0]; for(i=0;i<n;i++) if(x[i]>max) max=x[i]; imax=i; if(x[i]<min) min=x[i]; imin=i; cout<<"\n Maksimum sayi= "<<max<<" sira numarasi= "<<imax+1; cout<<"\n Minimum sayi= "<<min<<" sira numarasi= "<<imin+1; getch(); /* Ekrandan girilen sayi 3'un katı mı? **************************************************/ #include "iostreamh" #include "conioh" int i,n; void main() clrscr(); cout<<"\n Sayi= "; cin>>n; if(n%3==0) cout<<"\n 3'un katidir "; else cout<<"\n 3'un kati degildir "; getch();

83 /* Ekrandan girilen sayi asal mi? **************************************************/ 83 #include "iostreamh" #include "conioh" int i,n,k=0; void main() clrscr(); cout<<"\n Sayi= "; cin>>n; for(i=2;i<n;i++) if(n%i==0) k=1; if(k==0) cout<<"\n\n ASAL "; else cout<<"\n\n Asal DEGIL "; getch(); /**** Sartli hesap ********************************* sqrt(x) x>10 (karekok) z= x! 0<x<=10 (faktoriyel) x x<=0 (mutlak deger) *******************************************************/ #include "iostreamh" #include "conioh" #include "mathh" long double z,x,i,f=1; void main() clrscr(); cout<<"\n Sayi= "; cin>>x; if(x<=0) z=fabs(x); if(x>0 && x<=10) for(i=x;i>0;i--) f=f*i; z=f; if(x>10) z=sqrt(x); cout<<"\n\n Z= "<<z; getch();

84 /* Boy(cm) - Kilo (kg) **************************************************/ 84 #include "iostreamh" #include "conioh" int boy,kilo,fark; void main() clrscr(); cout<<"\n Boyunuz(cm)= "; cin>>boy; cout<<"\n Kilonuz(kg)= "; cin>>kilo; fark=boy-kilo; if(fark>120) cout<<"\n Cok zayif "; if(fark>=110 && fark<120) cout<<"\n Zayif "; if(fark>=100 && fark<110) cout<<"\n Normal "; if(fark>=90 && fark<100) cout<<"\n Kilolu "; if(fark<90) cout<<"\n Sisman "; getch(); /* Sayi tutan program - 1 **************************************************/ #include "iostreamh" #include "conioh" int n,tutulan=123; void main() clrscr(); s1: cout<<"\n Sayi girin= "; cin>>n; if(n>tutulan) cout<<"\n inin "; goto s1; if(n<tutulan) cout<<"\n cikin "; goto s1; if(n==tutulan) cout<<"\n Bildiniz! "; getch();

85 /* Sayi tutan program -2 (rasgele sayi ureterek) ********************************************************/ 85 #include "iostreamh" #include "conioh" #include "stdlibh" #include "timeh" int n,tutulan; void main() clrscr(); srand((unsigned) time(null)); // sistem saatinden deger aliyor tutulan=rand()%1000; // uc haneli rasgele deger uretiyor s1: cout<<"\n Sayi girin= "; cin>>n; if(n>tutulan) cout<<"\n inin "; goto s1; if(n<tutulan) cout<<"\n cikin "; goto s1; if(n==tutulan) cout<<"\n Bildiniz! "; getch(); /***************************************** * Menu ile alan ve hacim hesaplari * ******************************************/ #include "iostreamh" #include "conioh" #include "stdlibh" int secim; char oku; float p=314159; void Dikdortgen() float a,b,c; clrscr(); cout<<"\n En= "; cin>>a; cout<<"\n Boy= "; cin>>b; c=a*b; cout<<"\n\n Alan= "<<c; getch();

86 void Kare() float a,c; clrscr(); cout<<"\n Kenar uzunlugu= "; cin>>a; c=a*a; cout<<"\n\n Alan= "<<c; getch(); 86 void Daire() float a,c; clrscr(); cout<<"\n Dairenin yaricapi= "; cin>>a; c=(p*a*a); cout<<"\n\n Alan= "<<c; getch(); void Dikdortgenler() float a,b,c,d; clrscr(); cout<<"\n En= "; cin>>a; cout<<"\n Boy= "; cin>>b; cout<<"\n Yukseklik= "; cin>>c; d=a*b*c; cout<<"\n\n Hacim= "<<d; getch(); void Kup() float a,c; clrscr(); cout<<"\n Kenar uzunlugu= "; cin>>a; c=a*a; cout<<"\n\n Hacim= "<<c; getch(); void Silindir () float a,b,c; clrscr(); cout<<"\n Silindirin yaricapi= "; cin>>a; cout<<"\n Silindirin Yuksekligi= "; cin>>b; c=(4*a*a*a*p)/3; cout<<"\n\n Alan= "<<c; getch();

87 void Hacim() clrscr(); cout<<"\n 1- Dikdortgenler pirizmasinin hacmi"; cout<<"\n 2- Silindirin hacmi"; cout<<"\n 3- Kurenin hacmi"; cout<<"\n 0- Cikis"; cout<<"\n\n Tercihiniz= "; cin>>secim; if (secim==1) Dikdortgenler(); if (secim==2) Kup(); if (secim==3) Kare(); if (secim==0) exit(0); 87 void Alan() clrscr(); cout<<"\n 1- Dikdortgen Alani"; cout<<"\n 2- Kare alani"; cout<<"\n 3- Dairenin alani"; cout<<"\n 0- Cikis"; cout<<"\n\n Tercihiniz= "; cin>>secim; if (secim==1) Dikdortgen(); if (secim==2) Kare(); if (secim==3) Daire(); if (secim==0) exit(0); void Menu () clrscr (); cout<<"\n Yapmak istediginiz islemi seciniz!!?"; cout<<"\n 1- Alan Hesabi"; cout<<"\n 2- Hacim Hesabi"; cout<<"\n 0-Cikis"; cout<<"\n SECIMINIZ= "; cin>>secim; if (secim==1) Alan(); if (secim==2) Hacim(); if (secim==0) exit(0); void main() S1: Menu(); cout<<"\n\n Devam etmek ister misiniz (e/e)? "; cin>>oku; if (oku=='e' oku=='e') goto S1;

88 DOĞRU EĞĐM VE UZUNLUĞU 88 #include <vclh> #pragma hdrstop #include "Unit1h" #include "mathh" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; float x1,x2,y1,y2,uzunluk,egim; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::Button1Click(TObject *Sender) x1=strtofloat(edit1->text); y1=strtofloat(edit2->text); x2=strtofloat(edit3->text); y2=strtofloat(edit4->text); uzunluk=sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1)); Edit5->Text=FloatToStr(uzunluk); void fastcall TForm1::Button2Click(TObject *Sender) x1=strtofloat(edit1->text); y1=strtofloat(edit2->text); x2=strtofloat(edit3->text); y2=strtofloat(edit4->text); egim=(y2-y1)/(x2-x1); Edit6->Text=FloatToStr(egim); void fastcall TForm1::Button3Click(TObject *Sender) Close();

89 AĞIRLIKLI DERS NOTU ORTALAMASI 89 #include <vclh> #pragma hdrstop #include "Unit1h" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::Button1Click(TObject *Sender) float d1,d2,d3,d4,k1,k2,k3,k4,orta; d1=strtofloat(edit1->text); d2=strtofloat(edit2->text); d3=strtofloat(edit3->text); d4=strtofloat(edit4->text); k1=strtofloat(edit5->text); k2=strtofloat(edit6->text); k3=strtofloat(edit7->text); k4=strtofloat(edit8->text); orta=(d1*k1+d2*k2+d3*k3+d4*k4)/(k1+k2+k3+k4); Edit9->Text=FloatToStr(orta); void fastcall TForm1::Button2Click(TObject *Sender) Close();

90 VERĐ GĐRĐŞ PENCERESĐNDEN ORTALAMA HESABI 90 #include <vclh> #pragma hdrstop #include "MatisInputBoxh" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::SpeedButton1Click(TObject *Sender) int i,n,x[100]; float orta=0; n=strtoint(edit1->text); for(i=0;i<n;i++) x[i]=strtoint(inputbox("sayı girişi",inttostr(i+1)+" sayı"," ")); orta=orta+x[i]; orta=orta/n; Label2->Caption="Ortalama= "+FloatToStr(orta); void fastcall TForm1::SpeedButton2Click(TObject *Sender) Close();

91 DOSYADAN VERĐ OKUMA VE ORTALAMA 91 #include <vclh> #pragma hdrstop #include "fstreamh" #include "Unit1h" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; int n,i; float sayi,pay=0,payda=0,kredi,orta; char ad[200]; AnsiString D1; ifstream oku; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner)

92 92 void fastcall TForm1::Button1Click(TObject *Sender) oku>>n; for(i=0;i<n;i++) oku>>sayi>>kredi; pay+=sayi*kredi; payda+=kredi; ListBox1->Items->Add(FloatToStr(sayi)+" "+FloatToStr(kredi)); orta=pay/payda; Edit2->Text=FloatToStrF(orta,ffNumber,5,2); void fastcall TForm1::Button3Click(TObject *Sender) OpenDialog1->Execute(); D1=OpenDialog1->FileName; strcpy(ad,d1c_str()); okuopen(ad); Edit1->Text=D1; void fastcall TForm1::Button2Click(TObject *Sender) Close();

93 93 MOUSE KOORDĐNATLARINI TAKĐP #include <vclh> #pragma hdrstop #include "Unit1h" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::FormMouseMove(TObject *Sender, TShiftState Shift, int X, int Y) TPoint F,E; // Mouse koordinatlarının TPoint ataması char xcoord[40],ycoord[40]; Fx=X; Fy=Y; // koordinatları ekran koordinatına çevriliyor E=Form1->ClientToScreen(F); // Tamsayılar string e çevriliyor itoa(ex,xcoord,10); itoa(ey,ycoord,10); AnsiString xstring(xcoord),ystring(ycoord); // Farenin Form daki koordinatları yazılıyor Label1->Caption="Form X: "+String(X); Label2->Caption="Form Y: "+String(Y); // Farenin Ekran daki koordinatları yazılıyor Label3->Caption="Ekran X: "+xstring; Label4->Caption="Ekran Y: "+ystring;

94 OKEK-OBEB HESAPLAMASI 94 #include <vclh> #pragma hdrstop #include "Unit1h" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::Button1Click(TObject *Sender) int i,s1,s2; s1=strtoint(edit1->text); s2=strtoint(edit2->text); for(i=1;i<=s1*s2;i++) if(i%s1==0 && i%s2==0) Edit3->Text=IntToStr(i); break; if(s1>s2) i=s1; else i=s2; for(;i>0;i--) if(s1%i==0 && s2%i==0) Edit4->Text=IntToStr(i); break;

95 REZERVASYON 95 #include <vclh> #pragma hdrstop #include "Unit1h" #pragma package(smart_init) #pragma resource "*dfm" TForm1 *Form1; fastcall TForm1::TForm1(TComponent* Owner) : TForm(Owner) void fastcall TForm1::SpeedButton1Click(TObject *Sender) if(combobox3->text=="gidiş-dönüş") ShowMessage("Hareket günü: " + DateTimePicker1->Time + " Hareket yeri:" + ComboBox1->Text + " Dönüş günü:" + DateTimePicker2->Time + " Varış yeri:" + ComboBox2->Text + " olarak rezervasyon yapılmıştır"); else ShowMessage("Hareket günü: " + DateTimePicker1->Time + " Hareket yeri:" + ComboBox1->Text + " tek yön olarak rezervasyon yapılmıştır");