3. aşırı yükleme yaşam alanı - dinamik bellek kullanımı

KBUZEM
Karabük Üniversitesi
Uzaktan Eğitim Araştırma ve Uygulama Merkezi
3. HAFTA
NESNEYE DAYALI PROGRAMLAMA

BLM225
Nesneye Dayalı Programlama
2
3. Fonksiyonların Aşırı Yüklenmesi( Function
overloading) ve çok biçimlilik
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.
Çok biçimlilik (polimorfizm), genel anlamda bir adın, birbirleriyle ilişkili fakat teknik açıdan
farklı iki veya daha fazla amaç için kullanılabilmesi yeteneğidir.
C++'da çok biçimlilik özelliği, fonksiyonlara yeni görev yükleme veya bir başka değişle
fonksiyonlara aşırı yükleme (function overloading) ile sağlanabilir. Aşağıdaki programı
inceleyiniz.
#include <conio.h>
#include <iostream.h>
#include <iostream>
#include <string>
#include <list>
using namespace std;
void print()
{
cout<<"printed"<<endl;
}
void print(char c, int a)
{
for(int i=0; i<a;i++)
{
cout<<c<<endl;
}
}
int main()
{
print();
print('a', 6);
getch();
return 0;
}
Karabük Üniversitesi Uzaktan Eğitim Araştırma ve Uygulama Merkezi
Mühendislik Fakültesi No: 215 Balıklarkayası Mevkii 78050 Karabük TÜRKİYE
2

BLM225
3
#include <iostream>
void yaz(); //Bildirimler
void yaz(char);
void yaz(char, int);
int main()
{
yaz();
yaz('=');
yaz('+', 30);
cin.get();
return 0;
}
//--------------------------------------------------------------
// 45 defa * yazar
void yaz()
{
for(int j=0; j<45; j++) // herzaman 45 kez döner
cout << '*';
cout << endl;
}
//--------------------------------------------------------------
// belirtilen karakteri 45 kez yazar
void yaz(char ch)
{
for(int j=0; j<45; j++)
cout << ch;
cout << endl;
}
//--------------------------------------------------------------
// Belirtilen karakteri n kez yazar
void yaz(char ch, int n)
{
for(int j=0; j<n; j++) // n defa döner
cout << ch;
cout << endl;
}
3

BLM225
4
Operatörlerin Aşırı Yüklenmesi( Operator Overloading)
C++'da, + , - , *, !, ++ gibi operatörlere fonksiyonlar yazarak bu operatörlere yeni işlevler
yüklenebilir. Sadece C++'da zaten var olan operatörler aşırı yüklenebilir. Örneğin C++'da var
olmayan '^' operatörü için üs almak üzere bir fonksiyon yazılamaz. Fonksiyonlar
tanımlanırken operatörün orjinalinde var olan operand sayısı değiştirilemez. Örneğin '+'
operatörü iki değişken değerini toplar. Değişken sayısı tek olamaz. Ayrıca daha önceki
konularda geçtiği gibi operatörlerin öncelik sırası değiştirilemez. Bir 4, -, *, ! gibi bir işlem
operatörlerine ‘operator’ sözcüğü ile yükleme yapılır. Örneğin toplama operatörü ‘+’
operatörüne “operator+” şeklinde isim verilerek yükleme yapılır. Operatrör aşırı yüklemesi
aşağıda gösterildiği gibi yapılır.
DönüşTipi operatorOperatörismi(parametre listesi)
{
// gerçekleştirilecek işlem
}
a
55
56
57
ekran
55
57
4

BLM225
5
#include <conio.h>
#include <iostream>
struct Mat {
int a,b;
};
void goster( Mat m){
cout<<"a="<<m.a<<endl;
cout<<"b="<<m.b<<endl;
}
Mat operator+(Mat mt1, Mat mt2)
{
Mat sonuc;
sonuc.a=mt1.a + mt2.a;
sonuc.b=mt1.b + mt2.b;
return sonuc;
}
int main( )
{
Mat sayi1;
Mat sayi2;
Mat toplam;
sayi1.a=5;
sayi1.b=4;
sayi2.a=5;
sayi2.b=4;
toplam=sayi1+sayi2;
cout<<"a="<<toplam.a<<endl;
cout<<"b="<<toplam.b<<endl;
5

BLM225
6
goster(toplam);
getch();
return 0;
}
#include <conio.h>
#include <iostream>
struct Mat
{
int a; int b;
};
Mat operator+(Mat x, Mat y)
{
Mat sonuc;
sonuc.a=x.a-y.a; sonuc.b=x.b-y.b;
return sonuc;
}
int main () {
int a,b;
a=5; b=4;
b=b+a;
cout<<b<<endl;
Mat m1,m2,m3;
m1.a=6; m1.b=4; m2.a=3; m2.b=5;
m3=m1+m2;
cout<<m3.a<< "," <<m3.b<<endl;
getch();
return 0;
}
Örnek olarak aşağıda verile programda ‘+’ operatörü iki karmaşık sayıyı toplamak için aşırı
yüklenmektedir.
6

