C++ NEDİR VE TEMEL DERSLER

[Admin]

ÖNEMLİ NOT:Bu bir alıntıdır.

Temel Bilgiler


C++ bilindiği gibi programlama dünyasında en çok ilgi gören C
dilinden türemiştir. C++'ı klasik C dilinden farklı yapan yanı; Nesne
Yönelimli Programlamayı da ( Object Oriented Programming) C'nin
sözdizimi kurallarıyla birlikte desteklemesidir. Normalde C ile sadece
yapısal programlama yaparken C++ dili ile hem yapısal hem de nesne
yönelimli programlar yazabilirisiniz. C++ diline başlarken önce dilin
C'den gelen ve temel olan özelliklerini öğrenmek gerekir. Örneğin,
değişken tanımlama, atama ve diğer basit aritmektik işlemler, kontrol
yapıları ve döngüler gibi.
Teknolojinin ulaştığı son noktadaki programlama dillerinden olan C ve
C++, bir çok yeni ve güçlü özellikleri içerir. Derslerimiz devam
ettikçe bunların teker teker içine gireceğiz. C dilinin özelliklerinin
%80 i C++'da da mevcuttur (bu karşılaştırma şahsi görüşümdür). Zaten
C++, C'nin üst gurubudur. Bunu şöyle sıralayabiliriz. C, C++ ve C# dır.

C dilinin avantajları, az komut kümesinden oluşması ve bu komutların
diğer yüksek seviyeli dillere nazaran daha hızlı çalışmasıdır. Ayrıca C
deki kütüphaneler sayesinde fonksiyon tanımlamanıza gerek kalmadan
işlemlerinizi yapmak mümkün olacaktır. Bu konuda çok detaya inmeden,
programlamaya geçmek istiyorum. Çünkü, programlamaya başladığımızda her
örnekten sonra o an kullandığımız programın içinde geçen fonksiyon,
hata, değişken, belirleyiciler, kısıtlamalar, notasyonlar v.s gibi
bilgilerden ara ara bahsedeceğim. Yalnız çok önemli olan bir konuya
burada değinmek istiyorum. C nin avantajlarını programlamayla birlikte
görmek güzel ama C nin dezavantajlarını programlamadan önce bilmeliyiz
ki bunlardan sakınalım. Öncelikle Tanımlayıcılardan bahsetmek
istiyorum. Her derleyici ve assmbley için değişkenleri, sabitleri,
etiketleri ve fonksiyon adlarını tanımlama kuralları vardır. Bu
notasyonlara, tanımlayıcı denir. C++ da tüm tanımlayıcılar a, . . . , z
- A, . . . , Z harfleri ile ya da alt çizgi "_" ile başlar. Bundan
sonra rakam, harf, ya da alt çizgi kullanılabilir. ANCI C uyumlu
derleyiciler 31 karaktere kadar tanımlayıcı kabul ederler fakat
tanımlayıcının ilk sekiz karakterini kullanmayı kendimize alışkanlık
etmeliyiz. Dikkat etmemiz gereken özelliklerden biri de kullandığımız
ifadelerdeki büyük küçük harflerdir. C ve C++ büyük ve küçük harf
duyarlılığına sahiptir. Kullandığımız ifadeleri birbirinden farklı ve
aynı ifade olarak kullanıyorsak programımız hata verecektir. Bunu bir
örnekle anlatayım:
Program
PROGRAM
progRAM
ProgRam Bu şekilde tanımlarsak hepsi birbirinden farklı ifadeler olarak
C++ da okunacaktır. Biz Şunu alışkanlık edinmeliyiz;
tanımlayıcılarımızın baş harfi büyük olacak. Büyük ve küçük harf
kombinasyonlarının kullanılması ile önceden yapılan tanımlamalar bazen
işi zorlaştırabilir. Eğer bu değişkenlerden birini kullanmak
isterseniz, bu zamana kadar nasıl tanımladığınızı bilmeniz gerekir.
Örneğin printf()`in PRINTF() olarak çağrılması durumunda " bilinmeyen
tanımlayıcı " (Unknown identifier) hata mesajı vererek sizi uyarır.
Buna benzer olarak %f ve %F kullanımı hata verdirecektir. Programlamayı
yaparken bunlara dikkat etmemiz gerekecek. Çünkü bir değişkeni veya
tanımlayıcıyı başta nasıl kullandıysanız üç, dört sayfa kod yazdıktan
sonrada aynı şekliyle kullanmak zorundasınızdır. İşte burada en büyük
handikap yaşanacaktır. Çünkü C/C++ derleyicileri her zaman hatanın
nerde olduğunu göstermez. Bunu programcı kendisi satır satır takip
ederek bulacaktır. Bundan dolayı bu söylediklerime baştan dikkat
etmemiz gerekiyor.
Tavsiyeler:

İyi bir programlama yapabilmek için benim size olan tavsiyelerim;
daha az kod kullanarak daha çok işlem yapabilme. Gerçi bunu yapsak
zaten profesyonel oluruz .
Zaten C++ `ın paradigması da buradan geliyor. Aslında C++ da
yapabileceğimiz tüm programları C de yapma olanağımız var ama bu bize
hem fazla kod yazmayı gerektirecek hem de zaman kaybetmemize sebep
olacak. Zaten bunlardan kaçındığımız için C++ diyoruz. Elimizde nesneye
yönelik bir dil varken ve kullanacağımız fonksiyonlar içinde hazır
olarak mevcutsa, tabi bize de bunun keyfini sürmek kalıyor.
Tavsiyelerimden biride derslerde verdiğimiz örneklerin dışında aynı
algoritmaya benzer farklı örnekler yapın. Öğrenmenin en iyi yolu yanlış
yapmaktır. Bunu şöyle izah edeyim: eğer yanlış yapıyorsanız ve de o
yanlışın kaynağını bulup düzeltebiliyorsanız, o an onu öğrenmişsiniz
demektir. Tabi örnekler sizin için alıştırma olacaktır ve hafızanızda
kalıcı bir yer tutacaktır. Bunca kodu başka türlü hafızada tutamayız.
İlk başlarda sık sık not alınız, mümkün olduğunca da bol örnek yapınız.
Örneklerinizi de kendiniz düşünüp kendi hayal gücünüzle oluşturursanız
eminim bu işi başaracaksınızdır. Başta çok zor gelebilir ama başarı ter
dökülmeden olmaz. Bu kısmı fazla uzatıp sizi daha başlamadan C/C++ dan
uzaklaştırmak istemiyorum.

[Admin]

C++ İle Programlamaya Giriş

İlk programımız!

// ilk1.cpp
// Ekrana "Bu benim ilk programım" yazdırıyoruz
#include <iostream.h>

