C++ Kalıtım (inheritance)

Kalıtım (inheritance) bir nesnenin başka bir nesnenin özelliklerini birebir devralmasıdır. Eğer
tanımlamak istediğimiz bir nesne önceden tanımlanmış bir nesnenin de özelliklerine sahip ise kalıtım
yolu ile bu nesnenin özeliklerini alıp ek özellikleri ilave ederek nesneyi oluşturabiliriz.
Özellikleri devralınan sınıf Temel sınıf(base class) olarak
isimlendirilir. Temel sınıfın dahil edildiği sınıf türemiş sınıf(Derived class) olarak isimlendirilir.
Bir türemiş sınıf şu şekilde tanımlanır:
class Türemiş Sınıf : Erişim türü Temel Sınıf{

};

#include
#include
using namespace std;
class Cokgen {
protected:
int genislik, yukseklik;
public:
void DegerVer(int x,int y) {
genislik=x; yukseklik=y;
}
};
class Kare : public Cokgen{ // Kare sınıfı Cokgen sınıfından turetiliyor
public:
int Alan () {return genislik*yukseklik;}
};
class Ucgen : public Cokgen{ // Ücgen sınıfı Cokgen sınıfından türetiliyor.
public:
int Alan () {return (genislik*yukseklik)/2;}
};
int main ()
{
Kare D1;
Ucgen U1;
//D1 Kare nesnesinin genişlik ve yüksekliğine değeri atanıyor.
D1.DegerVer(3,3);
//U1 Ucgen nesnesinin genişlik ve yüksekliğine değeri atanıyor.
U1.DegerVer(7,2);
cout << “Kare Alan: ” << D1.Alan()<<endl;
cout << “Ucgen Alan: ” << U1.Alan()<<endl;
getch();
return 0;
}

C++ Dynamic memory usage

C++ da ise dinamik bellek işlemlerini gerçekleştirmek için daha çok yeteneğe sahip new ve delete komutları kullanılır. new bellek ten yer almak için, delete ise alınan yerleri geri vermek için kullanılır.

#include

using namespace std;

int main()
{
int *p;
p=new int; // tamsayi bir değer için bellekten yer al
*p=50; // Ayrılan yerin(adresin) içine 50 degerini at
cout<<*p<<endl;
delete p; //ayrılan yeri serbest bırak

cout<<“——————————————————–“<<endl;

int *x=new int[5];//ifadesi 5 elemanlı int türünden bir dizi için bellekte yer ayırmakta ve
//başlangıç adresini p ye atamaktadır.
x[0]=5; x[1]=2; //Dizi elemanlarına sanki normal bir dizi gibi erişilebilir.
cout<<“dizinin 1.elemanina ulastik::” <<x[0]<<endl;
cout<<“dizinin 2.elemanina ulastik::” <<*(x+1)<<endl;

}

———————————————————————————————————–

C++ Name Space

Takım halinde bir yazılım geliştirmek için programcılar bir araya geldiklerinde, her programcı kendine ait bir takım değişkenler ve fonksiyonlar tanımlar. Programlar bir araya getirildiğinde ise aynı isimde birden fazla değişken ve fonksiyon tanımlaması ile karşılaşılabilir. Bu durumda isim çakışması meydana gelir. Bunu önlemek için C++ de her programcının kendine ait bir name space tanımlamasına imkan verilmiştir.. Her bir isim uzayındaki değişkenler sadece o isim uzayı içinde tanınırlar.

#include
using namespace std;
namespace x
{
int a = 45465;
}

namespace y
{
string a = “HERMES”;
}

int main()
{
cout << x::a << endl;
cout << y::a << endl;

}

——————————————————————–

Herzaman x::a yazmaktansa bunun yerine daha kolaylık olsun diye using deyimini kullanabiliriz.

#include
using namespace std;
namespace x
{
int a = 45465;
string b=”FLAMA”;
}

namespace y
{
string a = “HERMES”;
int b=7884;
}

int main()
{

{
using namespace x;
cout < cout << b << endl;

}

{
using namespace y;
cout < cout << b << endl;

}

}

——————————————————————-

C++ scope resolution

Bir C++ programında global olarak tanımlanan bir değişkenle, yerel olarak tanımlanan bir değişken aynı isme sahip olabilir. Bu durumda yerel olarak tanımlanan değişken global olarak tanımlanan değişkene göre önceliğe sahiptir. Bir başka ifade ile en içte yer alan bloktaki değişken bir üsttekini örter.

Yaşam alanı belirtme (scope Resolution)operatörü(::) kullanılarak örtülmüş olan verilere erişebiliriz.

#include
int x = 3; //global x
using namespace std;

int main()
{
int x; //yerel x
x=5;
cout<< “Yerel degisken: ” << x ;
cout<< ” \nGlobal degisken: ” << ::x <<endl;
}

