C++ DERS NOTLARI ÖZET

c++ ders notları

1. Yorum Satırları ( // ve /* .. */ )

Bu satırlar derleyici için hiç şey ifade etmemektedir. Yani bu satırlar derleyici tarafından önemsenmeyecektir. Ancak yorum satırı kullanmak programcının, programı daha kolay anlayabilmesini sağlar. Düşünün bin hatta on bin, satırlık bir uygulama yazdığınızı... Bu programı başka bir programcıya devrettiğiniz zaman o programcı yorum satılarına bakarak programı rahatça anlayabilir ve geliştirebilir.

Unutmayın!

//  ile tek satır yorum yazılırken

 /*  ... */ arasına örnekte olduğu gibi çok satırlı yorum yazılabilir.

2. #include "stdafx.h”

"stdafx.h" programın daha hızlı çalışmasını sağlayan, daha önceden derlenmiş bir kütüphanedir. "stdafx.h" kütüphanesini, include deyimi ile uygulamamıza çağrıyoruz.

3. #include <iostream>

Açılımı In Out Stream, olan iostream kütüphanesini, include deyimi ile uygulamamıza çağırdık.

4. int main() {..}

C++ programlarında illa ki bir main fonksiyonu bulunmaktadır. int main C++'ın ana fonksiyonudur. Tüm C++ programları bu bölümde çalıştırılır.

5. std::cout << "Merhaba Dunya\n";

Açılımı Character Out olan cout ve << ifadeleri ile yazdığımız ifadeyi ekrana yazdırırız.

Unutmadan, yeri gelmişken söyleyelim. cout'un başında illa ki std:: kullanmamıza gerek yok. int main'den önce "using namespace std" kodunu kullanarak. Bunu bir örnekle inceleyelim.

#include “stdafx.h”

#include <iostream>

using namespace std;

int main(){

cout << “Merhaba Dünya! \n”;

system(“Pause”);
return 0;

}

 "\n" ise bir alt satıra geçmemizi sağlıyor.

6. system("PAUSE");

system("PAUSE"); klavyeden bir tuşa basana kadar, programın ekranda kalmasını sağlar.

7. return 0;

return 0; deyimi ile fonksiyonu bitiririz.

C++'da veri türlerini şu şekilde;

1) Char - Karakter - Boyut: 1 byte
2) Int - Tamsayı - Boyut: 4 byte
3) Short - Kısa Tam Sayı - Boyut: 2 byte
4) Long - Uzun Tam Sayı - Boyut: 4 byte
5) Bool - 1 ve yahut 0 yani True ya da False değeri alır - Boyut: 2 byte
6) Float - Ondalıklı Sayı - Boyut: 4 byte
7) Double - Uzun ondalıklı sayı - Boyut: 8 byte

Değişken İsimlendirme Kuralları

Gelelim değişkenleri isimlendirirken dikkat edeceklerimize.

§  Değişken isimleri, küçük-büyük harfe duyarlıdır.

§  Değişken tanımlarken mutlaka har ile başlanmalıdır.

§  Değişken ismi boşluk içeremez! Boşluk yerine" _" (alt çizgi) kullanabilirsiniz.

§  Değişken ismi en fazla 255 karakter olabilir.

§  C++ programlama dilinde özel anlamı olan sözcükler değişken olarak tanımlanamaz. Örneğin; class, double, char, do, else, for, friend, true, try ...

Değişken Türleri

Değişkenler üçe ayrılırlar.

1.     Yerel Değişkenler

2.     Global Değişkenler

3.     Static Değişkenler

Bildirimi fonksiyon içinde yapılan değişkenlere yerel değişkenler, eğer değişkenin değeri tüm fonksiyonlar için geçerli olması isteniyorsa, değişkenin değeri fonksiyonların dışında yapılır ve bu değişkenlere global değişkenler ve eğer program çalıştığı sürece değişkenin değerinin değişmemesini istiyorsak static deyimi kullanılır ve bu değişkenlere static değişkenler denir.

Örneğin:

int A = 10; // A değişkeni global değişkendir.
int main() {
int B = 5; // B değişkeni yerel değişkendir.
static int C = 15 // C değişkeni static değişkendir.
}

Sabitler

Sabitler,  programın çalıştığı sürece değişmeyecek olan değerlerin saklanmasında kullanılırlar.

Formül: (veri türü) const (değişken ismi) = (değişkenin değeri)

Örneğin:

int main{
double const pi = 3,14;
}

cin >>

Klavyeden bir değer girilmesi isteniyorsa "cin >>" değişim kullanılır.

Operatörler

Kısaca; programlama dillerinde, özel anlamı olan işaretlere operatörler denir, diyebiliriz.

Atama Operatörlerü ( = )

Bu operatörü aslında önceki derslerimizden biliyorsunuz.

Örnek:

int sayi = 25;

Aritmatik Operatörler

Aritmatik operatörler, matematiksel işlemleri yaparken kullandığımız operatörlerdir.

§  Toplama Opreatörü ( + )

§  Çıkarma Operatörü ( - )

§  Çarpma Operatörü ( * )

§  Bölme Operatörü ( / )

§  Mod Alma Operatörü ( % )

Örnek:

// Toplama
int A = 10 + 5;
// Çıkarma
int B = 35 - 5;
// Çarpma
int C = 6 * 6;
// Bölme
int D = 25 / 5;
// Mod Alma
int E = 10%2;

Artırma Operatörü (++) ve Azaltma Operatörü (--)

Arttırma operatörü, değişkenin değerini 1 değer arttır. Azaltma operatörü ise bir değer eksiltir.

Örnek:

int main() {
A = 5
std::cout <<  A << "\n";
A++;
std:: cout <<  A << "\n";
B = 5
std::cout <<  B << "\n";
B++;
std:: cout <<  B << "\n";
}

Aritmatik Atama Operatörleri 


Beş aritmatik operatörümüz var bildiğiniz üzere. Bu operatörlerimizi biraz geliştirerek aritmatik atama operatörlerini elde ediyoruz :)