BLM225
7
#include <conio.h>
#include <iostream>
#include <iostream>
struct KarmasikSayi{ // Karmaşık sayıları tanımlamak için bir yapı
float reel,sanal; // Reel ve sanal kısımlar
};
// + operatörünün karmaşık sayıları toplamak için yüklenmesi
KarmasikSayi operator+ (const KarmasikSayi &v1, const KarmasikSayi &v2)
{
KarmasikSayi sonuc; // sonucun yazılacağı yerel değişken
sonuc.reel=v1.reel+v2.reel; // reel kısımlar toplanıyor
sonuc.sanal=v1.sanal+v2.sanal; // sanal kısımlar toplanıyor
return sonuc; // sonuç çağıran programa döndürülüyor
}
void yaz (KarmasikSayi c){ //kompleks sayıları yazan print fonksiyonu
cout<< "reel= " << c.reel << " sanal= " << c.sanal << endl;
}
int main()
{
int a,b;
a=5;
b=1;
a=a+b;
cout<<"a="<<a<<endl;
KarmasikSayi c1,c2,c3; // Üç adet karmaşık sayı tanımlanıyor
c1.reel= 3;
c1.sanal= -1;
c2.reel= 2.5;
c2.sanal= 0.7;
c3= c1 + c2; // Burada + iki karmaşık sayıyı topluyor
yaz(c3);
getch();
return 0;
}
7

BLM225
8
//prefix
#include <conio.h>
#include <iostream>
#include <string>
#include <list>
struct Mat{
int x;
int y;
}m1;
void operator++(Mat m1)
{
Mat mr;
mr.x=(m1.x)+1;
mr.y=(m1.y)+1;
cout<<mr.x<<","<<mr.y<<endl;
}
int main()
{
m1.x=5; m1.y=5;
++m1;
m1.x++;
cout<<m1.x<<endl;
++m1;
getch();
return 0;
}
8

BLM225
9
//prefix
#include <conio.h>
struct Mat{
int x;
int y;
void operator++()
{
x++;
y++;
cout<<x<<","<<y<<endl;
}
}m1;
int main()
{
m1.x=5; m1.y=5;
++m1;
m1.x++;
cout<<m1.x<<endl;
++m1;
getch();
return 0;
}
//postfix
#include <conio.h>
struct Mat{
int x;
int y;
9

BLM225
10
void operator++(int)
{
x++;
y++;
cout<<x<<","<<y<<endl;
}
}m1;
int main()
{
m1.x=5; m1.y=5;
m1++;
m1.x++;
cout<<m1.x<<endl;
m1++;
getch();
return 0;
}
4.1 Yaşam alanı (scope)
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şerek kullanmak mümkün olmaktadır. (::) operatörü kısaca kapsam (scope) operatörü
olarak da ifade edilmektedir. Aşağıda verilen programı inceleyiniz.
#include <conio.h>
#include <iostream>
int a=6;
int main( )
10