int main()
{
cout << "Bu benim ilk programım";

return 0;
} Şimdi Yazdığımız programı inceleyelim:
"//" işaretini açıklama satırlarında kullanıyoruz. C++ derleyicisi bu
notasyonla başlayan satırı okumaz. Bununla birlikte daha uzun
cümlelerimiz olursa bunları da " /* */ " notasyonunun içinde yazıcağız.
Bu özellik de C den bize kalma. Demiştik zaten C `nin tüm özelliklerini
C++ içerir. Fakat biz genelde " // " yi kullanacağız.
#include <iostream.h> : Bu bizim C++ da bulunan kütüphane
dosyamızı çağırmaya yarıyor. Ben size şöyle tarif edeyim. iostream.h
kütüphanesindeki hazır olan " cout " fonksiyonunu çağırıyor. Yani buda
bizim fazla kod yazmamıza engel oluyor. .h ile biten dosyalar kütüphane
dosyalarıdır. Bunu şuna da benzetebiliriz. Farz edelim ki elimizde bir
alet çantası var içinden tornavidayı çağırdığımızda vida sıkacağızdır.
Bu da ona benziyor. C++ da ki hazır kütüphanelerde bir çok hazır
fonksiyonlar vardır. İlerde Bu hazır fonksiyonlar işimizi görmemeye
başlayınca kendi kütüphanemizi yapmaya başlayacağız. Tabi bu seviyeye
geldiğimizde olayı hemen hemen kavramış olacağız, tabi neden olmasın
öyle değil mi?
Daha sonraki satır her C++ programında mutlaka bulunması gereken bir
satırdır. Her C++ programında main() fonksiyonu olmak zorundadır; bu
fonksiyonumuzun önünde ise o fonksiyonun dönderdiği değişkenin veri
tipi olmalıdır. Tabi ki C++ fonksiyonlar ve onların dönderdikleri
değerler konusunu da ileride işleyeceğiz.
Bir sonraki satırda ise; C++ fonksiyonlar ve kod blokları " { } "
parantezleri arasında bulunmalıdır. main de bir fonksiyon ise onun
içindeki kodlar doğal olarak { } parantezleri arasındadır.
Program derlenip çalıştırıldığında ise ( Turbo C++ 3.1 kullanıyorsanız
ctrl+f9 kısa yoluyla programı çalıştırabilirsiniz (Run) ) karşımıza "Bu
benim ilk programım" yazısı çıkacaktır. İşte bu yazıyı ekrana veren
komut da iostream.h kütüphanesindeki cout fonksiyonudur.
Önemli bir nokta ise C++ dilinde her satır ifadenin sonuna " ; " koymak
zorundayız. Bundan farklı olarak #include satırlarının ve bir kaç
farklı satırın arkasına " ; " gelmez. Bunları ileride göreceğiz.
Return 0 : programımızın (aynı zamanda main fonksiyonumuzun) çıkış
noktasıdır. Eğer return ile 0 değeri dönderirsek programımızın güvenle
çıktığını işletim sistemine bildirmiş oluruz. Bu sayede güvenle
programımızın çalıştığını göreceğiz.
Şimdi size bir örnek daha vereceğim bununla da aynı çıktıyı elde
edeceğiz. Arasındaki farkları eminim basit olarak sizlerde
göreceksinizdir.
// ilk2.cpp
// Ekrana "Bu benim ilk programım" yazdırıyoruz
#include <stdio.h>
main()
{
printf("Selam bu benim ilk programım.\n");
return 0;
} Evet şimdi burada çok fark varmış gibi gözüküyor aslında ama öyle
değil. Sadece kütüphanemiz stdio.h oldu ve ekrana yazdır
fonksiyonumuzda printf oldu. Bu özellik C den kalma. Bunlar diğer
program ile aynı işlevi görüyor. Buradaki fark " \n " notasyonu. Bu
noptasyon bir sonraki satıra geçmek için kullanılır. Bu notasyonlara
Escape dizileri denir. Tablo olarak bunları size veriyorum. Son
yazdığımız ilk2.cpp de yerlerine koyarsanız çalışacaktır.


Şu an bunları bilmeniz yeterli.

[Admin]

Değişkenler

Şimdi bize yine çok lazım olacak bir özellik de değişken
tanımlamak ve atama yapmaktır. Bunu bir örnek üzerinde anlatmak
istiyorum. Örneğimiz;
// degisken.cpp
// Burda değişken tanımlamayı göreceğiz.
// Aynı zamanda verilen bir sayıyı kendisi ile carpma 2.2=4 gibi

#include <iostream.h>
#include <stdio.h> // kütüphane dosyamız
main()
{
int i; // Değişken tanımlama
cout << "Bir sayı giriniz: ";
cin >> i;
i=i*i;
cout << "sonuc: " << i ;
return 0;
} Burada bundan önce yaptığımız programlardan farklı olarak int i kullandık, yani değişken tanımladık.
Değişken Nasıl Tanımlanır?

Değişkenleri tanımlamak için aşağıdaki şema kullanılır.
[Veri Tipi] [Değişken Adı];
Örneğin
int sayi;
Şimdi degisken.cpp örneğindeki int i; kısmını anlamışsınızdır. Burada
değişkenlere değinmek istiyorum. Biz yukarda İçinde sayı tutan bir
değişkeni tanımladık. Benzer olarak aşağıdaki tanımlamalar da vardır.
char c;
int i;
float f;
double d;
unsigned int ui;
Burada [Veri Tipi] [Değişken Adı]; bu kalıba göre tanımlama yaptığımız için önce Veri Tiplerini inceleyelim.

[Admin]

Veri Tipleri


1) İnt tip.

Integer = Tamsayı

Tamsayıları içerir. Bellekte 2 Byte tutar. DOS'ta ve Win3.1'de 16 bit
uzunlugunda ama Windows9x, WinNT, Win200 ve WinXP 32 bit
uzunluğundadır.
Değer aralıkları Short ve long için değişir.
Örnek: 5, -20, 1 gibi.

2) Sort tip.

Tam sayıları içerir. 16 bit uzunluğundadır.
signed: -32768 ile +32767 arasinda değer alır, unsigned: 0 ile 65535 arasinda değer alır.
3) Long tip.

Tam sayılar içerir. 32 bit uzunluğundadır.
signed: -2147483648 ile +2177483647 arasinda değer alır, unsigned: 0 ile 65535 arasinda değer alır.
4) Gerçel Tipler (Float, Double, Long double)

Gerçel sayıları içerirler.
float : Bellekte 4 Byte yer tutar. 3.4E-38 ile 3.4E+38 aralığında değer alır. Hassasiyet 7-8 basamaktır.
double : Bellekte 8 Byte ter tutar. 1.7E-308 ile 1.7E308 aralığında değer alır. Hassasiyet 15-16 basamaktır.
long double : doublenin tipinin daha genişidir.1.2E-4932 ile 1.2E-4932 aralığında değer alır. Hassasiyet 19-20 basamak.
5) Char Tip

Char : Karakter
Alfanumerik karakterleri içerir. Ve ya 8 bit uzunluğunda tamsayı.
signed: -128 ile 127 arasinda değer alır, unsigned: 0 ile 255 arasında değer alır.
Örneğin: ' 0,1,2,3,4,5,6,7,... ' , ' *,-,+,... ' , 'a,b,c,....,A,B,C,D,,,,, '
6) Bool tip.

true(dogru) = 1 veya false(yanlis) = 0 değerini alır. Eski
derleyiciler bu türü desteklemeyebilir. Yeni ANSI C++ standardında
eklenmiştir. Bu soyut matematik gördüyseniz. "p V q" ya benzer ( matematikçiyiz, konuşturalım azıcık). Değer aralığı ise ya 1 dir (doğru) yada 0 dır (yanlış).
7) Enum tip.

enum sıralanmış değerleri tutar. Short int ile aynı değeri taşır.
Başta Fazla Detaya inip sizi bunaltmak istemiyorum. Çünkü C++ dili
başlarda karmaşık gelen bir dildir. Bu da zaten kendisini yüksek
seviyeli bir dil yapıyor . Ben size Bu dilin temel özelliklerini anlatarak basit programlar yapmayı göstereceğim.
Bu temel bilgileri aldıktan sonra programlamaya geçebiliriz. Derleyici
Olarak ben Turbo C++ 3.1 i tavsiye ederim. Şu an bununla başlar iseniz
işiniz daha kolay olacaktır (bence). İlerde Borland a geçeceğiz.
Değişken tanımlama konusunda bir konuya daha değinmek istiyorum.
Değişkenlere değer atama ve aynı anda bir çok değişken tanımlamamız C++
da mümkündür.
char c = 'c';
int i = 5;
Daha sonradan değer atama:
char c;
int i;
c = 'c ';
i = 5;
Bir de aynı anda bir çok değişken tanımlayalım.
Örneğin:
int x , y , z;
x = y = z = 5;
x,y,z' nın değeri 5 oldu
Bir sonraki derste ise değişkenlerle birlikte bir de Operatörleri ele alacağız.











__________________

[Admin]

Operatörler I


Operatör ve Operand nedir?

Bunu bir örnek üzerinde anlatmak istiyorum. Örneğin; x + y 'de x
ve y operand + ise operatördür. Bu bir aritmetiksel operatördür.
Matematikte işlemler operatörler ve operandlar ile anlatılır.
Operatörleri öncelikle türlerine göre ayıralım:
1) Aritmetiksel operatörler + , - , * , / , % , ++ , --
2) Karşılaştırma operatörleri < , > , <=, >= , ==, !=
3) Eşitleme operatörleri = , += , -=, *= , /= , %= , <=, >>=, &=, != , ^=
4) Mantıksal Operatörler ! , || , &&
5) Bit bazında işlem yapan operatörler & , ! , ^ , ~ ,
Aritmetiksel (Matematiksel) Operatörler:

Matematiksel ifadeleri günlük hayattaki biçimde bilgisayarda
yazamadığımız için belli kurallara uymamız gerekir. Bu kısım önemli
olduğu için biraz geniş yer vereceğim. Kullandığımız matematiksel
işlemler ve anlamları şöyledir:


















Bu operatörle verilen iki veya daha fazla operand toplanabilir. Yazılış şekli Aşağıdaki gibidir.
değişken1 + değişken2
Eğer bu iki değişkeni Sonuç gibi başka bir değişkene atarsak eşitleme operatörüyle aşağıdaki gibi yaparız.
Sonuç = değişken1 + değişken2
Buna bir örnek verelim.
// toplama.cpp
//Vize ve final notlarinindan geçme notunu hesaplama

#include <iostream.h>
#include <math.h>

main()
{
int vize, final, ort;
vize = 10;
final = 80;
ort = vize * 0.4 + final * 0.6;
cout<< "Geçme notunuz: " << ort;
} Burada çarpma operatörünü de kullandık sanırım, artık diğerlerinin de
ne olduğunu kavramış oldunuz. Bir örnekte işi ucuza getirdim . Fakat bir artma ve bir azalmaya örnek verelim. Bu bana çok lazım olmuştu.
Burada dikkat etmemiz gereken olay " ++ " operatörünü değişkenin önüne
yazmanız gerektiğidir. Bu sayede değişken bir arttırılarak işleme
konur. Arkasına konursa değişken işlenir, sonra bir arttırılır. " -- "
operatöründe ise aynı şekilde de bir azaltma yapılır.
// carpim.cpp
// x i bir arttırıp y yi bir azaltıp çarptık.

#include <iostream.h>

main()
{
int x = 5;
int y = 10;
cout << "x = " <<x << endl;
cout << "y = " << y << endl;

cout <<"++x * --y = " << ++x * --y ;

} İşte bir fark daha yakaladık bunu da hemen örnek üzerinde
anlatalım. Sanırım buraya kadar geldiğimiz yerlerde int i , çarpma
işlemini, bir arttırıp azaltmayı gördük, ama diyeceksiniz ki " endl "
ne oluyor? Hemen açıklayayım; Satır sonunu belirterek yeni satıra
geçmemizi sağlar, bir nevi " \n " Escape operatörü gibi bir işleve
sahiptir.

[Admin]

Operatörler II


Karşılaştırma Operatörleri:


Bunların teker teker ne olduğunu söylemeye gerek yok. İfadeler gayet
basittir. Burada dikkat etmemiz gereken önemli bir şey var: " >=,
<=, ==, !=" notasyonlarını kullanırken iki notasyon arasında boşluk
bırakmamalıyız. Buna dikkat edelim!
Eşitleme ( Atama) Operatörleri:

Bunlarıda liste halinda verelim.

[Admin]

Operatörler III


Mantıksal Operatörler (Lojik Operatör Sembolleri) :



Burası biraz Soyut Matematik, biraz değinmek istiyorum. Yukarıda
gördüğümüz mantıksal operatörler, Doğru (1) yada Yanlış (0) sonucunu
argümanlara bakarak üretirler. Mantıksal Değil (!), değeri tersine
çevirir. Ve ( && ) operatörü ise yalnızca her iki ifadede Doğru
(1) ise sonuç Doğru (1) ` dur; diğer durumlarda Yanlış (0)` dır. Veya`
da ( || ) ise yalnızca iki ifadenin Yanlış (0) durumunda sonuç Yanlış
(0) olur diğer durumlarda Doğru (1)`dur.
Ne diyorlardı? En iyi programcılar matematikçilerden çıkar .
Arkadaşlar umarım zorlanmıyorsunuzdur. Olabildiğince ince eliyorum ve
anlayacağınız şekle indirgemeye çalışıyorum. Bunun üstüne bir çay
içerim. Geldiğimde devam edeceğim...
Bit bazında İşlem Yapan Operatörler :

Bu kısımda Soyut Matematiğin daha da ayrıntılarına girilmesi
gerekiyor. Ben size kısaca bunu anlatayım. Çok karışıklık da sizi
yoracaktır. Örnekleri yaparken yine üstünde dururuz.
Bit bazında işlem yapan operatörler şunlardır: AND (Ve ( & ) , OR (Veya ( ~ )), XOR ( ^ ).
And (&) operatörü; bitleri karşılaştırır. Eğer her ikisi de Doğru (1) ise sonuç Doğru (1), aksi halde Yanlış (0)`dır.
OR (~) operatörü; iki biti karşılaştırır ve eğer ikisi de Doğru (1) ise
yada birisi Doğru (1) ise sonucu Doğru (1) yapar. OR işlemi belirli bir
bit i Doğru (1) e çekmek için kullanılabilir.
XOR (^) operatörü; bit düzeyinde EXCLUSIVE OR (dışında tutan veya)
(Türkçe'sini çevirince saçma oluyor) işlemi yalnızca karşılaştırılan
bitler bir birinden farklı ise Doğru (1) üretir, aksi halde Yanlış (0)
üretir.
! işareti ise her bir bit i ters çevirir.
Not: Bunlar yeni başlayanlar için yorucu olabilir. Son iki bölümün fazla üstünde durmayın
< Bir de bize C++ile gelmiş olan operatörlerden bahsetmek istiyorum. Bunlar;
" :: " Erim çözünürlüğü (Scope resolution operatörü).
" * " Dolaylı adresleme (Pointerlerle kullanacağız).
" & " Adres operatörü (Pointerlerle kullanacağız).
" new " Dinamik bellek ayırma .
" sizeof " Nesne Boyutu.
İlerde fonksiyonlara geçince, bunları ve diğerlerini de göreceğiz. Şu an için sizi bunlarla yormak istemiyorum.

[Admin]

Program Kontrol ve Döngü Komutları


Daha önceki bölümlerde, standart veri tiplerini öğrendik, bununla
birlikte diğer dillerde olmayan fakat C/C++`a özgü işlemleri de
tanıdık. Şimdi ise C/C++ mantıksal kontrol yapılarını öğreneceğiz. Bu
komutların bir çoğu diğer yüksek seviyeli dillerde de mevcuttur.
Örneğin; if, if-else, switch, for, while ve do-while döngüleri. Fakat ?:, break, ve continue
komutları gibi yalnızca C/C++`a özgü kontrol komutları da vardır. Ne
demiştik C++ , C yi kapsar. O halde C de olan tüm mantıksal kontrol
yapıları C++ da da mevcuttur.
Programlar (algoritmalar) üç temel
blok kullanılarak gerçekleştirilebilirler. Bunlar; artarda, bir koşula
bağlı olarak ve sonlu sayıda yineleme (döngü) dür.
Biz şimdi bu Mantıksal ifadeleri teker teker ele alacağız. Hem Bu
sayede hepsine daha çok yer vermiş olacağız ve de örneklerle bunu
pekiştireceğiz. Şimdiye kadar geldiğimiz bölümleri iyi bilip, Mantıksal
ifadelerin yapılarını da öğrendiğimizde, bayağı bir yol kat etmiş
olacağız.

[Admin]

If Komutu


if komutu anlaşılması ve yazılımı en basit olanıdır. if
komutu, bir grup komutun koşullu olarak yürütülmesi amacıyla
kullanılır. Buna bir örnek verecek olursak; düşünün ki bir sınav
yapılıyor ve 50 ve üzeri alanlar geçecek. Bunun için if i kullanırsak not 50 ye eşit veya büyükse (büyük eşit) geçer not olacak.
http://not.cpp
// 50 ve 50 den yukarsı geçiyor.
#include <iostream.h>

main()
{
int not;
cout << "Notu yazınız:";
cin >> not;

if ( not >= 50 )
cout << "Geçtiniz!";

} Sanırım bu örnekte ne dediğimi anlamış olacaksınız.
if ( not >= 50 )
cout << "Geçtiniz!";

if (ifade)
{
Komut;
Komut;
...
} Burda görüldüğü gibi if
(ifade) ve sonraki komutlarda { } bloğunun içine yazılır. Şimdi if`e
bir de şu açıdan yaklaşalım. if in kelime anlamı "eğer" dir. Mantık
şudur: eğer belirtilen parametre doğruysa, if komutu, if ten sonra
gelen bloktaki fonksiyonları gerçekleştirir. Doğru değilse, if den
sonraki bloğu yok sayar. Burada bir detaya daha inmek istiyorum. Ne
demiştik, mantık işlemlerinde olay ya doğrudur (1) ya da yanlıştır (0).
Şimdi yukarıdaki if in genel kullanım şekline tekrar bakalım. Bunu,
eğer parametre doğru ise kullanabiliriz. Bir de bunun tersini
düşünelim. Bit bazında işlemlerde sanırım ( ! ) bunu görmüştük. Her bir
biti ters çevirir.
if (!ifade)
{
komut (yanlış (0));
Komut (yanlış (0));
....
} Derdimi anlamış olduğunuzu ümit ediyorum .
Ama bence buranın üstünde biraz daha duralım. Çünkü bunu anlarsak
diğerlerinde zorlanmayız. Son yaptığımızda ifadeyi tersine çevirdik.

http://pozitif.cpp
// Bunada açıklama yaptırmayın ( yapamadımda)
#include <iostream.h>
main()
{
int x;
cout << "Bir sayı girin:" ;
cin>> x;
if ( x > 0 )
cout << "Pozitif" ;
} Aynısının negatif ini de siz yapın. Şimdi bir de iç içe if örneğine bakalım:
http://gecti.cpp
// Buna açıklama yapmıycam!
#include <iostream.h>
main()
{
int not;
cout << "Notunuzu giriniz:";
cin >> not;
if ( not> 50)
cout << "Geçtiniz!" ;
if (not < 50)
cout << "Kaldınız!" ;
if ( not==50)
cout << "zar zor geçtin ";
} Anlamış olduğunuzu umut ederek if komutunu burada bitiriyorum.











__________________

[Admin]

If-else Komutları


if-else komutu iki işlemden hangisinin uygulanacağına karar verir. Else kısmı seçimlidir, gerekmiyorsa kullanılmayabilir. Yazılım kuralı ile şöyledir;
if ( ifade)
komut1;
else
komut2; daha genel şekliyle
if ( ifade )
{
komut1;
komut2;
...
}
else
{
komut1;
komut2;
...
} Veya lojik olarak baktığımızda sanırım daha iyi anlayacaksınız
if (ifade)
blok_dogru (1);
else
blok_yanlis (0); Sanırım artık açıklama yapmama gerek kalmayacak. Şimdi örneklerle bunu pekiştirmeye çalışalım.
http://tekcift.cpp
//sayı tekmi çiftmi onu görüceğiz
#include <iostream.h>
main()
{
int sayi;
cout<< "Bir sayı giriniz:";
cin >> sayi;
if (sayi %2==1 )
cout <<"tek";
else
cout << "çift" ;
} Bir örnek daha verelim:
http://ifelse.cpp
#include <iostream.h>
main()
{
int not;
cout<< "Notu giriniz:";
cin >> not;
if (not >= 50)
cout << "Geçti!";
else
cout << "Kaldı!";
} if kısmından anlatmaya başlayacağım. Eğer notumuz 50 ye eşit veya 50 den büyük ise geçiyoruz aksi halde kalıyoruz.
Bir de bir if-else in altında bir tane daha if-else kullanalım.
http://sinav.cpp
// alt alta if-else
#include <iostream.h>
main()
{
int not;
cout<< "Not`u giriniz:";
cin >> not;
if (not >= 50)
cout << "Geçtiniz!";
else
{
cout <<"Bütten alınan not:";
cin >>not;
if( not>=60 )
cout << "Geçtiniz!";
else
cout <<"Kaldınız!";

}
} Burada da şunu inceledik: diyelim ki sınava girdik ve
notumuzu öğrendik, notu giriyoruz 50 nin altındaysa kalıyoruz. ve
bütünleme sınavına giriyoruz. Bütte de geçer not en az 60. Sanırım bu
basit örneklerle olayı iyice kavramışızdır. if-else i de burada
bitiriyoruz.