——————————————————————–

C++ Function overloading

C++ da isimleri aynı yaptıkları işler farklı fonksiyonlar yazılabilir. Buna göre iki farklı fonksiyon, parametrelerinin tipleri, sayıları veya sıraları farklı olmak koşulu ile aynı isme sahip olabilirler. Derleyici hangi fonksiyonun çağrıldığını parametre listesine bakarak karar verir. Aynı isimde birden fazla fonksiyonun tanımlanmasına fonksiyonların aşırı yüklenmesi
(function overloading) denir. Aşırı yüklenmiş fonksiyonlar, birbiriyle alakalı işlemlerin aynı adla çağrılmasına izin vererek programın karmaşıklığını azaltabilirler.

#include
#include
#include
#include

using namespace std;
void yaz();
void yaz(int);
void yaz(char, int);

int main()

{

yaz();
yaz(3);
yaz(‘B’, 30);
getch();
return 0;
}

void yaz()
{
for(int j=0; j<30; j++)
cout << ‘H’;
cout << endl;
}

void yaz(int ch)
{
for(int j=0; j<30; j++)
cout << ch;
cout << endl;
}
void yaz(char ch, int n)
{
for(int j=0; j<n; j++) // n defa döner
cout << ch;
cout << endl;
}

——————————————————-

Yukarıda da görüldüğü gibi 3 adet yaz fonksiyonumuz var. Bunların parametreleri farklı yada parametre sayıları farklı olmalıdır.Buna göre fonksiyon hangi işlemi yapacağına kendisi karar verir.

C++ Random number generation

rand fonksiyonu her çağırıldığında [0, RAND_MAX] aralığında rasgele bir tamsayı değerini geri döndürür. RAND_MAX stdlib.h başlık dosyası içinde 32767 olarak tanımlanmıştır.Rasgele sayı üreticilerinin (random number generator) kullandıkları başlangıç değerine tohum değeri (seed) denir. rand fonksiyonunu içeren programı her çalıştırdığımızda aynı tohum değerinden başlayacağı için aynı sayı zinciri elde edilecektir.

Aşağıdaki program her çalıştığında aynı değeri alır.

#include
#include
#include
using namespace std;

int main()
{
int x;
for (x = 0; x < 10; ++x)
cout<< rand()<<endl;
return 0;
}

—————————————————————————-

İşte ikinci fonksiyon olan srand fonksiyonu, rasgele sayı üreticisinin tohum değerini değiştirmeye yarar:

Programlarda bazen belirli bir aralıkta rasgele sayı üretmek isteyebiliriz. Bu durumda mod
operatörü kullanılabilir :
rand() % 2 Yalnızca 0 ya da 1 değerini üretir.
rand() % 6 0 – 5 aralığında rasgele bir değer üretir
rand() % 6 + 1 1 – 6 aralığında rasgele bir değer üretir.

C++ Function default initial values ​​of the parameters

Fonksiyonlar tanımlanırken parametrelerin varsayılan başlangıç değerleri de verilebilir. Böylece fonksiyon çağrıldığında parametre kullanılmamış ise kullanılmayan parametrenin varsayılan değeri fonksiyon için de kullanılır. Parametre değeri verilmiş ise bu takdirde bu değer fonksiyon içinde kullanılacaktır.

#include
#include
using namespace std;
int divide (int x=10, int y=5)
{
int r;
r=x/y;
return (r);
}

int main()
{
cout << divide ( )<<endl;
cout << divide (15)<<endl;
cout << divide (21,3)<< endl;
return 0;
}

——————————————————————

divide ( ) şeklinde fonksiyon çağrıldığında x değişkeni 10 ve y değişkeni 5 değerini alacak ve
fonksiyonda buna göre değerler hesaplanacaktır. Sonuç 2 olacaktır.

divide (15) şeklinde fonksiyon çağrıldığında x değişkeni 15 ve y değişkeni 5 değerini alacak
ve fonksiyonda buna göre değerler hesaplanacaktır. Sonuç 3 olacaktır.

divide (21,3) şeklinde fonksiyon çağrıldığında ise x=21 ve y=3 değerini alacak ve
fonksiyonda buna göre değerler hesaplanacaktır. Sonuç 7 olacaktır.

C++ Functions of the parameters to be passed by reference

#include
#include
using namespace std;
void degistir1( int &x, int &y ) // Referans ile parametre aktarımı
{
int gecici;
gecici = x;
x = y;
y = gecici;
}
void degistir2( int *x, int *y )
{
int gecici;
gecici = *x;
*x = *y;
*y = gecici;
}