§   Topla ve ata ( += )

§  Çıkar ve ata (  -= )

§  Çarp ve ata ( *= )

§  Böl ve ata ( /=)

§  Mod al ve ata ( %= )

Karşılaştırma Operatörleri

C++ programlama dilinde altı adet karşılaştırma operatörü bulunmaktadır. 

§  Büyüktür Operatörü ( > )

§  Küçüktür Operatörü ( < )

§  Büyük Eşittir Operatörü ( >= )

§  Küçük Eşittir Operatörü ( <= )

§  Denktir Operatörü ( == )

§  Farklı Operatörü ( != )

Mantıksal Operatörler 

İki ve yahut daha fazla koşul karşılaştırırken mantıksal operatörlerden yararlanırız.

§  Ve Operatörü ( && )

§  Veya Operatörü ( | | )

§  Değil Operatörü ( ! )

Merhaba arkadaşlar dördüncü dersimiz ile karşınızdayım. Bu dersimizde C++'da ki kontrol yapılarını diğer adıyla koşulları yani, if, else if, else ve switch-case yapılarını işleyeceğiz

Kontrol yapıları

IF Yapısı

Kullanımı

if ( ifade ) {
ifade doğru ise yapılacak işlemler
}

Örnek

int A = 10;
int B = 5;
int A + B = C;
if ( C = 15 ) {
std::cout << "İfade doğru.";
}

Else If Yapısı

Else If koşulu kendisinden önce bir if koşulu varsa çalışır.

Örnek

int A = 5;
if ( A > 5 ) {
A 5'ten büyüktür.
}
else if ( A < 10 ) {
A 10'dan küçüktür.
}

Else Yapısı

Tüm koşullar yanlış ise işler. Else yapısıda Else If gibi kendisinden önce bir if koşulu varsa anlam kazanır.

Kullanım

if ( ifade  ) {
// İfade doğru ise buradaki işlemler çalışır
}
else {
ifade yanlış ise buradaki işlemler çalışır
}

Örnek

int A = 100İ
if ( A = 50 ) {
std::cout << " A, 50'ye eşittir.";
}
else {
std::cout << " A, 50'ye eşit değildir."
}

Switch - Case Yapısı

Switch Case koşulu değişkenin değerine göre programa yön verir.

Kullanımı

switch ( değişken  ) {
case deger1: yapılacak işlemler;
case deger2: yapılacak işlemler;
case deger3: yapılacak işlemler;
...
default: üstteki durumlar sağlanmazsa yapılacak işlemler
}

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int main() {
cout << "Birden uce kadar bir sayi girin.\n";
int sayi;
cin >> sayi;
switch ( sayi ) {
case 1 :
cout << "Sayş bir.";
break;
case 2 :
cout << "Sayi iki.";
break;
case 3 :
cout << "Sayi üç.";
break;
default :
cout << "Yanlış sayı.";
}
system("PAUSE");
return 0;
}

---

Bir dersimizin daha sonuna geldik. Gelecek dersimizde döngüler konusunu işleyeceğiz. Gelecek dersimiz de görüşmek üzere. Esen kalın!

Merhabalar dostlarım, beşinci dersimiz ile tekrardan karşınızdayım. Bu dersimizde C++'da döngüler konusunu işleyeceğiz. 

Döngüler, programlamada ayrı bir yer tutmaktadır. Döngüler için programlamanın yapı taşlarıdır diyebiliriz, sanırım. Döngüler ile program içerisinde ki bazı komutları sürekli çalıştırabiliriz.

C++'da üç döngü tipi vardır. Bunlar

1.     While Döngüsü

2.     Do While Döngüsü

3.     For Döngüsü

While Döngüsü

Kullanımı

while ( koşul )
{
komut;
}

Şimdi While döngüsü ile 1'den 100'e kadar ki sayıları, ekrana yazdıralım.

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int main() {
 int a = 1;
 while ( a <= 100 ) {
  cout << a << endl;
  a++;
 }
 system("PAUSE");
 return 0;
}

While döngüsünü istersek iç içe de kullanabiliyoruz.

Do While Döngüsü

Do While döngüsünün çalışma prensibi, while döngüsü ile aynıdır. Ancak program do while döngüsünde ne olursa olsun bir kez çalıştırılır.

Kullanımı

do {
koşul
} while (şart);

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int main() {
// Bu örnekte 1'den girilen sayıya kadar ki olan sayıları yazdıracağız.
int sayi,a = 0;
cout << "\aBir sayi giriniz: ";
cin >> sayi;
do {
a++;
cout << a;
} while ( a < sayi );
cout << endl;
system("PAUSE");
return 0;
}

Not: 

/a Nedir?
Kullanımı "/n"'ye benzer olan '/a', program çalıştırıldığında, bip sesi çıkarır.

For Döngüsü

For Döngüsü, döngüde ki değişkenin, arttırılması ve yahut azaltılması gerektiğinde kullanılır.

Kullanımı

for ( değer, koşul, artırma değeri ) {
komutlar;
}

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int main() {
// Bu örneğimizde 1'dan 100'e kadar ki tek sayıları ekrana yazdıracağız.
int a ;
for ( a = 1; a <= 100; a+=2) {
cout << a << endl;
}
system("PAUSE");
return 0;
}

Gördüğünüz gibi For döngüsünün kullanımı da bu şekildedir.

Break ve Continue Komutları

Break, döngünün durdurulmasında kullanılır. Break, komutu kullanıldığında döngüden çıkılır.

Continue, döngüdeki bir değerin atlanmasında kullanılır.

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int main() {
// Bu örneğimizde 1'dan 20'ye kadar ki tek sayıları ekrana yazdıracağız.
int a ;
for ( a = 1; a <= 20; a+=2) {
if (a==11)
continue;
if (a==15)
break;
cout << a << endl;
}
system("PAUSE");
return 0;
}

Merhaba dostlarım. Yeni bir C++ dersinde yine birlikteyiz. Bu dersimizde diziler konusunu işleyeceğiz.