[Admin]

?: Komutu


Bu komut, yalnızca C++ a özgüdür. Kendine özgü bir yazılımı ve
mantıksal kullanımı vardır. if-else komutunun kısaltılmışıdır. Fakat,
tüm if-else komutları yerine kullanılmaz. Yalnızca karşılaştırma
sonrası, tek komut kullanılan uygulamalar için geçerlidir. Bu
söylediklerimizi örnek üstünde gösterelim:
http://tekcift.cpp
http://tekcift.cpp yi bu sefer ?: ile yapıyoruz
#include <iostream.h>
main()
{
int sayi;
cout<< "Bir sayı giriniz:";
cin >> sayi;
cout << (sayi %2==1 ? "tek" : "çift") ;
} Kullanış biçimi: cout << (sayi %2==1 ? "tek" : "çift") ; çok basit ama dikkat edelim. Her zaman kullanmıyoruz.

[Admin]

Switch-case Komutları


Switch Case deyimi işlev bakımından if deyimine çok benzemektedir.
Çok sayıda if işlem blokları kullandığımızda programın okunurluğu
azalacak ve programı izlemek zorlaşacaktır. Programımızın bir değerini
bir çok değerle karşılaştırmak gerektiğinde switch komutunu
kullanacağız. Switch seçeneği ile değişkenin durumuna göre bir çok
durum içersinden bir tanesi gerçekleştirilir. İstersek de if deyimi ile
switch case' yi birlikte kullanabiliriz. Switch in yaptığı iş kısaca,
ifadenin değerini sırayla sabitlerle karşılaştırarak ve her satırı
işlemektir.
switch( Kontrol Değişkeni )
{
case Sabit1 : komut1;
case Sabit2 : komut2;
.
.
.
default : Komutson;
} Buna en basit örneğimizi verelim

