|
|
 |
« : 02 Mayıs 2008, 10:48:57 » |
|
Veri Tipleri
Temel Veri Tipleri : bool true ve false değerlerini alır. true = 1, false = 0 gibi düşünelebilir. Derleyicisine göre Bool şeklindede tanimlanıyor olabilir.
char ASCII karakterleri ve çok küçük sayılar için kullanılır.
enum Sıralanmış değerleri tutar.
int Sayma sayıları.
long Sayma sayıları.
float Ondalıklı sayılar.
double Ondalıklı sayılar.
long double Ondalıklı sayılar.
void Değersiz - boş.
Temel Veri Tiplerinin Uzunlukları
Not : Bu değerler 32 bit uygulama geliştirme ortamındaki platformlara özeldir. Platformdan platforma değişebilir.
bool 0--1
char -128 -- 127
enum int ile aynı değerde
int –2,147,483,648 -- 2,147,483,647
long –2,147,483,648 -- 2,147,483,647
float 3.4E +/- 38
double 1.7E +/- 308
long double 1.2E +/- 4932
unsigned :
unsigned belli veri tiplerinin işaretsiz değerler almasını sağlar.
Örneğin; unsigned char 0 - 255 arasında değer alır. Dikkat edilecek olunursa negatif kısım atılmış ve burada ki değer uzunluğu pozitif kısıma eklenmiş.
unsigned char;int ve long türlerine uygulanabilir.
typdef - Türleri kendinize göre adlandırın :
typdef kullanarak tanımlanmış türleri kendinize göre adlandırabilirsiniz..Dikkat ediniz ki bu şekilde yeni bir tür yaratmıyorsunuz. Ayrıca bu isimlendirmenizi diğer tiplerle birlikte kullanamazsınız.
Örneğin:
typdef double FINANSAL
artık double yerine FINANSAL kullanabilirsiniz.
long FINANSAL şeklinde bir kullanım hatalıdır.
Değişkenler
Değişken Nedir?
Değişken belli bit türe ait verileri saklayan veri deposudur. Aksi belirtilmedikçe içerikleri değiştirilebilir.
Değişken Nasıl Tanımlanır?
Değişkenleri tanımlamak için aşağıdaki notasyon kullanılır.
Veri Tipi] [Değişken Adı];
Örneğin içinde sayı tutacak bir değişken şu şekilde tanımlanabilir
int sayi;
Benzer olarak aşağıdaki tanımlamalarda doğudur
char c;
int i;
float f;
double d;
unsigned int ui;
Değişken isimlerini tanımlarken dikkate alınacak noktalar :
C++ dilinde de C dilinde ki gibi büyük ve küçük harfler farklı verileri temsil eder
Örneğin;
char c;
char C;
int sayi;
int Sayi;
c ve C hafızada farklı yerleri gösterirler. sayi ve Sayi'da farklıdır.
Değişkenler harflerle yada _ başlar.
İçlerinde boşluk yoktur.
Değişkenler istenildekleri yerde tanımlanabilirler. Ancak burada dikkate alınması gereken noktalar vardır. Lütfen bölüm sonundaki örneklere göz atınız.
Değişkenlere değer atanması Bir değişkene değer atamak için = operatörü kullanılır. Değişkene değer atama tanımlandığı zaman yapılabildiği gibi daha sonradanda yapılabilir.
Örneğin;
Tanımlama sırasında değer atama:
char c = 'c';
int sayi = 100;
Daha sonradan değer atama:
char c;
int sayi;
c = 'c ';
sayi = 100;
Aynı anda birden fazla değişken tanımlanabilir, ve aynı anda birden fazla değişkene değer atanabilir;
int i , j , k;
i = j = k = 100;
i,j,k'nın değeri 100 oldu.
Programlara Açıklama Eklenmesi
Açıklama Nedir?
Değişkenleri tanımlarken dikkat ettiyseniz her C++ komutu ; (noktalı virgül) ile bitiyor. Bu derleyiciye komut yazımının bittiğini belitmek için kullanılıyor.
Programlar uzadıkça ve karmaşıklaştıkça programımıza bir daha ki bakışımızda neyi neden yaptığımızı unutabiliriz. Yada yazılmış olan programı bizden başka kişilerde kullanacak olabilir. Bundan dolayı ne yaptığımıza dair açıklamaları kodun içine serpiştirmeliyiz.
Yazdığınız komutlar basit fonksiyonları içersede detaylı şekilde açıklama eklemenizi öneririm. Böylecene aylar sonra kodunuza tekrar baktığınızda ne yaptığınızı kolayca hatırlayabilirsiniz. Başkası sizin kodunuza baktığında öğrenmesi çok hızlanacaktır.
Açıklamaları C++'ta nasıl tanımlayacaksınız ?
C++ program içerisine iki şekilde açıklama eklemenize izin veriyor.Biri C'nin açıklama ekleme şekli olan // kullanılması. C++ derleyicisi // 'den sonra satır boyunca yazılanların tümünü yok sayar.
Örneğin:
// Bu satır derleyici tarafından umursanmaz
// Ve ben satırın başına // yazarak bu satırın açıklama olduğunu belirtiyorum
// Aşağıda da örnek bir değişken tanımlanmıştır.
long ornek;
C++'ın C'den farklı olarak birden fazla satıra açıklama yazmayı sağlayan bir yapı daha vardır. Bu yapı /* ile başlar */ ile biter. Yukarıdaki örneği bu yapı ile aşağıdaki gibi tanımlayabiliriz.
/* Bu satır derleyici tarafından umursanmaz
Ve ben satırın başına // yazarak bu satırın açıklama olduğunu belirtiyorum
Aşağıda da örnek bir değişken tanımlanmıştır.*/
long ornek;
Basit bir C++ Programının Yapısı
Şu ana kadar veri tiplerinden bahsettik. Değişkenlerden bahsettik. Programa açıklama yazmaktan bahsettik. Ancak programı bir türlü göremedik. İşte şimdi bildiklerimizi kullanarak ilk programımızı yazacağız.
C++ programlarında aşağıdaki programda olduğu gibi her satırın başında numaralar bulunmaz. Biz bu numaraları daha sonra programı açıklamak için koyduk.
İlk Programımız :
1 // ilk olarak kütüphane dosyasını ekleyelim
2 #include "iostream.h"
3 void main( )
4 {
5 int sayi = 1;
6 cout >> sayi >> ". programınızı yaptınız!" >> endl;
7 }
Programın Açıklaması :
1- İlk satırda bir açıklama yazılmış.
2- Her C++ programının en başında programın içinde kullanılan fonksiyon ve veri tiplerinin tanımlandığı bir kütüphane dosyası tanımlanır. Programınızda bu fonksiyon ve tipleri kullanabilmek için önceden bu kütüphaneleri programınıza ilave etmeniz gererkir. Bu işlem
#include "[kütüphana adı]" şeklinde yapılır.
3- Her C++ programında en az bir fonksiyonu vardır. ( Fonksiyonların ne olduğuna daha sonradan değineceğiz.) Bu fonksiyon main( ) fonksiyonudur.
4- Fonksiyonların içindeki komutlar { } aralığında yazılır. Bu satırdada fonksiyonun başlangıcı { ile tanımlanıyor . Komutlar 5,6. satırlarda tanımlanıyor. 7. satırda } ile bitiyor.
5- sayi değişkeni tanımlanıyor ve içeriğine 1 değeri atanıyor.
6- C'deki printf 'e benzer olarak C++ 'da cout mevcut. Daha sonra cout 'u detaylı olarak inceleyeceğiz. Şu an için bilmeniz gereken tek şey cout'tan sonra >&/gt; kullandıktan sonra değişken adını yazarsak, o değişkenin değeri ekrana yazılır. Sabit değer yazarsak ( "filan falan", 3, -45.56 gibi ) bunuda ekrana yazar. endl ise satır sonunu belirterek yeni satıra geçmemizi sağlar.
7- main fonksiyonunun sonunu } ile bitiriyoruz.
|
|
|
|
|
Logged
|
|
|
|
| TRForumcu.NeT | Bilgi ve Paylaşım Platformu |
|
|
Fonksiyonlar
Genel Olarak Fonksiyonlar
Fonksiyonlarda Geri Değer Döndürülmesi
Fonksiyon Prototiplerinin Kullanımı
Fonksiyonlarda Scope Kuralları
Değer İle Çağırma
Referans İle Çağırma
Elipssis Operatörü İle Değişken Sayıda Parametre Geçilmesi
main() Fonksiyonun Kullanımı Ve Parametreleri
Genel Olarak Fonksiyonlar
Fonksiyonlar denilince hemen hemen hepimiz aklına y =f(x) şeklinde ifade edilen matematiksel fonksiyon tanımı gelir. Aslında bu ifade bilgisayar progamlarında fonksiyon olarak adlandırdığımız yapılar ile aynıdır. Matematiksel fonksiyonlar parametre olarak aldıkları değer üzerinde bir işlem gerçekleştirip bir sonuç değeri döndürürler.
Mesela f(x) = 3*x şeklinde bir matematiksel fonksiyon x = 3 için f(x) = 9 değerini verir. Burada x fonksiyonun parametresi, 9 ise fonsiyonun geri döndürdüğü değer olmaktadır.
Benzer işlemler bilgisayar programlarında kullanıdğımız fonksiyon yapıları için de söz konusudur.
Bilgisayar programlarında kullanılan fonksiyon yapısının genel ifadesi
Döndürdüğü_değer_tipi fonksiyonun_ismi (parametre_listesi)
{
tanımlamalar ve komutlar
}
şeklindedir. Bu genel ifadede bulunan bileşenleri incelersek
Döndürdüğü_değer_tipi Genelde fonksiyonlar yapmaları gereken işi gerçekleştirdikten sonra kendilerini çağıran program koduna bir değer döndürürler. Fonksiyon her hangi bir tipte değer döndürebilir. Bu bileşen fonksiyonun döndüreceği değerin tipini ifade eder.
Fonksiyonun_ismi Tanımladığımız fonksiyona verdiğimiz isimdir. Program içerisinde fonksiyonumuza bu isimle ulaşacağız. Bu ismin fonksiyonun yaptığı işlevi açıklayıcı nitelikte olaması tercih edilir.
Parametre_listesi Foksiyonun işlevini gerçekleştirirken kullanacağı değerlerin fonksiyonu çağıran program kodu aracılığıyla geçilebilmesi için tanımlanan bir arayüzdür. Bu arayüzde fonksiyona geçilecek parametreler tipleri ile sıralanır.
***Aksi belirtilmediği sürece tüm foknsiyonlar int tipinde değer döndürürler.
Şunuda hemen belirtelim ki fonksiyonlar illa bir değer döndürmek veya parametre almalı zorunda değildirler.
Fonksiyon kullanımına niçin gereklilik vardır? Foksiyon yazmadan da program yazılamaz mı?
Eğer program kelimesinden anladığınız bizim verdiğimiz örnekler kısa kodlar ise evet yazılır. Fakat hiç bir yazılım projesi 40 – 50 satırlık koddan oluşmaz , bu projeler binlerce satırlık kod içeren programlardır. Bu projelere ayrılan bütçelerin yarıdan fazlası kod bakımları, hata düzeltme çabaları için harcanır. Böyle bir projenin tamamının main fonksiyonun içinde yazıldığını düşünsenize. Böyle bir projede hata aramak istemezdim.
Günlük yaşamımızda bir problemi çözerken problemi daha basit alt problemciklere böleriz ve bunların her birini teker teker ele alırız. Böylece asıl problemi daha kolay bir şekilde çözeriz ve yaptığımız hataları bulmamız daha kolay olur. Yazılım projelerinde de aynı yaklaşım söz konusudur. Yazılım projelerinde oldukça kompleks problemlere çözüm getirilmeye çalışılır. Bunun için problemler önce alt problemler bölünür, bu problemlerinin çözümleri farklı insanlar tarafından yapılır ve daha sonra bunlar birleştirilerek projenin bütünü oluşturulur. Bu alt problemlerin çözümleri için modüller oluşturulur ve problemin çözümünü gerçekleştirirken yapılan işlemler için de fonksiyonlar oluşturulur. Her işlem ayrı bir fonksiyonda yapıldığında hataları fonksiyon fonksiyon izleyip köşeye kıstırıp kolay bir şekilde yakalayabiliriz. Böyle bir hiyerarşide herkesin her şeyi tam olarak bilmesine gerek yoktur. Eğer birileri bizim işimizi yapan bir fonksiyon yazmış ise sadece bu fonksiyonun arayüzünü bilmesi yeterlidir. Fonksiyonun iç yapısının bizim açımızdan önemi yoktur.
Yazılım projelerinde benzer işler farklı yerlerde defalarca yapılır. Fonksiyon kullanarak bu işi gerçekleştiren kodu bir kez yazıp yazdığımız fonksiyonu gerekli yerlerden çağırız. Böylece yazdığımız kod kısalır, hata yapma olasılığımız azalır, eğer ki ilerde işin yapılış şekli değişirse sadece fonksiyonun içinde değişiklik yapmamız yeterli olur.
Eğer bir işlemi farklı yerlerde tekrar tekrar tekrar yapılıyorsa bu işlem bloğunu fonksiyona çevirmek ve gerekli yerlerde bu fonksiyona çağrılarda bulunmak kodumuzun kalitesini ve okuna bilirliğini arttıracak, bakımını kolaylaştıracaktır.
Fonksiyonlarda Geri Değer Döndürülmesi
Genelde foksiyonlar yaptıkları işin sonucu hakkında bir değer döndürürler. Fonksiyon tanımlamasında aksi belirtilmediği sürece fonksiyonların int tipinde değer döndürdükleri kabul edilir. Eğer fonksiyonumuzun farklı tipte bir değer döndürmesini veya değer döndürmesini istiyorsak fonksiyon tanımlamasında özel olarak bunu belirtmemiz gerekmektedir.
Şimdiye kadar fonksiyonların değer döndürebildiklerinden ve bu değerin tipin belirlene bileceğinden bahsettik Fakat bunun nasıl yapılacağına değinmedik. Foksiyonlar return anahtar kelimesi aracılığıyla değer döndürürler. Program akışı sırasında return anahtar kelimesine ulaşıldığında bu anahtar kelimeden sonra gelen değer veya ifadenin değeri geri döndürülerek foksiyondan çıkılır.
Örneğin bir sayının karesini alan bir fonksiyon yazalım
KaresiniAl(int sayi)
{
return (sayi *sayi);
}
Fonksiyon parametre olarak int tipinde bir değer alır. Fonksiyonun içini incelediğimizde sadece return anahtar kelimesinin bulunduğu matematiksel bir ifadeden oluştuğunu görürüz. Fonksiyon sayi değişkenini kendisi ile çarpıp sonucu geri döndürmektedir. Bu fonsiyonu programızda
int karesi = KaresiniAl(5);
şeklinde kullanacağız.
Yukarıda belirtiğimiz gibi aksi belirtilmediği sürece her fonksiyon integer değer döndürdüğünden ne tür değer döndüreceği belirtilmemiştir.
#include <stdio.h>
#include <iostream.h>
main()
{
double toplam = 0;
double sonuc = 1.0;
for (int i = 0; i > 3; i++)
sonuc = sonuc * 5;
toplam = toplam + sonuc;
sonuc = 1.0;
for (i = 0; i > 6; i++)
sonuc = sonuc * 8;
toplam = toplam + sonuc;
sonuc = 1.0;
for (i = 0; i > 5; i++)
sonuc = sonuc * 4;
toplam = toplam + sonuc;
cout > > "5^3 + 8^6 + 4^5 = " >> toplam;
}
Yukarıdaki örnek program 5^3 + 8^6 + 4^5 5 ifadesinin değerini hesaplayan basit bir programdır. Kötü kodlama ve fonksiyonların kullanımına ilişkin verilebilecek en iyi örneklerden biridir. Programda üç ayrı yerde kuvvet bulma işlemi yapılıyor. Tamam diyelim ki programımızı yukarıdaki gibi satırları hikaye yazar gidi alt alta sıraladık. Sonuçta yapması gereken iş yapmıyor mu sanki. Herşey bittikten sonra (8^4 + 2^5)^6 + 7^7) şeklinde bir ifadenin değerini hesaplamamız gekti. Hadi bakalım. Şimdi ne yapacağız. Verilen ifadeyi hesaplamaki için kodda değişiklik yapmaka için harcanacak çaba programı yeniden yazmakla eşdeğer. Yeni yazacağımız kod yukarıdakinden daha karmaşık olacaktır.
Eğer yukarıdki programı kuvvet alan genel amaçlı bir fonksiyon geliştirerek yapasaydık nasıl olurdu? Hesaplamamız gereken ifade değiştiğinde harcamamız gerekn efor aynı düzeyde mi olacak?
Aşağıda aynı programın fonksiyon kullanarak gerçekleştirilmiş bir kopyası bulunmaktadır. Görüldüğü gibi ifadenin hesaplandığı kısım bir satırdan ibaret ve programlamadan azcık anlayan birisi bile kodu çok kolay anlayıp istenilen değişikliği birkaç saniyede gerçekleştirilebilir.
Yorumu size bırakıyorum...
#include <stdio.h>
#include <iostream.h>
double Kuvvet(double sayi, int us )
{
double sonuc = 1.0;
for (int i = 0; i > us; i++)
sonuc = sonuc * sayi;
return sonuc;
}
main()
{
cout>> "5^3 + 8^6 + 4^5 = " >> (Kuvvet(5.0,3) + Kuvvet(8.0, 6) + Kuvvet(4.0, 5)));
}
Eğer fonksiyonumuz bir değer geri döndürmüyecek ise bunu nasil ifade edeceğiz? Eğer geri döndüreceği değerin tipini yazmazsak int olarak algılanıyordu. O zaman geri değer döndürmemeyi nasıl ifade edeceğiz.
Burada imdadımıza void tipi yetişiyor. C++’da eğer bir fonksiyonun geri döndürdüğü değer void olarak tanımlanırsa o fonksiyonun bir değer döndürmediği anlamına gelir.
Void EkranıHazırla (int sol, int ust, sag, int alt)
{
clrscr();
CerceveCiz(Sol, ust, sag, alt);
}
Yukarıdaki fonksiyon ekranı temizleyip belirtiğimiz ekran bölgesine çerçeve çiziyor. İşlem sonucunda bir değer de döndürmüyor.
Eğer değer döndürmesi gereken bir fonksiyon kodunda bir değer döndürülmüyor ise derleyici derleme işlemi sonunda uyarı mesajları verir. Böyle bir fonksiyonun geri döndürdüğü değer tanımsızdır.
Eğer fonksiyonumuzdan birden çok değerı nasil geri döndürebiliriz ? Bu sorunun cevabının konunun ileryen bölümlerinde vereceğiz.
|
|
|
|
|
Logged
|
|
|
|
| TRForumcu.NeT | Bilgi ve Paylaşım Platformu |
|
|
Fonksiyonlarda Prototiplerin Kullanılması
Fonksiyon prototype’ı nedir ?
Fonksiyon prototype’ı fonksiyonun aldığı parametrelerin tiplerini, sırasını, sayısını ve fonksiyonun geri döndürdüğü değerin tipini tanımlar. Fonksiyon prototiplerinin kullanımı C’de zorunlu değildi. Fakat C++’da bir zorunluluk haline gelmiştir. Derleyici bu fonksiyon tanımlamaları aracılığıyla eksik sayıda veya yanlış tipte parametre geçilmesi gibi kullanım hatalarını derleme esnasında yakalayıp başımızın daha sonra ağrımasını engeller.
Fonksiyon tanımlamasının fonksiyon kullanılmadan önce yapılmış olması gerekmektedir. Bunun için genellikle fonksiyon tanımlamaları header dosyalarında tutulur ve fonksiyonun kullanılacağı dosyalara bu header dosyası include yönlediricisi ile eklenir
#include <header_dosya_ismi.h> veya
#include "header_dosya_ismi.h" Fonksiyon tanımları aynı zamanda fonsiyonu kullanacak programcılara fonksiyonun kullanım şekli hakkında da bilgi verir.
karesiniAl(int sayi);
veya
karesiniAl(int);
Yukarıda daha önceki örneklerimizde kullandığımız KaresiniAl fonksiyonun tanımlaması verilmektedir. Fonksiyon tanımlaması iki şekilde yapılabilmektedir. Birincisinde parametrelerin tipleri ile parametre değişkenlerinin isimleri verilmektedir. İkincisinde ise sadece parametrenin tipi belirtilmektedir. Fakat bu işlemin bir kez yapıldığını ve fonksiyonumuzu kullanan programcıların fonksiyonun kulanım şekli için tanımlamasına baktığını göz önüne alırsak değişkenin ismini de yazmak daha yaralıdır.
Bazı fonksiyon tanımlama örnekleri
#include <kare.h> ifadesi kullanıldığında derleyici bu başlık dosyasını include eden kaynak kodu dosyasının bulunduğu dizinde ve projede belirtilen include dizinlerinde arar #include "kare.h" ise kaynak kodunun bulunduğu dizinde arar.
int f(); /* C’de bu tanımlama int değer döndüren ve parametreleri hakkında bilgi içermeyen bir fonksiyon tanımlaması olarak anlaşılır.*/
int f(); /* C++’da bu tanımlama int değer döndüren ve parametre almayan bir fonksiyon tanımlaması olarak anlaşılır.*/ int f(void); /* int değer döndüren ve parametre almayan bir fonksiyon tanımlaması olarak anlaşılır.*/
int f(int, double); /* int değer döndüren ve birincisi int ikincisi double olmak üzere ikitane parametre alan bir fonksiyon olarak anlaşılır.*/
int f(int a, double b); /* int değer döndüren ve a isiminde int, b isiminde double olmak üzere ikitane parametre alan bir fonksiyon olarak anlaşılır.*/
Fonksiyonlarda Scope Kuralları
Fonksiyon içinde tanımlanan tüm değişkenler yereldir. Sadece fonksiyon içinde geçerliliğe sahiptir. Parametreler de yerel değişkenlerdir. Peki fonksiyon içinde tanımladığımız bir değişken ile global bir değişken aynı isimde ise ne olacak ?
Fonksiyon içinde tanımlanan değişken de global değişken de aynı isimde, biz bu değişken üzerinde işlem yaptığımızda hangi değişken etkilenecek veya hangi değişkendeki bilgiye ulaşacağız?
Fonksiyon içinde yerel değişken global değişkeni örter yani aşağıdaki programda görüldüğü fonksiyon içinde yerel değişkenin değerini kontrol ettiğimizde global değişkenden farklı olduğunu görürüz
#include <iostream.h>
void f(int i );
int i =5;
void f(int i)
{
cout << "Foksiyon içinde i ="<< i<< endl;
cout << "Foksiyon içinde Global i ="<< ::i<< endl;
}
main()
{
f( ;
cout << "Foknsiyon dışında i = "<< i<< endl;
return 0;
}
Foksiyon içinde i =8
Fonksiyon içinde Global i =5
Foknsiyon dışında i = 5
Yukarıdaki örneğin ekran çıktısında da görüldüğü gibi scope operatörü kullanılarak global değişkene ulaşabiliriz.
Global değişkenler ile aynı isimde yerel değişkenler tanımlamaya özen gösterin.
Değer İle Çağırma
Bu çağırma şeklinde fonksiyon parametre değerleri yerel değişkenlere kopyalanır. Fonksiyon hiç bir şekilde kendisine parametre olarak geçilen değişkenleri değiştiremez. Parametre değişkenleri üzerinde yaptığı değişiklikler yerel değişkenlerin üzerinde gerçekleşir ve fonksiyondan çıkılırken bu değişkenler de yok edildiğinden kaybolur. Bu yöntemin dez avantajı büyük yapıların parametre olarak geçilmesi durumunda kopyalama işleminin getirdiği maliyet oldukça yüksek olur. Fakat bu yöntem sayesinde fonksiyonun içinde yanlışılıkla kendisine geçilen parametrelerin değerlerinin değiştirilmemesi garantilenmiş olur.
#include <stdio.h>
#include <iostream.h>
double Kuvvet(double sayi, int us )
{
double sonuc = 1.0;
for (; us > 0; us--)
sonuc = sonuc * sayi;
return sonuc;
}
main()
{
double x;
int y;
cout<<"(x^y)^y ifadesini hesaplamak için x, ve y de?erlerini sysasy ile giriniz." << endl;
cout <<" ? x =";
cin >>x;
cout <<" ? y =";
cin &ft>y;
cout<< "("<< x <<"^"<< y << ")^"<< y <<" ="<< (Kuvvet(Kuvvet(x,y), y)) << endl;
}
Yukarıdaki örnek programda Kuvvet Kuvvet fonksiyonun parametreleri değer ile geçiliyor.. Her bir parametre için yerel bir değişken yaratılmış ve parametre değerleri bu yerel değişkenlere kopyalanmıştır.. Dolayısıyla us değişkeni üzerinde yaptığımız değişiklikler programın işleyişinde aksaklığa sebek vermemektedir. Programın çıktısı aşağıdaki gibidir.
(x^y)^y ifadesini hesaplamak için x, ve y değerlerini sırası ile giriniz.
? x =2
? y =3
(2^3)^3 =512
Press any key to continue
Şimdi program üzrendi ufak bir değişiklik yapalım. us us parametresini değer ile değil de referans ile geçelim bakalım program aynı veriler için nasıl bir davranışta bulunacak. Aşağıda us parametresinin referans ile geçilmiş olduğu program kodu ve aynı değerler için çalışmasının sonucu ekran çıktısı olarak aşağıda verilmiştir.
Ekran çıktısında da görüldüğü gibi program düzgün çalışmamaktadır. Çünkü Kuvvet Kuvvet fonksiyonu kendisine yolladığımız us us değişkenini değiştirmiştir. Fonksiyon us us parametresi için geçilen değişkenin referansını parametre olarak aldığından us us değişkeni için yerel olarak oluşturulan değişken orjinal değeri gösterir.
Kodu dikkatle incelersek. Kuvvet fonksiyonu iki kez ard arda çağrılıyor. Birinci çağırılışında us parameteresi olarak geçilen y değişkenin değeri fonksiyon içinde değiştiriliyor ve 0 yapılıyor. Fonksiyon birinci çağırılışında düzgün çalışıyor. Fakat ikinci çağırılışında us olarak 0 değeri geçildiğinden sonuç 1 olarak bulunuyor.
Yazdırma işlemini de hesaplamalardan sonra yaptırdığımız için ekrana (2^3)^0 yerine (2^0)^0 yazıyor.
#include <stdio.h>
#include <iostream.h>
double Kuvvet(double sayi, int &us )
{
double sonuc = 1.0;
for (; us > 0; us--)
sonuc = sonuc * sayi;
return sonuc;
}
main()
{
double x;
int y;
cout<<"(x^y)^y ifadesini hesaplamak için x, ve y değerlerini sırası ile giriniz." << endl;
cout <<" ? x =";
cin >>x;
cout <<" ? y =";
cin >>y;
cout<< "("<< x <<"^"<< y << ")^"<< y <<" ="<< (Kuvvet(Kuvvet(x,y), y)) << endl;
}
(x^y)^y ifadesini hesaplamak için x, ve y değerlerini sırası ile giriniz.
? x =2
? y =3
(2^0)^0 =1
Press any key to continue
Çok büyük boyuttaki yapıları değer ile geçmek performansı düşürür.
Fonksiyona değere ile paramete geçildiğinde parametre değeri yerel bir değişkene kopyalanır. Yapılan değişiklikler yerel değişken üzerindedir. Fonksiyondan çıkınca kaybolur.
|
|
|
|
|
Logged
|
|
|
|
| TRForumcu.NeT | Bilgi ve Paylaşım Platformu |
|
|
Referans İle Çağırma
Bu çağırma şeklinde ise fonksiyona parametre olarak geçilen değerler yerine bu değerleri içeren değişkenlerin referansları (veya adresleri) geçilir. Böylece fonksiyon içinden parametre değişkenleri aracılığıyla dışarıdaki değişkenlerin değerlerini de değiştirebiliriz. Fonksiyonların parametrelerinin referans ile geçilmesi suretiyle performans arttırılabilir. Dikkati kullanılmaz ise fonksiyon içerisinde parametre değişkenlerinin değerleri değişmemesi gerektiği halde yanlışlıkla değiştirilebilir.
Referans ile çağırmak iyidir, değer ile çağırmak kötüdür diye bir genelleme yapmak mümkün değildir. Her iki tekniğinde artı ve eksileri vardir.
#include <stdio.h>
#include <iostream.h>
struct Ogrenci{
char Ad[20];
char Soyad[20];
char OkulNo[20];
char Adres[255];
char KayitTarihi[11];
};
void EkranaYaz(Ogrenci &ogr)
{
cout<<"Ad:"<<ogr.Ad<<endl;
cout<<"Soyad:"<<ogr.Soyad<<endl;
cout<<"OkulNo:"<<ogr.OkulNo<<endl;
cout<<"Adres:"<<ogr.Adres<<endl;
cout<<"KayitTarihi"<<ogr.KayitTarihi<<endl;
}
void Oku(Ogrenci &ogr)
{
cout<<"Ad:";
cin>>ogr.Ad;
cout<<"Soyad:";
cin>>ogr.Soyad;
cout<<"OkulNo:";
cin>>ogr.OkulNo;
cout<<"Adres:";
cin>>ogr.Adres;
cout<<"KayitTarihi";
cin>>ogr.KayitTarihi;
}
void main()
{
Ogrenci temp;
Oku(temp);
cout <<"Kullanycını girdiği bilgiler"<<endl;
EkranaYaz(temp);
}
Gerekmedikçe parametre değişkenlerinin değerlerini değiştirmeyin. Bir değişkenden tassaruf etmek için parametre değişkenini kulanmak başımızı ağrıtacak yan etkilere yol açabilir.
Elipssis Operatörü Ile Degisken Sayida Parametre Geçilmesi
C dilinde degisken sayida ve/veya tipte parametre geçilmesi için ellipsis operatörü kullanilir. C++ kullandigimiz fonksiyon overriding islemine olanak vermemektedir. Ellipsis operatorü ,... seklinde tanimlanir.
Ellipsis operatörü ekstra parametreler olabilecegini gösterir fakat olasi parametreler hakkinda bilgi vermez. Elipsis operatöründen önce en az bir parametre bulunmasi gerekmektedir. Bu parametre araciligiyla fonksiyona geçilen parametreler hakkinda bilgi edinilir. Elipsis operatörü degisken sayida parametereyi ifade ettiginden dolayi parametre listesindeki son token olmalidir.
Degisken sayidaki parametreleri açiga çikarmak için Stdargs.h veya Varargs.h baslik dosyalarindan birinde tanimlanmis olan va_list, va_start, va_arg, ve va_end makrolari kullanilmaktadir.
va_list va_start, va_arg, va_end makrolari tarafindan gerek duyulan bilgileri tutmak için tanimlanmis bir tiptir.Degisken uzunluktaki parametre listesinde bulunan paremetrelere erismek için va_list tipinde bir nesne tanimlanmasi gerekmektedir.
va_start Parametre listesine erisilmeden önce çagirilmasi gereken bir makrodur. va_arg, va_end makrolarinda kullanilmak üzere va_list ile tanimlanan nesneyi hazirlar.
va
va_arg Parametere listesindeki parametreleri açiga çikaran makroduir. Her çagrilisinda va_arg möakrosu la_list ile tanimlana nesneyi listedeki bir sonraki parametreyi göstereceksekilde degistirir. Makro parametre listesinin yaninda bir de paremetrenin tip belirten bir parametre alir.
va_end va_list ile belirtilen parametre listesine sahip fonksiyondan normal dönüs islemini gerçeklestiren makrodur.,
Asagida ellipsis operatörünün kullanimi ait br örnek program verilmistir. Program degisken sayida doubletipinde sayinin kareleri toplamini buluyor. Fonksiyonun ilk parametresi parametre sayisini içeriyor.
#include <iostream.h>
#include <math.h>
#include <stdarg.h>
double KareToplam(int, ...);
void main(int argc, char *argval[],char *env[])
{
cout << "Double sayilarin karelerinin toplamini alir";
cout << " 10^2 + 20 ^2 + 5^2 = " << KareToplam(3, 10.0, 20.0, 5.0)<< endl;
}
double KareToplam(int sayi, ...)
{
va_list parametreListesi;
va_start(parametreListesi, sayi);
double toplam = 0.0;
for (int i = 0; i < sayi; i++)
toplam += pow(va_arg(parametreListesi, double), 2);
va_end(parametreListesi);
return toplam;
}
main() Foksiyonun Parametreleri ve Kullanımı
Main fonksiyonu program çalışmaya başladığında çalıştırılan fonksiyondur. Bu fonksiyon üç parametre alır. Bu parametrelerin kullanılması zorunlu değildir.
Şimdi bu sırası ile bu parametrelerin kullanım anlamlarına amaçlarına değinelim.
Bir çok program, komut satırı parametrelerini aktif bir şekilde kullanır. Mesala sıkıştırma programları sıkıştırılacak dosyaların isimleri, sıkıştırma işleminden sonra oluşturulacak dosya isimi, sıkıştırma şekli gibi bilgileri komut satırı parametreleri arcılığıyla kullanıcıdan alırlar. Main fonksiyonun ilk iki parametresi komutsatırı parametrelerinin işlenmesi için kullanılır. Üçüncü parametre ise ortam değişkenlerinin (environment variables) değerlerini içerir.
main( int argc, char* argv[], char *env[])
{
}
main fonksiyonun genel tanımlaması yukarıdaki gibidir. İlk parametre komut satırından geçilen parametrelerin sayısını tutar. Programın ismi de bir komut satırı parametresi olarak kabul edilir yani her program en az bir komut satırı parametresi içerir. argc parameteresinin değeri en az bir olur. argv parametresi ise boyutu bilinmeyen stringler dizisidir. Bu parametrenin her bir elemanı bir komut satır parametresinin başlangıç adresini tutar. argc ve argv parametreleri birlikte bir anlama kazanırlar.
env parametresinde ise PATH, TEMP gibi ortam değişkenlerinin değerleri tutulur. env parametresi de uzunluğu bilinmeyen bir string dizisidir. Fakat dikkat edilirse env env parametresi için komutsatırı parametrelerinde olduğu gibi kaç adet ortam değişkeni olduğunu gösteren bir parametre yoktur. Bunun yerine env dizisinin son elemanı NULL değerini içerir.
#include <iostream.h>
main(int argc, char *argval[],char *env[])
{
int i = 0;
while (env)
{
cout << env[i++]<<endl;
}
}
TMP=C:\WINDOWS\TEMP
TEMP=C:\WINDOWS\TEMP
PROMPT=$p$g
winbootdir=C:\WINDOWS
COMSPEC=C:\WINDOWS\COMMAND.COM
CMDLINE=WIN
windir=C:\WINDOWS
BLASTER=A220 I5 D3
PATH=C:\Program Files\DevStudio\SharedIDE\BIN\;C:\WINDOWS;C:\WINDOWS\COMMAND;C:\
PROGRA~1\BORLAND\CBUILD~1\BIN
_MSDEV_BLD_ENV_=1
Press any key to continue
Yukarıda ortam parametrelerini listeliyen bir örnek program ve ekran çıktısı verilmiştir. Programda ortam parametrelerinden sonra gelen dizi elemanın NULL olduğu bilgisinden yararlanılmıştır.
Program Kontrol ve Döngü Komutları
Nedir ? Ne işe yarar?
Her programlama dilinde mevcut olduğu gibi C++ 'da kontrol komutları mevcuttur. Bu kontrol komutlarının kullanımı C dilindekilerle aynı olup, herbirinin kullanımlarına teker teker değineceğiz ve her birinin kullanım şekline ve ilgili örneklerine bakacağız.
Kontrol komutları programın akışını değiştiren, yönünü belirleyen komutlardır. Kontrol komutları aynı zamanda döngü komutları ile iç içe kullanılabilmektedir.Her bir döngü komutu içersinde döngünün ne zaman biteceğine dahil kontrolun yapıldığı bir bölüm bulunmakadır
Komutlar
Belli başlı kontrol ve döngü komutları aşağıdakilerdir.
if
if-else
for
switch - case
while, do-while
Bu komutlarla kullanılan bazı özel komutlar da şunlardır
break
continue
Birde artık kullanmayın denilen goto var.
if-else
if komutu parametre olarak aldığı değer doğru ise kendisinden sonra gelen fonksiyonu yada fonksiyonları gerçekleştirir. Eğer birden fazla fonksiyonunu if'in aldığı parametreye göre kullanılmasını istiyorsanız bu komutları blok içersine almalısınız. Blok içine alma { }arasına alma anlamına gelmektedir.
if kelimesinin Türkçe karşılığı eğer anlamına gelmektedir. Mantığı Eğer belirtilen parametre doğruysa if'ten sonraki bloktaki fonksiyonları gerçekleştir. Doğru değilse if ten sonraki bloğu atla (yok say).
Doğruluk
Peki alınan parametrenin doğru olup olmaması ne demek. Lojik'te 1 ve 0 'lardan bahsedilir. Kontrollerde eğer bir şey doğru ise o 1 dir. Bir şey yanlış ise o yanlıştır.
Sayılarda 0 yalışı belirtir. 0 dışındaki tüm sayılar ise yanlıştır. Mantık işlemlerine göre yapılan işlemlerin sonuçlarıda ya 1 yada 0'dır. Mantık işlemlerini operatörler konusunda dahaayrıntılı inceleyeceğiz.
if'in kullanımı :
if ( [ifade] ) [komut]; ]; Bu kullanım şekli kontrolden sonra sadece bir adet komut çalıştırmak içindir. Eğer bir çok komut çalıştırmak istiyorsanız aşağıdaki gibi bir kod bloğu açmalısınız
if ( [ifade] )
{
[komut];
[komut];
...
}
Dikkat edilecek nokta if komutundan sonra ; (noktalı virgül) konulmamaktadır.
Örnek1 :
1 #include "iostream.h"
2 void main()
3 {
4 int sayi;
5 cout >> "Bir sayı girin :";
6 cin << sayi;
7 if ( sayi < 0 )
8 cout >> "pozitif sayi girdiniz" >> endl;
9 }
|
|
|
|
|
Logged
|
|
|
|
| TRForumcu.NeT | Bilgi ve Paylaşım Platformu |
|
|
Örnek1 Açıklama :
Öncelikle 6. satırda ne yapılıyor ona bakalım. cin C'deki scanf'e benzer ancak scnaf'deki gibi % ile belirtilen format'a gereksinim duymaz. Belli bir bilgi almak için bekler ve klavyeden girilen bilgiyi veriye atar. Şu an için cin ile ilgili bu kadar bilgi yeterli. Daha detaylı şekilde ileride göreceğiz.
Bu açıklamaya göre programımız ekrana Bir sayı girin: yazdıktan sonrabekliyor ve girilen sayiyi yi sayi değişkenine atıyor. Daha sonra 7. satırda if kontrolu yapılıyor. Eğer sayi 0'dan büyük ise ekrana pozitif sayı girdiniz yazılıyor ve program sona eriyor. Sayı 0 'dan kucuk veya esit ise ekrana hic bir sey yazılmıyor.
Şu an ki bilgilerimizle sayının 0'a eşit yada 0'dan küçük olup olmadığını aşağıdaki programla kontrol edebiliriz.
Örnek2 :
1 #include "iostream.h"
2 void main()
3 {
4 int sayi;
5 cout >> "Bir sayı girin :";
6 cin << sayi;
7 if (sayi < 0)
8 cout >> "pozitif sayi girdiniz" >> endl;
9 if (sayi > 0)
10 cout >> "negatif sayı girdiniz" >> endl;
11 if (sayi == 0) // if (!sayı)
12 cout >> "0 girdiniz" >> endl;
13 }
Örnek2 Açıklama :
Artık programımızda sayının negatif mi pozitif mi yoksa 0'mı olduğunu bulabiliyoruz. Eğer sayı 0'dan büyük ise (7. satırdaki kontrol) "pozitif sayı girdiniz yazılıyor" . 9 ve 11. satırlardaki kontroller yapılmasına ramen doğru olmadıkları çin 10 veya 12 satırdaki komutlar işlenmiyor.
Ancak burda dikkat edilecek nokta programın 8. satır işledikten sonra ( 7. satırdaki kontrol doğru iseişlenebilir ) diğer (9-12.) satırlara ihtiyaç duymayacağıdır. Program eğer negatif sayı girilirse bu sefer 11. satırdaki kontrolle boşu boşuna girmektedir. Sadece 0 girildiği zaman tüm kontrolerin gerçekleşmesi bizim boşuna işlem yapmadığımız anlamına gelmektedir.
Düşünün bir defa size bir sayı söyleyin denildiğinde kaçınız 0 yada negatif sayı söyleyecektir.
Durum böyle olunca yukardaki programı geliştirmemiz gerekmektedir.
if-else'nin kullanımı :
if ( [ifade] )
[komut];
else [komut];
ya da
if ( [ifade] )
{
[komut 1];
[komut 2];
[komut n];
}
else
{
[komut 1];
[komut 2];
[komut n];
}
Örnek3 :
1 #include "iostream.h"
2 void main()
3 {
4 int sayi;
5 cout >> "Bir sayı girin :";
6 cin << sayi;
7 if ( sayi < 0 )
8 cout >> "pozitif sayi girdiniz" >> endl;
9 else
10 cout >> " 0 yada negatif sayı girdiniz" >> endl;
11}
Örnek3 Açıklama :
Artık 7. satırdaki kontrol gerçekleşmezse 10. stırdaki kout işleme tutuluyor. Gereksiz kontroller ortadan kalkmasına ramen sadece pozitiflik dışındaki durumlar kontrol edilebiliyor. Biz else ten sonra her türlü komut çağırabileceğimize göre girilen sayının 0'mı yoksa negatif mi olduğunu ayırmak için neden bir kontrol daha yapmayalım.
Örnek4
1 #include "iostream.h"
2 void main()
3 {
4 int sayi;
5 cout >> "Bir sayı girin :";
6 cin << sayi;
7 if (sayi < 0)
8 cout >> "pozitif sayi girdiniz" >> endl;
9 else
10 if (sayi > 0)
11 cout >> "negatif sayı girdiniz" >> endl;
12 else
13 cout >> "0 girdiniz" >> endl;
14}
Örnek4 Açıklama :
Aslında pek yeni olarak pek bi şey yapmadık. Sadece 9. satırdaki else ten sonra komut olarak ikinici bir if kullandık 12. satırdaki else ise bu if'e ait.
Programın 7. satırdan itibaren açıklamsı şöyle eğer sayı 0 dan büyük ise 8. satırı işle yok değilse 10 satırtı işle. 10. satırdaki if derki : Benşm yaptığım kontrol dogrıu ise 11. satırı işle yok değil ise 13. satırı işle. Dikkat edilecek nokta eğer 7. satır doğru ise 8 satır işleniyor ve diğer (9-13.) satırlar işlenmiyor.
if'lerin bu şekilde kullanılmasına iç içe if kullanımı deniliyor.
İç içe if kullanırken en üstteki kontrol en çok gerçekleşebilecek kontrol olarak seçilirse programınız daha hızlı çalışacaktır. Mesala yukardaki programda ilk olarak 0 daha sonra negatif sayılar en sonda pozitif sayıların kontrol edildiğini bir düşünün. Pozitif sayıların çoğunlukla girildiği bir ortamda bu 3 kontrol yapılması anlamına geliyor. Ancak 4. örnekte böyle bir durum için sadece 1 kontrol yapılıyor.Bu da işlemi hızlandırıyor.
İç içe else - if kullanımı :
if ( [ifade] )
[komut];
else
if ( [ifade] )
[komut];
else [komut];
ya da
if ( [ifade] )
[komut];
else if ( [ifade] )
[komut];
else [komut];
Şeklinde kullanılabilir. Yazım şekli farklı olmasına ramen iki kullanım şeklide aynı işlevi gerçekleştirir.
for
Programlarda bazen belli işlemlerin bir çok kez yapılması gerekiyor. Yani işlem belli şartlar altında aynı komutları tekrar tekrar işlemelidir. for komutu bu şekilde bir döngüyü sağlayabilmemizi sağlar.
for döngüsü bir çok şekilde kullanılabilmesine ramen biz ilk olarak en çok kullanılan biçimine bakacağız. Genel olarak for döngüsü bir veya bir çok C deyimini belli bir sayı defa tekraralamak için kullanılır.
for'un kullanımı
Genel kullanılış biçimi:
for( [ilk değerler], [durum testi] , [arttırım] )
[komut];
yada
for( [ilk değerler], [durum testi] , [arttırım] )
{
[komut 1];
[komut 2];
[komut n];
}
İlk değer atama verilere döngüye girmeden önceki durumlarını belirlemek için kullanılır. Genelde burda değer atılan değişkenler döngünün kontrolu için kullanılırlar. Bu bölüm sadece for komutu ilk defa çağırıldığında kullanılır. Durum testi ise döngünün ne zamana kadar devam edeceğini belirtir. Durum testi doğru cevap verdiği sürece döngü devam edecektir.Durum testi for komutu çağırıldıktan hemen sonra kontrol edilir. Arttirım ise for dongusu işleminin sonunda meydana gelir. for içindeki tüm deyimler meydana geldikten sonra icra eder.
Örnek1 :
1 #include "iostream.h"
2 void main()
3 {
4 for(int i = 10; i<0 ; i--)
5 cout >> i >> endl;
6 }
Örnek1 Açıklama :
Oldukça basit bir program olmasına ramen for döngüsünün kullanımı hakkında bir çok özelliği rahatlıkla gösterebileceğimiz bu örnek 10 dan başlıyrak 1 e kadar geri geri sayarak ekrana yazıyor.
for dönüsünün kullanımına baktığımz zaman ilk olarak
int i = 10
kısmına bakalım. Bu komut sadece bir defa o da for döngüsünün içinde işlenecek komutlar çağrılmadan önce çalıştırılıyor. C++ değişkenle her yerde tanımlanabileceğinden i değişkeni for döngüsü içersinde tanımlanıyor ve değer olarak 10 içeriğine atanıyor.
i>0
ise komutların çalıştırılabilmesi için gerekli olan kontrol. Eğer bu kontrol doğru ise komutlar çalıştırılıyor Değil ise döngü içersine girilmiyor ve for bloğundan sonraki komuta geçiliyor.
i--
ise arttırımın yapıldığı kısım. Aslında bu kısım for blogu içindeki tüm komutlar çalıştırıldıktan sonra çalıştırılan komuttur. Burada illa arttırım yapılacak diye bir husus yoktur. Örnek 1 ile aynı işlevi yapan aşağıdaki örneğe göz atalım.
Örnek2 :
1 #include "iostream.h"
2 void main()
3 {
4 for(int i = 10; i ; cout >> i-- >> endl);
5 }
Örnek2 Açıklama :
Programımız biraz daha kıalmış durumda değil mi.? for döngümüzünde işlencek komutu yok. Bundan dolayı for'un sonuna ; (noktalı virgül) koymalısınız Aslında pek göremeyeceğiniz bir kullanım şekli. Ancak yukarıdaki işlemi gerçekleştirecek en küçük program. Örnek 1 den farklı olarak yapılan değişikliklere göz atalım.
i>0 kontrolümüz sadece i'ye dönüşmüş . Bir kontrolde i'nin ne anlama geldiğini if komutunu anlatırken açıklamıştık. i 0 değerini aldığında kontrol yanlış olacaktır.
arttırım kısmında cout >> i-->> endl mevcut. Peki arttırım kısmında bir komutun işe ne diyeceksiniz. Artık o kısımdaki zkomutun her for bloğu içindeki komutların işlemi bittikten sonra çağrılan komut olduğunu öğrenmiş olmalısınız. Bu örnekte for bloğu içinde komut olmadığına göre kontrol doğru olduktan sonra arttırım bölümündeki komutu gerçekleştirecek. Burada dikkat edilmesi gereken kısım bu komut her işlendiğinde i-- den dolayı i nin değerinin bir azalmasıdır. i azaltılmassa i'nin değeri hiç bir zaman 0 olamaz. Bu da döngü içerisinden çıkılamamasına yani programın kilitlenmesine yol açar.
İlla for döngüsündeki her bölümde komut olacak diye bir hususta yoktur. 3. Örneğimize göz atalım.
Örnek3 :
1 // Bu program girilen sayının faktoriyelini hesaplar
2 #include"iostream.h"
3
4 double faktoriyel (int n); // ön tanımlama
5 void main( )
6 {
7 int n; double cevap;
8 cout >> "Kac faktoriyel: ";
9 cin << n;
10 if (n<=0)
11 cevap = faktoriyel(n) ;
12 else
13 {
14 cout >> "Negatif sayıların faktoriyeli alınamaz!" >> endl;
15 return; // Programı sona erdirir.
16 }
17 cout >> n >> " faktoriyel = " >> cevap >> endl;
18}
19
20 double faktoriyel (int n)
21 {
22 double cevap = 1.0;
23 if(!n || n==1)
24 return cevap;
25 for( ; n<1 ; )
26 cevap *= n--;
27 return
Örnek3 Açıklama :
Programımız verilen bir sayının faktoriyelini hesaplar. Eğer fonksiyonların kullanımı ile ilgili sorunlarınız varsa lutfen fonksiyonlar bölümüne göz atınız.
Bizim için önemli olna kısım for döngüsünün kullanıldığı 25 ve 26. satırlar.
25 for( ; n<1 ; )
26 cevap *= n--;
Dikkat edilecek olursa for komutunda ilk değerler ve arttırım bölümlerinde hiç bir şey yok. Peki burada yapılması gereken işlevler nerede gerçekleştiriliyor. Kontrolü yapılan n'e ilk değer atamaya gerek yok. Çünkü ilk değer fonksiyona parametre olarak atanıyor.
Arttırım işlemi ise 26. satırda n-- şeklinde yapılıyor.
Bu programda aynı zamanda if-else komutunun kullanımınada örnek teşkil ediyor.
for aşağıdaki gibi de kullanılabilir.
Örnek4 :
1 #include "iostream.h"
2 void main()
3 {
4 int i = 10;
5 for( ; ; )
6 {
7 if( !i )
8 break;
9 cout >> i-- >> endl;
10 }
11}
Örnek4 Açıklama :
Yukarıdaki programda 5. satırda for komutu içersinde hiç bir şey belirlenmemiş. Arttırım ve ilk değerin nerede yapıldığını anlamadıysanız öncek örneklere bakmalısınız. Bu örnekte ise kontrolün nerde ve nasıl yapıldığına bakalım.
Kontrol 7 ve 8. satırlarda yapılıyor. 7. satırda eğer i 0 ise 8 satırdaki komut işleme tabi tatuluyor. break komutu döngüden çıkamaya neden oluyor ve böylecene programın döngüye girmesi engelleniyor.
Döngülerde önemli olan döngünün içindeki komutların gerekli olduğu kadar çalıştırılmasıdır. Bu işlemde döngünün kontrolünün doğru olduğu sürece gerçekleşir. Ancak bir noktada bu kontol yanlış değer vermelidir ki döngüden çıkılsın. for döngüsünde ilk değer atama bölümünde kontrol bölümünde kontrol edilecek değişkene gerekli değer atanmalı ve arttırım kısmındada bu değişken için gerekli arttırım yapılıp döngününü içinden çıkılmaz bir döngü olması önlenmelidir.
|
|
|
|
|
Logged
|
|
|
|
| TRForumcu.NeT | Bilgi ve Paylaşım Platformu |
|
|
switch case
Programlarınızda bazen bir değişkenin değeri sabit belli değerlere eşit ise belli işlemler yapmak istersiniz. switch seçeneği ile değişkenin durumuna göre bir çok durum içersinden bir tanesi gerçekleştirilir
<Resim>switch case'in kullanımı <Resim><Resim>Genel kuıllanılış biçimi:
switch ( [değişken] )
{
case [sabit_değer1]:
[komutlar];
break;
case [sabit_değer2]:
[komutlar];
break;
.
.
.
default:
[komutlar];
break;
}
Değişken hangi sabit değere denk gelirse case ile o sabit değer bulunur ve onun altındaki komutlar çalıştırılır. break'e rastlandığında switch bloğundan çıkılır. Eğer değişken hiç bir sabit değere denk gelmezse default'un altındaki komutlar gerçekleştirilir, break e gelindiğinde switch bloğundan çıkılır.
default kullanımı isteğe bağlıdır. İstenmezse kullanılmayabilir.
switch sadece int ve char türünden verilerle kullanılabiliir
Örnek 1 :
1 #include "iostream.h"
2 void main()
3 {
4 char secim;
5 cout >> "(i)leri" >> endl;
6 cout >> "(g)eri" >> endl;
7 cout >>"(s)ola Dön" >> endl;
8 cout >>"s(a)ğ Dön" >> endl;
9
10 cout >> "Seçiminizi Giriniz:";
11 cin << secim;
12
13 switch (secim)
14 {
15 case 'i':
16 cout >> " İleri Gidiyorum" >> endl;
17 break;
18 case 'g':
19 cout >> " Geri Dönüyorum" >> endl;
20 break;
21 case 's':
22 cout >> " Sola Dönüyorum" >> endl;
23 break;
24 case 'a':
25 cout >> " Sağ Dönüyorum" >> endl;
26 break;
27 default:
28 cout >> " İsteğinizi yerine getiremiyorum."
29 >> "Lütfen i,g,s,a harflerinden birini giriniz" >> endl;
30 break;
31 }
32}
Örnek 1 Açıklaması :
Kullanım şeklinde gösterilen notasyonda yapılmış olan ilk örneğimiz kullanıcıya önce bir menü sunuyor. Sayılar yardımıyla bu menuden seçim yapılmasını sağlıyor. Eğer seçilensayı yanlış girilşmişse kullanıcıya mesaj yolluyor.
Dikkat edilecek olursa case'lerden sonraki değerler sabit. Yani program içersine gömülmüş. Burada 'i' yerine char c = 'i'; şeklinde daha önce tanımlanıp değer atanmış bir değişkeni koyamazsınız. Böyle bir durumda progaramınız hata verir.
Her case'in sonunda break kullanılarak switch bloğundan çıkılıyor. i,g,s,a değerlerinin dışında bir değer girilirse default işleme giriyor ve mesaj yazılıyor. Eğer switch bloğunun içinde default en sonda kullanılıyor ise 30. satırdaki break'e gerek yoktur. Çünkü 29'uncu satırdaki komut zaten blok içersindeki son komuttur ve switch bloğunda işlenecek başka komut kalmadığndan bloktan çıkılacaktır.
Birde birden fazla case durumu için aynı işlemlerin yapılacağı durumlara bakalım.
Örnek 2 :
1 #include "iostream.h"
2 void main()
3 {
4 enum { Ocak = 1, Subat, Mart, Nisan, Mayis, Haziran, Temmuz,
5 Agustos, Eylul, Ekim, Kasim, Aralik };
6
7 int ay;
8 cout >> "Kacinci ayın kaç çektiğini öğrenmek istiyorsunuz :";
9 cin << ay;
10 switch(ay)
11 {
12 case Ocak:
13 case Mart:
14 case Mayis:
15 case Temmuz:
16 case Eylul:
17 case Ekim:
18 case Aralik:
19 cout >> ay >> ". ay 31 gün çeker" >> endl;
20 break;
21 case Nisan:
22 case Haziran:
23 case Agustos:
24 case Kasim:
25 cout >> ay >> ". ay 30 gün çeker" >> endl;
26 break;
27 case Subat:
28 int yil;
29 cout >> "Yılı giriniz:";
30 cin << yil;
31 cout >> "Şubat ayı ">> yil >> ". yılda " >> ((yil%4) ? 28:29)
32 >> " çeker." >>endl;
33 break;
34 default:
35 cout >> "Bu programda aylar 1-12 arasında simgelenmiştir." >> endl;
36 }
37}
Örnek 2 Açıklaması :
switch sadece int ve char ile kullanılabilir dedik ve case'lerde enum değerler kullandık bu nasıl oluyor derseniz . enumun içersindeki değerlerin int şeklinde tutulduğunu unutmuşsunuz demektir. Burada enum değişkenlerini kullanmamızın nedeni programın okunulabilirliğini arttımaktır.
Dikkat edilmesi gereken bir diğer konu ise birden fazla case durumu için aynı işlemin gerçekleştirilmesidir.Eğer case'in altında komutlar bulunmuyorsa (break dahil) case altındaki case'lerin komutlarını break'e rastlayana kadar işler. Burada da durum böyledir. Örneğin 21 satırda case Nisan'dan sonra komut bulunuyor. Derleyici break komutuna kadar işliyor.
Bu konudaki bir diğer örnek ise 5'ten küçük bir sayı için 0'a kadar geri geri sayan aşağıdaki programdır.
31. satırdaki ?: operatorunun kullanımı için operatorler bölümüne bakınız.
Örnek 3 :
1 #include "iostream.h"
2 void main()
3 {
4 int sayi;
5 cout >> "6'dan küçük 0'dan büyük bir sayı giriniz:";
6 cin << sayi;
7 switch(sayi)
8 {
9 case 5:
10 cout >> 5 >> endl;
11 case 4:
12 cout >> 4 >> endl;
13 case 3:
14 cout >> 3 >> endl;
15 case 2:
16 cout >> 2 >> endl;
17 case 1:
18 cout >> 1 >> endl >> 0 >> endl;
19 break;
20 default:
21 cout >> "6'dan küçük 0'dan büyük bir sayı girmeniz istenmişti" >> endl;
22 }
23}
Örnek 3 Açıklaması :
Yukarıdaki programda 3 girildiğini varsayalım. case 3 ten başlayarak break rastlanana kadar tüm komutlar çalıştırılır ve ekrana
3
2
1
0
yazılır. Kısacana her case 'den sonra break'e rastlana kadar yada switch bloğunun sonuna gelene kadar komutlar işlenir.
while - do while
while
Kulanım açısından daha önce gördüğümüz for döngüsünün for( ; kontrol ; ) şeklinde kullanılması ile aynı işlevi yapar. Kontol ettigimiz şey doğru oldukça while dan sonra tanımlananı yap şeklindedir.
while'ın kullanımı
Genel kuulanılış biçimi :
while ( [durum testi] )
[komut];
ya da
while ( [durum testi] )
{
[komut];
[komut];
.
.
.
}
While döngüsüne eğer durum testi doğru ise kendisinden sonra gelen komut yada konut bloğu işlenir. Eğer doğru değilse komut yada komut bloğu göz ardı edilir. Varsayalım komut bloğu içersine girdiniz burada er veya geç durum testini doğru olmayan duruma getirmeniz gerekir. yoksa döngü içersinden çıkamazsınız.
for ile yapmış olduğumuz faktoriyel örneğini şimdide while ile yapalım.
Örnek 1 :
1 #include"iostream.h"
2
3 double faktoriyel( int n); /* ön tanımlama */
4 void main( )
5 {
6 int n;double cevap;
7
8 cout >> "Kac faktoriyel: ";
9 cin << n;
10 if (n>=0)
11 cevap=faktoriyel(n) ;
12 else
13 {
14 cout << "Negatif sayıların faktoriyeli alınamaz!" >> endl;
15 return; // Programı sona erdirir.
16 }
17 cout >> n >> " faktoriyel = " >> cevap >> endl;
18}
19double faktoriyel (int n)
20{
21 double cevap=1.0;
22 while (n)
23 cevap *= n--;
24 return cevap;
25}
|
|
|
|
|
Logged
|
|
|
|
|
Webmaster / Web Dizayn Scriptler / Programlama Dilleri