Diziler, aynı tür verilerin sıralanarak kullanılmasında, kullanılır. C++'da iki çeşit diziler vardır. Şimdi bunları inceleyeceğiz.

A. Tek Boyutlı Diziler

Topluca bir grup halinde bulunan, veri içeren dizilere tek boyutlu diziler denir.

Tek Boyutlu Dizi Tanımlaması

Kural

dizinin_tipi dizinin_adı[eleman_sayısı]

Örnek

int arabalar[10];
int harfler[29];
char kelimeler[100];

Unutulmamalıdır ki, diziler de bir veri türüdür. Yani dizilerin de değişkenler gibi tanımlanmaları gerekir. Ayrıca  tanımlamaları, değişken tanımlamaları ile de kullanılabilir.

 Diziler, indeks mantığı ile çalışmaktadır. Bir dizide ki her elemana bir indeks verilmektedir. İndekslerin 0'dan başladığı unutulmamalıdır.

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int main(){
int a[5];
a[0] = 5;
a[1] = 10;
a[2] = 15;
a[3] = 20;
a[4] = 25;
cout << a[0] << endl;
cout << a[1] << endl;
cout << a[2] << endl;
cout << a[3] << endl;
cout << a[4] << endl;
system("PAUSE");
}

Daha bir pratik yol ile dizi tanımlaması yapabiliriz.

Örnek

int dizi[5] = {0,1,2,3,4};

Not: int dizi[5] = {0} ifadesini kullanır isek, tüm değerler 0 değerini alıcağını unutmayalım.

B. Çok Boyutlu Diziler

Çok boyutlu diziler, matris mantığı ile çalışırlar ve iki indekse sahiptirler. Aslında çok boyutlu dizilerin tanımlaması, tek boyutlu dizilerin kine benzer.

Kural

(veri_tipi) (dizinin_adı[eleman_sayisi][eleman_sayisi])
ve yahut değer verilmek istenirse,
(veri_tipi) (dizinin_adı[eleman_sayisi][eleman_sayisi]) = {..,...}

Örnek

int sayilar[4][2];
sayilar[0][0]=1;
sayilar[0][1]=2;
sayilar[1][0]=3;
sayilar[1][1]=4
sayilar[2][0]=5;
sayilar[2][1]=6;
sayilar[3][0]=7;
sayilar[3][1]=8 

int sayilar[4][2] = {(1,2), (3,4), (5,6), (7,8)}

Hiç de zor değil, değil mi :)

Karakter Dizileri

C++ programlama dilinde, diziyi veri türünden bir nesne olarak tanımlamakta mümkün. <cstring> kütüphanesini kullanarak, string fonksiyonlarını karakter dizileri üzerinde kullanacağız.

Örnek

#include "stdafx.h"
#include <iostream>
#include <cstring>
using namespace std;
int main() {
char takim[20];
cout << "Tuttuğunuz takımı giriniz: ";
gets(takim);
cout << "\nTuttuğunuz takım : ";
puts(takim);
system("PAUSE");
return 0;
}

Fonksiyonlar

Fonksiyonları programın yapı taşı olarak tanımlamak doğru olur. Kullandığımız int main() 'in de bir fonksiyon olduğunu unutmamak gerekir.

Fonksiyon Tanımlamak

fonksiyonun_tür fonksiyonun_adı(parametreler) {
komutlar
}

Not: Eğer fonksiyonumuzun değer döndürmüyorsa tür olarak 'void' yazılır.

Fonksiyon Prototipleri

Eğer birden çok fonksiyon kullanıyorsak, fonksiyon prototipleri derleyiciye fonksiyonu tanıtmak için kullanılır.Fonksiyon prototipleri kütüphane çağırmalarının, hemen altında kullanılır.

Örnek

 #include "stdafx.h"
#include <iostream>
using namespace std;
int fonksiyon_adi(parametreleri);

Fonksiyonların Çağrılması

Bunu bir örnek ile açılamak istiyorum.

Örnek

void fonksiyon(){
komutlar...
}
int main() {
fonksiyon();
}

Bir fonksiyonu, örnekteki gibi, istediğiniz yerde çağırabilirsiniz.

Fonksiyonların Değer Döndürmesi

Bunu da bir örnekle açıklamak istiyorum.

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int toplama() {
int x,y;
cout << "İlk sayıyı girin: : ";
cin >> x;
cout << "\nİkinci Sayıyı Girin : ";
cin >> y;
return x+y;
}
int main() {
cout << "Sayilarin toplami = " << toplama() << endl;
system("PAUSE");
return 0;
}

Sanırım anlaşılmıştır :)

Değer ile Çağırma

Bir örnekle açıklayalım.

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
void fonksiyon(int a) {
a = 10;
}
int main() {
int b = 5;
cout << "Degiskenin ilk degeri: " << b << endl;
fonksiyon(a);
cout << "Deger ile cagirdiktan sonraki degeri: " << a << endl;
system("PAUSE");
return 0;
}

Göstericiler, içerisinde bir hafıza adresi olan değişkenlerdir. Buradaki adresten kastımız bellekteki verinin yerini göstermesidir.

Gelelim tanımına;

<gösterici türü> *<gösterici adı>

 Gördüğünüz gibi gösterici tanımı da değişken tanımına benziyor.Arasındaki tek fark, gösterici adından önce "*" kullanılmasıdır.

Örnek

int a;
// A bir değişkendir.

int *b;
 // B bir göstericidir.

int *C,D;
// C bir gösterici iken, D bir değişkendir. Yani C'de ki yıldızın D'nin üzerinde bir etkisi yoktur.

Gösterici Operatörleri

& karakteri adres operatörü olarak kullanılır. Bunu bir örnek ile açıklayalım.

Örnek

int a = 10; // A değişkenini bildirdik
int *ptr; // PTR göstericisini bildirdik.
ptr = &a; // Değişken adresini göstericiye atadık

Yani burada A değişkeni 10 verisini bellekte tutarken, ptr göstericisi ise bellekteki A değişkeninde ki 10 verisinin yerini tutmaktadır.

Gösterici Aritmatiği