http://switch.cpp
// switch-case yi öğreniyoruz.

#include <iostream.h>

main()
{
int i;
cout<< " 1 ile 4 arası sir sayı giriniz:";
cin>>i;
switch(i)
{

case 1 :cout<<"1 Girdiniz"; break;
case 2 :cout<<"2 Girdiniz"; break;
case 3 :cout<<"3 Girdiniz"; break;
case 4 :cout<<"4 Girdiniz"; break;

default:cout<<"1 ile 4 ten farklı";
}
} Burada gördüğümüz gibi i değişkenine bağlı olarak program işliyor.
Case'lerinin aldığı değere göre kendinden sonra gelen komutları
işliyorlar. Burada daha önce görmediğimiz break komutunu gördük. Buna
ilerde daha detaylı olarak değineceğim. Fakat biraz bahsetmek
istiyorum. Programımızda değişkene 1 değerini verdiğimizi farz edelim.
Case 1 adlı satırı geçip ondan sonraki komut dizisini işleme soktuk. Bu
işlemin tamamlanması için break komutu kullanılıyor. Yazılımda break
komutu goto gibi işlev görür ve derleyiciye switch komutundan çıkması
için talimat verir. Sorunu ortadan kaldırmak için her durum için break
deyimi eklemeliyiz (tavsiye). Ne demiştik; bir çok karşılaştırma
olduğunda switch'e ihtiyaç duyuyoruz. Karşılaştırmaların hiç biri
olmadığı anda da ortaya default tan sonraki satırın işlenmesi kalıyor.
Sanırım bu örnekte basit olarak anlamış olacağız.
Daha karmaşık bir örnek verecek olursak:
http://ucgen.cpp
// Program gireceğimiz ölçülere göre üçgenin Alan, Yükseklik ve Tabanını bulur
// switch-case örneğimiz.

#include <iostream.h>

int main()
{
char secenek;
float alan, yukseklik, taban;

cout << "Program gireceğimiz ölçülere göre üçgen'in Alan,
Yükseklik ve Tabanını bulur!\n" << endl
<< " A ---> Alan : Bulmak için yükseklik ve tabanı gireceğiz:" << endl
<< " h ---> Yükseklik : Bulmak için alan ve tabanı gireceğiz:" << endl
<< " t ---> Taban : Bulmak için alan ve yüksekliği gireceğiz:" << endl
<< endl << endl;
cout<< "Seçeneğiniz? ---> A, h, t :";
cin>> secenek;

switch(secenek)
{
case 'a':

case 'A':
{
cout<< endl <<endl <<"Yükseklik: ";
cin>> yukseklik;
cout<<endl << "Taban: ";
cin >> taban;

alan = 0.5 * taban * yukseklik;

cout<<endl << endl << "Alanı: " << alan << endl;

break;
}

case 'h':
case 'H':
{
cout<< endl << endl <<"Alanı: ";
cin>> alan;
cout<<endl << "Tanabı: ";
cin >> taban;

yukseklik = 2.0 * alan / taban;

cout << endl << endl << "Yükselik: " << yukseklik << endl;
break;
}

case 't':
case 'T':
{
cout << endl <<endl <<"Alanı: ";
cin >> alan;
cout << endl << "Yüksekliği: ";
cin >> yukseklik;

taban = 2.0 * yukseklik / alan;

cout << endl << endl <<"Tabanı: " << taban << endl;
break;
}
}
return 0;
} Gayet basit bir örnek değişkenleri tanımladık. Caseleri koyduk ve
caselerden sonra gelecek komut satırlarını yerleştirdik. Bu program
göründüğü gibi zor değildir.











__________________

[Admin]

Döngü Komutları


Bir ya da birden fazla deyimin tekrar edilmesini sağlarlar.
Döngüler, " belli bir koşul sağlandığı sürece sürekli çalıştırılacak
kod parçası " olarak nitelendirilebilir. For döngüsü, while döngüsü,
do-while döngüleri, diğer yüksek seviyeli dillerdeki gibidir. Ancak en
büyük fark, programın bu tekrar döngüleri istediğinde terk
edebilmesidir. C/C++, döngüden çıkmak için beş ayrı yöntem vardır.