BLM225
11
{
int a=5;
cout<<"a="<<a<<endl;
cout<<"a="<<::a<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
int main ()
{
int a=5;
int i;
for(i=0;i<3; i++)
{
a++;
int k=1;
}
k++; // error
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <iostream>
int k = 10; //global k
int main()
{
int k; //yerel k
11

BLM225
12
for (k = 0; k < 5; ++k)
{
cout<< " yerel degisken " << k ;
cout<< " Global degisken " << ::k <<endl;
}
::k++;
cout<<endl;
cout<< " Donguden sonra n " ;
cout<< " yerel degisken " << k ;
cout<< " Global degisken " << ::k <<endl;
getch();
return 0;
}
İsim uzayı (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 isim uzayı tanımlamasına imkân verilmiştir.
#include <conio.h>
#include <iostream>
namespace zafer
{
int a = 5;
}
namespace salih
{
int a = 6;
}
int main () {
12

BLM225
13
cout <<"zafer hocanin a
degiskeni="<<zafer::a << endl;
cout <<"salih hocanin a
degiskeni="<<salih::a << endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
namespace zafer
{
int a = 15;
}
namespace salih
{
int a = 6;
}
using namespace zafer;
//using namespace salih; hatalı satır
int main () {
cout<<a<<endl;
cout <<"zafer hocanin a degiskeni="<<zafer::a << endl;
cout <<"salih hocanin a degiskeni="<<salih::a << endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
namespace zafer
{
int a = 5;
int karesi(int a)
{
return a*a;
}
}
13

BLM225
14
namespace salih
{
double a = 6;
}
int main () {
cout <<"zafer hocanin a degiskeni="<<zafer::a << endl;
cout <<"zafer hocanin a degiskeninin karesi="<<zafer::karesi(zafer::a) << endl;
cout <<"salih hocanin a degiskeni="<<salih::a << endl;
cout <<"salih hocanin a degiskeninin karesi="<<zafer::karesi(salih::a) << endl;
getch();
return 0;
}
Her bir isim uzayındaki değişkenler sadece o isim uzayı içinde tanınırlar. Aşağıda verilen
direktif,
std isim uzayının kullanılacağını belirtir.
cin, cout ve endl fonksiyonları gibi C++ standart kütüphanesinde yer alan tüm değişkenler ve
fonksiyonlar bu isim uzayı içinde tanımlanmıştır. Bu direktifin verilmemesi halinde bu
fonksiyonları kullanmak için başlarına std yazmak gerekir.
Örnek:
Std::cout<<”merhaba”<<endl;
Std::cin>>x;
İsim uzayı tanımlama
Bir isim uzayı aşağıdaki şekilde tanımlanır.
namespace tanımlayıcı
{
Değişkenler;
}
14

BLM225
15
Örnek:
namespace isimuzayı1
{
int a, b;
}
İsimuzayi1 de tanımlanan a ve b değişkenlerine erişmek için aşağıdaki şekilde kullanmak
gerekmektedir.
isimuzayi1::a=5;
isimuzayi1::b=7;
örnek
#include <conio.h>
#include <iostream>
namespace isimuzayi1
{
int a = 5;
}
{
double a = 3.1416;
}
int main () {
cout << isimuzayi1::a << endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
{
int a = 5;
}
15

BLM225
16
{
double a = 3.1416;
}
using namespace isimuzayi1;
int main ()
{
cout << a << endl;
getch();
return 0;
}
Using bildirimi
Kullanımı kolaylaştırmak ve her değişkeni kullanırken değişken ismi önüne isim uzayı ismini
yazmamak için using bildirimi kullanılır. Her bir değişken için using bildirimi ayrı ayrı olarak
kullanılabileceği gibi, tüm isim uzayı için de kullanılabilir.
#include <conio.h>
#include <iostream>
namespace zafer
{
int a = 5;
int karesi(int a)
{
return a*a;
}
}
namespace salih
{
double a = 6;
}
int main () {
cout <<"zafer hocanin a degiskeni="<<a
<< endl;
getch();
16

BLM225
17
return 0;
}
#include <conio.h>
#include <iostream>
#include <conio.h>
#include <iostream>
namespace zafer
{
int a = 5;
int karesi(int a)
{ return a*a; }
}
namespace salih
{
double a = 6.9;
double yazdir(){ return a;}
}
int main () {
cout <<"zafer hocanin a degiskeni="<<a
<< endl;
cout <<"karesi "<<karesi(10) << endl;
cout <<salih::yazdir()<<endl;
getch();
return 0;
}
#include <iostream>
{
int x = 5;
int y = 10;
17

BLM225
18
}
{
double x = 3.1416;
double y = 2.7183;
}
int main ()
{
using isimuzayi1::x;
using isimuzayi2::y;
cout << x << endl;
cout << y << endl;
cout << isimuzayi1::y << endl;
cout << isimuzayi2::x << endl;
return 0;
}
Using bildirimi ile tüm isim uzayı bildirildikten sonra isim uzayı içinde tanımlanmış tüm
değişkenleri kullanırken önünde isim uzayı ismini belirtmeye gerek kalmaz. Bu durumda
using namespace olarak kullanılır.
#include <conio.h>
{
int x = 5;
int y = 10;
}
{
double x = 3.1416;
double y = 2.7183;
}
int main ()
{
cout << x << endl;
cout << y << endl;
18

BLM225
19
cout << isimuzayi2::y << endl;
cout << isimuzayi2::x << endl;
getch();
return 0;
}
İsimuzayı aşağıdaki gibi de kullanılabilir.
#include <iostream>
{
int x = 5;
int y = 10;
}
{
double x = 3.1416;
double y = 2.7183;
}
int main ()
{
{
cout << x << endl;
cout << y << endl;
}
{
cout << y << endl;
cout << x << endl;
}
return 0;
}
#include <conio.h>
19

BLM225
20
#include <iostream>
#include <string>
#include <list>
namespace p1
{
int a=5,b=6,c=7;
}
namespace p2
{
int a=1,b=2,c=3;
}
int main()
{
using p1::a; // int a=5;
using p2::a; // int a=1; error
a++;
cout<<a<<endl;
getch();
return 0;
}
4.2. Dinamik bellek kullanımı
Daha önceki derslerimizde yerel ve global değişkenlerden bahsedilmişti. Yerel değişkenler
tanımlandıkları blok içinde veya fonksiyon içinde geçerli olup blok veya foksiyon
sonlandığında bellekten otomatik olarak atılan, yok edilen değişkenlerdir. Global değişkenler
ise ana program sonlanıncaya değin bellekte yer işgal etmeyi sürdürürler. Bu değişkenlerle
her hangi bir işlem yapılmasa dahi bellekten atılması mümkün değildir.
Bazen bellekten istediğimiz zaman istediğimiz kadar(ihtiyacımız kadar) yer alma ve işimiz
bittiğinde de aldığımız yerleri serbest bırakmak isteyebiliriz. Tabi ki burada yer alma ve
serbest bırakma işlemi program çalışıyorken(run time) gerçekleşmektedir. Belleğin bu şekilde
kullanılması dinamik bellek kullanımı olarak tanımlanır.
C dilinde bellekte yer alma için malloc( ), ayrılan yeri geri vermek için free( )
fonksiyonları kullanılmaktadır. 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. Aşağıda verilen örneği inceleyiniz.
int *p;
p=new int; //Tamasayı bir değer için bellekten yer al
20

BLM225
21
*p=100; //Ayrılan yerin(adresin) içine 100 değeri at
delete p; //ayrılan yeri serbest bırak.(geri ver)
Örnekler:
float *p;
p=new float;
*p=3.14;
delete p;
int *p=new int; ifadesi aşağıdaki iki satırın yerine geçer.
int *p;
p=new int;
int *p=new int(100); ifadesi aşağıdaki üç satırın yerine geçer. Adres alındıktan sonra içine
başlangıç değeri olarak 100 değeri atılmaktadır.
int *p
p=new int;
*p=100;
Dinami bellek kullanımı ile ilgili olarak:
int *p=new int[10]; ifadesi 10 elemanlı int türünden bir dizi için bellekte yer ayırmakta ve
başlangıç adresini p ye atamaktadır.
Dizi elemanlarına sanki normal bir diziyi kullanıyormuşçasına p[0]=5; p[1]=2; şeklinde
erişmek mümkün olmaktadır.
Daha sonra bu dizi için ayrılan yeri
delete [ ] p;
ifadesi ile geri vermek mümkün olmaktadır. Bu ifadede dizi sembolü [ ] kullanımına dikkat
ediniz.
Verilen örnek programda klavyeden istenen değer kadar yer ayrılmakta ve girilen değerler
ekrana yazdırılmaktadır.
int main ()
{
int i;
int * p;
p= new int[2];
for (i=0; i<2; i++)
21

BLM225
22
{
cout << "Sayi giriniz :";
cin >> p[i];
}
cout << "Girilen sayilar"<<endl;
for (i=0; i<2; i++)
{
cout << p[i] <<endl;
}
delete[] p;
cout << p[0] <<endl;
getch();
return 0;
}
#include <iostream>
int main ()
{
int i,n;
int * p;
cout << "Kac sayi gireceksiniz ? ";
cin >> i;
p= new int[i];
if (p == 0)
cout << "Hata: bellekten yer alınamadı";
else
{
for (n=0; n<i; n++)
{
cout << "Sayi gir: ";
cin >> p[n];
}
cout << "Girdiginiz sayilar: ";
for (n=0; n<i; n++) cout << p[n] <<", "; //for döngüsü içinde sadece cout var.
delete[] p; //bu komut for dongusune dahil değil
}
return 0;
}
22

BLM225
23
23

3. aşırı yükleme yaşam alanı - dinamik bellek kullanımı

Recommended

Recommended

More Related Content

What's hot

What's hot (8)

Similar to 3. aşırı yükleme yaşam alanı - dinamik bellek kullanımı

Similar to 3. aşırı yükleme yaşam alanı - dinamik bellek kullanımı (20)

More from karmuhtam

More from karmuhtam (18)

3. aşırı yükleme yaşam alanı - dinamik bellek kullanımı