C++ : Daha iyi bir C

C++ programlama dili ,C diline bazı özelliklerin eklenmesiyle oluşturulmuştur.
Yapılan eklemeler üç grupta toplanabilir:
1.Programcıların kodlama aşamasında kullanabilecekleri teknik özellikler.
Bunlar programlama yöntemiyle ilgili değildir.
2.Nesneye dayalı programlama yöntemini destekleyen özellikler.
3.Üretken programlamayı(generic programming) destekleyen özellikler.
C++ , C dilinin bir üst kümesi olduğundan bu dilin hemen hemen tüm özelliklerini içerir.



Nesneye dayalı programlama ile ilgili olmayan ,ancak kodlama aşamasında C diline göre üstünlükler sağlayan eklentiler:

Tek satırlık açıklamalar

C de kullanılan /* */ sembolleri arasına yazılan ve birden fazla satıra yayılabilen açıklamalara ek olarak , C++ da sadece tek satır uzunluğunda olabilen ve // simgesiyle başlayan açıklamalar yazmak mümkündür.

z=x/y // açıklama satırı

Tanımlar(definition)

Değişkenler C dilinde blokların başlarında tanımlanırken C++ dilinde değişkenlerin kullanıldığı satırdan bir önce veya aynı satırda olabilir.
Bir veri ilk tanımlandığı yerden itibaren geçerli olup, tanımlandığı bloktan çıkınca geçerliliği sona erer. Bir verinin geçerli olduğu bloğa o verinin yaşam alanı (scope )denir.

Örnek
C’de C++ ‘da
{ {
int a; int a,b,c;
float b; c=a*b;
: int d;
: d=d/2;
} }
Burada a ve b geçerliliğini kaybeder. Burada da a, b, c,d geçerliliğini kaybeder.
C++ a diğer bir örnek
for (int i=0; i<n; ++i)

Bildirimler(Declarations)

Bir bildirim yapıldığında, derleyiciye o program dosyasında kullanılacak olan verilerin yada fonksiyonların sadece adı ve tipleri belirtilmiş olur. Bildirimler veriler veya fonksiyonlar
için bellekte yer ayırtmazlar.

Örnek
void fonksiyon(float,int); // burada bellekte yer ayrılmaz
void fonksiyon(float a,int b); // burada bellekte yer ayrılır


struct Date { // bu bildirimde de bellekte yer ayrılmaz
int day, month, year;
};

Date d1,d2; // bellekte d1 ve d2 için ayrı ayrı 6 bytlık yer ayrılacaktır.

Yaşam alanı (scope)

Bir C++ programında iç içe yer alan bloklarda, aynı isimde veriler tanımlanabilir. Böyle bir durumda iç bloktaki (yerel)veri, aynı isme sahip olan dış bloktakini(global) örter(değeri bozulmaz).
Yaşam alanı belirtme (scope Resolution)operatörü(::) kullanılarak örtülmüş olan verilere de ulaşmak mümkündür.

int a=3;
int b=2;
void fonk( ) {
int a=1;
::a++; //global a=4
a++; //yerel a=2
b++; // global b=3
}

İsim uzayı (Name Space)

Program boyları büyüdükçe yazılan programlarda isim çakışması olabildiği gibi, nesne veya
fonksiyon arşivlerinin kullanımlarında da çakışmalar olabilir . Bunu önlemek için C++ da
isim uzayı kavramı kullanılmaktadır

namespace programcı1 {
int no;
:
}
namespace programcı2 {
int no;
void fonk(char);
:
}