C/C++ da ki döngülerin arasındaki fark, beklenen döngü sayıları
arasındaki farktan kaynaklanır. Eğer önceden belirli bir döngü sayımız
mevcut ise For döngüsü kullanılır. while ve do-while döngülerinde döngü
sayısı belli değildir. C++ nın bize vermiş olduğu esneklik sayesinde,
döngüleri son derece esnek bir biçimde kullanma şansımız vardır.

[Admin]

While Döngüsü


İçlerinde anlatımı ve anlaşılması en kolay olan döngüdür. While
döngüsü, döngü sayısının belli olmadığı zamanlarda kullanılır.
while ( koşul )
Komut; While döngüsü, içinde bulunan ifade doğru olduğu sürece
altındaki komut veya komut bloğu yürütülür. Eğer yanlış ise kontrol bir
sonraki komut veya komut bloğuna geçer.
While döngüsü daha genel şekliyle:

while ( ifade )
{
komut;
komut;
komut;
.
.
.
} Burada bir şeye dikkat etmenizi istiyorum. Çoklu komutlar kullandığımızda " { } "parantezleri gereklidir.
// while1.cpp
// while döngüsünü kullandık
// girdiğimiz sayıdan 100 e kadar olan sayıları topladık

#include <iostream.h>

main()
{
int x, y;
y= 0;
cout<< " Bir Sayı Giriniz ( Sayı 100 den küçük olucak ) : ";
cin>>x;
while (x< 101)
{

y =y+x;
x =x+1;


}

cout<< "Toplam= "<< y;
} Burada önce x ve y
yi tanımladık. y=0 değerini verdik. Sonra klavyeden girilen değerin x
olduğunu yazdık. while (x< 101) işte burada ifademiz x< 101.
Şimdi bu koşul sağlanıncaya kadar döngümüz devam edecek. While' den
sonraki bloğa geçtiğimizde ise. y` ye x i ekliyoruz ve x in değerini
her seferinde 1 arttırıyoruz. Sanırım bu basit örnekte döngünün basit
yapısını ve mantığını anlamış oldunuz.
Döngünün verilen ifade veya koşula göre sağlanması döngülerin en önemli
konusudur. Eğer bir döngüden çıkılmazsa o döngü sonsuza gider. Buna da
"sonsuz döngü" denir. Döngüler konusunda en çok rastlayacağımız hata da
budur.Şimdi buna bir örnek verelim. Fakat, şimdiden uyarıyorum, sonsuz
döngü yapıldığında bilgisayarınız kilitlenebilir. Onun için buna
şimdiden hazır olun. Zaten bir sefer denediğimizde ne demek istediğimi
anlayacaksınızdır.
http://sonsuz.cpp
//while döngüsü ile sonsuz bir döngü yaptık

#include <iostream.h>

main()
{
int x=1;
while(x)

cout<< "x= "<< x++<< endl;

}
Burada neden sonsuz bir döngü oldu? Evet işte x ifadesini koşula
bağlamadık. Şayet while(x<10) demiş olsaydık. 1,2,3,4,5,6,7,8,9 a
kadar x sayısı sıralanacaktı.
http://klavye.cpp
//while döngüsü ile klavyeden girilen sayı

#include <iostream.h>

main()
{
int x, y = 0;

while (y< 20)
{
cin>>x;
y = y+x;
}
cout<< "Toplam= "<< y ;
} Bu programda da klavyeden girilen sayıların toplamı 20' den büyük
olunca program Toplam olarak söylüyor. Sanırım basit While yapısını
anladınız. Şimdi birazda karmaşık programcıklar yapalım.
1. Örnek: Girilen altı not'un ortalamasını alıyor.
http://ortalama.cpp
// while döngüsü ile girilen notların ortalamasını aldık.


#include <iostream.h>

int main()
{
int toplam,
sayac,
not,
ortalama;

toplam = 0;
sayac = 1;

while ( sayac <= 6 )
{
cout << "Notu giriniz: ";
cin >>not;
toplam = toplam + not;
sayac = sayac + 1;
}

ortalama = toplam / 6;
cout << "Sınıf ortalaması = " << ortalama << endl;

return 0;

} Bu örneğimizde yine toplam, sayac, not, ortalama gibi değişkenleri
tanımladık. ( toplam =0 ; ve sayac = 1; ) de değişkenlere ilk
değerlerini atadık. While döngüsünün içinde sayac değişkenimizi altı
defa işlemesini söyledik. Sonra alttaki toplam ve sayac bölümlerinde
ise toplam a not' u ekliyoruz, her seferinde de sayac değerini bir
arttırıyoruz ve sayac değeri 6' ya gelince while döngümüz duruyor.
Program sonra toplamı alıp altıya böler bu sayede ortalamayı alır,
sonrada çıktısını gerçekleştirir.
2. Örnek:
http://faktoriyel.cpp
// while ile faktoriyel hesaplama

#include <iostream.h>
int main()
{
int sayi;
long int faktoriyel=1;
cout << "Bir sayı giriniz: ";
cin >> sayi;
cout << sayi << " `in Faktöriyeli: ";
while (sayi > 1)
faktoriyel *= sayi--;

cout << faktoriyel << endl;
return 0;
} Burda while (sayi>1) şeklinde koşulumuzu belirttik. Bir altında
ise faktoriyel *= sayi--; evet burda da daha önce gördüğümüz gibi
eşitleme operatörü olan ( *= ) i kullandık. Yani faktoriyel'e
faktoriyel*sayi-- nin değeri atanır. Matematiğini düşünürseniz; 7
sayısının faktöriyeli 7 *= 7-- gibi. yani 7 ye devamlı 7-- oda 6
demektir. 6 ile carpımı eklenir, bu 6-- ile devam eder. En basit
anlatımı bu
Sonrada tüm while döngüsü bittikten sonrada faktoriyel' in sonucu çıktı
olarak ekrana gelir. Bu örnekte negatif sayıların faktöriyelini de 1'e
eşit tutuyor. Dikkat ediniz. Negatif sayıların faktöriyeli alınmaz
şartını koymadık. Şayet siz koymak isterseniz bir if else bloğu
yerleştirmelisiniz if(sayi>=0) faktoriyel al yoksa faktoriyel alma
gibi.
3. Örnek:
// maas.cpp
// while if-else ile bir maas vergi uygulaması


#include <iostream.h>

int main( )
{
unsigned long maas, net, vergi = 0.0; // maas net vergi bunları tanımladık

cout<< "Lütfen maaşınızı giriniz: "; // maası giriyoruz
cin>> maas; // maası programa alıyoruz

while( maas >= 0.0 ) // maaşın koşlunu yazıyorus döngüye
{
if( maas <= 250000000 ) // maaş 250 milyondan az ise
vergi = 0.0;
else // vergi yok
if( maas < 500000000 ) // maas 500 den az ise
vergi = maas * 0.10; // vergi %10
else // 500 den fazla ise
vergi = maas * 0.20; // vergi %20

net = maas - vergi; // net maaşımız vergi düşünce çıkar
cout<< "Ödenmesi Gereken vergi " << vergi << endl; // vergi ekranda
cout<< "Net maaşınız: " << net << endl; // geriye kalan maaşımız


cout<< "Lütfen maaşınızı giriniz: "; // bir dahaki ayki yeni maaşımız
cin>> maas; // maaşı program alıyor

}
return 1;

} Bu örnekte sanırım fazla açıklama yok. Sizden istediğim, üç kişinin
maaşını girdikten sonra onların alacağı toplam maaş ve ödemeleri
gereken toplam vergiyi bulmanız. Bunu yaparsanız buraya kadar
olanlardan bir şeyler anlamışızdır.











__________________
Knisath

[Admin]

Do-while Döngüsü


Do - while Döngüsü:

Bu döngü while döngüsünün biraz değiştirilmiş halidir. Do-while
döngüsünde karşılaştırma işlemi, döngünün sonunda gerçekleşir. Bunun
sonucu olarak döngünün içine en az bir defa girilmiş olur. Yapısı
aşağıdaki gibidir.
do

cümle