int main()
{
int a, b;
a = 12;
b = 27;
cout<< “degistir1 before a: “<<a<<” b : “<<b<<endl;
degistir1(a, b);
cout<< “degistir1 after a: “<<a<<” b : “<<b<<endl;

cout<<“———————————-“<<endl;
cout<< “degistir2 before a: “<<a<<” b : “<<b<<endl;
degistir2(&a, &b);// Argumanları aktarırken, baslarina & konur
cout<< “degistir2 after: a: “<<a<<” b : “<<b<<endl;
return 0;
}

—————————————————————————————-

C++ Fonksiyonlar

Fonksiyonlar belirli bir amaç için yazılmış program parçalarıdır ve programcının programını modüler hale getirmesini sağlamaktadır. Fonksiyonlar bir başka ifade ile böl ve yönet (divide and conquer) prensibinin
uygulanmasına imkan vermektedir.Başka bir sebep ise yazılımın yeniden kullanılmasıdır.

Aşağıda verilen programda minimum isimli fonksiyona üç tamsayı parametre olarak gönderilmekte ve en küçük değer geriye döndürülmekte ve ana program içinde dönen değer ekrana yazdırılmaktadır.

#include
#include
int minimum( int, int, int );
using namespace std;

int main()
{
int a, b, c;
cout<>a>>b>>c ;
cout<< “Minimum: “<< minimum( a, b, c )<<” dir\n” ;
return 0;

}

int minimum( int x, int y, int z )
{
int mini = x;
if ( y < mini )
mini= y;
if ( z <mini )
mini = z;
return mini;
}

—————————————————————————————————————————–

Adres ile çağırma

Geriye birden fazla değer döndermek gerekirse veya fonksiyon içinde yapılan işlemlerin
fonksiyona gönderilen parametre değişkenini etkilemesi isteniyorsa adres ile çağırma yöntemi
kullanılır.

#include
#include
using namespace std;
void degistir1( int x, int y )
{
int gecici;
gecici = x;
x = y;
y = gecici;
}
void degistir2( int *x, int *y )
{
int gecici;
gecici = *x;
*x = *y;
*y = gecici;
}

int main()
{
int a, b;
a = 12;
b = 27;
cout<< “degistir1 before a: “<<a<<” b : “<<b<<endl;
degistir1(a, b);
cout<< “degistir1 after a: “<<a<<” b : “<<b<<endl;

cout<<“———————————-“<<endl;
cout<< “degistir2 before a: “<<a<<” b : “<<b<<endl;
degistir2(&a, &b);//!!!!!
cout<< “degistir2 after: a: “<<a<<” b : “<<b<<endl;
return 0;
}

degistir1() fonksiyonunda fonksiyona a ve b değerlerin kopyası yerel değişkenler x ve y ye geçirilmektedir . Değişim bu yerel değişkenler üzerinde olmaktadır. Fonksiyon sonlandığında yerel değişkenlerde yok olmaktadır. Dolayısı ile a ve b değişkenleri yer değişmemiş olmaktadır.

Degistir2 () fonksiyonunda ise a ve b değişkenlerinin adresleri fonksiyona geçirilmektedir. Adreslerin içindeki değerler yer değiştiğinden ve fonksiyondan çıktıktan sonrada bu değişken adresleri kaybolmayacağından değişim işlemi gerçekleşmektedir

C++ Pointers

Pointers, bellek alanındaki herhangi bir gözün adresinin saklandığı değişkenlerdir. Pointers verileri değil o verilerin bulunduğu yerlerin bellek adreslerini tutarlar. Tüm Pointersbellekte kapladığı alan int boyutundadır. Her değişken bellekte yer kapladığına göre belirli bir adrese sahiptir. Değişkenlerin adresleri, derleyici ve işletim sistemi tarafından ortaklaşa
olarak belirlenir.

float *f; -> f değişkeni float türünden bir değişkenin adresini tutacaktır.
char *s; -> s değişkeni char türünden bir değişkenin adresini tutacaktır.
int *dizi; -> dizi değişkeni int türünden bir değişkenin adresini tutacaktır.

& ya da adres operatörü, operandın adresini döndüren bir tekli operatördür.
* operatörü hem gösterici tanımlanırken kullanılır. hemde göstericinin tuttuğu adresin içindeki değere ulaşmak için kullanılır.

#include
using namespace std;
int main()
{
int x, *y;
long f=0x12345678 , *a;
x=45;
y=&x;
a=&f;
cout<< y<<endl;
cout<<*y<<endl;
cout<<x<<endl;
cout<<*a<<endl;
}

Yukarıdaki kod parcacığında ilk başta int olarak x ve *y (pointer) tanımladık. Daha x değişkenine 45 değerini verdik.
Daha sonra y=&x ile x adresini y eşitledik. Artık y nin içeriginde x saklı. Eğer adresini yazdırmak istersek y yazabiliriz. Eğer verdiğimiz 45 değerini yazdırmak istersek *y yapabiliriz.