C++ programlama dilinde göstericiler; aritmatik işlemlere sokulabilir, karşılaştırma operatörleri kullanılabilir.

Örnek

int *a;
a++;

Burada a göstericisinin, bellekteki yerini bir arttırmış olduk. Yani göstericinin adresi 100 ise, 101 olmuş oldu.

Göstericiler ve Fonksiyonlar

Gelelim, göstericiler ve fonksiyonların ilişkisine. Bu konuda aynı zamanda fonksiyonları referans ile çağırmayı da öğreneceğiz.

Önce şu örneğe göz atalım

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;

void referans( int *a ) {
 *a = 10;
}

int main() {
int b = 5;
cout << "Degiskenin ilk degeri: " << b << endl;
referans(&b);
cout << "\aDegiskenin deger ile cagirdiktan sonra ki degeri: " << b << endl;
system("PAUSE");
return 0;
}

Bir fonksiyonu refarans ile çağırmak; o fonksiyona parametre olarak bir değer, bir gösterici göndermektir. Yani refarans ile fonksiyon çağırırken, fonksiyona gönderilen adres orjinal verinin adresidir. Fonksiyona gönderilen adreste ki veri üzerinde yapılan her değişiklikte orjinal veri değişir.
Göstericiler ve Diziler

C++ programlama dilinde, göstericiler ve diziler iç içe olup, çoğu yerde birbirlerinin yerlerine kullanılabilirler. Göstericiler, dizilerin pekçok işleminde kullanırlar. Dizi ismi, sabit bir gösterici olarak da düşünülebilir. 

Örnek

int *a, b[2];
a = b;
// ve yahut
int *a, b[2];
a = &b[0];

 Böylelikle, b dizisinin başlangıç adresi, a'ya atanmış oldu.

Void Göstericiler

Void Göstericiler, herhangi bir veri türü olmayan göstericilerdir. Hatırlayacağınız gibi Void ile fonksiyonlar da tanışmıştık. Void Göstericilerin tek özelliği, diğer göstericiler arasındaki atama işlemlerinde, adres saklayıcı olarak görev yapmasıdır.

Not: Void göstericilerin türü olmadığı için bir değerin göstericisi olamadığı gibi aritmatik işlemlere de sokulamazlar.


Göstericilerde Sabit Tanımı

Hatırlayacağınız gibi program içerisinde, değişmesini istemediğimiz değerleri sabit olarak tanımlıyorduk. Değişmesini istemediğimiz göstericileri de sabit olarak tanımlayabiliriz.

Göstericileri üç şekilde sabit tanımlaması yapabiliriz.

a. Göstericinin tuttuğu adresi sabit olarak tanımlama

Örnek 

int a = 10;
int * const ptr = &a;

b. Göstericinin içeriğinin sabit olarak tanımlanması

Örnek

int a = 10;
const int *c = &a;

c. Göstericinin içeriğinin ve tuttuğu adresi sabit olarak tanımlama

Örnek

int a = 10,
const int * const c = &a;

Peki yapılar nedir? Birbirleri ile ilişki içinde bulunan veri kümelerine yapı (struct) denir. Yapılar genel olarak dizilere benzer. Çünkü yapılar, diziler gibi birden fazla nesneyi içinde tutarlar. Ayrıca diziler gibi, bellekte sıralı bir biçimde bulunurlar. Diziler tek türde değerleri bir arada tutarken, yapılar bir den çok türden nesneleri bir arada tutarlar.

Yapıların Tanımlanması

struct (yapıların_ismi) {
(veri_türü) ( değişken_adı )
(veri_türü) ( değişken_adı )
...
} (nesne_adı);

Örnek

struct okul{
char *ad,*soyad,*sinif;
int yas,dogum_tarihi;
} ogrenci;

Yapı Elemanları

Yapıda eleman tanımlaması şu şekildedir.

Örnek

(yapı değişkeni). (değişken adı)

Bir örnekle bunu açıklayalım.

#include "stdafx.h"
#include <iostream>
using namespace std;
struct okul{
char *ad,*soyad,*sinif;
int yas,dogum_tarihi;
} ogrenci;
int main() {
 okul a;
 a. ad = "İlker";
 a. soyad = "Akyel";
 a. sinif = "A";
 a. yas = 16;
 a. dogum_tarihi = 1997;
 cout << "Ogrencinin adi = " << a.ad << endl;
 cout << "Ogrencinin soyadi = " << a.soyad << endl;
 cout << "Ogrencinin sinifi = " << a.sinif << endl;
 cout << "Ogrencinin yasi = " << a.yas << endl;
 cout << "Ogrencinin dogum tarihi = " << a.dogum_tarihi << endl;
  system("PAUSE");
 return 0;
}

Not: Yapıları fonksiyon dışında tanımlıyoruz.

Kısa Yoldan Yapı Elemanları Tanımlama

Bunu bir örnekle açıklamak istiyorum.

#include "stdafx.h"
#include <iostream>
using namespace std;
struct okul{
char *ad,*soyad,*sinif;
int yas,dogum_tarihi;
} ogrenci;
int main() {
 okul a={"İlker","Akyel","A",16,1997}
 cout << "Ogrencinin adi = " << a.ad << endl;
 cout << "Ogrencinin soyadi = " << a.soyad << endl;
 cout << "Ogrencinin sinifi = " << a.sinif << endl;
 cout << "Ogrencinin yasi = " << a.yas << endl;
 cout << "Ogrencinin dogum tarihi = " << a.dogum_tarihi << endl;
  system("PAUSE");
 return 0;
}

Typedef İfadesi

C++ Programlama dilinde, kullandığımız veri türlerin isimlerini değiştirebiliriz. Örneğin; char yerine karakter; int yerine tamsayi diyebiliriz.

Örnek

typedef char karakter;
typedef int tamsayi;

Peki, bunun yapılar ile alakası ne? Typedef ifadesi yapılar ile birlikte de kullanılabilir.

Nesne Dizileri