while ( koşul ); do' nun altındaki cümle kısmındaki komut satırları
birden fazla olursa diğer döngülerde olduğu gibi " { } " içine
alıyoruz. Bunu kullanmamız kodları okuma da ve ayırma da daha çok
işimize yarayacaktır.
do
{
cümle
cümle
cümle
...
}
while ( koşul ); Şimdi yukarıda demek istediğimizi standart kod satırı
üzerinde anlatalım. Kodları yazdığımızda, komut sırası do'ya geldiği
zaman, do' dan sonraki komutun döngünün başı olduğunu belirtiyor.
Diğerlerinden farklı ( for, While ) olarak döngüye giriş yapıyor, yani
hiçbir kontrol yapmadan en az bir defa döngünün içine girmiş oluyoruz.
While'e geldiğinde ise koşulu kontrol ediyor, eğer doğru ise döngünün
başındaki komuta giderek yeniden komutları işliyor. Eğer koşul kontrolü
yanlış ise while'den bir sonra ki komutu veya komutları işleyip
döngüden çıkıyor. Şimdi bu söylediklerimizi örnek üzerinde gösterelim.
http://do.cpp
// number echoer
//do-while döngüsünü kullandık

#include <iostream.h>

int main ()
{
unsigned long x;
do {
cout<< "Bir sayı giriniz ( Durdurmak için 0 ) : ";
cin>> x;
cout<< "Girdiğiniz sayı: " << x << "\n";
}
while (x != 0);
return 0;
} Örneğimizde de görüldüğü gibi önce do dan sonraki komutlar işleniyor.
Şayet 0 girersek while işlemeye başlıyor. Do-while döngüsü C++ da çok
fazla kullanılmaz bunun yerine biz for' u kullanacağız çünkü for
döngüsü çok daha güçlüdür.

[Admin]

Do-while Döngüsü


Do - while Döngüsü:

Bu döngü while döngüsünün biraz değiştirilmiş halidir. Do-while
döngüsünde karşılaştırma işlemi, döngünün sonunda gerçekleşir. Bunun
sonucu olarak döngünün içine en az bir defa girilmiş olur. Yapısı
aşağıdaki gibidir.
do

cümle

while ( koşul ); do' nun altındaki cümle kısmındaki komut satırları
birden fazla olursa diğer döngülerde olduğu gibi " { } " içine
alıyoruz. Bunu kullanmamız kodları okuma da ve ayırma da daha çok
işimize yarayacaktır.
do
{
cümle
cümle
cümle
...
}
while ( koşul ); Şimdi yukarıda demek istediğimizi standart kod satırı
üzerinde anlatalım. Kodları yazdığımızda, komut sırası do'ya geldiği
zaman, do' dan sonraki komutun döngünün başı olduğunu belirtiyor.
Diğerlerinden farklı ( for, While ) olarak döngüye giriş yapıyor, yani
hiçbir kontrol yapmadan en az bir defa döngünün içine girmiş oluyoruz.
While'e geldiğinde ise koşulu kontrol ediyor, eğer doğru ise döngünün
başındaki komuta giderek yeniden komutları işliyor. Eğer koşul kontrolü
yanlış ise while'den bir sonra ki komutu veya komutları işleyip
döngüden çıkıyor. Şimdi bu söylediklerimizi örnek üzerinde gösterelim.
http://do.cpp
// number echoer
//do-while döngüsünü kullandık

#include <iostream.h>

int main ()
{
unsigned long x;
do {
cout<< "Bir sayı giriniz ( Durdurmak için 0 ) : ";
cin>> x;
cout<< "Girdiğiniz sayı: " << x << "\n";
}
while (x != 0);
return 0;
} Örneğimizde de görüldüğü gibi önce do dan sonraki komutlar işleniyor.
Şayet 0 girersek while işlemeye başlıyor. Do-while döngüsü C++ da çok
fazla kullanılmaz bunun yerine biz for' u kullanacağız çünkü for
döngüsü çok daha güçlüdür.

[Admin]

Break Komutu


Break komutunu, swtich komutundan çıkmak için önceki derslerimizde
görmüştük. Komutun kendine özgü bir kullanımı daha vardır. Break komutu
bir döngünün içinde çalıştırılırsa o an o döngü biter. Bir goto gibi
işlem gördüğünü de söyleyebiliriz. Break kullanınca program döngüyü
bitirir ve döngünün sonundaki satırdan çalışmaya devam eder. Bir örnek
verelim.
http://break.cpp
//break komutunu kullandik.


#include <iostream.h>

main()

{

for (int x = 1; x <= 10; x++) {
if (x == 7) {
break;
}
cout<< x << " ";
}
} İşte örneğimizde gördüğünüz gibi. X 7'ye eşit olunca break; döngüyü
bitiriyor ve döngüden sonraki satırı çalıştırmaya başlıyor.

[Admin]

Continue Komutu


Continue komutu bir döngü içinde çalıştırılırsa , o döngü içinde
bulunan tur sona erer ancak döngü devam eder. Diğer bir deyişle,
gövdenin içinde bulunan continue komutundan sonra gelen cümleleri
atlayarak, döngüyü devam ettirir. Bunu bir örnekle açıklayayım.
http://continue.cpp
//continue ve break komutunu kullandik.


#include <iostream.h>

main()

{

for(int i=0; i <= 9; i++)
{
if(i==5)
break;
cout<<i<< endl;
}


for(int x=0; x <= 9; x++)
{
if(x ==3)
continue;
cout<< x;
}

} Bu örnekte break ve continue'yu birlikte kullandım. Hem continue'yu
hem de break ve continue karışımını bir arada vermiş oluruz diye
düşünüyorum. Örneğimizi inceleyecek olursak. Break olan kısımda
görüleceği gibi 5'e kadar döngü devam ediyor, döngü bitiyor ve ondan
sonraki cümleye geçiliyor. Sonra yine bir for döngüsü başlıyor ve bu
sefer x 3' e eşit olana kadar devam ediyor. 3'e eşit olunca da if
içindeki x==3 koşulunu sınıyor ve continue ye olduğu için bunu atlıyor.
Zaten ekran çıktısını aldığınızda ne demek istediğimi daha rahat
anlayacaksınız.
Benim size tavsiyem break ve continue komutlarını yapmış olduğunuz basit programlarda kullanmanızdır.











__________________

[Admin]

Exit Fonksiyonu


Hayati hata durumlarını ele almak için exit() fonksiyonundan
yararlanılır. Bu hatalar main() fonksiyonunu return ile normal olarak
sonlandırılmadan önce oluşabilir. Exit() fonksiyonu, durum değerini bir
tam sayı parametre olarak döndürür.
Exit() ile özel bir değerin gönderilmesi bazı işlemler yapması için
kullanılabilir. Örneğin program komut satırında kullanılıyorsa ve durum
değeri bazı hataları gösteriyorsa, işletim sistemi bunları mesaj olarak
yazabilir. Exit() fonksiyonu programı sonlandırmanın yanında, tüm
bekleyen yazma işlemlerini tamamlar ve açık tüm dosyaları kapatır.
Exit() fonksiyonunu kullanırken kullanmamız gerek kütüphaneler ise process.h ve stdlib.h tır.






Exit Fonksiyonu


Hayati hata durumlarını ele almak için exit() fonksiyonundan
yararlanılır. Bu hatalar main() fonksiyonunu return ile normal olarak
sonlandırılmadan önce oluşabilir. Exit() fonksiyonu, durum değerini bir
tam sayı parametre olarak döndürür.
Exit() ile özel bir değerin gönderilmesi bazı işlemler yapması için
kullanılabilir. Örneğin program komut satırında kullanılıyorsa ve durum
değeri bazı hataları gösteriyorsa, işletim sistemi bunları mesaj olarak
yazabilir. Exit() fonksiyonu programı sonlandırmanın yanında, tüm
bekleyen yazma işlemlerini tamamlar ve açık tüm dosyaları kapatır.
Exit() fonksiyonunu kullanırken kullanmamız gerek kütüphaneler ise process.h ve stdlib.h tır.

[Admin]

Örnekler 2


7) #include <iostream.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
int idariPersonel=0, yazilimciKadrolu=0, yazilimciProje=0;
double netMaasToplam=0, cesitliKesintiToplam=0, saglikKesintiToplam=0;
//programın en sonunda hesaplayacağı toplamlar.