İsim uzayında verilere erişilmesi:
Programcı2::no=1234;
Programcı1::no= 78;
Programcı2::fonk(&#8216;a&#8217;)

using Bildirimi:

İsim uzaylarındaki verilere her erişimde uzayında isminin yazılması gereğini ortadan kaldırarak erişimi kolaylaştırmak için using bildirimi kullanılmaktadır.
using programcı2::no; //isim uzayında bir değişken için geçerli
no=1234;
Programcı1::no= 78;
Programcı2::fonk(&#8216;a&#8217;);

Bu bildirim istenirse tek bir veri yerine isim uzayının tamamı için yapılabilir. Bunu için using namespace sözcükleri birlikte kullanılır.

using programcı2; //isim uzayının tamamı için geçerli
no=1234;
fonk(&#8216;a&#8217;)
Programcı1::no= 78; //diğer isim uzayı için isim belirtmek gerekli

Standart C++ Başlık(Header )Dosyaları

C++ ın ilk sürümlerinde başlık dosyalarında .h uzantıları kullanılmıştır.
Değişik işletim sistemi ve derleyicilerde değişik uzantılar olduğu için uzantılar tamamen kaldırılmıştır. Standart arşivler düzenlenirken tüm veriler std adındaki bir isim uzayı içinde tanımlanmıştır. C den gelen başlık dosyaları da başına c harfi koyarak yeni standarda uydurulmuştur.
Yeni derleyici Eski derleyici
#include<iostream> #include<iostream.h>
using namespace std;

C&#8217; de C++&#8217; da

#include <stdio.h> #include <cstdio>
#include <stdlib.h> #include <cstdlib>

Giriş/ Çıkış İşlemleri

C++ da C den farklı olarak giriş/çıkış fonksiyonlarının yerine giriş /çıkış nesneleri kullanılır.

Cin : Standart giriş birimi. Çoğunlukla tuş takımı işlemlerinde kullanılır. Cin >>
Cout : Standart çıkış birimi. Çoğunlukla ekran işlemlerinde kullanılır. Cout<<

Örnek 1
#include<iostream>
using namespace std;
int main( ) {
int a,b;
float c;
a=150;
b=305;
c=25.125;
cout<<&#8221;değerler: &#8220;;
cout <<a;
cout <<&#8217; &#8216;;
cout<<b;
cout <<&#8217; &#8216;;
cout<<c;
return 0;
}

programın sonucu:

değerler: 150 305 25.125

Örnek 1
#include<iostream>
using namespace std;
int main( ) {
int a,b;
float c;
a=150;
b=305;
c=25.125
cout<<&#8221;değerler: &#8220;;
cout <<a<<&#8217; &#8216;<<b<<&#8217; &#8216;<<c;
return 0;
}

programın sonucu:

değerler: 150 305 25.125

Mantıksal Değişkenler

C dilinde, doğru(true),yanlış(false) gibi mantıksal değerleri tutmak için özel değişkenler yoktur.Bu işlemler için de tamsayılar kullanılır. Sıfırdan farklı değerler doğru(true) olarak kabul edilirken sıfır değeri yanlış (false) olarak kabul edilir.

C++ da C deki durum korunurken ayrıca bool ve true, false sözcükleri de derleyiciye eklenmiştir.
Örnek
Bool esit; //mantıksal değişken
esit= false ;
int x=0;
int y=0;

esit = x = = y;
if(esit)---

Sabitler
Standart C dilinde sabitler tanımlamak için önişlemcinin #define direktifi kullanılmaktadır.
#define PI 3.14
C++ da ise const sözcüğü kullanılır.

const int i = 100; //i sabittir ve değeri 100 dür.
........
i=5; // Derleme hatası i sabit olarak tanımlanmıştır, değiştirilemez.
Diğer bir gösteriliş şekli

int const i = 100; //const int i =100; ile aynı

Dinamik Bellek Yönetimi

C dilinde bellekte yer alma gerektiğinde malloc( ),ayrılan yeri geri vermek için de free( )
fonksiyonları kullanılıyordu. C++ da ise dinamik bellek işlemlerini gerçekleştirmek için C ye göre kullanımı daha kolay olan ve daha çok yeteneğe sahip operatörler tanımlanmıştır. Bu operatörlerden new bellek ten yer almak için, delete ise alınan yerleri geri vermek için kullanılır. Bu operatörlerin genel kullanım formu aşağıdaki gibidir.
p_var = new type;
delete p_var;
type, bellekte yer ayrılan nesnenin türü, p_var ise göstericinin türüdür. new operatörü ,type ile türü belirtilen nesneyi alacak kadar büyüklüğü olan belleğe bir gösterici(pointer) döndürür. delete ise iş bittiğinde belleği geri verir. delete sadece daha önce new ile ayrılmış belleğin göstericisi ile çağrılır. delete başka gösterici ile çağrılırsa program kilitlenebilir.

Yer ayırma işleminin gerçekleşmesi için yeteri kadar bellek bulunmuyorsa , ya boş bir gösterici döndürür veya bir ayrıcaklı durum oluşur. (Bu hatalar çalışma anında ortaya çıkar)
Uygulamada hata durumunda new &#8216;ün göstericisinin boş dönüp dönmediğini kontrol etmek yeni derleyiciye zarar vermeyeceğinden şimdilik kontrol etmekte yarar vardır. En iyisi derleyicinin dokümanına bakmaktır. New ve delete&#8217;in malloc() ve free&#8217;ye göre aşağıdaki üstünlükleri vardır.

1) new size of komutunu kullanmadan nesnenin tipine göre yeterli miktarda yer ayırır.
2) Kendiliğinden belirtilen tip için bir gösterici döndürür.
3) new ve delete komutlarının her ikisi de yeniden yüklenebilir. Bu sayede kendi özel yer ayırma sisteminizi oluşturma olanağı tanınır.
4) Dinamik olarak oluşturulmuş bir nesneye hazırlık amacıyla başlangıç öncesi iş yaptırmak mümkündür.
5) <cstdlib> satırını da program içerisinde bulundurulması gerekmez.

örnek:
#include<iostream>
using namespace std;
int main() {
int *p;
p=new int; // tamsayı için bellekte yer ayırır
if(!p){
cout<<&#8221;bellekte yer ayırma hatası&#8221;\&#8221;;
return 1;
}
*p=100;
cout<<&#8221;p&#8217; deki tamsayı: &#8220;<<*p<<&#8221;\n&#8221;;
delete p;
return 0;
}
dinamik olarak yer ayrılan belleğe başlangıç değeri genel formülü aşağıda gösterildiği gibi başlangıç değeri atanabilir.

p_var=new type (ilk_değer);
Yukarıdaki örneği

örnek:
#include<iostream>
using namespace std;
int main() {
int *p;
p=new int(100);
if(!p){
cout<<&#8221;bellekte yer ayırma hatası&#8221;\&#8221;;
return 1;
}
cout<<&#8221;p&#8217; deki tamsayı: &#8220;<<*p<<&#8221;\n&#8221;;
delete p;
return 0;
}

new kullanarak tek boyutlu diziye dinamik bellek ayrılmak istenirse aşağıdaki genel formül kullanılır.

p_var=new type[eleman sayısı]

bu komut çalıştırıldığında p_var&#8217;a dizinin ilk elemanının adresi atanacaktır. Bazı teknik sebeplerden diziye ilk değer atmak mümkün değildir. Ayrılan yeri yok etmek için delete[]p; şekli kullanılır.
Örnek;
------
------
int *p=new int[10];
if(!p){
cout<<&#8221;bellekte yer ayırma hatası&#8221;\&#8221;;
return 1;
for(int k=0; k<10; k++) // Tanıtım ortalarda olabilir
p[k] = 0;
delete [ ] p;
----
----

Fonksiyon Bildirimleri Tanımları

1) C++ dilinde hata olasılığını azaltmak için fonksiyon çağrılırken tür kontrolleri yapmak zorunludur. Fonksiyon çağrıldığı programda(dosyada ) bildirimi yani prototipi olmalıdır. Prototipte parametrelerin sadece türleri belirtilirken , fonksiyonun çağrıldığı yerde gerçek argümanların isimleri bulunur(sabit veya değişken).

