Daha önce yapıcılar ve yıkıcılar dersinde zaten bahsetmiştik. Şimdi detaylara bakalım.
Contstructor Nedir?
- Sınıfımıza ait bir obje oluşturduğumuzda çalışan ilk fonksiyonumuzdur.
- Bir veya daha fazla olabilir
- Eğer hiç tanımlanmamışsa compiler otomatik olarak default constructor tanımlar.
- Constructor, sınıfımızdaki değerleri tanımlamak ve başlangıçta yapılması gereken işlemler için kullanılabilir.
class Player {
private:
std::string name;
int health;
public:
Player() {}
Player(std::string name) {
this->name = name;
}
Player(std::string name, int health) {
this->name = name;
this->health = health;
}
};
Default Constructor
A default constructor is a constructor which can be called with no arguments.
https://en.cppreference.com/w/cpp/language/default_constructor
- Herhangi bir argüman olmadan bir nesneyi oluşturduğumuzda default constructor çağrılır.
- Player p1
- Player * p2 = new Player;
- Eğer kullanıcı tanımlamazsa compiler otomatik olarak bir tane oluşturur
- Default dışında farklı bir constructor tanımlandığında, compiler default constructor tanımlamaz.
// compiler bizim için bir tane tanımladı
class Player {
std::string name;
int health;
};
int main() {
Player p1;
}
// ----- ----- ----- ----- ----- ----- -----
class Player {
std::string name;
int health;
public:
Player() {} // biz tanımladık
};
int main() {
Player p1;
}
// ----- ----- ----- ----- ----- ----- -----
// Farklı şekillerde tanımlayabiliriz:
Player() {}
Player() {
name = "esat";
health = 10;
}
Player(std::string name = "esat", int health = 10) {
this->name = name;
this->health = health;
}
// ----- ----- ----- ----- ----- ----- -----
// Eğer biz bir constructor tanımlarsak compiler otomatik olarak default constructor tanımlamaz ve dolayısıyla nesne oluştururken hata alırız
class Player {
std::string name;
int health;
public:
Player(int health){
this->health = health;
}
};
int main() {
Player p1; // HATA
Player p2(100); // OK
}Overloading Constructors
Tıpkı fonksiyonları overload yaptığımız gibi constructor’ları da overload yapabiliyoruz.
class Player {
std::string name;
int health;
public:
Player() {}
Player(std::string name, int health) {
this->name = name;
this->health = health;
}
Player(std::string name) {
this->name = name;
}
};
Member Initializer List
Sınıfa ait değişkenlere değer atarken şuana kadar hep constructor fonksiyonunun gövdesinde yaptık.
Player(std::string name, int health) {
this->name = name;
this->health = health;
}
// Önce değişkeni oluşturduk
// Sonra değer atadık. Tıpkı şunun gibi:
int a;
a = 5; gibi. Fakat bu verimsizdir, çünkü değişkeni oluşturup sonra assigment yapıyor ama bunun yerine direk initialize yapabiliriz. Yani değişkeni değeriyle beraber oluşturabiliriz:
//Member Initializer List
Player(std::string name, int health) : name{ name }, health{ health } {}
// Değişkeni oluştururken değer ataması yaptık. Tıpkı şunun gibi:
int a = 5;Delegating Constructors
Baze constructorlar birbirlerine benzer işleri tekrar eder. Böyle durumlarda benzer olan kısımlar için diğer constructor’ı da çağırabiliriz.
“bak beni call ettin geldim işimi yaptım, şimdi şunu call eyle ki işe devam etsin” deyip benzer kısımları birbirine kitleyen tembel constructorlardır.
#include <iostream>
using namespace std;
class Player {
std::string name;
int health;
public:
Player() : // C1
Player{ "NULL", 0 } {}
Player(std::string name) : // C2
Player{ name, 0 } {}
Player(std::string name, int health) : // C3
name{ name }, health{ health } {}
};
int main() {
// çağrılan constructorlar sırasıyla aşağıda verilmiştir.
Player ahmet("ahmet"); // C2 -> C3
Player mehmet; // C1 -> C3
Player hasan("hasan", 20); // C3
}Daha düzgün bir anlatım için :
https://learn.microsoft.com/en-us/cpp/cpp/delegating-constructors?view=msvc-170
Default values
Daha önceki örneğimizde 3 adet constructor’ımız bulunmaktaydı. Bunlardan ilk ikisi bazı “default” değerler için kullanıyorduk:
- Eğer hiç bir parametre verilmezse
- name = “NULL”
- health = 0
- Eğer 1 parametre verilirse
- this->name = name
- health = 0
- Eğer 2 parametre verilirse
- this->name = name
- this->health = health
class Player {
std::string name;
int health;
public:
Player() : Player{ "NULL", 0 } {}
Player(std::string name) : Player{ name, 0 } {}
Player(std::string name, int health) : name{ name }, health{ health } {}
};Bu karmaşıklığı daha basite indirgeyebiliriz:
class Player {
std::string name;
int health;
public:
Player(std::string name = "NULL", int health = 0) : name{ name }, health{ health } {}
};Burada gördüğünüz gibi tek bir constructor ile aynı işi yapmamız mümkün. Burada name için default olarak “NULL” ; health için default olarak 0 değerini verdik. Eğer kullanıcı bir değeri parametre olarak vermezse bu default değerler kullanılacaktır.
Burada dikkat edilmesi gereken şey ise default değerlerin sonda olması gerektiğidir.
Leave a Reply