4. nesneler ve sınıflar

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

BLM225
Nesneye Dayalı Programlama
2
4. Nesneler ve Sınıflar
NYP yönteminde veriler ve bu veriler üzerinde işlem yapan fonksiyonlar bir
araya getirilerek nesne (object) adı verilen bir yapı oluşturulmuştur. Bir nesne
tanımlamak için kullanılan Sınıflar, Nesne yönelimli programlamanın en önemli
parçasını oluştururlar. Sınıflar(Classes) veri ve fonksiyonları bir arada
bulunduran bir yapıdır. Veri ve fonksiyonların bir arada bulunmasına
paketleme(Encaptulation) denilmektedir.
Sınıf içinde tanımlanan veri ve fonksiyonlara sınıfın üyeleri (member) denir.
Gerçek dünyada nesneleri tanımlarken nesnenin özelliklerinden ve
davranışlarından bahsedilir. Örneğin insandan bahsederken adı, saç rengi, ten
rengi, boyu , kilosu gibi özellikleri yanı sıra, konuşması, yürümesi, spor yapması
gibi davranışlarından da bahsedilir. Nesne dayalı programlamada ise insan
nesnesi tanımlanırken adı, saç rengi, ten rengi, boyu , kilosu çeşitli veri tipleri ile
tanımlanabilir.
Örnek:
string adi; string tenrengi; int boy;
Bu veriler insan nesnesinin özelliklerini ifade eder. Bir başka ifade ile
Nesnelere ait özellikler sınıf tanımlamaları içinde verilerle ifade
edilirler.
İnsanın yürüme, konuşma ve spor yapma gibi davranışları vardır. Bu
davranışları da
Yuru(), Konuş(), Sporyap() gibi fonksiyonlar yazarak ifade edebiliriz.
Sınıf tanımları içinde yapılan fonksiyonlar nesnenin davranışlarını ifade eder.
Sınıf Fonksiyonlarına Sınıfın metodları da denir.
Bir sınıf bildirimi(decleration) şu şekilde yapılır.
Class Sınıf_ismi
{
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
Erişim belirleyici :
Değişkenler;
Erişim belirleyici :
Fonksiyonlar;
};
Erişim belirleyicileri public, private, protected terimleri ile belirtilir. Erişim
belirleyicileri Sınıf içinde tanımlanan değişken ve fonksiyonlara nasıl
erişilebileceğini belirler. Bir başka ifade ile değişken ve fonksiyonların
kullanımını sınırlandırır, erişim denetimi sağlar.
Public: Sınıf içindeki değişkenler ve fonksiyonlar bu sınıf içinden
kullanılabileceği gibi dışardan da erişilip kullanılabilir.
Private: Sınıfın üye verilerine sadece o sınıfın üye fonksiyonları ve o sınıfın
arkadaş(friend) sınıfları erişip kullanabilir. Sınıfın üyeleri dışardan erişime
kapalıdır.
Protected: Sınıfın kendi üyeleri, arkadaş sınıflar ve bu sınıftan türetilen nesneler
sınıfın üyelerine erişebilir.
Herhangi bir belirleyici kullanılmamış ise varsayılan olarak sınıfın üyeleri
private dir.
#include <conio.h>
#include <iostream.h>
#include <iostream>
#include <string>
#include <list>
using namespace std;
struct Yapi {
int a;
int b;
int size()
{
return 2*sizeof(int);
}
#include <conio.h>
#include <iostream>
#include <string>
#include <list>
class Yapi {
private:
long a;
int b;
public:
int size()
{
return 2*sizeof(int);
}
3

BLM225
4
};
int main ()
{
Yapi y;
y.a=12;
y.b=16;
y.a=25;
cout<<y.size()<<endl;
getch();
return 0;
}
void degerVer(int x, int y)
{
a=x=y; b=y;
}
};
int main ()
{
Yapi y;
y.degerVer(5,6);
cout<<y.size()<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
struct Node{
string type;
int source;
int dest;
int size()
{
return
sizeof(int)*2+sizeof(string);
}
};
int main ()
{
Node n;
n.type="routeRequest";
4

BLM225
5
n.source=192;
n.dest=185;
cout<<"type of node is
"<<n.type<<endl;
cout<<"size of
node="<<n.size()<<endl;
cout<<"ok"<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
class Node{
private:
string type;
int source;
int dest;
public:
int size()
{
return sizeof(int)*2+sizeof(string);
}
void setVariable(string t, int s , int d)
{
type=t; source=s; dest=d;
}
string getType() {
return type;
}
int getSourceId() {
return source;
}
5

BLM225
6
int getDestId() {
return dest;
}
};
int main ()
{
Node n;
n.setVariable("routeRequest", 125, 859);
cout<<"size of node="<<n.size()<<endl;
cout<<"type of node is "<<n.getType()<<endl;
cout<<"Source Id of node is "<<n.getSourceId()<<endl;
cout<<"Destination Id of node is "<<n.getDestId()<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
class Node{
private:
string type;
int source;
int dest;
public:
int size();
void setVariable(string, int, int);
string getType();
int getSourceId();
int getDestId();
};
int Node::size()
{
}
6

BLM225
7
void Node::setVariable(string t, int s , int d)
{
}
string Node::getType()
{
return type;
}
int Node::getSourceId()
{
return source;
}
int Node::getDestId()
{
return dest;
}
int main ()
{
Node n;
n.setVariable("routeRequest", 125, 859);
cout<<"size of node="<<n.size()<<endl;
cout<<"type of node is "<<n.getType()<<endl;
cout<<"Source Id of node is "<<n.getSourceId()<<endl;
cout<<"Destination Id of node is "<<n.getDestId()<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
7

BLM225
8
class Packet{
private:
string type;
int source;
int dest;
public:
int size();
string getType();
int getSourceId();
int getDestId();
friend class Node;
};
int Packet::size()
{
}
void Packet::setVariable(string t, int s , int d)
{
}
string Packet::getType()
{
return type;
}
int Packet::getSourceId()
{
return source;
}
int Packet::getDestId()
{
8

BLM225
9
return dest;
}
class Node{
int ip;
public:
void setVariable(int a)
{
ip=a;
}
void rcvPacket(Packet *p, Node *n)
{
cout<<p->type<<" "<<n->ip<<" adresinden alindi"<<endl;
}
void sendPacket(Packet *p, Node *n)
{
cout<<p->type<<" "<<n->ip<<" adresinden gonderildi"<<endl;
}
};
int main ()
{
Packet *p = new Packet; // normal defination of object
p->setVariable("routeRequest", 125, 859); // calling function belongs to
normal object
Node *n1= new Node();
Node *n2= new Node();
n1->setVariable(192);
n2->setVariable(191);
cout<<"size of node="<<p->size()<<endl;
cout<<"type of node is "<<p->getType()<<endl;
cout<<"Source Id of node is "<<p->getSourceId()<<endl;
9

BLM225
10
cout<<"Destination Id of node is "<<p->getDestId()<<endl;
n1->sendPacket(p,n1);
n2->rcvPacket(p,n2);
delete p;
cout<<endl;
cout<<"after deleted n"<<endl;
/*
cout<<"type of node is "<<p->getType()<<endl;
cout<<"Source Id of node is "<<p->getSourceId()<<endl;
cout<<"Destination Id of node is "<<p->getDestId()<<endl;
*/
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
class Acc {
// public:
int id;
int hop;
}s;
int main ()
{
s.id=5;
cout<<s.id<<endl; // int Acc::id is private
getch();
return 0;
#include <conio.h>
#include <iostream>
#include <list>
struct Acc {
int id;
int hop;
}s;
int main ()
{
s.id=5;
cout<<s.id<<endl;
getch();
return 0;
}
10

BLM225
11
}
#include <conio.h>
#include <iostream>
#include <string>
#include <list>
class Insan {
int boy, kilo,yas;
string ad, tip;
public:
void kimlik(int,int,int,string,string);
void sporyap (int);
int parakazan(string);
};
void Insan::sporyap(int t)
{
cout<<t<<" dakika spor yaptim"<<endl;
}
int Insan::parakazan(string gorev)
{
if(gorev=="baba")
cout<<"ev ekmek bekler"<<endl;
else
cout<<"ekmek bekleyeni yok"<<endl;
}
void Insan::kimlik(int x, int y, int z, string isim, string gorev)
{
boy=x; kilo=y; yas=z; ad=isim; tip= gorev;
}
int main ()
11

BLM225
12
{
Insan baba;
baba.kimlik(175,118,40,"zafer","baba");
baba.sporyap(5);
baba.parakazan("cocuk");
cout<<"tamam"<<endl;
getch();
return 0;
#include <conio.h>
#include <iostream>
#include <list>
class Okul {
string adi;
int ogs;
int sns;
bool rp;
public:
void okulOzllikleriniYaz (string, int, int, bool);
void boya(string);
int zil(int);
void ucrethesapla(bool);
};
void Okul::boya(string reg)
{ cout<<"okul boyandi"<<endl;}
int Okul::zil(int s)
{ return s;}
void Okul::ucrethesapla(bool rp)
{
if (rp==true)
{ cout<<"ucretsiz"<<endl;}
else
12

BLM225
13
{cout<<"ucretli"<<endl;}
}
void Okul::okulOzllikleriniYaz(string a, int b, int c, bool d)
{
adi=a; ogs=b; sns=c; rp=d;
}
int main ()
{
Okul ok;
ok.okulOzllikleriniYaz("Karabuk", 25000, 250, true);
ok.boya("mavi");
ok.ucrethesapla(true);
cout<<ok.zil(5)<<" saniye zil caldi"<<endl;
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <string>
class Oto{
string marka;
int model;
char seg;
bool uretim;
public:
void ozYaz(string,int,char,bool);
int verHes(int, bool);
};
void Oto::ozYaz(string a, int b, char c, bool d)
{
marka=a; model=b; seg=c; uretim=d;
13

BLM225
14
}
int Oto::verHes(int tr, bool b)
{
int fiat;
if (b==true)
{
fiat=(tr*118)/100;
return fiat;
}
else
{
fiat=(tr*125)/100;
return fiat;
}
}
int main ()
{
Oto oto;
oto.ozYaz("Anadol", 1975, 'c', true);
cout<<oto.verHes(27500, true);
getch();
return 0;
}
#include <conio.h>
#include <iostream>
#include <string>
class Araba {
public:
string marka;
int modelyili;
string yakit;
bool uretim;
14

BLM225
15
void kimlikata ( string, int, string, bool);
int sur(string, bool);
};
void Araba::kimlikata(string a, int y, string yk, bool b)
{
marka=a; modelyili=y; yakit=yk; uretim=b;
}
int Araba::sur(string s, bool b)
{
int h;
if (s=="dizel")
{
h=120;
return h;
}
else
{
if(b==true)
h=90;
else
h=150;
return h;
}
}
int main ()
{
Araba a1;
a1.kimlikata("anadol", 1975, "benzin", true);
cout<<"maksimum hiz="<<a1.sur(a1.yakit, a1.uretim)<<endl;
getch();
return 0;
}
15

BLM225
16
Aşağıda Dortgen isimli sınıf bildirimi yapılmıştır. x ve y değişkenleri private
dir. DegerVer ve Alan isimli fonksiyonlar ise public dir.
class Dortgen {
int x, y; //üye private değişkenler
public:
void DegerVer(int,int); //Bu iki üye fonksiyon public dir.
int Alan (void);
};
Bu sınıfın Fonksiyonları(Metodları)ise şu şekilde tanımlanır. Sınıf ismi ile
sınıfa ait fonksiyon ismi arasına “::” operatörü kullanılır. Bu operatör daha önce
farklı amaçlar için kullanılmıştı.
void Dortgen::DegerVer(int a, int b) {
x = a;
y = b;
}
Sınıfların bir kez bildirimleri yapıldıktan sonra, bu sınıftan istenildiği kadar
nesne tanımlanabilir.
Örnek:
Dortgen D1,D2;
İfadesinde D1 ve D2 isimli iki tane Dortgen sınıfından nesne tanımlanmıştır.
Sınıflar kullanılarak tanımlanan her nesne için üye değişkenler için bellekte ayrı
yer ayrılırken, fonksiyonlar (Metodlar)ortak kullanılır. Başka bir ifade ile D1
nesnesinin x ve y değişkenleri ayrı, D2 nesnesinin x ve y değişkenleri için ayrı
bellek alanları kullanılır.
Aşağıdaki ifadelerde D1 ve D2 nesnelerinin x ve y değişkenlerine ayrı ayrı
dışardan değer atanmaktadır.
D1.x=5;
D1.y=6;
D2.x=10;
D2.y=4;
16

BLM225
17
Burada dikkat edilmesi gereken nokta bu şekilde nesnelerin
değişkenlerine(verilerine) dışardan değer atayabilmek için x ve y
değişkenlerinin public olarak tanımlanması gerekir. X ve y private olarak
tanımlı oldukları yukarıdaki kullanımda derleyici hata mesajı verecektir.
#include <conio.h>
#include <iostream>
class Dortgen {
int x, y;
public:
void DegerVer(int,int);
int Alan (void);
};
x = a;
y = b;
}
int Dortgen::Alan (void) {
return x*y;
}
int main ()
{
Dortgen D1,D2;
//aşağıdaki iki satırı daha sonra siliniz
D1.x=7; //x private olduğunda hata mesajı verecektir.
D1.y=8; //y private olduğunda hata mesajı verecektir.
D1.DegerVer(3,4); //D1 nesnesinin x ine 3 ve y sine 4 değeri atanır.
D2.DegerVer(7,2); //D2 nesnesinin x ine 7 ve y sine 2 değeri atanır.
cout << "Alan1: " << D1.Alan()<<endl;
getch();
return 0;
}
17

BLM225
18
#include <conio.h>
#include <iostream>
class Dortgen {
int x, y;
public:
void DegerVer(int a ,int b)
{
x = a;
y = b;
}
int Alan (){
return x*y;
}
};
int main ()
{
Dortgen D1,D2;
D1.DegerVer(3,5);
D2.DegerVer(7,4);
getch();
return 0;
}
18

BLM225
19
Nesnelerin Dinamik olarak kullanımları
Nesneleri sınfları kullanarak tanımladık. Daha önceki derslerimizde
istediğimizde dinamik olarak bellekten yer alma ve geri verme işlemlerini
görmüştük. Nesneler için de bellekten dinamik olarak yer almak ve işi bitince de
geri vermek mümkündür.
Bunun için aşağıdaki gibi bir tanımlama yapmak gerekir.
Dortgen *P1=new Dortgen;
Bu tanımlamalarda P1 ve P2 Dortgen türünde pointer nesneler olarak
tanımlanmıştır. Dortgen sınıfının bellekte işgal edeceği yer kadar bellekte yer
ayrılmakta ve başlangıç adresi P1 ve P2 pointer nesnelerine atanmaktadır.
Dortgen sınıfının aşağıdaki gibi bildirimi yapıldığı var sayılsın. x ve y public
olduğuna dikkat ediniz.
class Dortgen {
public:
int x, y;
int Alan (void);
};
Aşağıdaki şekilde P1 ve P2 nesneleri tanımlandığında,
19

BLM225
20
Bu nesnelerin üye değişkenlerine şu şekilde erişilir.
P1->x=5; P1->y=10;
P2->x=4; P2->y=20;
Fonksiyon erişimleri(Sınıfın metodlarına)şu şekilde olur.
P1->DegerVer(3,4);
P1->Alan();
P2->DegerVer(5,8);
P2->Alan();
P1 ve P2 bellekten
Delete P1;
Delete P2;
Şeklinde atılırlar.
Aşağıdaki programı inceleyiniz
#include <iostream>
class Dortgen {
int x, y;
public:
int Alan (void);
};
x = a;
20

BLM225
21
y = b;
}
return x*y;
}
int main ()
{
P1->DegerVer(3,4);
P2->DegerVer(5,8);
cout << "Alan1: " << P1->Alan()<<'n';
cout << "Alan2: " << P2->Alan()<<endl;
delete P1, P2;
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
class Node{
private:
string type;
int source;
int dest;
public:
int size();
string getType();
21

BLM225
22
int getSourceId();
int getDestId();
};
int Node::size()
{
}
void Node::setVariable(string t, int s , int d)
{
}
string Node::getType()
{
return type;
}
int Node::getSourceId()
{
return source;
}
int Node::getDestId()
{
return dest;
}
int main ()
{
Node *n = new Node; // normal defination of object
n->setVariable("routeRequest", 125, 859); // calling function belongs to
normal object
cout<<"size of node="<<n->size()<<endl;
cout<<"type of node is "<<n->getType()<<endl;
cout<<"Source Id of node is "<<n->getSourceId()<<endl;
cout<<"Destination Id of node is "<<n->getDestId()<<endl;
22

BLM225
23
delete n;
cout<<endl;
cout<<"after deleted n"<<endl;
cout<<"type of node is "<<n->getType()<<endl;
cout<<"Source Id of node is "<<n->getSourceId()<<endl;
cout<<"Destination Id of node is "<<n->getDestId()<<endl;
getch();
return 0;
}
Nesnelerin dizi olarak kullanımları
Nesnelerde diğer türlerde olduğu gibi dizi olarak tanımlanıp kullanılabilirler.
Aşağıdaki örneği inceleyiniz.
#include <iostream>
class Dortgen {
public:
int x, y;
int Alan (void);
};
x = a;
y = b;
}
return x*y;
}
23

BLM225
24
int main ()
{
Dortgen P1[10];
P1[0].x=6;
P1[0].y=8;
P1[1].DegerVer(7,2);
cout << "Alan1: " << P1[0].Alan()<<'n';
cout << "Alan2: " << P1[1].Alan()<<endl;
return 0;
}
#include <conio.h>
#include <iostream>
#include <list>
class Hastane {
int id;
string adi;
public:
void kimliklendir(int, string);
int getId();
}h2;
void Hastane::kimliklendir(int a, string b)
{
id=a; adi=b;
}
24

BLM225
25
int Hastane::getId()
{
return id;
}
int main ()
{
Hastane h1;
h1.kimliklendir(25, "Karabuk");
cout<<h1.getId()<<endl;
h2.kimliklendir(98, "Sakarya");
cout<<h2.getId()<<endl;
Hastane *h3=new Hastane();
h3->kimliklendir(12, "Bolu");
cout<<h3->getId()<<endl;
delete h3;
cout<<h3->getId()<<endl;
getch();
return 0;
}
5.1 Sınıf metodlarının makro olarak tanımlanmaları
Daha önceki örneklerde kullandığımız Dortgen sınıfına baktığımızda Sınıf
metodlarının Sınıf tanımı içinde sadece prototipleri yer aldığı görülmüştü.
Metodların gövdeleri ise sınıf bildirimi dışında yapılmaktaydı. Metodların sınıf
bildirimi içinde gövdeleri de yazılırsa makro olarak tanımlanmış olurlar. Daha
önceki derslerimizde bir fonksiyonu makro olarak tanımlamak için fonksiyon
başına inline kelimesinin getirildiğini görmüştük. Burada ise bu kelimenin
25

BLM225
26
yazılmasına gerek yoktur. Aşağıda verilen Dortgen sınıfında Alan() metodu
makro olarak tanımlanmıştır.
class Dortgen {
int x, y;
public:
int Alan (void) //alan metodu makro olarak tanımlandı
{
return x*y;
}
};
#include <conio.h>
#include <iostream>
// Packet adında sınıf tanımlayın
// üyeleri tipi, kaynakDugumve hedefDugum
// public metodları degerAta ve her bir özelliği gosteren ayrı ayrı metodlar
//
// Dugum adında sınıf tanımlayın
// üyeleri tipi ve ip
// public metodları degerAta ve her bir özelliği gosteren ayrı ayrı metodlar
// paketGonder ve paketAl adında iki tane Paket snıfının nesnesini parametre olarak
// alan ve nesnenin içeriğini gösteren fonksiyonlar yazın
int main () {
// paket sınıfından p1 nesnesi türetin
// düğüm sınıfından n1 ve n2 nesneleri türetin
// n1 nesnesinin paketGonder ve
// n2 nesnesinin de paketAl metodlarını çalıştır.
getch(); return 0;
}
26

4. nesneler ve sınıflar

Recommended

Recommended

More Related Content

More from karmuhtam

More from karmuhtam (20)

4. nesneler ve sınıflar