char basari(int, int, int); // basari adli fonksiyonun prototipi (bildirimi)
Fonksiyonun tanımında parametrelerin gerçek adları yer alacaktır:
char basari (int vize1, int vize2, int final) // basari adli fonksiyonun tanımı
{
char sonuc;
&#8230;&#8230;&#8230;&#8230; // Fonksiyonun gövdesi, sonuc uygun şekilde hesaplanacak
return sonuc;
}

2) Bir fonksiyonun parametresi yoksa ,C de parametre olarak void yazılmalıdır. C++ da ise hiç bir şey yazılmaz.
İnt fonk(void) // C de
int fonk( ) // C++ da
3) C++ da fonksiyon geriye bir değer gönderecek şekilde tanıtılmışsa mutlaka o değeri göndermelidir. Yani return deyimi mutlaka bir değer içermelidir. C de fonksiyonun döndüreceği sonucun türü tam olarak belirlenmezse bu türün tamsayı olduğu varsayılır. C++ da böyle bir durum olmadığı için fonksiyonların return türü tam olarak belirlenmelidir.
4) C de yerel değişkenler sadece blokların başında tanımlanırken , C++ da ilk kullanıldıkları yere yakın bir yerde tanımlanabilirler.

İnline fonksiyonlar(Makrolar)

C dilinde makroları tanımlamak için önişlemcinin #define direktifi kullanılmaktadır. C++ da ise makrolar normal fonksiyonlar gibi yazılabilmektedir.

Fonksiyonların gövdeleri bir kez derlenir ve makine dilindeki kod belleğe yerleştirilir. Bu fonksiyon her çağrıldığında çağıran programdan fonksiyonun koduna gidilir ve bu kod yürütüldükten sonra yine çağıran programa dönülür.
Makrolarda ise, çağrının yapıldığı her yere makronun kodu eklenir. Yani her makro çağrısı programın boyunun uzamasına neden olur. Burada başka bir koda gitme, geri gelme ve parametre aktarımı olmadığından makro çağrıları daha hızlı gerçekleşirler. Özellikle hızlı çalışmasını istediğimiz ve kodu kısa olan program parçalarını makro olarak oluşturmak doğru olacaktır.

//bir inline fonksiyon örneği
#include<iostream>
using namespace std;
inline int tek(int x)
{
return (x%2);
}
int main() {
int y;
if (tek(y))
cout <<y<< &#8220; tek sayıdır \n&#8221;;
else
cout<<y << &#8220; cift sayıdır \n&#8221;;
return 0;
}
(inline fonksiyonlar class lar içerisinde değişik şekillerde kullanılacaktır.)
Fonksiyon Parametrelerine Başlangıç Değerlerinin Verilmesi

Örnek olarak aşağıda üç adet parametre alan bir fonksiyon tanımlanmıştır. Birinci parametrenin ( char c, int i1 = 0 , int i2 = 1) // i1 ,i2 nin başlangıç değerleri var
{
........ //fonksiyonun gövdesi
........
}

Bu fonksiyon aşağıdaki gibi üç farklı şekilde çağrılabilir:

