Object Oriented Programlama (Nesne Yönelimli Programlama), en temelinde karmaşık yapıları mantıksal sınıflar oluşturarak basite indirgemektir.
Şimdi 3D uzayda iki tane vektörü daha önceki bilgilerimizle toplamaya çalışalım:
#include <iostream>
using namespace std;
void print_vec(int x, int y, int z) {
cout << x << ", " << y << ", " << z << "\n";
}
int main() {
// Vektörleri tanımladık
int x1, y1, z1; // Vektör 1
int x2, y2, z2; // Vektör 2
int x3, y3, z3; // Vektör 1 ve 2 nin toplamı
x1 = 3; y1 = 4; z1 = 5;
x2 = 7; y2 = 8; z2 = 0;
// Vektörleri topladık
x3 = x1 + x2;
y3 = y1 + y2;
z3 = z1 + z2;
// Vektörleri yazdırdık
print_vec(x1, y1, z1);
print_vec(x2, y2, z2);
print_vec(x3, y3, z3);
}
// 3, 4, 5
// 7, 8, 0
// 10, 12, 5Sadece 2 tane vektörü toplamak istedik ama ~30 satırlık bir kodumuz oldu. İşin daha da kötüsü başka vektörleri toplamak istesem kat be kat daha fazla emek harcamamız gerekecek. Bu sebepten ötürü işimizi kolaylaştıracak bir yapıla ihtiyacımız var:
#include <iostream>
using namespace std;
class Vector{
public:
int x, y, z;
};
void print_vec(Vector vector) {
cout << vector.x << ", " << vector.y << ", " << vector.z << "\n";
}
int main() {
// Vektörleri tanımladık
Vector vector1; // Vektör 1
Vector vector2; // Vektör 2
Vector vector3; // Vektör 1 ve 2 nin toplamı
vector1.x = 3; vector1.y = 4; vector1.z = 5;
vector2.x = 7; vector2.y = 8; vector2.z = 0;
// Vektörleri topladık
vector3.x = vector1.x + vector2.x;
vector3.y = vector1.y + vector2.y;
vector3.z = vector1.z + vector2.z;
// Vektörleri yazdırdık
print_vec(vector1);
print_vec(vector2);
print_vec(vector3);
}
// 3, 4, 5
// 7, 8, 0
// 10, 12, 5ilk adımımız da Vector isminde bir sınıf tanımlayıp içinde x, y, z değişkenleri oluşturduk.
class Vector{
public:
int x, y, z; // değişkenlerimiz
}; // sınıfın sonuna ; konulmalı. Şuana kadar tıpkı bir struct gibi değişkenleri kümeledik, bir araya topladık. Şimdi kodumuzu bir adım daha iyileştirelim:
#include <iostream>
using namespace std;
class Vector{
public:
int x, y, z;
};
void print_vec(Vector vector) {
cout << vector.x << ", " << vector.y << ", " << vector.z << "\n";
}
Vector topla(Vector vec1, Vector vec2) {
Vector toplam;
toplam.x = vec1.x + vec2.x;
toplam.y = vec1.y + vec2.y;
toplam.z = vec1.z + vec2.z;
return toplam;
}
Vector vector_olustur(int xx, int yy, int zz) {
Vector yeni_vector;
yeni_vector.x = xx;
yeni_vector.y = yy;
yeni_vector.z = zz;
return yeni_vector;
}
int main() {
// Vektörleri tanımladık
Vector vector1; // Vektör 1
Vector vector2; // Vektör 2
Vector vector3; // Vektör 1 ve 2 nin toplamı
vector1 = vector_olustur(3, 4, 5);
vector2 = vector_olustur(7, 8, 0);
// Vektörleri topladık
vector3 = topla(vector1, vector2);
// Vektörleri yazdırdık
print_vec(vector1);
print_vec(vector2);
print_vec(vector3);
}
// 3, 4, 5
// 7, 8, 0
// 10, 12, 5Daha kötüye gidiyor gibiyiz 🙂 Hali hazırda main fonksiyonunun içinde yapacağımız işleri farklı fonksiyonlara atadık. Böylece daha fazla kod yazdık ama en azında main fonksiyonumuz daha temiz ve anlaşılıbaliri hale geldi.
AMA tabi ki bu da bize yeterli değil. Daha da fazla kod yazmak istiyoruz:
#include <iostream>
using namespace std;
class Vector{
public:
int x, y, z;
void deger_ata(int xx, int yy, int zz) {
x = xx;
y = yy;
z = zz;
}
void print(){
cout << x << ", " << y << ", " << z << "\n";
}
Vector topla(Vector vec2) {
Vector toplam;
toplam.x = x + vec2.x; // vec1.x + vec2.x;
toplam.y = y + vec2.y; // vec1.y + vec2.y;
toplam.z = z + vec2.z; // vec1.z + vec2.z;
return toplam;
}
};
int main() {
// Vektörleri tanımladık
Vector vector1; // Vektör 1
Vector vector2; // Vektör 2
Vector vector3; // Vektör 1 ve 2 nin toplamı
vector1.deger_ata(3, 4, 5);
vector2.deger_ata(7, 8, 0);
// Vektörleri topladık
vector3 = vector1.topla(vector2);
// Vektörleri yazdırdık
vector1.print();
vector2.print();
vector3.print();
}
// 3, 4, 5
// 7, 8, 0
// 10, 12, 5Bu sefer de fonksiyonları sınıfın içine attık. Böylece bu fonksiyonları sadece bu sınıflarla kullanabileceğiz. Bu durum bize aynı fonksiyon isimlerini farklı amaçlarla kullanabilmeyi sağlıyor. Örneğin Vector için print fonksiyonu yazdık. Insan diye bir sınıf oluşturup onun için de print fonksiyonu yazabilirdik:
#include <iostream>
using namespace std;
class Insan{
public:
std::string isim = "muhammet esat";
std::string soyad = "buyukbulut";
void print(){
cout <<isim << " " << soyad << "\n";
}
};
int main() {
Insan esat;
esat.print(); // muhammet esat buyukbulut
}
50 tane farklı sınıf yazıp 50 tane farklı print fonksiyonu yazabiliriz ve bunların herbiri ayrı bir işleve sahip olabilir. Bu size oop’nin gücü hakkında bir fikir verebilir.
Hayatımıza . nokta operatörü girdi. Bu operatörle nesneye ait değişkeni veya fonksiyonu çağırabiliriz.
nesne.print()
nesne.x;Access specifier dediğimiz bize sınıfın içindeki neyin dışardan görünüp görünemeyeceğini belirten bir anahtar kelimemiz var.
public:Bunlara access modifier diyoruz. public: satırından itibaren yazılan değişken ve fonksiyonlar sınıfın dışında . nokta(dot) operatörü ile elişilebilir
Sınıf tanımı yaparken
class Isim {
// bla bla bla
};şeklinde yapıyoruz. Sonun ; koyduğumuza dikkat edelim
Leave a Reply