Yapılarında bir veri türü olduğunu unutmamak gerekir. Bu yüzden yapılarla da veri türü oluşturabiliriz.

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
typedef struct kutuphane{
char *kitap_adi, *yazar_adi;
int kitap_no;
} kitap;
int main() {
kitap kitaplar[]={"Tutunamayanlar","Oguz Atay",1,"Dava","Franz Kafka",2};
cout << "Kitap Listesi" << endl;

cout << "Kitap Adi, Yazar Adi, No" << endl;
for(int i=0; i<2; i++) {
cout << kitaplar[i].kitap_adi << "," << kitaplar[i].yazar_adi << "," << kitaplar[i].kitap_no << endl;
}
system("PAUSE");
return 0;
} 

Yapılar ve Fonksiyonlar

Yapıları, fonksiyonlar ile beraber kullanabiliriz. Bir fonksiyonun geri dönüş değeri ve yahut parametre değeri bir yapı olabilir.

Örnek

struct kisi{
char *ad,*soyad;
}

şeklindeki kişi yapımızı kullanarak bir fonksiyon oluşturalım.

struct kalabalık kisi(...) {
struct kisi birey;
komutlar;
return birey;
}

Peki fonksiyona parametre olarak bir yapı göndereceksek nasıl bir tanımlama yapmalıyız?

Örnek

struct kalabalık kisi(struct kisi birey) {
komutlar;
return birey;
}

Önişlemci Komutların Kullanımı

Ön işlemci komutların yazım kuralları, aşağıdaki gibidir:

§  Her komut tek satırdan oluşur.