while(1)
{
cout<<"Personel türü:"<<endl;
cout<<"A-İdari"<<endl;
cout<<"B-Yazılımcı (Kadrolu)"<<endl;
cout<<"C-Yazılımcı (Proje)"<<endl;
cout<<"X-Programdan Çıkış"<<endl;
char tur;
cin>>tur;
tur=toupper(tur);
if(tur=='X') {break;}
switch (tur)
{
case 'A' : {
int saat=0, saatUcreti=0;
const int NORMAL=22*8;
double brut=0, net=0, kesinti=0;
cout<<"Toplam çalışma süresini (saat) giriniz: ";
cin>>saat;
cout<<"Saat ücretini giriniz: ";
cin>>saatUcreti;
brut=(double)(NORMAL + 1.5*(saat-NORMAL))*saatUcreti;
//bu satır hem normal hemde fazlamesai de çalışır
net=brut*0.8; kesinti=brut*0.2;
//artık bordor yazılabilir.
cout<<"Bordor bilgileri:"<<endl;
cout<<"Toplam çalışma sürtesi:"<<saat<<"saat."<<endl;
cout<<"Brüt ücret: \t"<<brut<<"TL."<<endl;
cout<<"Kesintiler: \t"<<kesinti<<"TL."<<endl;
cout<<"Net ücret: \t"<<net<<"TL."<<endl;
//genel hesaplara ilişkin yenilemeler
netMaasToplam+=net; cesitliKesintiToplam+=kesinti;
idariPersonel++;
//switchden çıkıyorus.
break;
}
case'B':{
int saat=0, saatUcreti=0;
const int NORMAL=22*10;
double brut=0, net=0, kesinti=0, saglik=0;
cout<<"Toplam çalışma süresi (saat) giriniz: ";
cin>>saat;
cout<<"Saat ücretini giriniz: ";
cin>>saatUcreti;
brut=(double)(NORMAL+1.5*(saat-NORMAL))*saatUcreti;
//bu satır hem nromal hem de fazla mesai de çalışır.
net=brut*0.65;
kesinti=brut*0.2;
saglik=brut*0.15;
//artik bordro yazılabilir
cout<<"Bordro bilgileri: "<<endl;
cout<<"Toplam çalışma süresi:"<<saat<<"saat."<<endl;
cout<<"Brüt ücret: \t"<<brut<<"TL."<<endl;
cout<<"Kesşntiler: \t"<<kesinti<<"TL."<<endl;
cout<<"Sağlık kesintileri: \t"<<saglik<<"TL."<<endl;
cout<<"Net ücret: \t"<<net<<"TL."<<endl;
//genel hesaplara ilişkin yenilemeler.
netMaasToplam+=net;
cesitliKesintiToplam+=kesinti;
saglikKesintiToplam+=saglik;
yazilimciKadrolu++;
//switch den çıkıyoruz.
break;
}
case'C': {
int modul;
double temel=0, modulBasi=0;
double net=0;
cout<<"Temel ücreti girin: ";
cin>>temel;
cout<<"Teslim edilen modül sayısını girin: ";
cin>>modul;
cout<<"Modül başı ücreti girin: ";
cin>>modulBasi;
net=(double) temel+modul*modulBasi;
//artık bordro yazılabilir.
cout<<"Bordor bilgileri:"<<endl;
cout<<"Bitirilen Modül sayısı: "<<modul<<endl;
cout<<"Net ücret: \t"<<net<<"TL."<<endl;
//genel hesaplara ilişkin yenilemeler
netMaasToplam+=net; yazilimciProje++;
//switch den çıkıyorus
break;
}
default: {
cout<<"Geçersiz personel türü. Yeniden Deneyin."<<endl;
}
}//switch

cout<<"Başka bir personelin maaşını hesaplamak istiyormusunuz?(E/H)";
char secenek;
cin>>secenek;
secenek=toupper(secenek);

if(secenek=='H') {break;} //bu while den çıkartır.
else if (secenek=='E'){} //birşey yapma
else {cout<<"Geçersiz seçenek. Ana menüye dönüyor..."<<endl;

//acaba ekranı nasıl temizlerdik?
//Böylece daha güzel görünümlü olan bir programımız olurdu

}//while



cout<<"Oturum İçin Genel Bilgiler:"<<endl;
cout<<"--------------------------------------"<<endl;
cout<<"Toplam İdari Personel: \t"<<idariPersonel<<endl;
cout<<"Toplam Yazılımcı (Kadrolu): \t"<<yazilimciKadrolu<<endl;
cout<<"Toplam Yazılımcı (Proje): \t"<<yazilimciProje<<endl;
cout<<"--------------------------------------"<<endl;
cout<<"Toplam Net ödeme: \t\t"<<netMaasToplam<<"TL."<<endl;
cout<<"Toplam Cesitli Kesintiler: \t"<<cesitliKesintiToplam<<"TL."<<endl;
cout<<"Toplam Sağlık Sigortası Kesintisi: \t"<<saglikKesintiToplam<<"TL."<<endl;
cout<<"--------------------------------------"<<endl;

system("PAUSE");
return 0;
} Bu örnek Bora GÜNGÖREN`e ait olan C++ İLE NESNE TABANLI PROGRAMLAMA kitabından alınmıştır.











__________________
Knisath

[Admin]

Fonksiyonlar


1. Fonksiyonlar

Bundan sonraki bölümlerdeki kullanacagimiz derleyici Borland Turbo C++ 4.5
tir. Fazla zorlanmayacaginizi umut ediyorum. Kolay anladiginiz yerlere
lütfen dikkat ediniz. Hata yapma olasiliginiz daha da çok artmaktadir.
Yapacaginiz hatalar programin çökmesine, belki de sistemin zarar
görmesine sebep olabilir. Lütfen vermis oldugum uyarilara ve
tavsiyelere uymaya çalisin. Sizin de tavsiyeniz olursa bana bildiriniz. Haydi kolay gelsin...
1. Fonksiyonlara Giris:

Fonksiyonlarin programlama hayatina girmesi ile daha büyük boyutta
sistemlerin tasarimi mümkün hale gelmistir. Fonksiyonlar ile alakali
derslerimizde, fonksiyonlarin tanimlanmasi ve kullanimi hakkinda bilgi
edineceksiniz. Fonksiyonlar konusu size her ne kadar ilk bakista
"Fonksiyon" adi altinda bir konu gibi gelse de, aslinda bir alt
programdir. Hatta programimizin içine, kodlamamizin daha kolay ve
gelistirilebilir hale gelmesini saglayan programciklar da diyebiliriz.
Daha önce baska bir programlama dili gördüyseniz (yüksek seviyeli
diller), bu konuda fazla zorlanmayacaksinizdir. Diger yüksek seviyeli
dillerdeki fonksiyon kullanimina çok benzemektedir. Hiç bilmediginizi
farz ederek konuya giris yapalim.
Fonksiyon Nedir?
Örnegin, y=F(x) fonksiyonu; Bu matematiksel fonksiyon parametre olarak
aldinan deger üzerinde bir islem gerçeklestirip, bir sonuç degerini
döndürür. Mesela F(x)=x^3+5 seklinde bir fonksiyonumuz olsun, x=2 için
F(x)=13 olur. Burada x fonksiyonun parametresi, 13 ise fonksiyonun geri
döndürdügü degerdir. Simdi de bu matematiksel ifadeyi kodlarimizla
yorumlayalim.
Int x;
x=F(2,5)
//buradan da " int f(2,5) " gibi görebiliriz... Dikkat edersek ikinci
satirda, daha önce islemedigimiz bir kod var. Int x, F(2,5) degerine
esitlenmistir. Simdi bir fonksiyonun nasil yazildiginin kalibini
çikartabiliriz.
<Döndürdügü deger> <Fonksiyonun adi> ( <parametre listesi> ) {

<ifadeler>
} Buradaki parantezlere ve küme isaretlerine dikkat ediniz. Simdi yukarda yazdigimiz kalibi biraz açalim.
<Döndürdügü deger> :
Fonksiyon her hangi bir tipte deger döndürebilir. Bu bilesen
fonksiyonun döndürecegi degerin tipini ifade eder. (örnegin, int,
dounle, float v.s v.s )
<Fonksiyonun adi> : Yapmak
istedigimiz islemin adidir. Örnegin bir asal sayi fonksiyonu yazacagiz.
Burada yazacagimiz fonksiyonun adini belirtiyoruz. Benim size tavsiyem
AsalSayi veya asal_sayi seklinde kullanmanizdir. Okunabilirlik
açisindan size avantaj saglayacaktir.
<parametre listesi> : Fonksiyonun kullanacaga parametrelerin tipleri ile siralanir. Örnegin, FonksiyonAdi(int x, double y) gibi.
<ifadeler> :
Fonksiyonun kullanacagi tanimlamalar ve kodlardan olusan kisimdir.
Nasil biz main() { kodlar } seklinde kullaniyorsak. Bunu da ona
benzetebiliriz. Ama main() i bunlarla karistirmayiniz.
Simdi bu
fonksiyon kalibina uygun bir kod yazalim. Örnegin, Faktoriyel bulma
islemini ele alalim. Biz bir sayinin Faktörüyelini nasil bulurduk?
n!=n(n-1)(n-2)...1 Yani, 1 den n e kadar olan sayilarin çarpimidir.
long Faktoriyel(int n) {
return n*Faktoriyel(n-1);
} Evet, burada fonksiyonumuzu tanimladik. Sanirim yukaridaki blokla
karsilastirinca, ne kadar kolay oldugunu sizde görmüssünüzdür. Simdi bu
Faktoriyel fonksiyonumuzu nasil bir programda kullanacagiz? Hemen
devamini yazayim.
long Faktoriyel(int n) {
return n*Faktoriyel(n-1);
}
void main() {
cout<<"5! (Bes Faktoriyel)= "<<Faktoriyel(5);
} Iste gördügünüz gibi ne kadar basit degil mi? J Fonksiyonumuzu
tanimladik. Sonra programimizda n`e 5 degerini verdik. Faktoriyel
fonksiyonu hesaplayip bize söyledi.
Biraz da yaygın yapılan hatalardan ve dikkat etmemiz gereken
noktalardan bahsedelim. Kodlama yaparken fonksiyon adini belirttigim
sekilde yazarsaniz 30-40 sayfalik kodlarda hata bulmaniz ve de
fonksiyonlarin yerini belirlemeniz açisindan büyük kolaylik olucaktir.
Yukarida verdigimiz x=F(2,5) fonksiyonununu göz önünde tutalim.
Görüldügü gibi F(2,5) degeri x e atanmistir. Hiç bir zaman Fonksiyonun
aldigi deger sola yazilmaz. Ayrica bir Fonksiyon çagrisi, baska bir
fonksiyonun çagrisi olabilir. Örnegin, x=F(a,F(a,5) gibi. Burada F
Fonksiyonun iki parametresi vardir a ve F(a,5) dir. Bu durumda
öncelikle parametreler hesaplananacagi için F(a,5) in degeri ile a nin
degeri F te parametreler olarak kullanilir.

[Admin]

Tanımlayıcının Görünürlüğünün Kontrolü ve Kendini Çağıran Fonksiyonlar


2. Tanımlayıcının Görünürlüğünün Kontrolü ve Kendini Çağıran Fonksiyonlar

Bir değişkenin görünürlüğü değişkenin etki dizinini gösterir. Bir
yerel değişken, tamamen, bir fonksiyon içinde kullanılır. Onun
görünürlüğü fonksiyonun içi ile sınırlıdır. Değişkenin görünürlüğü ve
ulaşılabilirliğinden sadece fonksiyonun içinde bahsedilebilir. Buna "Scope Kuralları" da denir. Şimdi bunu bir örnek ile izah edelim;
#include <iostream.h>
void main(){
int i=5;
{
int i=1;
cout<<"İçerideki i: "<<i<<endl;

cout<<"Dışarıdaki i: "<<::i<<endl;
}
} Görüldüğü gibi İçerdeki i:1, Dışarıdaki i:5 şeklinde bir çıktı
verecektir. Main ide bir fonksiyon gibi görürsek (gerçi özel bir
fonksiyondur), denilmek isteneni anlayacaksınızdır.
Kendini tekrarlama, bir fonksiyon kendini çağırdığında oluşur.
Başlangıçta bu sonsuz döngü gibi gözükür, ancak öyle değildir. C++
kendini çağırmayı destekler. Bunu bir fonksiyonun döndürdüğü değeri
bulabilmesi için içindeki bir parametrenin de fonksiyon olması gibi
değerlendirebiliriz. Hani başta vermiştik ya: F(x,F(x,y) gibi...











__________________

[Admin]

İnline Fonksiyonlar


3. İnline Fonksiyonlar

C++ `ın C ye ek olarak getirmiş olduğu bir özellikte inline
fonksiyonlardır. Anlamak için basit bir örnekle başlayalım. Örneğin
öyle bir program yazıcağız ki, aşırı miktarda kare alma işlemi yapmamız
gerekecek ve bunun için herhangi bir fonksiyon çağırmıyor olalım. Bu
durumda define komutu ile derleyiciye şu şekilde bir komut veririz:
#define kare(x) x*x İşlemin sonunda ; olmamasına dikkat ediniz. Kullanımına gelince de,
y=kare(x); bu durumda derleyici derleme aşamasında bütün kare(x) `leri
x*x olarak yorumlayacaktır. Burada dikkat edilmesi gereken yer, #define
topla(x,y) x+y ve kullanımda da z=topla(x,y)*topla(x,y); işte işlem
sırasının vermiş olduğu hatayı görüyorsunuzdur. Tabi bunu da
parantezlerle ayıracağız. Şimdi bunu C++ tam uyarlarsak, inline
kelimesini, bir direktif olarak yada C++ derleyicisine fonksiyonu tek
satıra koyması önerisi olarak düşünebiliriz. Derleyici bir çok nedenden
dolayı bunu kabul etmeyebilir. Mesela, Fonksiyon çok uzun olabilir,
Döngü içeren bir fonksiyon, değişken tanımı içeren bir fonksiyon,
kendini çağıran bir fonksiyon her zaman inline olmaz.
http://kup.cpp
//Kupun hacmini bulma
#include <iostream.h>

//inline fonksiyonumuz
//------------------
inline double kup( const double x)
{

return x * x * x;

}
//---------------------

int main()
{
cout << "Kübün bir kenar uzunluğunu giriniz: ";

double kenar;

cin >> kenar;
cout << "Kenar" << kenar << "olan kübün hacmi = "
<< kup (kenar) << endl;
return 0;
}











__________________

[Admin]

Fonksiyon Yüklemesi ve Prototipleri


4. Fonksiyon Yüklemesi ve Prototipleri

Şimdi C++ `ın getirmiş olduğu başka bir özellikten daha
bahsedeceğiz. Aynı isimli fonksiyonların farklı işlemler yapabilmesi.
Aynı şekilde çağrılacaklardır, fakat derleyici bunların farklı
fonksiyonlar olduğunu anlayacaktır. Tabi bunun şartları var.
Fonksiyonların tipleri yada bunların sıraları farklı olmalıdır.
Fonksiyonların başında kalıbın tanımını yaparken, parametre listesinden
bahsetmiştik. Bu parametreler belli değerler döndürürler, işte
derleyicide bu döndürdüğü değerlere yani imzalarına göre bunların
farklı fonksiyonlar olduğunu anlayacaktır. Tabi bunların sıraları da
farklı fonksiyonlar gibi gözükmelerini sağlayacaktır. Hemen olayı
anlamak için örnek verelim.
double Ortalama(int *dizi, int uzunluk){
//kodlar
}
double Ortalama(double*dizi, int uzunluk){
//kodlar
} Görüldüğü gibi bu iki fonksiyon da bir birinden farklıdır. Her ne kadar isimleri aynı olsa da...
Fonksiyon tanımlamasının fonksiyon kullanılmadan önce yapılmış olması
gerekmektedir. Fonksiyonlarımızı header başlığı altından çağırabiliriz.
Mesela ben daha önce bir Faktoriyel fonksiyonu yazip bunu Fakt.h olarak
saklıyorum. Programımı yazarken #include <Fakt.h> diyerek bunu
çağırıyorum ve programda yazdığım "5'in faktoriyelini al" dediğim zaman
direk Fakt.h taki fonksiyonda işlemi yapıp aldığı değeri programa
verir. Mümkün olduğunda C++ ın kendi kütüphanelerindeki hazır
fonksiyonları kullanmaya çalışacağız. Var olan bir fonksiyonu yeniden
yazmanın pek bir anlamı olmaz. İleride kütüphanelerdeki fonksiyonları
da mümkün olduğunca göreceğiz.











__________________

[Admin]

Fonksiyonları Referans ile Çağırma


5. Fonksiyonları Referans ile Çağırma

Daha önceki örneklerimizde fonksiyona parametre olarak geçilen bir
değer olarak çağırmıştık. Şimdi ise onu referanslar ile çağıracağız.
Bunu çok uzatmadan direk örnek üzerinde anlatalım.
http://referans.cpp
//fonksiyonlarda referans

#include <iostream.h>

void deneme(int &x, int &y);

int main()
{
int x,y;
cout<<" iki sayı giriniz:";
cin>>x>>y;

cout << "Denemeden önceki:\n";
cout << "X: " << x << endl;
cout << "Y: " << y << endl;
deneme(x, y);
cout << "\nDenemeden sonraki:\n";
cout << "X: " << x << endl;
cout << "Y: " << y << endl;
return 0;
}

void deneme(int &x, int &y)
{
int deger = x;
x = y;
y = deger;
} Referans parametresi (&) dir. Bu sayede fonksiyona argüman yerine
o argümanın adresini yolluyoruz. Fonksiyon bu sefer verdiğimiz değere,
o adresi kullanarak ulaşır. Bu çok yüksek değerleri fonksiyona
gönderdiğimizde kullanacağımız yöntem olmalıdır.











__________________