fon(&#8216;A&#8217;,4,6); // c=&#8217;A&#8217;, i1= 4, i2=6
fon(&#8216;B&#8217;,3 ); // c=&#8217;B&#8217;, i1= 3, i2=1
fon(&#8216;C&#8217;); // c=&#8217;C&#8217;, i1= 0, i2=1
Bir fonksiyon çağrılırken parametrelere karşı düşecek olan argümanlar soldan sağa doğru verilmelidir.
fon(&#8216;C&#8217;,,7 ); //HATA! İkinci parametre eksik bırakılmış, üçüncü verilmiş

fonksiyonlar yazılırken de parametrelere başlangıç değerleri sağdan başlanarak ve parametre atlamadan verilmelidir.
void fon(char c= &#8216;A&#8217;, int i1, int i2 =1) // HATA ! Aradaki parametre atlanmış

Fonksiyonların Aşırı Yüklenmesi( Function overloading)
C++ derleyicileri fonksiyonları birbirinden ayırırken sadece isimlerini değil parametre listelerini de dikkate alırlar. Buna göre iki farklı fonksiyon, parametrelerinin tipleri, sayıları veya sıraları farklı olmak koşulu ile aynı isme sahip olabilirler. Bir fonksiyonun ismi ve parametre listesi o fonksiyonun imzasını ( signature) oluştururlar.
İki veya daha fazla fonksiyon aynı adı paylaşıyorsa onlara aşırı yüklenmiş denir. Aşırı yüklenmiş fonksiyonlar, birbiriyle alakalı işlemlerin aynı adla çağrılmasına izin vererek programın karmaşıklığını azaltabilirler.

PROGRAM 1
// Programın normal yazılmış hali
#include<iostream.h>
//using namespace std;
int absi(int n){
return n<0 ? -n :n;}

float absf(float n){
return n<0 ? -n :n;}

double absd(double n){
return n<0 ? -n :n;}

main()
{
int j=5;int l=-6; float r=-10.5;double x=-12.1234567898;

cout<<endl;
cout<<"k="<<absi(j)<<endl;
cout<<"lk="<<absi(l)<<endl;
cout<<"s="<<absf(r)<<endl;
cout<<"y="<<absd(x)<<endl;
return 0;
}
Çıktılar

j=5, l=6, r=10.5, x=12.1234567898

PROGRAM 2
// parametre türleri farklı aynı isimde kullanılmaları
#include<iostream.h>
//using namespace std;
int abs(int n){
return n<0 ? -n :n;}

float abs(float n){
return n<0 ? -n :n;}

double abs(double n){
return n<0 ? -n :n;}

main()
{
int j=5;int l=-6; float r=-10.5;double x=-12.1234567898;

cout<<endl;
cout<<"j"<<abs(j)<<endl;
cout<<"l="<<abs(l)<<endl;
cout<<"r="<<abs(r)<<endl;
cout<<"x="<<abs(x)<<endl;
return 0;
}
Çıktılar

j=5, l=6, r=10.5, x=12.1234567898

PROGRAM 3
// Parametre sayıları farklı
#include<iostream.h>
using namespace std;
int topla(int x,int y)
{
int tp1;
tp1=x+y;
return tp1;
}
int topla(int a,int b,int c)
{
int tp2;
tp2=a+b+c;
return tp2;
}
main(){
int a,b,c,t,p;
a=5; b=3; c=4; t=2; p=6;
int r,s,q;
r=topla(a,t);
s=topla(c,b,p);
q=topla(9,b);
cout<<"r="<<r<<" s="<<s<<" q="<<q<<endl;
return 0;
}
Çıktılar
r=7, s=13, q=12

PROGRAM 4
// parametre sayıları ve türleri farklı
#include<iostream.h>
using namespace std;
int topla(int x,int y)
{
int tp1;
tp1=x+y;
return tp1;
}
float topla(int a,float b,float c)
{
float tp2;
tp2=a+b+c;
return tp2;
}
main(){
int a,t,p;
float b,c;
a=5; b=6.4; c=7.2; t=2; p=6;
int r,q;
float s;
r=topla(a,t);
s=topla(p,b,c);
q=topla(9,b);
cout<<"r="<<r<<" s="<<s<<" q="<<q<<endl;
return 0;
}
Çıktılar
r=7, s=19.6, q=15

PROGRAM 5
#include <iostream>
using namespace std;
struct ComplexT{ // Karmaşık sayıları için bir yapı
float re,im; // reel ve sanal kısımlar
};
void print (float deger){ // reel sayılar için
cout <<" deger = " << deger << endl;
}
void print (ComplexT c){ // Karmaşık sayılar için
cout <<"reel= " << c.re << " , sanal= " << c.im << endl;
}
void print (float deger,char c){ // reel sayılar ve char için
cout << "deger= " << deger << " , c= " << c << endl;
}
int main()
{
ComplexT z; Çıktılar
z.re=0.5;
z.im=1.2; reel=0.5, sanal=1.2
print(z); değer=4.2
print(4.2); değer=2.5, c=A
print(2.5,'A');
return 0;
}

Referans
C++'da ampersan (&) simgesini kullanarak değişkenler için referanslar tanımlamak mümkündür. Bir değişken için referans tanımlanması aynı bellek gözüne ikinci bir isim vermek demektirDiğer taraftan referansa bir değişkenin diğer ismi gibi davranan bir göstericidir de denilebilir. Referanslar, bağımsız bir referans oluşturularak, bir fonksiyona geçirilerek, ve bir fonksiyon tarafından döndürülerek üç farklı şekilde kullanılırlar.

Örnek1
// gösterici
int b; // b bir tamsayı değişkeni
int *a = &b; // a bir gösterici olarak tanımlanmış ve b nin adresi a ya aktarılmış
* a = 10; // a ya 10 değeri aktarılır. Bu b nin değerini de 10 yapar

// referans
int b; // b bir tamsayı değişkeni
int &a = b; // burada a bir referans olarak b nin adresini göstermektedir
a = 10; // a ya 10 değeri aktarılır. Bu b nin değerinide 10 yapar.

örnek 2
int i = 5;
int &j = i; // j, i'ye bir referanstır. j ve i aynı adrese sahipler.
j++; // i = 6 olmuştur.

Fonksiyonlara Parametrelerin Referans Olarak Gönderilmesi
C'de eğer parametre olarak gönderilen bir verinin orijinal değerinin fonksiyon
içinde değişmesi isteniyorsa bu durumda o verinin adresinin parametre olarak
fonksiyona gönderilmesi gerekir.

Örnek 1
//gösterici ile
#include <iostream>
using namespace std;
void f(int *n); // gösterici(gösterici) parametresi kullanma işlemi
int main()
{
int i = 0;
f(&i);
cout << &#8220;i&#8217;nin yeni değeri: &#8220; << i << &#8216;\n&#8217;;
return 0;
}
void f(int *n)
{
*n = 100; // n tarafından gösterilen argümana 100 yerleştirme
}

//referans ile
#include <iostream>
using namespace std;
void f(int &n); // referans parametresi bildirme
int main(){
int i = 0;
f(i);
cout << &#8220;i&#8217;nin yeni değeri: &#8220; << i << &#8216;\n&#8217;;
return 0;
}
void f(int &n) // f( ) artık referans parametresi kullanıyor
n = 100; // şimdiki komut için * operatörüne gerek kalmamıştır
} // f() çağırmak için kullanılan argümana 100 koy

Örnek 2
/* C'deki Çözüm: Göstericiler*/
void hesap(int *j) {
*j = *j**j/2; /* Okuması ve anlaması zor */
}
int main()
{
int i=5;
hesap(&i); /* i'nin adresi gönderiliyor */
return 0;
}
Örnekte kullanılan & simgesi adres operatörüdür (referans değildir).

Aynı fonksiyonun C++'da referanslar kullanılarak yazılması
// C++'da referanslar ile çözüm
void hesap(int &j) // j gelecek olan veriye bir referanstır, aynı adrese sahiptir
{ j = j*j/2; } // Fonksiyonun gövdesi, j normal bir değişken gibi
int main( )
{
int i=5;
hesap(i);
return 0;
}
Büyük boyutlu veriler bir fonksiyona parametre olarak aktarılırken değerleri yerine adreslerinin aktarılması tercih edilir.Çünkü değer olarak aktarılması durumunda büyük boyutlu verinin tamamı yığına kopyalanacaktır.Bu da hem bellekte fazla yer harcanmasına hem de programın yavaşlamasına neden olacaktır. Eğer bir veri içeriğinin değişmesi için değil, sadece aktarım zamanını kısaltmak için referans olarak aktarılacaksa fonksiyondaki referans parametresi sabit (const) olarak tanımlanmalıdır.

Örnek 3
#include <iostream> // Giriş/çıkış için
#include <cstring> // Karakter katarları için
using namespace std;
struct Kisi{ // Kişileri tanımlamak için bir yapı
char isim [40]; // İsim alanı 40 sekizli
int sicil_no; // Sicilno alanı 4 sekizli
}; // Toplam 44 sekizli
void goster (const Kisi &k) // parametre sabit referans
{
cout << "İsim: " << k.isim << endl; // isim ekrana
cout << "No: " << k.sicil_no << endl; // sicil_no ekrana
}
int main(){
Kisi ahmet; // Kisi tipinden bir veri ahmet
strcpy(ahmet.isim,"Ahmet Bilir"); // isim = "Ahmet Bilir"
ahmet.sicil_no=324; // sicil_no= 324
goster(ahmet); // Fonksiyon çağırılıyor.
return 0;
}

Fonksiyonlardan Verilerin Referans Olarak Döndürülmesi
C++'da ise gerekli olduğu durumlarda geri döndürülen veri bir referans olarak tanımlanabilir ve bu durumda değer aktarımı adresler ile yapılır. Bu tür aktarım iki yarar sağlar:
&#8226; Büyük boyutlu veriler yığına kopyalanmamış olur
&#8226; Geri döndürülen adrese çağıran program içinde atama yapılabilir
// max fonksiyonu dizinin başlangıç adresini ve uzunluğunu
// alıyor en büyük elemana bir referansı geri döndürüyor
int& max(int a[], int uzunluk)
{
int i=0; // i en büyük elemanın indisi olacak
for (int j= 0 ; j<uzunluk ; j++) // En büyük eleman aranıyor
if (a[j] > a[i]) i = j;
return a[i]; // Eleman geri döndürülüyor (referans)
}

int main()
{
int dizi[] = {12, -54 , 0 , 123, 63}; // Bir dizi tanımlanıyor, değerler atanıyor
max(dizi,5) = 0; // En buyuk eleman bulundu ve sıfırlandı
for(int i=0; i<5; i++)
cout << array[i] << " "; // Dizi ekranda görüntüleniyor
return 0;

Böyle durumlarda geri döndürülen verinin ana programda değiştirilmemesi istenebilir. Bunu sağlamak için geriye sabit (const) referanslar döndürülür. Büyük boyutlu verileri geri döndürmek için de referanslar kullanılır.
// max fonksiyonu dizinin başlangıç adresini ve uzunluğunu alıyor
// en büyük elemana bir sabit referansı geri döndürüyor
const int& max(int a[], int uzunluk)
{
int i=0; // i en büyük elemanın indisi olacak
for (int j= 0 ; j<uzunluk ; j++) // En büyük eleman aranıyor
if (a[j] > a[i]) i = j;
return a[i]; // Eleman geri döndürülüyor (referans)
}
Bu şekilde yazılan fonksiyon atama deyimlerinin sadece sağında yer alabilir.
int main()
{
int buyuk; // En büyük elemanı tutacak değişken
int dizi[] = {12, -54 , 0 , 123, 63}; // Bir dizi tanımlanıyor, değerler atanıyor
buyuk = max(dizi,5); // En buyuk eleman buyuk'e atandı
return 0;
}
Yerel değişkenler referans ile döndürülemez!
Yerel değişkenler sadece tanımlandıkları bloğun içinde geçerlidirler. Benzer
şekilde bir fonksiyonun içinde tanımlanan yerel değişkenler de fonksiyondan
çıkıldıktan sonra bellekten kaldırılırlar.
int& f( ) // Referans ile veri geri döndürülecek
{
int i; // Yerel değişken. Bir çok sistemde yığında yaratılır
:
return i; // Hata! i'nin adresi artık geçerli değildir.
}
Doğru olan yerel değişkenlerin değer olarak döndürülmeleridir.
int f( ) // Değer döndürülecek
{
int i; // Yerel değişken. Bir çok sistemde yığında yaratılır
:
return i; // Doğru, çünkü değer döndürülüyor.
}
Operatörlerin Aşırı Yüklenmeleri( Operator Overloading)

Genel formülü
Dönüş tipi sınıf adı::operatör#(argüman_listesi)
{
// gerçekleştirilecek işlem
}
C++'da, + , - , *, !, ++ gibi operatörlere ilişkin fonksiyonlar yazılarak bu operatörlere yeni işlevler yüklenebilir.
&#8226; Sadece C++'da zaten var olan operatörler için fonksiyon yazılabilir. Örneğin C++'da var olmayan '^' operatörü için üs almak üzere bir fonksiyon yazılamaz.
&#8226; Operatörlerin orijinalindeki operand sayısı değiştirilemez. Örneğin '+' operatörü için mutlaka iki operandlı (parametreli) bir fonksiyon, '!' operatörüiçin tek operandlı bir fonksiyon yazmak gerekir.
&#8226; Operatörlerin orijinal öncelikleri değiştirilemez. Örneğin yeni bir işlev yüklense bile '*' operatörü her zaman '+' operatöründen daha önceliklidir. Bir operatöre işlev yükleyen fonksiyonların adı operator özel sözcüğünü içerir. Örneğin '+' operatörüne işlev yükleyecek olan fonksiyonun adı operator+ ve '*' operatörüne işlev yükleyecek olan fonksiyonun adı da operator* olmalıdır.

İkili operatörlerin aşırı yüklenmesi
Bir üye operatör fonksiyonu bir ikili operatörü aşırı yüklediğinde , bu fonksiyonun sadece tek parametresi olacaktır. Bu parametre operatörün sağ tarafındaki nesneyi alacaktır. Sol taraftaki nesne ise operatör fonksiyonunu çağıran nesnedir ve üstü kapalı olarak this tarafından gönderilir.

// Example for opertor overloading
struct ComplexT{ // Karmaşık sayıları tanımlamak için bir yapı
float re,im; // Reel ve sanal kısımlar
};
// + operatörünün karmaşık sayıları toplamak için yüklenmesi
ComplexT operator+ (const ComplexT &v1, const ComplexT &v2)
{
ComplexT sonuc; // sonucun yazılacağı yerel değişken
sonuc.re=v1.re+v2.re; // reel kısımlar toplanıyor
sonuc.im=v1.im+v2.im; // sanal kısımlar toplanıyor
return sonuc; // sonuç çağıran programa döndürülüyor
}
void print (ComplexT c){ //kompleks sayıları yazan print fonksiyonu
cout<< "real= " << c.re << " im= " << c.im << endl;
}
int main()
{
ComplexT c1,c2,c3; // Üç adet karmaşık sayı tanımlanıyor
c1.re= 0.5; // Sayıların alanları dolduruluyor
c1.im= -1;
c2.re= 1.5;
c2.im= 0.5;
c3= c1 + c2;
// Yukarıdaki operator+ fonksiyonu
print(c3); // c3= operator+(c1,c2); aynı işi yapar
return 0;
}

NESNE MODELLERİ : SINIFLAR 4/10/2004
Bu bölümünden itibaren C++ programlama dilinin nesneye dayalı programlamaya yönelik özellikleri tanıtılacaktır. C++ ın en önemli özelliği sınıflardır. Bu özellikler yazılımların kalitesini yükseltmek amacıyla geliştirilmişlerdir.Bilgisayar programı yazmanın, aslında gerçek dünyadaki unsurların bilgisayarda birer modellerinin oluşturulması anlamına gelir.
Gerçek dünya nesnelerden oluşmaktadır. Bu nedenle bilgisayar programları da bu nesnelerin modellerinden oluşturulmaktadır.

Nesne Nedir?
Gerçek dünyada bir nesne iki kısımdan oluşur:
1. Nitelikler. Buna durumlar ya da özellikler de denir.
2. Davranışlar (yetenekler).
Nesnelerin bilgisayarda kurulan modellerinde ise aşağıda gösterildiği gibi nitelikleri belirtmek için veriler, davranışları belirtmek için de fonksiyonlar kullanılacaktır.
Gerçek dünyada nesne = Nitelikler + Davranışlar
Yazılım dünyasında nesne = Veriler + Fonksiyonlar

Sınıflar ve Nesneler
C++'da nesnelerin modellerini oluşturmak için sınıf ( class) adı verilen bir yapı kullanılmaktadır. class&#8217;ların bildirimi yapılarınkine benzer bir şekilde yapılır. Bu bildirimin genel formatı şu şekildedir.
Class sınıf _adı {
// private (özel) fonksiyonlar ve değişkenler
public:
// public (genel) fonksiyonlar ve değişkenler

Örnek olarak grafik programlarında kullanılacak nokta nesnelerini tanımlamak üzere bir model tasarlansın. Noktalar iki boyutlu düzlemde yer alacağından özellik olarak iki adet koordinat bilgisine sahiptirler:
&#8226; x ve y koordinatları. Bu özellikler tamsayı değişkenler ile ifade edilebilirler.
Örnek programımızda noktaların sahip olması gereken yetenekler (davranışlar) ise şunlardır:
&#8226; Noktalar, düzlemde herhangi bir yere konumlanabilmeli: git fonksiyonu
&#8226; Noktalar bulundukları koordinatları ekrana çıkartabilmeli: goster fonksiyonu
&#8226; Noktalar, sıfır (0,0) koordinatında olup olmadıkları sorusunu yanıtlayabilmeli: sifir_mi
fonksiyonu
Bu yapı bir nesneyi oluşturacak olan verileri ve fonksiyonları birlikte barındırmaktadır.
Sınıflar, nesnelerin modeli diğer bir deyişle şablonudur. Programda bir kez sınıf yazılıp şablon oluşturulduktan sonra o sınıftan gerektiği kadar nesne yaratılabilir.
Nokta sınıfı:
class Nokta{ // Nokta Sınıfı
int x,y; // Nitelikler: x ve y koordinatları
public:
void git(int, int); // Noktanın hareket etmesini sağlayan fonksiyon
void goster(); // Noktanın koordinatlarını ekrana çıkartır
bool sifir_mi(); // Noktanın (0,0) koordinatlarında olup olmadığı
};

Bildirim class sözcüğü ile başlar, daha sonra sınıfın ismi gelir (Nokta).
Yukarıdaki örnekte önce veriler sonra fonksiyonlar yazılmıştır. Bu sıra ters de olabilir.
Sınıfın içindeki veri ve fonksiyonlara o sınıfın üyeleri ( member) denir. Sınıf bildirimi noktalı virgül (;) ile bitirilir. Örnek sınıf bildiriminin içinde fonksiyonların sadece prototipleri yer
almaktadır. Fonksiyonların gövdeleri ise ayrı bir yerde tanımlanabilir. Sınıf class kelimesi kullanılarak bildirimi yapılır. Üye fonksiyonlara o sınıfın metotları da ( method) denilmektedir.

// ***** Üye Fonksiyonların Gövdeleri *****
Sınıfa ait fonksiyonların genel formatı aşağıda şekilde olduğu gibidir.

döndürme_ tipi sınıf_adı::fonksiyon_ adı (parametre_listesi)
{
// fonksiyon yordamı(gövdesi)
}

Burada sınıf_ adı fonksiyonların ait olduğu sınıfın adıdır. Üye fonksiyonları tanımlamak için , sınıfın tip adını fonksiyon adıyla bağlamak gerekir. Bu işlem , sınıf adı ve iki nokta üst üste işaretlerinin ardından fonksiyonun adı yazılarak yapılabilir. Yan yana yazılmış olan iki tane iki nokta üst üste işaretine kapsam çözümleme operatörü adı verilir.

// Noktanın hareket etmesini sağlayan fonksiyon
void Nokta::git(int yeni_x, int yeni_y)
{
x = yeni_x; // x koordinatına yeni değer atandı
y = yeni_y; // y koordinatına yeni değer atandı
}
// Noktanın koordinatlarını ekrana çıkaran fonksiyon
void Nokta::goster()
{
cout << "X= " << x << ", Y= " << y << endl;
}
// Noktanın (0,0) koordinatlarında olup olmadığını belirten fonksiyon
bool Nokta::sifir_mi()
{
return (x == 0) && (y == 0); // x=0 VE y=0 ise doğru
}

Üye fonksiyonların gövdeleri de yazıldıktan sonra Nokta modeli (şablon) tamamlanmıştır. Artık bu sınıftan gerektiği kadar nokta nesnesi yaratılabilir. Sınıfa ait bir nesne oluşturulduğunda , yapıya ait üyelere erişildiği gibi, nokta(dot, periyot) operatörünü kullanarak bu nesnelere de erişilebilir.

int main()
{
Nokta n1,n2; // 2 adet nesne tanımlandı n1 ve n2
n1.git(100,50); // n1 (100,50)'ye gönderiliyor
n1.goster(); // n1'in koordinatları ekrana çıkartılıyor
n1.git(20,65); // n1 (20,65)'e gönderiliyor
n1.goster(); // n1'in koordinatları ekrana çıkartılıyor
if(n1.sifir_mi()) // n1 sıfır da mı?
cout << "n1 şu anda sıfır noktasındadır." << endl;
else
cout << "n1 şu anda sıfır noktasında değildir." << endl;
n2.git(0,0); // n2 (0,0)'a gönderiliyor
if(n2.sifir_mi()) // n2 sıfır da mı?
cout << "n2 şu anda sıfır noktasındadır." << endl;
else
cout << "n2 şu anda sıfır noktasında değildir." << endl;
return 0;
}
// ekran cıktıları
// X=100, Y=50
// X=20, Y=65
// n1 şu anda sıfır noktasında değildir.
// n2 şu anda sıfır noktasında değildir.

Programda iki adet nesne (n1 ve n2) tanımlanmıştır. Bu nesnelerin üye fonksiyonları çağırılarak nesnelerin belli davranışlarda bulunmaları sağlanmıştır. Nesnelerin metotlarının canlandırılmasına o nesneye mesaj göndermek denir.

Değerlendirme:
Sınıflar ve nesneler hakkında bu aşamaya kadar öğrenilenler değerlendirildiğinde şu sonuçlara varılabilir:
Sınıflar 'aktif' veri tipleridir. Bu tiplerden nesneler tanımlanır. Nesnelere mesajlar gönderildiğinde nesneler bir davranışta bulunarak cevap verirler. Sınıflar hem verileri hem de bu veriler üstünde işlem yapan fonksiyonları aynı paket içinde barındırırlar ( DEPOLAMA) (ENCAPSULATION). Depolama, kodu ve kodun işlediği verileri bir araya getiren ve onları dış etkilerden , yanlış kullanımlardan koruyan mekanizmadır. Nesneye dayalı dillerde kod ve veri, bir &#8220;kara kutu&#8221; oluşturacak şekilde bir araya getirilir. Kod ve verinin bu şekilde birbirine bağlanmasıyla da nesne meydana getirilmiş olur. Diğer bir deyişle nesne depolama yaptığımız yerdir. Bunun sonucu olarak:
&#8226; Nesneler gerçek dünyadakine benzer şekilde modellenebilir,
&#8226; Program daha kolay okunabilir, çünkü birbirleriyle ilgili olan veriler ve fonksiyonlar bir
aradadır,
&#8226; Hataları bulmak kolay olur, çünkü bu veriler üzerinde işlem yapabilen fonksiyonlar bellidir.

Sınıf Üyelerine Erişimin Denetlenmesi
Programcılar, sınıfların oluşturulması ve kullanılması açısından ikiye ayrılırlar.Birincisi sınıfları yazan programcılardır. İkincisi ise sınıfları kullanarak nesneler yaratan ve bu nesnelere mesajlar göndererek onların canlandıran programcılardır. Sınıfı oluşturan programcı sınıf yapısının doğru çalışmasından sorumludur. Sınıfı nesne tanımlamak için kullanan programcı sınıfın iç yapısını bilmek zorunda değildir. Bilmesi gereken tek şey nesnelere nasıl mesaj yollanacağıdır. Bu özellikleri sağlamak için, sınıfı yazan programcı, sınıfın bazı üyelerini gizleyerek ( data hiding) onlara sınıf dışından erişilmesini engelleyebilir. Bir sınıfın içindeki üyelere erişimi denetleyen üç farklı etiket bulunmaktadır: public (açık), private (özel) ve protected (korumalı). Açık (public) olarak tanımlanan üyelere, bu sınıftan yaratılan tüm nesneler yoluyla erişilebilir.
Özel (private) olarak tanımlanan üyelere (veri ve fonksiyon) ise sadece sınıfın içindeki fonksiyonlar erişebilir. Bu sınıftan yaratılan nesneler üzerinden özel üyelere erişmek mümkün değildir.
Korumalı (protected) üyeler ise kalıtım ( inheritance) özelliği ile birlikte kullanılmaktadır. Kalıtım konusu anlatılırken korumalı erişim yöntemi de açıklanacaktır.

Bir sınıfın içindeki açık elemanlar o sınıfın dışarıya verdiği hizmetleri ( services) tanımlarlar. Bunların tümüne sınıfın arayüzü ( interface) denir. Özel üyeler sınıfın gerçeklenmesiyle ( implementation) ilgili olduklarından sınıfın kullanıcılarını ilgilendirmezler. Bir sınıftaki üyelerin erişim tipi normalde özeldir (private). Sınıfın yazarı dışarıya açmak istediği üyelerin tanımından önce public: etiketini koyar. Bu nedenle örnekteki Nokta sınıfındaki ilk iki üye (x , y) özeldir ve dışarıya kapalıdır. Ana programda yaratılan nesneler üzerinden bu verilere erişmek mümkün değildir.





Örnek olarak Nokta sınıfından üretilen noktaların hareket alanlarının x ekseninde 0-500, y ekseninde ise 0-300 aralığında olması ve noktalar bu alanın dışına çıkamamaları istensin.
class Nokta{ // Nokta Sınıfı
int x,y; // özel (private) Nitelikler: x ve y koordinatları
public: // açık (public) üyeler
bool git(int, int); // Noktanın hareket etmesini sağlayan fonksiyon
void goster(); // Noktanın koordinatlarını ekrana çıkartır
bool sifir_mi(); // Noktanın (0,0) koordinatlarında olup olmadığı
};
// Noktanın hareket etmesini sağlayan fonksiyon
bool Nokta::git(int yeni_x, int yeni_y)
{
if( yeni_x > 0 && yeni_x < 500 && // yeni_x 0-500 aralığında ise
yeni_y > 0 && yeni_y < 300) // yeni_y 0-300 aralığında ise
{
x = yeni_x; // x koordinatına yeni değer atandı
y = yeni_y; // y koordinatına yeni değer atandı
return true; // atama yapıldı, hata yok
}
return false; // Giriş değerleri kabul edilmedi
}
Yeni yazılan git fonksiyonu geriye bir mantıksal değer döndürmektedir. Bu değer sayesinde fonksiyona gönderilen koordinatların kabul edilip edilmediği anlaşılmaktadır.

int main()
{
Nokta n1; // n1 nesnesi yaratıldı
int x,y; // Tuş takımından değer okumak için iki değişken tanımlandı
cout << "Noktanın gideceği koordinatları veriniz "
cin >> x >> y; // Tuş takımından iki değer okunuyor
if( n1.git(x,y) ) // git fonksiyonu çağırılıyor ve sonuç değerlendiriliyor
n1.goster(); // Atama yapıldıysa ekrana yeni koordinatlar çıkacak
else
cout << "\nGirilen değerler kabul edilmemiştir";
}
Erişim Etiketlerinin Geçerlilik Alanları:
Bir erişim etiketi yazıldığı yerden aşağıya doğru geçerli olur. Bu etiketin altında yer alan tüm veriler ve fonksiyonlar etikette belirtilen erişim türüne sahip olurlar. Bir etiketin geçerlilik alanı, başka bir etiket yazıldığında ya da sınıfın sonuna gelindiğinde sona erer.

C++'da struct Yapısı:
C++'da struct yapısı da class ile aynı işlevi yerine getirmekte ve sınıf bildirimleri için kullanılmaktadır. struct ile class arasındaki tek fark üyelerin erişim haklarında ortaya çıkmaktadır. class bildirimlerinde aksi bildirilmedikçe üyelerin erişim tipi özeldir (private)
struct bildirimlerinde ise aksi bildirilmedikçe üyelerin erişim tipi açıktır (public).

Metotların inline Fonksiyon (Makro) Olarak Tanımlanmaları:
Nokta sınıfının bildiriminde metotların (üye fonksiyonların) sadece prototipleri yer almaktadır. Fonksiyonların gövdeleri ise sınıfın dışında tanımlanmıştı. Metotların gövdeleri de sınıf bildiriminin içine yazılabilir. Bu durumda o fonksiyon makro (inline) olarak tanımlanmış olur İnline fonksiyonu sınıf bildiriminin içinde tanımlanmışsa inline anahtar kelimesi artık gerekli değildir.( Fakat kullanılmasında da bir sakınca yoktur.)

Aşağıdaki örnekte sifir_mi adlı üye fonksiyon sınıfın içine yazılarak makro
olarak tanımlanmıştır.
class Nokta{ // Nokta Sınıfı
int x,y; // Nitelikler: x ve y koordinatları
public:
void git(int, int); // Noktanın hareket etmesini sağlayan fonksiyon
void goster(); // Noktanın koordinatlarını ekrana çıkartır
bool sifir_mi() // Noktanın (0,0) koordinatlarında olup olmadığı (makro)
{
return (x == 0) && (y == 0);
}
};

Sabit Nesneler ve Sabit Fonksiyonlar

Diğer veri tiplerinde olduğu gibi bir nesne de sabit (const) olarak tanımlanabilir. Bunun anlamı nesnenin veri alanlarının program boyunca doğrudan ya da dolaylı olarak (fonksiyon çağırarak) değiştirilemeyeceğidir.

const Nokta sn(10,20); // Sabit nokta
Derleyiciler sabit olarak tanımlanan nesnelerin içeriklerinin değişmemesi için bu nesnelerin üye fonksiyonlarının çağırılmasına izin vermezler. Sınıfın yazarları üye veriler üzerinde değişiklik yapmayan fonksiyonları da sabit (const) olarak bildirmelidirler. Sabit nesneler için sadece sabit fonksiyonlar çağırılabilirler.

DEVAMI SAYFA 2'DE >>