§  '#' (diyez) karakteri ile başlar ve daha sonra ön  işlemci komutu (Örneğin #include) ve gerekirse argüman içerir.

Şimdi ön işlemci komutlarına bir göz atalım

#include komutu

Şu ana kadar her programda kullandığımız bu komut, programa kütüphane dosyalarını dahil etmek için kullanılır. 

#define komutu

#define komutu, yardımıyla bir program parçasına isim verilebilir ve makro fonksiyon tanımlaması yapılabilir. Bu komutun kullanılması, programın okunabilirliğini ve anlaşılabilirliğini kolaylaştırır.

Kullanım

#define isim deger

Örnek

#include "stdafx.h"
#include <iostream>
#define basla int main() {
#define yaz cout
#define dur system("PAUSE");
#define return return 0;
#define bitir }
basla
yaz << "Islem basarili.";
dur
return
bitir

Gördüğünüz gibi #define komutunun kullanımı bu şekildedir.

#undef komutu

Daha önce tanımlanan sabit ve makroları sona erdirmek için kullanılır.

#if, #else, #endif, #elif, #indef ve #ifndef komutları

Bu komutlar, koşullu derleme yapmak için kullanılır.

Örnek

#if kosul
// koşul gerçekleşirse çalışacak olan komutlar
#elif kosul2
// koşul gerçekleşirse çalışacak olan komutlar
#else
// koşul gerçekleşmezse çalışacak olan komutlar
#endif

#error komutu

#error komutu, olumsuz bir durum ile karşılaşınca derleme işlemini durdurur ve uyarı mesajı verir.

#pragma komutu

#pragma komutu ise sistem parametrelerin ayarlanmasında kullanılır.

sizeof fonksiyonu

Hatırlayacağınız gibi değişkenler bellekte yer tutarlar ve tuttukları yerlerin kapladığı belirli bir alan vardır. İşte sizeof fonksiyonu belirttiğiniz değişkenin kapladığı alanı, byte değerinde, ekrana yazar.

Örnek

int a;
std::cout << sizeof a << endl; // A değişkeninin kapladığı alanı ekrana yazdırdık.
std::cout << sizeof(char); /* char tipinden bir değişken için bellekte ne kadar yer ayrıldığını ekrana yazdırmış olduk. */

Matematik Fonksiyonları

Adından da anlaşabileceği üzere matematik işlemlerini kolaylaştıran fonksiyonlardır. Bu fonksiyonları kullanmadan önce #include deyimi ile <cmath> kütüphanesini programımıza çağırmalıyız.

Kullanımı

11 adet matematik fonksiyonu vardır. Şimdi bunları görelim:

cos() = radyan olarak verilen açının kosinüsünü hesaplar,
sin() = radyan olarak verilen açının sinüsünü hesaplar.
tan() = radyan olarak verilen açının tanjantını hesaplar
exp() = ex değerini hesaplar
fabs() = mutlak değer hesaplar
ceil() = verilen değerden küçük olmayan en küçük tamsayıyı bulur
floor() = verilen değerden büyük olmayan en büyük tamsayıyı bulur
log() = verilen değerin In değerini hesaplar
log10 = verilen değerin 10 tabanındaki logaritmasını hesaplar
pow() = iki değerin kuvvetini hesaplar
sqrt() = verilen değerin karekökünü hesaplar

Kullanımları şu şekildedir;

sqrt(16); // 16'nın karekökünü hesapladık
pow(x,y); // x'in y'ye kuvvetini hesapladık

gibi.

Karakter Fonksiyonları

Adından da anlaşılabileceği gibi, bu fonksiyonlar ile karakterler üzerinde işlem yapabiliriz. Fakat bu fonksiyonlar yalnızca bir karakter üzerinde işlem yaparlar. Bu fonksiyonları kullanmadan önce #include deyimi ile <cctype> kütüphanesini programımıza çağırmalıyız.

Kullanımı

12 adet karakter fonksiyonu vardır.  Şimdi bunları görelim

isalpha() = verilen değerin harf olup olmadığını kontrol eder, harf değilse 0 değerini döndürür
isdigit = verilen değerin rakam olup olmadığını konrol eder.
isalnum = verilen değerin harf ve yahut rakam  olup olmadığını kontrol eder.
islower = verilen değerin küçük harf olup olmadığını sorgular.
isupper = verilen değerin büyük harf olup olmadığını sorgular.
isgraph = boşluk dışında verilen değerin yazılabilir karakter olup olmadığını sorgular
isprint = verilen değerin yazılabilir karakter olup olmadığını sorgular
isxdigit = verilen değerin onaltılık tabanda bir rakam olup olmadığını sorgular
isspace = verilen değerin boşluk olup olmadığını sorgular
iscntrl = verilen değerin kontrol karakteri olup olmadığını sorgular
tolower = büyük harfleri küçük harfe çevirir, değil ise aynı bırakır
toupper = küçük harfleri büyük harfe çevirir, değil ise aynı bırakır.

Tarih ve Zaman Fonksiyonları

Adından anlaşılacağı gibi , bu fonksiyonlar ile belirli özellikleri kullanacağız. Bu fonksiyonları kullanmadan önce #include deyimi ile <ctime> kütüphanesini programımıza çağırmalıyız. Bu fonksiyonların tamamına buradanulaşabilirsiniz.

Peki nesne yönelimli progralama nedir?

Nesne yönelimli programlama ve ya , birbiri ile alakalı ve sistematik olarak çalışabilecek, kod parçalarını bir arada tutarak yazılımın bir bütün olarak çalışmasını sağlayan bir programlama yaklaşımıdır.

Nesne yönelimli programlamanın üç özelliği vardır: Depolama (Encapsulation), Kapsülleme (Inheratence) ve Çok biçimlilik (Polimorfizm).

Temel Kavramlar

Nesneler, kendi içinde tanımlanan değişken ve fonksiyonlardan oluşur. Bir nesne içinde tanımlanan değişkenlere özellik, nesneye ait fonksiyonlara ise metod ve yahut davranış denir.

Sınıflar (Class)

Nesne Yönelimli Programlama'da sürekli olarak kullanacağımız sınflar, fonksiyon ve değişkenlerin bir arada toplandığı bir yapıdır.

Sınıf Bildirimi

Şimdi Sınıf bildirimi yapmayı öğreneceğiz. Sınıf bildirimi yaparken dikkat edeceğimiz bazı kurallar mevcut, şimdi onlara göz atalım.

§  Sınıf bildirimi, class deyimi ile başlar ve sınıfın adı yazılır.

§  Sınıf adı, tıpkı değişken gibi isimlendirilir. Yani değişken isimlendirmede olan kurallar, sınıf isimlendirmede de geçerlidir.

§  Sınıflar fonksiyonların dışında tanımlanır.

§  Sınıf bildirimi noktalı virgül ";" ile biter.

§  Aşağıdaki örnekte, public ve private kısmında, önce fonksiyonlar daha sonra veriler yazılmıştır. Bu durum tam terside olabilir.

§  Sınıf içinde bulunan, veriler ve fonksiyonlara, o sınıfın elemanları denir.

§  Private adı altında veri ve fonksiyon yazılmasına gerek yoktur. Çünkü {'tan sonra direk veriler ve fonksiyonlar yazılırsa otomatik olarak private olarak tanımlanır. Yanlız programın görünülürlüğü açısından yazmanızı öneririm.

Örnek bir sınıf prototipi

class sinif_adi {
private:
fonksiyonlar;
veriler;
public:
fonksiyonlar;
veriler;
} nesne_listesi;

Örnek bir sınıf bildirimi

#include "stdafx.h"
#include <iostream>
using namespace std;
class dikdortgen {
public:
 int kisa_kenar;
 int uzun_kenar;
 int alan() {
  return kisa_kenar*uzun_kenar;
 }
 int cevre() {
  return 2*(uzun_kenar+kisa_kenar);
 }
} x;
int main() {
 setlocale(LC_ALL,"Turkish");
 cout << "Kısa kenarı giriniz: ";
 cin >> x.kisa_kenar;
 cout << "Uzun kenarı giriniz: ";
 cin >> x.uzun_kenar;
 cout << "Dikdörtgenin alanı: " << x.alan() << endl;
 cout << "Dikdörtgenin çevresi : " << x.cevre() << endl;
 system("PAUSE");
 return 0;
}

Yapıcı Fonksiyonlar 

Bir sınıf içerisinde yer alan her hangi bir değişkene başlangıç değeri, verebilmek için yapıcı fonksiyonlar kullanılır. Yapıcı fonksiyonların belirli kuralları vardır. Kurallar şu şekilde.

§  Bir nesne oluşturulduğu zaman, o nesnenin yapıcı fonksiyonu otomatik olarak çağrılır.

§  Yapıcı fonksiyonların ismi, sınıf ismi ile aynı olmak zorundadır.

§  Birden fazla yapıcı fonksiyonlar tanımlanabilir.

§  Değer döndürmezler.

§  Nesne oluşturulurken, bir kez çalıştırılırlar.

§  Parametre alabilirler.

§  Yapıcı fonksiyon tanımlanmazsa, derleyici tarafından otomatik olarak belirlenir.

Yıkıcı Fonksiyonlar

Bir nesnenin yok edileceği zaman çalıştırılan fonksiyonlara, yıkıcı fonksiyonlar denir. 

Kuralları:

§  Yapıcı fonksiyonlar gibi, sınıf ismi ile isimleri aynıdır. Ancak isimlerinin yanında tilda (~) işareti bulunmalıdır.

§  Değer döndürmerzler.

§  Parametre almazlar.

§  Bir sınıf içerisinde sadece bir adet, yıkıcı fonksiyon olabilir.

§  Yapıcı fonksiyonlarda ki gibi, yıkıcı fonksiyonlar tanımlanmazsalar, derleyici tarafından otomatik olarak tanımlanacaktır.

Inline Fonksiyonlar

Program yazarken, fonksiyonları kullanmak yararlıdır. Ancak fonksiyonlar ne kadar çok olursa program çalıştırıldığında, o kadar çok fonksiyon çağrısı olacaktır. Bu yüzden Inline Fonksiyonları kullanırız. Inline Fonksiyonlar, programa ek olarak fonksiyonların getirdiği yükü azaltır. Fonksiyonun başına inline ekleyerek, kullanılır.

Örnek

inline char araba(int model);

Arkadaş Fonksiyonlar

Sınıfın dışında global olarak tanımlanan fonksiyonlara arkadaş fonksiyonlar denir. Bu fonksiyonlar sınıf içerisinde private verilere erişebilir. Bildirimi sınıfın her yerinde yapılabilir. Sadece sınıf ile fonksiyon arasında değil, sınıf ile sınıf arasında da bağ kurabilir. 

Bildirimi Şu Şekildedir:

class arkadas{
public:
friend int a;
};
void a {
...
}

Fonksiyonların Aşırı Yüklenmesi Nedir?

Bir fonksiyonun iki ya da daha fazla görevi yerine getirmeye çalışmasına, fonksiyonların aşırı yüklenmesi diyoruz. Fonksiyonların aşırı yüklenmesinin üç kuralı vardır;

1.     En az iki fonksiyon olmalı

2.     Bu fonksiyonlar aynı isme sahip olmalı

3.     Ve bu fonksiyonlar farkı argümalara sahip olmalıdır.

Bu üç kuralı sağlayan fonksiyonlar oluşturulduğunda, fonksiyonlar aşırı yüklenmiş oluyor. 

Örnek

#include "stdafx.h"
#include <iostream>
using namespace std;
int toplama(int sayi1,int sayi2){
 return sayi1+sayi2;
}
double toplama(double sayi1,double sayi2){
 return sayi1+sayi2;
}
int main() {
 int a;
 double b;
 a=toplama(10,6);
 b=toplama(15.8,10.2);
 cout << "Tamsayilari toplayalim " << a << endl;
 cout << "Ondalik sayilari toplayalim " << b << endl;
 system("PAUSE");
 return 0;
}

Not: Constructor (Yapıcı) fonksiyonların da aşırı yüklenebileceğini unutmayalım.

Operatörlerin Aşırı Yüklenmesi

C++'da operatörler, kendi anlamlarının dışında, yeni anlamlar kazanabilmektedir yani kendi istediğimiz işlemleri yapmalarını sağlayabiliriz. Buna operatörlerin aşırı yüklenmesi diyoruz.

Not: C++'da, ".", ".*", "::", "?:" ve sizeof operatörleri aşırı yüklenmezler.

Operatörlerin Aşırı Yüklenmelerinin Yapılışı

(dönüş tipi) (sınıf adı) :: operatör (aşırı yüklenecek operatör) (argüman listesi) {
fonksiyonun yapacakları;
}

Örnek

void ornek :: operator + (argumanlar)() // + operatörü aşırı yüklenmekte

Operatörlerin Aşırı Yükleme Sınırlamaları

§  Operatörün işlem yönü değiştirilemez.

§  Argüman sayısı değiştirilemez.

§  Var olan operatörler aşırı yüklenebilir.

§  Operatörlerin aşırı yüklenmesi kapalı bir şekilde olmamalıdır.

Dinamik Bellek Yönetimi

new Operatörü

Bellekten yer ayırmak istendiğinde kullanılan new operatörü bir tamsayıyı gösteren gösterici için bir tamsayılık yer aşağıdaki şekilde bellekte kendisine yer edinir.

 Kullanımı 

int *deneme
deneme = new int;

delete Opreatörü

Bellekten, new operatörü ile yer ayırdı isek ve bu ayırdığımız yeri geri vermek istiyorsak delete operatörü kullanılır.

 Kullanımı 

int *deneme
deneme = new int;
delete deneme;

Kalıtım

Hatırlayacağınız gibi kalıtımdan nesne yönelimli programlama konusunda bahsetmiştik. Nesne yönelimli programlamanın en önemli konusu, belki de kalıtımdır. Kalıtım, var olan bir ana sınıfın özelliklerinin yeri geldiğinde değiştirilerek yeri geldiğinde yeni özellikler ekleyerek bir alt sınıfa aktarılmasıdır. Kalıtım, yukarıdan aşağıya doğru hiyerarşik bir yapıda bulunur ve üst kademedeki ana sınıfa "temel sınıf", temel sınıftan alt sınıftaki sınıflara ise "türetilmiş sınıf" denir.

Temel Sınıf ve Türetilmiş Sınıf Tanımlama

Aşağıdaki örnekte ki gibi ana sınıftan bir türetilmiş sınıf tanımlarken öncelikle türetilmiş sınıfın adı yazılır ve devamında erişim türü ve ana sınıfın adı  yazılır. Erişim türü public ve ya private olabilir. Erişim türü her zaman yazılmak zorunda değildir, yazılmaz ise erişim türü private olarak sayılacaktır.

 Örnek 

class türetilen_sınıf : erisim_türü ana_sınıf{};

Public ile Sınıf Türetme

public olarak sınıf türetme işleminde, erişim türü public olarak yazılır. Bir sınıf bir başka sınıftan public olarak türetilirse, türetildiği ana sınıfın, public olan bütün elemanları türetilmiş sınıfında public elemanlarıdır. Türetilmiş sınıfın bütün nesneleri ana sınıfın public elemanlarına erişebilir.

Private ile Sınıf Türetme

Ana sınıftan public olarak sınıf türetebildiğimiz gibi private olarak ta bir sınıf türetebiliriz. private sınıf türetmede, ana sınıfın public üyeleri türetilmiş sınıfın private üyeleri haline gelir. Dikat edilmesi gereken nokta; sınıf türetme işlemi public de olsa private de olsa, ana sınıfın private üyelerine türetilmiş sınıf nesneleri erişemez.

Protected Elemanlar

Türetilmiş sınıfın, ana sınıftaki private bir üyeye erişiminin olmadığı daha önce söylemiştik. Fakat programlarımızda türetilmiş sınıfın, ana sınıfın private öğelerine erişmesini istediğimiz zamanlarda olacak. İşte tam bu noktada devreye Protected Elemanlar giriyor. Bir protected eleman bulunduğu sınıf için private olmasına rağmen diğer sınıflar için erişebiliyor.

 Örnek 

class sinif_adi{
protected:
komutlar;
fonksiyonlar;
public:
komutlar;
fonksiyonlar;
} nesne_listesi;

Protected ile Sınıf Türetme

public ve private de olduğu gibi protected olarak da sınıf türetilebilir. protected ile sınıf türetmede, ana sınıfın public ve ya protected elemanlarının türetilmiş sınıfın protected elemanları haline gelir.

Not: Aklıma gelmişken söyleyeyim, kalıtımda yapıcı ve fonksiyonlar da kullanılabilir.
Not-2: Kalıtımda nesne işaretçileri de kullanılabilir.

Çok Biçimlilik

Kalıtımda birbirleriyle ilişkili sınıfların her birinde yeniden tanımlanmış fonksiyonların tek bir sınıfın nesnesiyle çağrılmasına çok biçimlilik denir. Daha önce bahsetmiş olduğumuz fonksiyonların aşırı yüklenmesi de çok biçimliliktir.

 ÖRNEK  

class A {
public:
void eleman(){
}
};
class B:public A{
void eleman(){
}
};
int main() {
B nesne1;
A *aptr = nesne1;
aptr->eleman();
}

Sanal (Virtual) Fonksiyonlar

Çok biçimlilik ile birlikte kullanılan sanal fonksiyonlar, bir sınıfın fonksiyonunun miras alan diğer sınıflar tarafından kullanılmasını sağlamak için virtual anahtar kelimesiyle tanımlanır.

 ÖRNEK 

class dortgen
{
    public:
    virtual int alan(int taban, int yukseklik){
       return taban*yukseklik;
    }
    int cevre(int taban, int yukseklik){
       return 2*(taban+yukseklik);
    }
};

class ucgen : public dortgen
{
    public:
    int alan(int taban, int yukseklik){
       return (taban*yukseklik)/2;
    }
};

Not: Yapıcı fonksiyonlar sanal fonksiyon olamazlar. Ancak yıkıcı fonksiyon sanal olabilmektedir.

Akışlar

Akış sınıfları kalıtım ile birbirlerinden türetilmiş sınıflardır. C++'ta giriş çıkış işlemleri, akışlar kullanılarak yapılır. Genellikle iki tür akış kullanılır. Giriş akışları klavye ve ya dosya gibi bilgi sağlayıcı birimlerden gelen bilgiyi tutmaya yaramaktadır. Çıkış akışları ise monitör yazıcı gibi bilgi çıkışı olacak yerlerde bilginin yazıcı ya da monitörün bilgiyi vermeye hazır olmadığı zamanlarda tutulmasını sağlar.

C++'da Giriş ve Çıkış

iostream sınıfı, akış girdileriyle çalışırken kullanılacak birincil sınıftır.

ostream sınıfı, akış çıktılarıyla uğraşırken kullanılacak birincil sınıftır.

iostream sınıfı, input ve output'un ikisini de iki yönlü olarak kullanabilir.

C++'ta Standart Akışlar

Standart akış, derleyici tarafından bilgisayar programına sağlanırken bir ön-bağlama akışıdır. C++, sizin kullanmanız için önceden tanımlanmış dört standart akış nesnesi kurmuştur. Bunlar; cin, cout, cerr ve clog.

Manipülatörler

Manipülatörler kullanıcının giriş yaptığı karakterler veya sayıların belirli bir kısmını kullanmak istediğimizde kullanılırlar. Manipülatörleri kullanabilmek için <iomanip> kütüphanesini programımıza dahil etmeliyiz.

Örnek

...
#include <iomanip>
int main(){
char dizi[10];
cin >> setw(10) >> dizi;
}

Dizgiler için Akış Sınıfları

Dizgiler için akışın çalışması istream ve ostream gibi bilgiyi tutma yoluyla gerçekleşir. Dizgi akışlarının en önemli kullanımlarından bir tanesi, çıkıştaki bilgiyi sonraki bir zaman gösterilmesi için tutmak ya da bilgiyi satır satır ilerletmektir. Dizgi akışı için 6 tane sınıf bulunmaktadır. Bunlar; istringstream, ostringstream, stringstream, wistringstream, wostringsteam ve wstringsteam.

Not: Dizi akışlarını kullanabilmek için, <sstream> kütüphanesini programımıza dahil etmeliyiz.

stringsteam'de bilgi elde etmenin 2 yolu vardır.

1.     Çıkarma operatörünü kullanmak

2.     str("dizgi") fonksiyonunu kullanarak tamponun değerini atamak.

stringstream'de bilgi elde etmenin 2 yolu vardır.

1.     str() fonksiyon kullanarak tampondaki bilgileri elde etmek.

2.     Ekleme (>>) operatörü kullanmak.

Dizgi Akışlarını Temizlemek

Bunun için iki yol var. 

1.     str() kullanarak boş bir dize kurmak.

2.     clear()'ı çağırmak.

Dosya Giriş Sistemleri

Dosyalama işlemleri için öncelikle <fstream> kütüphanesini programımıza dahil etmeliyiz.

Dosya Çıkışı

Dosya çıkışı yapabilmek için öncelikle verilerin üzerine yazılacağı bir dosyamız olması gerekiyor. Bu dosya tanımlama işlemleri için ofstream sınıfı kullanılır.

Örnek

#include "stdafx.h"
#include <iostream>
#include <fstream>
using namespace std;
int main(){
ofstream dosya("dosya.txt");
if (!dosya) {
cerr << "Dosya acilmadi!!! << endl;
exit(1);
}
dosya <<  "İlker Akyel" << endl;
system("PAUSE");
return 0;
}

Bu program ile dosyaya İlker Akyel yazdık.

Dosya Girişi

Dosya girişi ile bir .txt dosyasındaki yazılanları programa dahil edebiliriz.

Örnek

.txt dosyamızda; Galatasaray yazıyor olsun.

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
int main() {
ifstream dosya("galatasaray.txt");
if (!dosya) {
cerr << "Dosya acilmadi!" << endl;
exit(1);
}
while(dosya){
string isim;
getline(dosya,isim);
cout << isim << endl;
}
system("PAUSE");
return 0;
}

Dosyada yazılan "Galatasaray"ı ekrana yazdırdık.