├── .gitignore ├── 01_Creational_Yaratilis ├── 01_Singleton │ ├── 01_Giris │ │ ├── CMakeLists.txt │ │ ├── bin │ │ │ └── Singleton-01_Giris │ │ └── src │ │ │ └── main.cpp │ ├── 02_Multithread │ │ ├── CMakeLists.txt │ │ ├── bin │ │ │ └── Singleton-03_Multithread │ │ └── src │ │ │ └── main.cpp │ └── README.md ├── 02_Factory │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Factory │ └── src │ │ └── main.cpp ├── 03_Abstract_Factory │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Abstract_Factory │ └── src │ │ └── main.cpp ├── 04_Builder │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Builder │ └── src │ │ └── main.cpp └── 05_Prototype │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ └── Prototype │ └── src │ └── main.cpp ├── 02_Behavioral_Davranissal ├── 01_Chain_of_Responsibility │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── ChainofResponsibility │ └── src │ │ └── main.cpp ├── 02_Command │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Command │ └── src │ │ └── main.cpp ├── 03_Interpreter │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Interpreter │ └── src │ │ └── main.cpp ├── 04_Iterator │ ├── CMakeLists.txt │ ├── bin │ │ └── Iterator │ └── src │ │ └── main.cpp ├── 05_Mediator │ ├── CMakeLists.txt │ └── src │ │ └── main.cpp ├── 06_Memento │ ├── CMakeLists.txt │ └── src │ │ └── main.cpp ├── 07_Observer │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Observer │ └── src │ │ └── main.cpp ├── 08_State │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── State │ └── src │ │ └── main.cpp ├── 09_Strategy │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Strategy │ └── src │ │ └── main.cpp ├── 10_Template │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Template │ └── src │ │ └── main.cpp └── 11_Visitor │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ └── Visitor │ └── src │ └── main.cpp ├── 03_Structural_Yapisal ├── 01_Adapter │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Adapter │ └── src │ │ └── main.cpp ├── 02_Bridge │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Bridge │ └── src │ │ └── main.cpp ├── 03_Composite │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Composite │ └── src │ │ └── main.cpp ├── 04_Decorator │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Decorator │ └── src │ │ └── main.cpp ├── 05_Facade │ ├── CMakeLists.txt │ ├── README.md │ ├── bin │ │ └── Facade │ └── src │ │ └── main.cpp ├── 06_Flyweight │ ├── CMakeLists.txt │ └── src │ │ └── main.cpp └── 07_Proxy │ ├── CMakeLists.txt │ ├── bin │ └── Proxy │ └── src │ └── main.cpp ├── LICENSE └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | .idea* 2 | .vscode* 3 | build/ -------------------------------------------------------------------------------- /01_Creational_Yaratilis/01_Singleton/01_Giris/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Singleton-01_Giris") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Singleton 01 Giris") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/01_Singleton/01_Giris/bin/Singleton-01_Giris: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/01_Creational_Yaratilis/01_Singleton/01_Giris/bin/Singleton-01_Giris -------------------------------------------------------------------------------- /01_Creational_Yaratilis/01_Singleton/01_Giris/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 01_Singleton 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Singleton Giriş Örneği 7 | //============================================================================ 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | class Mesaj 14 | { 15 | private: 16 | // INSTANCE değişkenini tanımlıyoruz 17 | static Mesaj *INSTANCE; 18 | string mesaj; 19 | 20 | protected: 21 | // Constructor Methodumuz 22 | Mesaj() 23 | { 24 | } 25 | 26 | // c++ 11 ile gelen, constructor kopyalanmasını engellenyen yapı 27 | Mesaj(const Mesaj &) = delete; 28 | 29 | // Atama operatörü "=" derleyici tarafından 30 | // otomatik üretebilinen bir operatördür. 31 | // Bu da singleton için işlevini kaybetmeye sebep olabilir. 32 | // Bunuda tanımlamamız karşılaşılacak problemleri azaltır. 33 | Mesaj &operator=(const Mesaj &) = delete; 34 | 35 | // Güvenlik olarak Destructor özel yapmaktır. Bu önlem, 36 | // Singleton nesnesinin istem dışı olarak silmesini engeller. 37 | ~Mesaj(); 38 | 39 | public: 40 | // Mesaj sınıfımızı kullanmak için oluşturduğumuz public türündeki method 41 | static Mesaj *getInstance() 42 | { 43 | // Eğer INSTANCE değeri 0 ise yani hiç bu sınıf çağırılmamışsa, 44 | // sınıfı oluşturuyoruz. 45 | if (INSTANCE == 0) 46 | { 47 | INSTANCE = new Mesaj(); 48 | } 49 | // Eğer bu sınıf daha öncd oluşturulmuşsa, yani çağırılmışsa geriye 50 | // var olan "INSTANCE"yi döndürüyoruz 51 | return INSTANCE; 52 | } 53 | 54 | // mesaj değişkenine veri atamamıza yardımcı olan method 55 | void setMesaj(string mesaj) 56 | { 57 | this->mesaj = mesaj; 58 | } 59 | 60 | // mesaj değişkeninden veri almaya yarayan method 61 | string getMesaj() 62 | { 63 | return this->mesaj; 64 | } 65 | 66 | // mesaj değişken içeriğini yazmaya yarayan method 67 | void mesajYazir() 68 | { 69 | cout << "Mesajınız : " << getMesaj() << endl; 70 | } 71 | }; 72 | 73 | // INSTANCE değerine ilk atama, sıfırlama işlemi yapan kısım 74 | Mesaj *Mesaj::INSTANCE = 0; 75 | 76 | int main() 77 | { 78 | // 1. Kullanış Biçimi : Bir "Mesaj" sınıfından "m1" adında nesne yaratıp, 79 | // Mesaj sınıfının "Instance"sini içeri aktrıyoruz 80 | Mesaj *m1 = Mesaj::getInstance(); 81 | m1->setMesaj("Test"); 82 | m1->mesajYazir(); 83 | 84 | // 2. Kullanış Biçimi : Hiç bir nesne yaratmadan direk kullanabiliyoruz. 85 | Mesaj::getInstance()->setMesaj("Merhaba"); 86 | Mesaj::getInstance()->mesajYazir(); 87 | 88 | // Burada da gösterilmek istenen, tekrar bir nesne yaratılmasına rağmen ve 89 | // setMesaj() fonksiyonunu kullanmamamıza rağmen, bir önceki hali oluyor. 90 | Mesaj *m2 = Mesaj::getInstance(); 91 | m2->mesajYazir(); 92 | 93 | return 0; 94 | } 95 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/01_Singleton/02_Multithread/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Singleton-03_Multithread") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Multithread Singleton") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/01_Singleton/02_Multithread/bin/Singleton-03_Multithread: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/01_Creational_Yaratilis/01_Singleton/02_Multithread/bin/Singleton-03_Multithread -------------------------------------------------------------------------------- /01_Creational_Yaratilis/01_Singleton/02_Multithread/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 02_Multithread 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Multithread Singleton Kullanımı 7 | //============================================================================ 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace std; 13 | 14 | mutex mtx; 15 | 16 | class Mesaj 17 | { 18 | private: 19 | // INSTANCE değişkenini tanımlıyoruz 20 | static Mesaj *INSTANCE; 21 | string mesaj; 22 | 23 | protected: 24 | // Constructor Methodumuz 25 | Mesaj() 26 | { 27 | } 28 | 29 | // c++ 11 ile gelen, constructor kopyalanmasını engellenyen yapı 30 | Mesaj(const Mesaj &) = delete; 31 | 32 | // Atama operatörü "=" derleyici tarafından 33 | // otomatik üretebilinen bir operatördür. 34 | // Bu da singleton için işlevini kaybetmeye sebep olabilir. 35 | // Bunuda tanımlamamız karşılaşılacak problemleri azaltır. 36 | Mesaj &operator=(const Mesaj &) = delete; 37 | 38 | // Güvenlik olarak Destructor özel yapmaktır. Bu önlem, 39 | // Singleton nesnesinin istem dışı olarak silmesini engeller. 40 | ~Mesaj(); 41 | 42 | public: 43 | static Mesaj *getInstance() 44 | { 45 | // Eğer çift kontrollü olursa daha güvenli olduğu gözlemlenmiştir http://www.drdobbs.com/cpp/c-and-the-perils-of-double-checked-locki/184405726 46 | if (INSTANCE == 0) 47 | { 48 | mtx.lock(); 49 | if (INSTANCE == 0) 50 | { 51 | INSTANCE = new Mesaj(); 52 | } 53 | mtx.unlock(); 54 | } 55 | return INSTANCE; 56 | } 57 | 58 | void mesajYazir() 59 | { 60 | cout << "Mesajınız : " << getMesaj() << endl; 61 | } 62 | 63 | void setMesaj(string mesaj) 64 | { 65 | this->mesaj = mesaj; 66 | } 67 | 68 | string getMesaj() 69 | { 70 | return this->mesaj; 71 | } 72 | }; 73 | 74 | // INSTANCE değerine ilk atama, sıfırlama işlemi yapan kısım 75 | Mesaj *Mesaj::INSTANCE = 0; 76 | 77 | int main() 78 | { 79 | // 1. Kullanış Biçimi 80 | Mesaj *m1 = Mesaj::getInstance(); 81 | m1->setMesaj("Test"); 82 | m1->mesajYazir(); 83 | 84 | // 2. Kullanış Biçimi 85 | Mesaj::getInstance()->setMesaj("Merhaba"); 86 | Mesaj::getInstance()->mesajYazir(); 87 | 88 | return 0; 89 | } 90 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/01_Singleton/README.md: -------------------------------------------------------------------------------- 1 | # Singleton Pattern 2 | 3 | **Singleton** kelime anlamı olarak dilimize **"Tek Şey"** şeklinde çevrilebilir. İsimdende yola çıkarak, aslında **Tek** sınıf daha doğrusu bir sınıftan üretilen sadece tek bir obje olmasıdır. Yani nereden çağırılırsa çağırılsın tek sonuç, aynı sonuç dönme durumudur. Kısaca bir **Singleton** sınıfını nerede çağırırsanız çağırın, hepsinde aynı şekilde işlemler sağlayacaktır. Kaç kere obje oluşturulursa oluşturulsun, ilk oluşturulan hali ile geri dönme durumudur. Bu patterni bir çok projede görebilirsiniz. 4 | 5 | Singleton patternini 2 porje olarak göreceksiniz. Bunun sebebi, bu pattern multithread yapılarda bazı istenmeyen sonuçlar sağlama olasılığıdır ve buna alınan önlemler içindir. 6 | 7 | ## Singleton Pattern Kullanım Adımları 8 | Bu pattern kullanılması için uyulacak adımlar şu şekildedir. 9 | * İlk adım olarak, **Singleton** olacak sınıf içinde **private** erişim hakkı olarak **static** biçiminde, **** tipinde bir değişken tanımlıyoruz. Bizim projemizde bu şu şekilde tanımlıyoruz; 10 | ```cpp 11 | class Mesaj // Singleton Sınıfımız 12 | { 13 | private: // Erişim Türü 14 | static Mesaj *INSTANCE; // "Singleton Sınıf" türünde "INSTANCE" değişkeni 15 | }; 16 | ``` 17 | * **Constructor** methodumuz, **kesinlikle** **public** erişim türünde olmamalıdır. Bunun sebebi, bu sınıftan isteğimiz dışında obje oluşturulmasını engellemektir. Fakat başka sınıflara miras bırakılma durumu için **protected** erişim hakkı içinda tanımlanabilir. İsteğe bağlı olarak **private** erişim hakkı seçilebilir. Biz projemizde, **protected** tercih ediyoruz. 18 | 19 | ```cpp 20 | protected: 21 | // Constructor Methodumuz 22 | Mesaj() 23 | { 24 | } 25 | ``` 26 | 27 | * **Singleton** bir sınıf temel kullanım için son olarak, sınıfı çağıran bir method gerekmektedir. Bu method her yerden çağırılabilmesi için **public** erişim hakkında olması gerekmektedir. Bu method, geriye ilgili sınıf türünü döndürecektir. Bu method **static** olmasına dikkat etmek gerekmektedir. genel kullanım isimlendirmesi sebebi ile biz fonksiyonumuzun ismini **"getInstance"** yaptık. Bu fonksiyon içinde dikakt edilmesi gereken bir bölüm bulunmaktadır. **private** bölümünde oluşturduğumuz sınıf değişkeni -bizim projemizde **"INSTANCE"**- içi boş durumdadır. Yani **0** dır. Ve biz methodumuzda eğer **0** ise yani hiç değer atanmamış ise **INSTANCE = new Mesaj();** kullanımı olarak ilk değeri atıyoruz. methodun sonunda ise geriye **"INSTANCE"** değerini döndürüyoruz. Yani, eğer bu method oluşturulmamış ise, ilk kez kullanılıyor ise, koşulumuz sayesinde, sınıfımızı değişkene atayıp geri döndürüyoruz. Eğer daha önce oluşturulmuş ise, var olan sınıfı geri döndürüyoruz. Bu durumda bize teklik sağlamış oluyor. 28 | 29 | ```cpp 30 | public: 31 | // Mesaj sınıfımızı kullanmak için oluşturduğumuz public türündeki method 32 | static Mesaj *getInstance() 33 | { 34 | // Eğer INSTANCE değeri 0 ise yani hiç bu sınıf çağırılmamışsa, 35 | // sınıfı oluşturuyoruz. 36 | if (INSTANCE == 0) 37 | { 38 | INSTANCE = new Mesaj(); 39 | } 40 | // Eğer bu sınıf daha öncd oluşturulmuşsa, yani çağırılmışsa geriye 41 | // var olan "INSTANCE"yi döndürüyoruz 42 | return INSTANCE; 43 | } 44 | ``` 45 | ## Singleton Pattern Kullanım Örneği 46 | 47 | Örneğimizde basit bir **Singleton** sınıf tasarlanmıştır. Bu sınıf, **Singleton Pattern Kullanım Esasları** kısmında anlatılanların dışında, mesaj değişkeni eklenmiştir. Aynı zamanda güvenlik önlemleri de eklenmiştir. 48 | 49 | ```cpp 50 | #include 51 | #include 52 | 53 | using namespace std; 54 | 55 | class Mesaj 56 | { 57 | private: 58 | // INSTANCE değişkenini tanımlıyoruz 59 | static Mesaj *INSTANCE; 60 | string mesaj; 61 | 62 | protected: 63 | // Constructor Methodumuz 64 | Mesaj() 65 | { 66 | } 67 | 68 | // c++ 11 ile gelen, constructor kopyalanmasını engellenyen yapı 69 | Mesaj(const Mesaj &) = delete; 70 | 71 | // Atama operatörü "=" derleyici tarafından 72 | // otomatik üretebilinen bir operatördür. 73 | // Bu da singleton için işlevini kaybetmeye sebep olabilir. 74 | // Bunuda tanımlamamız karşılaşılacak problemleri azaltır. 75 | Mesaj &operator=(const Mesaj &) = delete; 76 | 77 | // Güvenlik olarak Destructor özel yapmaktır. Bu önlem, 78 | // Singleton nesnesinin istem dışı olarak silmesini engeller. 79 | ~Mesaj(); 80 | 81 | public: 82 | // Mesaj sınıfımızı kullanmak için oluşturduğumuz public türündeki method 83 | static Mesaj *getInstance() 84 | { 85 | // Eğer INSTANCE değeri 0 ise yani hiç bu sınıf çağırılmamışsa, 86 | // sınıfı oluşturuyoruz. 87 | if (INSTANCE == 0) 88 | { 89 | INSTANCE = new Mesaj(); 90 | } 91 | // Eğer bu sınıf daha öncd oluşturulmuşsa, yani çağırılmışsa geriye 92 | // var olan "INSTANCE"yi döndürüyoruz 93 | return INSTANCE; 94 | } 95 | 96 | // mesaj değişkenine veri atamamıza yardımcı olan method 97 | void setMesaj(string mesaj) 98 | { 99 | this->mesaj = mesaj; 100 | } 101 | 102 | // mesaj değişkeninden veri almaya yarayan method 103 | string getMesaj() 104 | { 105 | return this->mesaj; 106 | } 107 | 108 | // mesaj değişken içeriğini yazmaya yarayan method 109 | void mesajYazir() 110 | { 111 | cout << "Mesajınız : " << getMesaj() << endl; 112 | } 113 | }; 114 | 115 | // INSTANCE değerine ilk atama, sıfırlama işlemi yapan kısım 116 | Mesaj *Mesaj::INSTANCE = 0; 117 | 118 | int main() 119 | { 120 | // 1. Kullanış Biçimi : Bir "Mesaj" sınıfından "m1" adında nesne yaratıp, 121 | // Mesaj sınıfının "Instance"sini içeri aktrıyoruz 122 | Mesaj *m1 = Mesaj::getInstance(); 123 | m1->setMesaj("Test"); 124 | m1->mesajYazir(); 125 | 126 | // 2. Kullanış Biçimi : Hiç bir nesne yaratmadan direk kullanabiliyoruz. 127 | Mesaj::getInstance()->setMesaj("Merhaba"); 128 | Mesaj::getInstance()->mesajYazir(); 129 | 130 | // Burada da gösterilmek istenen, tekrar bir nesne yaratılmasına rağmen ve 131 | // setMesaj() fonksiyonunu kullanmamamıza rağmen, bir önceki hali oluyor. 132 | Mesaj *m2 = Mesaj::getInstance(); 133 | m2->mesajYazir(); 134 | 135 | return 0; 136 | } 137 | 138 | ``` 139 | 140 | ## Singleton Pattern Multithread Eklentisi 141 | 142 | **Singleton**, multithread bir yapıda, istenmeyen durumlar oluşturabilir. Aynı anda birden fazla sınıf yaratma durumu ile karşılaşılabilir. Bunu önlemek için, sınıfımıza bazı eklentiler yapmak gerekmektedir. 143 | 144 | * İlk olarak içeriye **** sınıfını ekliyoruz. Bu sınıf bizim **"lock"** yani kitleme mekanizmasını kazandıracak. 145 | ```cpp 146 | #include 147 | ``` 148 | 149 | * Ardından bu sınıftan, Singleton sınıfımızdan önce bir nesne oluşturuyoruz. 150 | ```cpp 151 | mutex mtx; 152 | ``` 153 | 154 | * Son olarak **"getInstance"** sınıfımıza eklemelerimiz gerçekleştiriyoruz. 155 | 156 | ```cpp 157 | static Mesaj *getInstance() 158 | { 159 | // Eğer çift kontrollü olursa daha güvenli olduğu gözlemlenmiştir 160 | if (INSTANCE == 0) 161 | { 162 | mtx.lock(); 163 | if (INSTANCE == 0) 164 | { 165 | INSTANCE = new Mesaj(); 166 | } 167 | mtx.unlock(); 168 | } 169 | return INSTANCE; 170 | } 171 | ``` -------------------------------------------------------------------------------- /01_Creational_Yaratilis/02_Factory/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Factory") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Factory Pattern") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp ) 21 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/02_Factory/README.md: -------------------------------------------------------------------------------- 1 | # Factory Method Pattern 2 | Bu pattern kullanmım amacı, siz projenizde bir takım standartlar oluşturmak isteyebilirsiniz. Yapacağınız sınıfları, sadece istediğiniz yötemler ile kontrol etmek isteyebilirsiniz. Bunun için **Factory Method Pattern** gayet kullanışlıdır. 3 | 4 | **Factory Pattern**, bir var olan şablona uygun olarak nesneler yaratmaktadır. **Factory Method Pattern**, nesneler oluşturmak için bir arabirim tanımlar. Fakat işlevi kullanıcı belirler. Örneğin bir plastik baskı fabrikası düşünün. Baskı malzemesi aynıdır. Fakat sonunda çıkan ürün, kalıba göre farklılılar gösterir. 5 | 6 | ## Factory Method Pattern Kullanım Adımları 7 | 8 | * İlk adım olarak **soyut** bir üst sınıf oluşurulur. 9 | 10 | ```cpp 11 | class Arac 12 | { 13 | public: 14 | virtual void aracSesCikar() = 0; 15 | static Arac *create(AracTipi); 16 | }; 17 | ``` 18 | * Ardından o sınıftan miras alacak diğer sınıflarımızı tanımlıyoruz. 19 | 20 | ```cpp 21 | class Ucak : public Arac 22 | { 23 | public: 24 | void aracSesCikar() override 25 | { 26 | cout << "Vuuuuuuuuuuh Vuuuuuuh" << endl; 27 | } 28 | }; 29 | 30 | class Tren : public Arac 31 | { 32 | public: 33 | void aracSesCikar() override 34 | { 35 | cout << "Çuuuf Çuuuuuf" << endl; 36 | } 37 | }; 38 | 39 | class Araba : public Arac 40 | { 41 | public: 42 | void aracSesCikar() override 43 | { 44 | cout << "Vııın Vııın" << endl; 45 | } 46 | }; 47 | ``` 48 | * **enum**, kullanım aşamalarımız sabit ve kullanışlı olması amacı ile yazılmıştır. 49 | 50 | ```cpp 51 | enum AracTipi 52 | { 53 | Tren_T, 54 | Araba_T, 55 | Ucak_T 56 | }; 57 | 58 | ``` 59 | 60 | * Soyut sınıfımızda olan **"create"** methodumuzu tanımlıyoruz. 61 | 62 | ```cpp 63 | Arac *Arac::create(AracTipi tip) 64 | { 65 | if (tip == Tren_T) 66 | { 67 | return new Tren(); 68 | } 69 | else if (tip == Araba_T) 70 | { 71 | return new Araba(); 72 | } 73 | else if (tip == Ucak_T) 74 | { 75 | return new Ucak(); 76 | } 77 | else 78 | { 79 | return NULL; 80 | } 81 | } 82 | ``` 83 | 84 | * Kullanım için, 85 | 86 | ```cpp 87 | int main() 88 | { 89 | AracTipi tip = Ucak_T; 90 | Arac *aracPtr = Arac::create(tip); 91 | aracPtr->aracSesCikar(); 92 | 93 | return 0; 94 | } 95 | ``` -------------------------------------------------------------------------------- /01_Creational_Yaratilis/02_Factory/bin/Factory: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/01_Creational_Yaratilis/02_Factory/bin/Factory -------------------------------------------------------------------------------- /01_Creational_Yaratilis/02_Factory/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 02_Factory 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : 02_Factory Pattern 7 | //============================================================================ 8 | #include 9 | 10 | using namespace std; 11 | 12 | enum AracTipi 13 | { 14 | Tren_T, 15 | Araba_T, 16 | Ucak_T 17 | }; 18 | 19 | // Abstract sınıf 20 | class Arac 21 | { 22 | public: 23 | virtual void aracSesCikar() = 0; 24 | static Arac *create(AracTipi); 25 | }; 26 | 27 | class Ucak : public Arac 28 | { 29 | public: 30 | void aracSesCikar() override 31 | { 32 | cout << "Vuuuuuuuuuuh Vuuuuuuh" << endl; 33 | } 34 | }; 35 | 36 | class Tren : public Arac 37 | { 38 | public: 39 | void aracSesCikar() override 40 | { 41 | cout << "Çuuuf Çuuuuuf" << endl; 42 | } 43 | }; 44 | 45 | class Araba : public Arac 46 | { 47 | public: 48 | void aracSesCikar() override 49 | { 50 | cout << "Vııın Vııın" << endl; 51 | } 52 | }; 53 | 54 | Arac *Arac::create(AracTipi tip) 55 | { 56 | if (tip == Tren_T) 57 | { 58 | return new Tren(); 59 | } 60 | else if (tip == Araba_T) 61 | { 62 | return new Araba(); 63 | } 64 | else if (tip == Ucak_T) 65 | { 66 | return new Ucak(); 67 | } 68 | else 69 | { 70 | return NULL; 71 | } 72 | } 73 | 74 | int main() 75 | { 76 | AracTipi tip = Ucak_T; 77 | Arac *aracPtr = Arac::create(tip); 78 | aracPtr->aracSesCikar(); 79 | 80 | delete[] aracPtr; 81 | return 0; 82 | } 83 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/03_Abstract_Factory/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Abstract_Factory") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Abstract Factory Pattern") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/03_Abstract_Factory/README.md: -------------------------------------------------------------------------------- 1 | # Abstract Factory Pattern 2 | **Abstract Factory Pattern**, ortak bir sınıf türünden türetilecek, farklı nesnelerin oluşturulmasında kullanılmaktadır. **Abstract Factory** düzeni, genel bir deseni takip eden nesneler oluşturmamıza izin veren bir çerçeve sunmaktadır. Bu pattern, somut sınıflarını doğrudan belirtmeden, ilgili veya bağımlı nesnelerin ailelerinin oluşturulmasını sağlar. 3 | 4 | 5 | ## Abstract Factory Pattern Kullanım Adımları 6 | 7 | * İlk önce, soyut bir sınıf oluşturuyoruz. Bu sınıf, bizim ürünlerimizi kapsayacak. 8 | 9 | ```cpp 10 | class Marangoz 11 | { 12 | public: 13 | virtual void urunTip() = 0; 14 | }; 15 | 16 | ``` 17 | 18 | * Ardından oluşturduğumuz soyut sınıftan somut sınıflar oluşturuyoruz. 19 | 20 | ```cpp 21 | class Masa : public Marangoz 22 | { 23 | public: 24 | void urunTip() override 25 | { 26 | std::cout << "Masa Yapım Onarım" << std::endl; 27 | } 28 | }; 29 | 30 | class Dolap : public Marangoz 31 | { 32 | public: 33 | void urunTip() override 34 | { 35 | std::cout << "Dolap Yapım Onarım" << std::endl; 36 | } 37 | }; 38 | ``` 39 | 40 | * Ardından **Abstract Factory** oluşturuyoruz. Bu sınıf içinde, daha önce oluşturulan soyut sınıf türünden veri geri döndüren method bulunmakta. 41 | 42 | ```cpp 43 | class Fabrika 44 | { 45 | public: 46 | virtual Marangoz *fabrikaOlustur() = 0; 47 | }; 48 | ``` 49 | 50 | * Şimdiki adım ise işe özgü somut sınıflar üretmekte. 51 | 52 | ```cpp 53 | class DolapOlustur : public Fabrika 54 | { 55 | public: 56 | Marangoz *fabrikaOlustur() override 57 | { 58 | return new Dolap; 59 | } 60 | }; 61 | 62 | class MasaOlustur : public Fabrika 63 | { 64 | public: 65 | Marangoz *fabrikaOlustur() override 66 | { 67 | return new Masa; 68 | } 69 | }; 70 | ``` 71 | 72 | * Kullanım olarak ilk önce fabrika türümüzü belirlilyoruz. Ardından yapıalcak iş tanımlayıp, fabrikamıza atama gerçekleştiriyoruz. 73 | 74 | ```cpp 75 | int main() 76 | { 77 | Fabrika *fabrika = new DolapOlustur; 78 | Marangoz *marangoz = fabrika->fabrikaOlustur(); 79 | marangoz->urunTip(); 80 | 81 | return 0; 82 | } 83 | ``` -------------------------------------------------------------------------------- /01_Creational_Yaratilis/03_Abstract_Factory/bin/Abstract_Factory: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/01_Creational_Yaratilis/03_Abstract_Factory/bin/Abstract_Factory -------------------------------------------------------------------------------- /01_Creational_Yaratilis/03_Abstract_Factory/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 03_Abstract_Factory 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : 03_Abstract_Factory Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | #define DOLAP 1 12 | //#define MASA 1 13 | 14 | class Marangoz 15 | { 16 | public: 17 | virtual void urunTip() = 0; 18 | }; 19 | 20 | class Masa : public Marangoz 21 | { 22 | public: 23 | void urunTip() override 24 | { 25 | std::cout << "Masa Yapım Onarım" << std::endl; 26 | } 27 | }; 28 | 29 | class Dolap : public Marangoz 30 | { 31 | public: 32 | void urunTip() override 33 | { 34 | std::cout << "Dolap Yapım Onarım" << std::endl; 35 | } 36 | }; 37 | 38 | class Fabrika 39 | { 40 | public: 41 | virtual Marangoz *fabrikaOlustur() = 0; 42 | }; 43 | 44 | class DolapOlustur : public Fabrika 45 | { 46 | public: 47 | Marangoz *fabrikaOlustur() override 48 | { 49 | return new Dolap; 50 | } 51 | }; 52 | 53 | class MasaOlustur : public Fabrika 54 | { 55 | public: 56 | Marangoz *fabrikaOlustur() override 57 | { 58 | return new Masa; 59 | } 60 | }; 61 | 62 | int main() 63 | { 64 | #ifdef DOLAP 65 | Fabrika *fabrika = new DolapOlustur; 66 | #elif MASA 67 | Fabrika *fabrika = new MasaOlustur; 68 | #endif 69 | 70 | Marangoz *marangoz = fabrika->fabrikaOlustur(); 71 | marangoz->urunTip(); 72 | 73 | delete[] fabrika; 74 | delete[] marangoz; 75 | return 0; 76 | } 77 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/04_Builder/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Builder") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Builder Pattern") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/04_Builder/README.md: -------------------------------------------------------------------------------- 1 | # Builder Pattern 2 | **"Builder Pattern"**, karmaşık bir nesnenin yapısını temsilinden ayırmak için kullanılır. Böylece aynı oluşturma işlemi ile farklı nesneler oluşturabilmektedir. Bu patterni, karmaşık bir obje oluşturmak istendiğinde fakat karmaşık bir kurucu üyeye veya argümanlara ihtiyaç duymak istemediğimizde kullanmaktayız. 3 | 4 | ## Builder Pattern Kullanım Adımları 5 | 6 | * İlk olarak ana sınıfımızı oluşturuyoruz. Ana sınıfımız **"Bilgisayar"** ismindedir. İçeriğinde bilgisayar donanımı değişkenleri ve bunlar ile iletişim methodları barındırmakta. En son olarak, verilen parçları **"kur()"** methodu ile ekrana yazdırmakta. 7 | 8 | ```cpp 9 | class Bilgisayar 10 | { 11 | private: 12 | string anakart; 13 | string ram; 14 | string ekranKarti; 15 | string segment; 16 | 17 | public: 18 | void setAnakart(const string &anakart) 19 | { 20 | this->anakart = anakart; 21 | } 22 | void setRam(const string &ram) 23 | { 24 | this->ram = ram; 25 | } 26 | void setEkranKarti(const string &ekranKarti) 27 | { 28 | this->ekranKarti = ekranKarti; 29 | } 30 | 31 | void setSegment(const string &segment) 32 | { 33 | this->segment = segment; 34 | } 35 | 36 | void kur() const 37 | { 38 | cout << segment << " Bilgisayar Özellikleri - Anakart " << anakart << ", Ram Bellek : " << ram << ", Ekran Kartı : " 39 | << ekranKarti << " - Kurulum Tamamlandı" << endl; 40 | } 41 | }; 42 | ``` 43 | 44 | * Ardından ana sınıfımızın **"Builder"**ını oluşturuyoruz. Bu sınıf içinde **"Bilgisayar"** türünde değişken bulunmakta. **"unique_ptr"** kullanmamızın nedeni, **pointer** ile çalıştığımızda ve **"new"** ile yeni sınıflar oluşturduğumuzda, **"RAM"** bellekte yer kaplamaktadır. Bunları işlemlerimiz bitince silmemiz gerekmektedir. **"unique_ptr"** bu işlemi bizim için, efektif bir biçimde yerine getirmektedir. Bu sınıfta **"getBilgisayar"** methodu bulunmaktadır. Bu method, geriye oluşturduğumuz **"Bilgisayar"** nesnesini döndürür. **"yeniBilgisayarOlustur"** methodu ise, **"Bilgisayar"** türünden bir sınıf oluşturup, **"bilgisayar"** değişkenine atar. Bu sınıf soyut bir sınıftır. **"buildAnakart"**, **"buildRam"**, **"buildEkrankarti"**, **"buildSegment"** methodları bulunmaktadır. 45 | 46 | ```cpp 47 | class BilgisayarBuilder 48 | { 49 | protected: 50 | unique_ptr bilgisayar; 51 | 52 | public: 53 | virtual ~BilgisayarBuilder(){}; 54 | 55 | Bilgisayar *getBilgisayar() 56 | { 57 | return bilgisayar.release(); 58 | } 59 | void yeniBilgisayarOlustur() 60 | { 61 | bilgisayar = make_unique(); 62 | } 63 | virtual void buildAnakart() = 0; 64 | virtual void buildRam() = 0; 65 | virtual void buildEkrankarti() = 0; 66 | virtual void buildSegment() = 0; 67 | }; 68 | ``` 69 | 70 | * **BilgisayarBuilder** dan türetilen, spesifik alt sınıfları oluşturuyoruz. Bu sınıfların amacı, **"BilgisayarBuilder"** da bulunan ve istenen **"buildAnakart"**, **"buildRam"**, **"buildEkrankarti"**, **"buildSegment"** methodlarını anlamlandırmak. Verileri atamak. 71 | 72 | ```cpp 73 | class OrtaSegmetBilgisayarBuilder : public BilgisayarBuilder 74 | { 75 | public: 76 | virtual ~OrtaSegmetBilgisayarBuilder(){}; 77 | 78 | void buildAnakart() override 79 | { 80 | bilgisayar->setAnakart("Asus"); 81 | } 82 | 83 | void buildRam() override 84 | { 85 | bilgisayar->setRam("8 GB"); 86 | } 87 | 88 | void buildEkrankarti() override 89 | { 90 | bilgisayar->setEkranKarti("2 GB AMD"); 91 | } 92 | 93 | void buildSegment() override 94 | { 95 | bilgisayar->setSegment("Orta Segmet"); 96 | } 97 | }; 98 | 99 | class UstSegmetBilgisayarBuilder : public BilgisayarBuilder 100 | { 101 | public: 102 | virtual ~UstSegmetBilgisayarBuilder(){}; 103 | 104 | void buildAnakart() override 105 | { 106 | bilgisayar->setAnakart("Gigabyte"); 107 | } 108 | 109 | void buildRam() override 110 | { 111 | bilgisayar->setRam("16 GB"); 112 | } 113 | 114 | void buildEkrankarti() override 115 | { 116 | bilgisayar->setEkranKarti("8 GB NVDIA"); 117 | } 118 | 119 | void buildSegment() override 120 | { 121 | bilgisayar->setSegment("Üst Segmet"); 122 | } 123 | }; 124 | ``` 125 | 126 | * En son olarak **"Build"** işlemini yapacak olan sınıfımızı oluşturuyoruz. bu sınıfımızda **"BilgisayarBuilder"** sınıfından bir nesnemiz bulunmakta. **"bilgisayarSec"** isminde bir methodumuz bulunmakta. Bu method, kullanıcıdan **"BilgisayarBuilder"** türünde değişken almakta. Fonksiyonda aldığı veriyi, sınıf içinde oluşturduğu **"bilgisayarBuilder"** nesnesine atamakta. **"bilgisayarKur"** methodu ilede, **"Bilgisayar"** sınıfındaki **"kur"** methodunu çalıştırmaktadır. 127 | 128 | ```cpp 129 | class Build 130 | { 131 | private: 132 | BilgisayarBuilder *bilgisayarBuilder; 133 | 134 | public: 135 | void bilgisayarSec(BilgisayarBuilder *pb) 136 | { 137 | bilgisayarBuilder = pb; 138 | bilgisayarBuilder->yeniBilgisayarOlustur(); 139 | bilgisayarBuilder->buildAnakart(); 140 | bilgisayarBuilder->buildEkrankarti(); 141 | bilgisayarBuilder->buildRam(); 142 | bilgisayarBuilder->buildSegment(); 143 | } 144 | 145 | void bilgisayarKur() 146 | { 147 | bilgisayarBuilder->getBilgisayar()->kur(); 148 | } 149 | }; 150 | ``` 151 | 152 | * Kullanım için ilk önce **"Build"** nesnesi oluşturuyoruz. Ardınan **Builder** dan türetilen, spesifik alt sınıflardan nesneler oluşturuyoruz. **"build.bilgisayarSec"** methodu ile **Builder** dan türetilen nesneyi atıyoruz. En son olarka kur methodunu çalıştıryoruz. 153 | 154 | ```cpp 155 | int main() 156 | { 157 | Build build; 158 | OrtaSegmetBilgisayarBuilder ortaSegment; 159 | UstSegmetBilgisayarBuilder ustSegment; 160 | 161 | build.bilgisayarSec(&ortaSegment); 162 | build.bilgisayarKur(); 163 | 164 | build.bilgisayarSec(&ustSegment); 165 | build.bilgisayarKur(); 166 | } 167 | ``` -------------------------------------------------------------------------------- /01_Creational_Yaratilis/04_Builder/bin/Builder: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/01_Creational_Yaratilis/04_Builder/bin/Builder -------------------------------------------------------------------------------- /01_Creational_Yaratilis/04_Builder/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 04_Builder 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Builder Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | class Bilgisayar 14 | { 15 | private: 16 | string anakart; 17 | string ram; 18 | string ekranKarti; 19 | string segment; 20 | 21 | public: 22 | void setAnakart(const string &anakart) 23 | { 24 | this->anakart = anakart; 25 | } 26 | void setRam(const string &ram) 27 | { 28 | this->ram = ram; 29 | } 30 | void setEkranKarti(const string &ekranKarti) 31 | { 32 | this->ekranKarti = ekranKarti; 33 | } 34 | 35 | void setSegment(const string &segment) 36 | { 37 | this->segment = segment; 38 | } 39 | 40 | void kur() const 41 | { 42 | cout << segment << " Bilgisayar Özellikleri - Anakart " << anakart << ", Ram Bellek : " << ram << ", Ekran Kartı : " 43 | << ekranKarti << " - Kurulum Tamamlandı" << endl; 44 | } 45 | }; 46 | 47 | class BilgisayarBuilder 48 | { 49 | protected: 50 | unique_ptr bilgisayar; 51 | 52 | public: 53 | virtual ~BilgisayarBuilder(){}; 54 | 55 | Bilgisayar *getBilgisayar() 56 | { 57 | return bilgisayar.release(); 58 | } 59 | void yeniBilgisayarOlustur() 60 | { 61 | bilgisayar = make_unique(); 62 | } 63 | virtual void buildAnakart() = 0; 64 | virtual void buildRam() = 0; 65 | virtual void buildEkrankarti() = 0; 66 | virtual void buildSegment() = 0; 67 | }; 68 | 69 | //---------------------------------------------------------------- 70 | 71 | class OrtaSegmetBilgisayarBuilder : public BilgisayarBuilder 72 | { 73 | public: 74 | virtual ~OrtaSegmetBilgisayarBuilder(){}; 75 | 76 | void buildAnakart() override 77 | { 78 | bilgisayar->setAnakart("Asus"); 79 | } 80 | 81 | void buildRam() override 82 | { 83 | bilgisayar->setRam("8 GB"); 84 | } 85 | 86 | void buildEkrankarti() override 87 | { 88 | bilgisayar->setEkranKarti("2 GB AMD"); 89 | } 90 | 91 | void buildSegment() override 92 | { 93 | bilgisayar->setSegment("Orta Segmet"); 94 | } 95 | }; 96 | 97 | class UstSegmetBilgisayarBuilder : public BilgisayarBuilder 98 | { 99 | public: 100 | virtual ~UstSegmetBilgisayarBuilder(){}; 101 | 102 | void buildAnakart() override 103 | { 104 | bilgisayar->setAnakart("Gigabyte"); 105 | } 106 | 107 | void buildRam() override 108 | { 109 | bilgisayar->setRam("16 GB"); 110 | } 111 | 112 | void buildEkrankarti() override 113 | { 114 | bilgisayar->setEkranKarti("8 GB NVDIA"); 115 | } 116 | 117 | void buildSegment() override 118 | { 119 | bilgisayar->setSegment("Üst Segmet"); 120 | } 121 | }; 122 | 123 | //---------------------------------------------------------------- 124 | class Build 125 | { 126 | private: 127 | BilgisayarBuilder *bilgisayarBuilder; 128 | 129 | public: 130 | void bilgisayarSec(BilgisayarBuilder *pb) 131 | { 132 | bilgisayarBuilder = pb; 133 | bilgisayarBuilder->yeniBilgisayarOlustur(); 134 | bilgisayarBuilder->buildAnakart(); 135 | bilgisayarBuilder->buildEkrankarti(); 136 | bilgisayarBuilder->buildRam(); 137 | bilgisayarBuilder->buildSegment(); 138 | } 139 | 140 | void bilgisayarKur() 141 | { 142 | bilgisayarBuilder->getBilgisayar()->kur(); 143 | } 144 | }; 145 | 146 | int main() 147 | { 148 | Build build; 149 | OrtaSegmetBilgisayarBuilder ortaSegment; 150 | UstSegmetBilgisayarBuilder ustSegment; 151 | 152 | build.bilgisayarSec(&ortaSegment); 153 | build.bilgisayarKur(); 154 | 155 | build.bilgisayarSec(&ustSegment); 156 | build.bilgisayarKur(); 157 | } -------------------------------------------------------------------------------- /01_Creational_Yaratilis/05_Prototype/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Prototype") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Prototype Pattern") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /01_Creational_Yaratilis/05_Prototype/README.md: -------------------------------------------------------------------------------- 1 | # Prototype Pattern 2 | **"Prototype Pattern"**, bir şablon kullanarak, oluşturulacak nesnelerin türünü belirtir. 3 | 4 | ## PrototypeBuilder Pattern Kullanım Adımları 5 | 6 | * İlk önce soyut bir sınıf oluşturuyoruz. Bu sınıf bizim temel protatip sınıfımız. 7 | 8 | ```cpp 9 | class Kayit 10 | { 11 | public: 12 | virtual ~Kayit() {} 13 | virtual void print() = 0; 14 | virtual unique_ptr clone() = 0; 15 | }; 16 | ``` 17 | 18 | * Oluşturduğumuz soyut sınıftan somut protatiplerimizi oluşturuyoruz. 19 | 20 | ```cpp 21 | class ArabaKayit : public Kayit 22 | { 23 | private: 24 | string arabaIsim; 25 | int arabaID; 26 | 27 | public: 28 | ArabaKayit(string arabaIsim, int ID) : arabaIsim(arabaIsim), arabaID(ID) 29 | { 30 | } 31 | 32 | void print() override 33 | { 34 | cout << "Araba Kaydı" << endl 35 | << "Marka : " << arabaIsim << endl 36 | << "Model : " << arabaID << endl 37 | << endl; 38 | } 39 | 40 | unique_ptr clone() override 41 | { 42 | return make_unique(*this); 43 | } 44 | }; 45 | 46 | class BisikledKayit : public Kayit 47 | { 48 | private: 49 | string bisikletIsim; 50 | int bisikletID; 51 | 52 | public: 53 | BisikledKayit(string bisikletIsim, int ID) : bisikletIsim(bisikletIsim), bisikletID(ID) 54 | { 55 | } 56 | 57 | void print() override 58 | { 59 | cout << "Bisiklet Kaydı" << endl 60 | << "Marka : " << bisikletIsim << endl 61 | << "Model : " << bisikletID << endl 62 | << endl; 63 | } 64 | 65 | unique_ptr clone() override 66 | { 67 | return make_unique(*this); 68 | } 69 | }; 70 | 71 | class InsanKayit : public Kayit 72 | { 73 | private: 74 | string insanIsim; 75 | int yas; 76 | 77 | public: 78 | InsanKayit(string insanIsim, int yas) : insanIsim(insanIsim), yas(yas) 79 | { 80 | } 81 | 82 | void print() override 83 | { 84 | cout << "İnsan Kaydı" << endl 85 | << "İsim : " << insanIsim << endl 86 | << "Yaş : " << yas << endl 87 | << endl; 88 | } 89 | 90 | unique_ptr clone() override 91 | { 92 | return make_unique(*this); 93 | } 94 | }; 95 | ``` 96 | 97 | * Anlamlı bir kullanım için **"KayitTipi"** oluşturuyoruz. 98 | 99 | ```cpp 100 | enum KayitTipi 101 | { 102 | ARABA, 103 | BISIKLET, 104 | INSAN 105 | }; 106 | ``` 107 | 108 | * Bu kısımda ise kaydımızı oluşturuyoruz. 109 | 110 | ```cpp 111 | class KayitFactory 112 | { 113 | private: 114 | unordered_map, hash> kayit; 115 | 116 | public: 117 | KayitFactory() 118 | { 119 | kayit[ARABA] = make_unique("Tofaş Şahin", 94); 120 | kayit[BISIKLET] = make_unique("Yamaha", 2525); 121 | kayit[INSAN] = make_unique("Mert Acel", 25); 122 | } 123 | 124 | unique_ptr kayitOlustur(KayitTipi recordType) 125 | { 126 | return kayit[recordType]->clone(); 127 | } 128 | }; 129 | ``` 130 | 131 | * Kullanımda ise ilk önce **"KayitFactory"** nesnesi oluşturuyoruz. ardıdnan oluşturduğımız nesne ile **"kayitOlustur"** methodunu kullanıp, ilgili protatibimizi çağırmış oluyoruz. 132 | 133 | ```cpp 134 | int main() 135 | { 136 | KayitFactory kayitFactory; 137 | 138 | auto kayit = kayitFactory.kayitOlustur(ARABA); 139 | kayit->print(); 140 | 141 | kayit = kayitFactory.kayitOlustur(BISIKLET); 142 | kayit->print(); 143 | 144 | kayit = kayitFactory.kayitOlustur(INSAN); 145 | kayit->print(); 146 | } 147 | ``` -------------------------------------------------------------------------------- /01_Creational_Yaratilis/05_Prototype/bin/Prototype: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/01_Creational_Yaratilis/05_Prototype/bin/Prototype -------------------------------------------------------------------------------- /01_Creational_Yaratilis/05_Prototype/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 05_Prototype 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Prototype Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | #include 11 | #include 12 | using namespace std; 13 | 14 | class Kayit 15 | { 16 | public: 17 | virtual ~Kayit() {} 18 | virtual void print() = 0; 19 | virtual unique_ptr clone() = 0; 20 | }; 21 | 22 | class ArabaKayit : public Kayit 23 | { 24 | private: 25 | string arabaIsim; 26 | int arabaID; 27 | 28 | public: 29 | ArabaKayit(string arabaIsim, int ID) : arabaIsim(arabaIsim), arabaID(ID) 30 | { 31 | } 32 | 33 | void print() override 34 | { 35 | cout << "Araba Kaydı" << endl 36 | << "Marka : " << arabaIsim << endl 37 | << "Model : " << arabaID << endl 38 | << endl; 39 | } 40 | 41 | unique_ptr clone() override 42 | { 43 | return make_unique(*this); 44 | } 45 | }; 46 | 47 | class BisikledKayit : public Kayit 48 | { 49 | private: 50 | string bisikletIsim; 51 | int bisikletID; 52 | 53 | public: 54 | BisikledKayit(string bisikletIsim, int ID) : bisikletIsim(bisikletIsim), bisikletID(ID) 55 | { 56 | } 57 | 58 | void print() override 59 | { 60 | cout << "Bisiklet Kaydı" << endl 61 | << "Marka : " << bisikletIsim << endl 62 | << "Model : " << bisikletID << endl 63 | << endl; 64 | } 65 | 66 | unique_ptr clone() override 67 | { 68 | return make_unique(*this); 69 | } 70 | }; 71 | 72 | class InsanKayit : public Kayit 73 | { 74 | private: 75 | string insanIsim; 76 | int yas; 77 | 78 | public: 79 | InsanKayit(string insanIsim, int yas) : insanIsim(insanIsim), yas(yas) 80 | { 81 | } 82 | 83 | void print() override 84 | { 85 | cout << "İnsan Kaydı" << endl 86 | << "İsim : " << insanIsim << endl 87 | << "Yaş : " << yas << endl 88 | << endl; 89 | } 90 | 91 | unique_ptr clone() override 92 | { 93 | return make_unique(*this); 94 | } 95 | }; 96 | 97 | enum KayitTipi 98 | { 99 | ARABA, 100 | BISIKLET, 101 | INSAN 102 | }; 103 | 104 | class KayitFactory 105 | { 106 | private: 107 | unordered_map, hash> kayit; 108 | 109 | public: 110 | KayitFactory() 111 | { 112 | kayit[ARABA] = make_unique("Tofaş Şahin", 94); 113 | kayit[BISIKLET] = make_unique("Yamaha", 2525); 114 | kayit[INSAN] = make_unique("Mert Acel", 25); 115 | } 116 | 117 | unique_ptr kayitOlustur(KayitTipi recordType) 118 | { 119 | return kayit[recordType]->clone(); 120 | } 121 | }; 122 | 123 | int main() 124 | { 125 | KayitFactory kayitFactory; 126 | 127 | auto kayit = kayitFactory.kayitOlustur(ARABA); 128 | kayit->print(); 129 | 130 | kayit = kayitFactory.kayitOlustur(BISIKLET); 131 | kayit->print(); 132 | 133 | kayit = kayitFactory.kayitOlustur(INSAN); 134 | kayit->print(); 135 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/01_Chain_of_Responsibility/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "ChainofResponsibility") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Chain of Responsibility") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/01_Chain_of_Responsibility/README.md: -------------------------------------------------------------------------------- 1 | # Chain of Responsibility Pattern 2 | 3 | **"Chain of Responsibility Pattern"**, Türkçe anlamı **"Sorumluluk Zinciri"dir**. Bu pattern, bir talebin göndericisini alıcısına, birden fazla nesneyi isteği yerine getirme şansı vererek birleştirmekten kaçınmak niyetindedir. Alıcı nesneleri zincirler ve istekleri bir nesne ele geçirene kadar zincir boyunca geçirir. 4 | 5 | ## Chain of Responsibility Pattern Kullanım Adımları 6 | 7 | * İlk önce **"TrafikKurallari"** isminde bir sınıf oluşturuyoruz. Bu sınıf, içinde kendi tipinde bir nesne bulundurmakta. Bu nesne üzerinden işlemler gerçekleşecek. Bu sınıf oluşturulnca yani **"constructor"**da, oluşturduğumuz nesneye **"NULL"** değerini atıyoruz. Ardından sanal bir **"deconstructor"** oluşturuyoruz. Bu oluşturduğumuz sınıfı silme işleminde kullanılmaktadır. Bu işlemden sonra **sorgula** isminde bir method oluşturuyoruz. Bu method, alt sınıfta hıza göre işlemler yapacak. **"setKuralDegistir"** methodu ise, başta belirtilen kuralları değiştirmeye yaramaktadır. 8 | 9 | ```cpp 10 | class TrafikKurallari 11 | { 12 | protected: 13 | TrafikKurallari *trafikKurallari; 14 | 15 | public: 16 | TrafikKurallari() 17 | { 18 | trafikKurallari = NULL; 19 | } 20 | 21 | virtual ~TrafikKurallari() {} 22 | 23 | virtual void sorgula(int value) = 0; 24 | 25 | void setKuralDegistir(TrafikKurallari *yolTipi) 26 | { 27 | trafikKurallari = yolTipi; 28 | } 29 | }; 30 | ``` 31 | 32 | * Şimdi ise oluşturduğumuz **"TrafikKurallari"** sınıfında miras alan **"Yol"** sınıfını oluşturuyoruz. İlk önce sorgularda kullanılacak olan parametreleri alıyoruz. Bunlar **"hizLimiti"** ve **"yolTipi"**. Her yol tipine göre hız limiti farklıdır. Bu sınıfın **"constructor"** methodunda yola ait tipi ve limiti alıyoruz. Burada **"sorgula"** isimde, **"TrafikKurallari"** sınıfından gelen bir method bulunmakta. Bu method, yapılan hıza göre, **"Yol"** sınıfı oluşurken belirlediği limitlere ile karşılaştırmasını sağlar. Karşılaştırma sonucuna görede ekrana belirli bilgiler verir. 33 | 34 | ```cpp 35 | class Yol : public TrafikKurallari 36 | { 37 | private: 38 | int hizLimiti; 39 | string yolTipi; 40 | 41 | public: 42 | Yol(string yolTipi, int hizLimiti) 43 | { 44 | this->hizLimiti = hizLimiti; 45 | this->yolTipi = yolTipi; 46 | } 47 | 48 | ~Yol() {} 49 | 50 | void sorgula(int yapilanHiz) override 51 | { 52 | if (yapilanHiz < hizLimiti) 53 | { 54 | cout << "--------------------------------------------------" << endl; 55 | cout << "Yol Tipi : " << yolTipi << endl 56 | << "Hız Limiti : " << hizLimiti << endl 57 | << "Yapılan Hız : " << yapilanHiz << endl 58 | << "Sonuç : Ceza Almadınız." << endl; 59 | } 60 | else if (trafikKurallari != NULL) 61 | { 62 | trafikKurallari->sorgula(yapilanHiz); 63 | } 64 | else 65 | { 66 | cout << "--------------------------------------------------" << endl; 67 | cout << "Dikkat !!! Hız Limit Aşımı" << endl 68 | << "Yol Tipi : " << yolTipi << endl 69 | << "Yapılan Hız " << yapilanHiz << endl 70 | << "Bu Yolda Limit : " << hizLimiti << endl 71 | << "Lütfen Limitte Kalınız." << endl; 72 | } 73 | } 74 | }; 75 | ``` 76 | 77 | * Bu sistematiği kullanmak için, **"TrafikKurallari"** tipinde ve **"Yol"** sınıfından nesneler oluşturmamız gerekmektedir. Ardından hız sorgulamaları gerçekleşecektir. Eğer **"setKuralDegistir"** methodu kullanılırsa, **"()"** içinde belirtilen, daha önceden tanımlanmış olan yol bilgilerine göre, yol tipi ve hızına göre işlem gerçekleşecektir. 78 | 79 | ```cpp 80 | int main() 81 | { 82 | TrafikKurallari *ulke1 = new Yol("Tek Şerit", 100); 83 | TrafikKurallari *ulke2 = new Yol("Çift Şerit", 120); 84 | TrafikKurallari *ulke3 = new Yol("Otoban", 150); 85 | 86 | ulke1->sorgula(80); 87 | ulke1->sorgula(115); 88 | 89 | ulke1->setKuralDegistir(ulke2); 90 | ulke1->sorgula(90); 91 | ulke1->sorgula(115); 92 | 93 | ulke2->sorgula(85); 94 | ulke2->sorgula(130); 95 | ulke2->setKuralDegistir(ulke3); 96 | ulke2->sorgula(140); 97 | 98 | delete ulke1; 99 | delete ulke2; 100 | delete ulke3; 101 | 102 | return 0; 103 | } 104 | ``` -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/01_Chain_of_Responsibility/bin/ChainofResponsibility: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/01_Chain_of_Responsibility/bin/ChainofResponsibility -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/01_Chain_of_Responsibility/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 01_Chain_of_Responsibility 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Chain of Responsibility 7 | //============================================================================ 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | class TrafikKurallari 14 | { 15 | protected: 16 | TrafikKurallari *trafikKurallari; 17 | 18 | public: 19 | TrafikKurallari() 20 | { 21 | trafikKurallari = NULL; 22 | } 23 | 24 | virtual ~TrafikKurallari() {} 25 | 26 | virtual void sorgula(int value) = 0; 27 | 28 | void setKuralDegistir(TrafikKurallari *yolTipi) 29 | { 30 | trafikKurallari = yolTipi; 31 | } 32 | }; 33 | 34 | class Yol : public TrafikKurallari 35 | { 36 | private: 37 | int hizLimiti; 38 | string yolTipi; 39 | 40 | public: 41 | Yol(string yolTipi, int hizLimiti) 42 | { 43 | this->hizLimiti = hizLimiti; 44 | this->yolTipi = yolTipi; 45 | } 46 | 47 | ~Yol() {} 48 | 49 | void sorgula(int yapilanHiz) override 50 | { 51 | if (yapilanHiz < hizLimiti) 52 | { 53 | cout << "--------------------------------------------------" << endl; 54 | cout << "Yol Tipi : " << yolTipi << endl 55 | << "Hız Limiti : " << hizLimiti << endl 56 | << "Yapılan Hız : " << yapilanHiz << endl 57 | << "Sonuç : Ceza Almadınız." << endl; 58 | } 59 | else if (trafikKurallari != NULL) 60 | { 61 | trafikKurallari->sorgula(yapilanHiz); 62 | } 63 | else 64 | { 65 | cout << "--------------------------------------------------" << endl; 66 | cout << "Dikkat !!! Hız Limit Aşımı" << endl 67 | << "Yol Tipi : " << yolTipi << endl 68 | << "Yapılan Hız " << yapilanHiz << endl 69 | << "Bu Yolda Limit : " << hizLimiti << endl 70 | << "Lütfen Limitte Kalınız." << endl; 71 | } 72 | } 73 | }; 74 | 75 | int main() 76 | { 77 | TrafikKurallari *ulke1 = new Yol("Tek Şerit", 100); 78 | TrafikKurallari *ulke2 = new Yol("Çift Şerit", 120); 79 | TrafikKurallari *ulke3 = new Yol("Otoban", 150); 80 | 81 | ulke1->sorgula(80); 82 | ulke1->sorgula(115); 83 | 84 | ulke1->setKuralDegistir(ulke2); 85 | ulke1->sorgula(90); 86 | ulke1->sorgula(115); 87 | 88 | ulke2->sorgula(85); 89 | ulke2->sorgula(130); 90 | ulke2->setKuralDegistir(ulke3); 91 | ulke2->sorgula(140); 92 | 93 | delete ulke1; 94 | delete ulke2; 95 | delete ulke3; 96 | 97 | return 0; 98 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/02_Command/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Command") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Command") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -Werror -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/02_Command/README.md: -------------------------------------------------------------------------------- 1 | # Command Pattern 2 | 3 | **"Command Pattern"** bir isteği bir nesne olarak kapsüllemek için kullanılır. Böylece istemcileri farklı isteklere, sıraya veya kayıt isteklerine göre parametrelendirmenize ve geri alınamayan işlemleri desteklemenize izin verir. 4 | 5 | ## Command Pattern Kullanım Adımları 6 | 7 | * İlk olarak soyut bir sınıf oluşturuyoruz. Bu sınıfa **"Komut"** ismini verdik. Bu sınıfın **"calistir"** isminde bir methodu bulunmakta. 8 | 9 | ```cpp 10 | class Komut 11 | { 12 | public: 13 | virtual void calistir() = 0; 14 | }; 15 | ``` 16 | 17 | * Ardından işlem görecek sınıfımızı hazırlıyoruz. Bu sınıf ismine **"Isik"** ismini verdik. Bu sınıf, ışığı açma ve kapama işlemi gerçekleştiriyor. 18 | 19 | ```cpp 20 | class Isik 21 | { 22 | public: 23 | Isik() {} 24 | 25 | void ac() 26 | { 27 | cout << "Işık Açıldı..." << endl; 28 | } 29 | 30 | void kapat() 31 | { 32 | cout << "Işık Kapandı..." << endl; 33 | } 34 | }; 35 | ``` 36 | 37 | * Sonraki adım olarak, **Komut"** sınıfından komutlar üretiyoruz. Projemizde **"AcKomut"** ve **"KapatKomut"** olarak 2 komut bulunmakta. 38 | 39 | ```cpp 40 | class AcKomut : public Komut 41 | { 42 | private: 43 | Isik &isik; 44 | 45 | public: 46 | AcKomut(Isik &isik) : isik(isik) 47 | { 48 | } 49 | 50 | virtual void calistir() 51 | { 52 | isik.ac(); 53 | } 54 | }; 55 | 56 | 57 | class KapatKomut : public Komut 58 | { 59 | private: 60 | Isik &isik; 61 | 62 | public: 63 | KapatKomut(Isik &isik) : isik(isik) 64 | { 65 | } 66 | virtual void calistir() override 67 | { 68 | isik.kapat(); 69 | } 70 | }; 71 | ``` 72 | 73 | * Son adım olarak **"Degistir"** sınıfını tanımlıyoruz. Bu sınıf, bir ışığın açma ve kapatma durumlarını kontrol etmektedir. 74 | 75 | ```cpp 76 | class Degistir 77 | { 78 | private: 79 | Komut &acKomut; 80 | Komut &kapatKomut; 81 | 82 | public: 83 | Degistir(Komut &acKomut, Komut &kapatKomut) 84 | : acKomut(acKomut), kapatKomut(kapatKomut) 85 | { 86 | } 87 | 88 | void ac() 89 | { 90 | acKomut.calistir(); 91 | } 92 | 93 | void kapat() 94 | { 95 | kapatKomut.calistir(); 96 | } 97 | }; 98 | ``` 99 | 100 | * Şimdi yazdığımız sınıfların kontrolünü yapalım. ilk olarak **"Isik"** sınıfından bir nesne üretiyoruz. Ardından **"Komut"** sınıfından türetilen, **"AcKomut"** ve **"KapatKomut"** sınıflarıdnan nesneler üretiyoruz. **"Isik"** sınıfından ürettiğimiz nesneleride komutlara veriyoruz. En sonra **"Degistir"** sınıfından nesne üret,yoruz ve komut nesnelerinide parametre olarak veriyoruz. Artık kolay bir şekilde komutumuzu kullanabiliriz. **"ac"**, **"kapat"** fonksiyonları sayesinde, ışık açma - kapatma işlemlerini gerçekleştiriyoruz. 101 | 102 | ```cpp 103 | int main() 104 | { 105 | Isik lamba; 106 | AcKomut degistirAc(lamba); 107 | KapatKomut degistirKapat(lamba); 108 | 109 | Degistir s(degistirAc, degistirKapat); 110 | s.ac(); 111 | s.kapat(); 112 | } 113 | ``` -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/02_Command/bin/Command: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/02_Command/bin/Command -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/02_Command/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 02_Command 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Command Pattern 7 | //============================================================================ 8 | #include 9 | 10 | using namespace std; 11 | 12 | class Komut 13 | { 14 | public: 15 | virtual void calistir() = 0; 16 | }; 17 | 18 | class Isik 19 | { 20 | public: 21 | Isik() {} 22 | 23 | void ac() 24 | { 25 | cout << "Işık Açıldı..." << endl; 26 | } 27 | 28 | void kapat() 29 | { 30 | cout << "Işık Kapandı..." << endl; 31 | } 32 | }; 33 | 34 | class AcKomut : public Komut 35 | { 36 | private: 37 | Isik &isik; 38 | 39 | public: 40 | AcKomut(Isik &isik) : isik(isik) 41 | { 42 | } 43 | 44 | virtual void calistir() override 45 | { 46 | isik.ac(); 47 | } 48 | }; 49 | 50 | 51 | class KapatKomut : public Komut 52 | { 53 | private: 54 | Isik &isik; 55 | 56 | public: 57 | KapatKomut(Isik &isik) : isik(isik) 58 | { 59 | } 60 | virtual void calistir() override 61 | { 62 | isik.kapat(); 63 | } 64 | }; 65 | 66 | class Degistir 67 | { 68 | private: 69 | Komut &acKomut; 70 | Komut &kapatKomut; 71 | 72 | public: 73 | Degistir(Komut &acKomut, Komut &kapatKomut) 74 | : acKomut(acKomut), kapatKomut(kapatKomut) 75 | { 76 | } 77 | 78 | void ac() 79 | { 80 | acKomut.calistir(); 81 | } 82 | 83 | void kapat() 84 | { 85 | kapatKomut.calistir(); 86 | } 87 | }; 88 | 89 | int main() 90 | { 91 | Isik lamba; 92 | AcKomut degistirAc(lamba); 93 | KapatKomut degistirKapat(lamba); 94 | 95 | Degistir s(degistirAc, degistirKapat); 96 | s.ac(); 97 | s.kapat(); 98 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/03_Interpreter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Interpreter") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Interpreter") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++11") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/03_Interpreter/README.md: -------------------------------------------------------------------------------- 1 | # Interpreter Pattern 2 | 3 | **"Interpreter Pattern"**, özellikle dil işleme gibi durumlarda oldukça tercih edilen bir türdür. 4 | 5 | ## Interpreter Pattern Kullanım Adımları 6 | 7 | Biz örneğimizde, girilen bir **"ROMA Rakamının"** karşılığını veren programı yazacağız. 8 | 9 | * İlk adım olarak **"RomaRakamInterpreter"** isminde bir sınıf oluşturuyoryuz. Bu sınıfta **"private"** erişim hakkında ve **"RomaRakamInterpreter"** türünde **"binler"**, **"yuzler"**, **"onlar"**, **"birler"** isminde nesneler oluşturuyoruz. Ardından **"protected"** türünde geri **"char"** tipinde değer döndüren **"bir"**, **"dort"**, **"bes"**, **"dokuz"** ve int tipinde **"carpan"** isminde methodlar tanımlıyoruz. Bu methodlar, romen rakamlarında etkileşime giren rakamlardır. Çarpanda, hangi basamak olduğunu belli eder. Dikkat edilmesi gereken husus, bu methodlar **"virtual"** yani soyuttur. Ardından **"public"** erişim hakkında bazı işlemlerimiz bulunmakta. İlk olarak Constructorlar tanımlıyoruz ardından **"interpret"** tanımlıyoruz. En son bunların anlatımını gerçekleştireceğiz. Sonra, geri değer döndürmeyen ve sanal olan bir **"interpret"** methodu daha tanımlıyoruz. Bu fonsiyon bizim için çok önemli çünkü bütün hesapalama burada gerçekleşmektedir. Dikkat ederseniz, **"virtual"** olarak tanımlanmış. Bu sayede, alt sınıflardan gelen verinin, değer ve basamağına göre işlem yapmakta. 10 | 11 | ```cpp 12 | class RomaRakamInterpreter 13 | { 14 | private: 15 | RomaRakamInterpreter *binler; 16 | RomaRakamInterpreter *yuzler; 17 | RomaRakamInterpreter *onlar; 18 | RomaRakamInterpreter *birler; 19 | 20 | protected: 21 | virtual char bir() {} 22 | virtual char *dort() {} 23 | virtual char bes() {} 24 | virtual char *dokuz() {} 25 | virtual int carpan() {} 26 | 27 | public: 28 | RomaRakamInterpreter(); 29 | RomaRakamInterpreter(int) {} 30 | int interpret(char *); 31 | 32 | virtual void interpret(char *input, int &total) 33 | { 34 | int index; 35 | index = 0; 36 | if (!strncmp(input, dokuz(), 2)) 37 | { 38 | total += 9 * carpan(); 39 | index += 2; 40 | } 41 | else if (!strncmp(input, dort(), 2)) 42 | { 43 | total += 4 * carpan(); 44 | index += 2; 45 | } 46 | else 47 | { 48 | if (input[0] == bes()) 49 | { 50 | total += 5 * carpan(); 51 | index = 1; 52 | } 53 | else 54 | index = 0; 55 | for (int end = index + 3; index < end; index++) 56 | if (input[index] == bir()) 57 | total += 1 * carpan(); 58 | else 59 | break; 60 | } 61 | strcpy(input, &(input[index])); 62 | } 63 | }; 64 | ``` 65 | 66 | * Şimdiki adım olarak oluşturduğumuz **"RomaRakamInterpreter"** sınıfından miras alan **"Binler"**, **"Yuzler"**, **"Onlar"**, **"Birler"** sınıflarını oluşturuyoruz. bu sınıflar hemen hemen aynıdır, farkları ise, ilgili basamakta döndürülen işaret. Mesela **"Binler"** sınıfında **"bir()"** methodu geriye **"M"** döndürürken, **Onlar"** sınıfı **"bir()"** methodu geriye **"X"** değeri döndürmektedir. 67 | 68 | ```cpp 69 | class Binler : public RomaRakamInterpreter 70 | { 71 | public: 72 | Binler(int) : RomaRakamInterpreter(1) {} 73 | 74 | protected: 75 | char bir() override 76 | { 77 | return 'M'; 78 | } 79 | char *dort() override 80 | { 81 | return ""; 82 | } 83 | char bes() override 84 | { 85 | return '\0'; 86 | } 87 | char *dokuz() override 88 | { 89 | return ""; 90 | } 91 | int carpan() override 92 | { 93 | return 1000; 94 | } 95 | }; 96 | 97 | class Yuzler : public RomaRakamInterpreter 98 | { 99 | public: 100 | Yuzler(int) : RomaRakamInterpreter(1) {} 101 | 102 | protected: 103 | char bir() override 104 | { 105 | return 'C'; 106 | } 107 | char *dort() override 108 | { 109 | return "CD"; 110 | } 111 | char bes() override 112 | { 113 | return 'D'; 114 | } 115 | char *dokuz() override 116 | { 117 | return "CM"; 118 | } 119 | int carpan() override 120 | { 121 | return 100; 122 | } 123 | }; 124 | 125 | class Onlar : public RomaRakamInterpreter 126 | { 127 | public: 128 | Onlar(int) : RomaRakamInterpreter(1) {} 129 | 130 | protected: 131 | char bir() override 132 | { 133 | return 'X'; 134 | } 135 | char *dort() override 136 | { 137 | return "XL"; 138 | } 139 | char bes() override 140 | { 141 | return 'L'; 142 | } 143 | char *dokuz() override 144 | { 145 | return "XC"; 146 | } 147 | int carpan() override 148 | { 149 | return 10; 150 | } 151 | }; 152 | 153 | class Birler : public RomaRakamInterpreter 154 | { 155 | public: 156 | Birler(int) : RomaRakamInterpreter(1) {} 157 | 158 | protected: 159 | char bir() override 160 | { 161 | return 'I'; 162 | } 163 | char *dort() override 164 | { 165 | return "IV"; 166 | } 167 | char bes() override 168 | { 169 | return 'V'; 170 | } 171 | char *dokuz() override 172 | { 173 | return "IX"; 174 | } 175 | int carpan() override 176 | { 177 | return 1; 178 | } 179 | }; 180 | ``` 181 | 182 | * **"RomaRakamInterpreter"** constructorda değişkenlere atama gerçekleştiriyoruz. Ardından **"interpret"** methodunun tanımlamasını gerçekleştiriyoruz. Bu method, kullanıcıdan aldığı değeri, constructorda oluşturduğu sınıflara tek tek gönderip işlenmesini sağlıyor. 183 | 184 | ```cpp 185 | RomaRakamInterpreter::RomaRakamInterpreter() 186 | { 187 | binler = new Binler(1); 188 | yuzler = new Yuzler(1); 189 | onlar = new Onlar(1); 190 | birler = new Birler(1); 191 | } 192 | 193 | int RomaRakamInterpreter::interpret(char *input) 194 | { 195 | int total; 196 | total = 0; 197 | binler->interpret(input, total); 198 | yuzler->interpret(input, total); 199 | onlar->interpret(input, total); 200 | birler->interpret(input, total); 201 | 202 | if (strcmp(input, "")) 203 | { 204 | return 0; 205 | } 206 | 207 | return total; 208 | } 209 | ``` 210 | 211 | * Kullanım için ise, **"RomaRakamInterpreter"** sınıfından bir nesne oluşturuyoruz. Ardından, **"interpreter.interpret(input) "** kodu ile, biz durdurana kadar dönüştürme işlemine devam ediyor. 212 | 213 | ```cpp 214 | int main() 215 | { 216 | RomaRakamInterpreter interpreter; 217 | char input[20]; 218 | cout << "Roma rakamı giriniz : "; 219 | while (cin >> input) 220 | { 221 | cout << "Latin Karşılığı : " << interpreter.interpret(input) << endl; 222 | cout << "Roma rakamı giriniz : "; 223 | } 224 | } 225 | ``` -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/03_Interpreter/bin/Interpreter: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/03_Interpreter/bin/Interpreter -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/03_Interpreter/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 03_Interpreter 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Interpreter Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | class RomaRakamInterpreter 14 | { 15 | private: 16 | RomaRakamInterpreter *binler; 17 | RomaRakamInterpreter *yuzler; 18 | RomaRakamInterpreter *onlar; 19 | RomaRakamInterpreter *birler; 20 | 21 | protected: 22 | virtual char bir() {} 23 | virtual char *dort() {} 24 | virtual char bes() {} 25 | virtual char *dokuz() {} 26 | virtual int carpan() {} 27 | 28 | public: 29 | RomaRakamInterpreter(); 30 | RomaRakamInterpreter(int) {} 31 | int interpret(char *); 32 | 33 | virtual void interpret(char *input, int &total) 34 | { 35 | int index; 36 | index = 0; 37 | if (!strncmp(input, dokuz(), 2)) 38 | { 39 | total += 9 * carpan(); 40 | index += 2; 41 | } 42 | else if (!strncmp(input, dort(), 2)) 43 | { 44 | total += 4 * carpan(); 45 | index += 2; 46 | } 47 | else 48 | { 49 | if (input[0] == bes()) 50 | { 51 | total += 5 * carpan(); 52 | index = 1; 53 | } 54 | else 55 | index = 0; 56 | for (int end = index + 3; index < end; index++) 57 | if (input[index] == bir()) 58 | total += 1 * carpan(); 59 | else 60 | break; 61 | } 62 | strcpy(input, &(input[index])); 63 | } 64 | }; 65 | 66 | class Binler : public RomaRakamInterpreter 67 | { 68 | public: 69 | Binler(int) : RomaRakamInterpreter(1) {} 70 | 71 | protected: 72 | char bir() override 73 | { 74 | return 'M'; 75 | } 76 | char *dort() override 77 | { 78 | return ""; 79 | } 80 | char bes() override 81 | { 82 | return '\0'; 83 | } 84 | char *dokuz() override 85 | { 86 | return ""; 87 | } 88 | int carpan() override 89 | { 90 | return 1000; 91 | } 92 | }; 93 | 94 | class Yuzler : public RomaRakamInterpreter 95 | { 96 | public: 97 | Yuzler(int) : RomaRakamInterpreter(1) {} 98 | 99 | protected: 100 | char bir() override 101 | { 102 | return 'C'; 103 | } 104 | char *dort() override 105 | { 106 | return "CD"; 107 | } 108 | char bes() override 109 | { 110 | return 'D'; 111 | } 112 | char *dokuz() override 113 | { 114 | return "CM"; 115 | } 116 | int carpan() override 117 | { 118 | return 100; 119 | } 120 | }; 121 | 122 | class Onlar : public RomaRakamInterpreter 123 | { 124 | public: 125 | Onlar(int) : RomaRakamInterpreter(1) {} 126 | 127 | protected: 128 | char bir() override 129 | { 130 | return 'X'; 131 | } 132 | char *dort() override 133 | { 134 | return "XL"; 135 | } 136 | char bes() override 137 | { 138 | return 'L'; 139 | } 140 | char *dokuz() override 141 | { 142 | return "XC"; 143 | } 144 | int carpan() override 145 | { 146 | return 10; 147 | } 148 | }; 149 | 150 | class Birler : public RomaRakamInterpreter 151 | { 152 | public: 153 | Birler(int) : RomaRakamInterpreter(1) {} 154 | 155 | protected: 156 | char bir() override 157 | { 158 | return 'I'; 159 | } 160 | char *dort() override 161 | { 162 | return "IV"; 163 | } 164 | char bes() override 165 | { 166 | return 'V'; 167 | } 168 | char *dokuz() override 169 | { 170 | return "IX"; 171 | } 172 | int carpan() override 173 | { 174 | return 1; 175 | } 176 | }; 177 | 178 | RomaRakamInterpreter::RomaRakamInterpreter() 179 | { 180 | binler = new Binler(1); 181 | yuzler = new Yuzler(1); 182 | onlar = new Onlar(1); 183 | birler = new Birler(1); 184 | } 185 | 186 | int RomaRakamInterpreter::interpret(char *input) 187 | { 188 | int total; 189 | total = 0; 190 | binler->interpret(input, total); 191 | yuzler->interpret(input, total); 192 | onlar->interpret(input, total); 193 | birler->interpret(input, total); 194 | 195 | if (strcmp(input, "")) 196 | { 197 | return 0; 198 | } 199 | 200 | return total; 201 | } 202 | 203 | int main() 204 | { 205 | RomaRakamInterpreter interpreter; 206 | char input[20]; 207 | cout << "Roma rakamı giriniz : "; 208 | while (cin >> input) 209 | { 210 | cout << "Latin Karşılığı : " << interpreter.interpret(input) << endl; 211 | cout << "Roma rakamı giriniz : "; 212 | } 213 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/04_Iterator/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Iterator") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Iterator") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/04_Iterator/bin/Iterator: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/04_Iterator/bin/Iterator -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/04_Iterator/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 04_Iterator 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Iterator Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | class StackIter; 12 | 13 | class Stack 14 | { 15 | int items[10]; 16 | int sp; 17 | 18 | public: 19 | friend class StackIter; 20 | StackIter *createIterator() const; // 2. Add a createIterator() member 21 | 22 | Stack() 23 | { 24 | sp = -1; 25 | } 26 | 27 | void push(int in) 28 | { 29 | items[++sp] = in; 30 | } 31 | 32 | int pop() 33 | { 34 | return items[sp--]; 35 | } 36 | 37 | bool isEmpty() 38 | { 39 | return (sp == -1); 40 | } 41 | }; 42 | 43 | class StackIter 44 | { 45 | // 1. Design an "iterator" class 46 | const Stack *stk; 47 | int index; 48 | 49 | public: 50 | StackIter(const Stack *s) 51 | { 52 | stk = s; 53 | } 54 | 55 | void first() 56 | { 57 | index = 0; 58 | } 59 | 60 | void next() 61 | { 62 | index++; 63 | } 64 | 65 | bool isDone() 66 | { 67 | return index == stk->sp + 1; 68 | } 69 | 70 | int currentItem() 71 | { 72 | return stk->items[index]; 73 | } 74 | }; 75 | 76 | StackIter *Stack::createIterator() const 77 | { 78 | return new StackIter(this); 79 | } 80 | 81 | bool operator==(const Stack &l, const Stack &r) 82 | { 83 | // 3. Clients ask the container object to create an iterator object 84 | StackIter *itl = l.createIterator(); 85 | StackIter *itr = r.createIterator(); 86 | // 4. Clients use the first(), isDone(), next(), and currentItem() protocol 87 | for (itl->first(), itr->first(); !itl->isDone(); itl->next(), itr->next()) 88 | if (itl->currentItem() != itr->currentItem()) 89 | break; 90 | bool ans = itl->isDone() && itr->isDone(); 91 | delete itl; 92 | delete itr; 93 | return ans; 94 | } 95 | 96 | int main() 97 | { 98 | Stack s1; 99 | for (int i = 1; i < 5; i++) 100 | { 101 | s1.push(i); 102 | } 103 | 104 | Stack s2(s1), s3(s1), s4(s1), s5(s1); 105 | 106 | s3.pop(); 107 | s5.pop(); 108 | s4.push(3); 109 | s5.push(9); 110 | 111 | cout << "1 == 2 is " << (s1 == s2) << endl; 112 | cout << "1 == 3 is " << (s1 == s3) << endl; 113 | cout << "1 == 4 is " << (s1 == s4) << endl; 114 | cout << "1 == 5 is " << (s1 == s5) << endl; 115 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/05_Mediator/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Mediator") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Mediator") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/05_Mediator/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 05_Mediator 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Mediator Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/06_Memento/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Memento") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Memento") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/06_Memento/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 06_Memento 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Memento Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/07_Observer/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Observer") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Observer") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/07_Observer/README.md: -------------------------------------------------------------------------------- 1 | # Observer Pattern 2 | 3 | Uygulamada bir yer ya da birçok yer, bir sistem olayı veya bir uygulama durumu değişikliği hakkında bilgi sahibi olmamız gerekir. Sistem olaylarını dinlemeye ve ilgili taraflara bildirimde bulunmanın standart bir yoluna, standart bir şekilde abone olmak durumunda kullanılmaktadır. 4 | 5 | Yani **"Observer Pattern"**, nesneler arasında bağımlılık tanımlar, böylece bir nesne değiştiğinde, tüm bağımlıları otomatik olarak bildirilir ve güncellenir. 6 | 7 | ## Observer Pattern Kullanım Adımları 8 | Bu örneğimizde hava durumu gösterici yapıyoruz. Projemizde, nem, sıcaklık ve basıç verilerini bir ekranda gösteren, yeni veriler geldikçe de gerekli yerleri güncelleyen yapıyı inceleyeceğiz 9 | 10 | * İlk önce bir soyut sınıf tanımlıyoruz. Bizim sınıfımızın ismini **"ObserverInterface"** olarak belirledik. Bu sınıf, içinde **"guncelle"** adında bir soyut method bulundurmakta. Bu fonksiyon, nem, sıcaklık ve basınç verilerini almakta. 11 | 12 | ```cpp 13 | class ObserverInterface 14 | { 15 | public: 16 | virtual void guncelle(float nem, float sicaklik, float basinc) = 0; 17 | }; 18 | ``` 19 | 20 | * Yapılan değişikliği göstermeye yarayan soyut bir sınıf tanımlıyoruz. 21 | 22 | ```cpp 23 | class DurumGostericiInterface 24 | { 25 | public: 26 | virtual void goster() = 0; 27 | }; 28 | ``` 29 | 30 | * Gelen hava durumlarını kontrol etmeye yaran, **"HavaDurumuVerisiInterface"** isminde soyut bir sınıf tanımlıyoruz. 31 | 32 | ```cpp 33 | class HavaDurumuVerisiInterface 34 | { 35 | public: 36 | virtual void kayitOb(ObserverInterface *ob) = 0; 37 | virtual void silOb(ObserverInterface *ob) = 0; 38 | virtual void bildiriOb() = 0; 39 | }; 40 | ``` 41 | 42 | * Hava durumu verilerini alan **"HavaDurumuVerileri"** ismindeki sınıfımızı tanımlıyoruz. Bu sınıf **"HavaDurumuVerisiInterface"** soyut sınıfını miras olarak alan somut bir sınıftır. 43 | 44 | ```cpp 45 | class HavaDurumuVerileri : public HavaDurumuVerisiInterface 46 | { 47 | private: 48 | float nem; 49 | float sicaklik; 50 | float basinc; 51 | list observeInterfacesListe; 52 | 53 | protected: 54 | void bildiriOb() override 55 | { 56 | for (list::iterator it = observeInterfacesListe.begin(); it != observeInterfacesListe.end(); it++) 57 | { 58 | (*it)->guncelle(nem, sicaklik, basinc); 59 | (dynamic_cast(*it))->goster(); 60 | } 61 | } 62 | 63 | public: 64 | void yeniSensorVerisi(float nem, float sicaklik, float basinc) 65 | { 66 | this->nem = nem; 67 | this->sicaklik = sicaklik; 68 | this->basinc = basinc; 69 | bildiriOb(); 70 | } 71 | 72 | void kayitOb(ObserverInterface *ob) override 73 | { 74 | observeInterfacesListe.push_back(ob); 75 | } 76 | 77 | void silOb(ObserverInterface *ob) override 78 | { 79 | observeInterfacesListe.remove(ob); 80 | } 81 | }; 82 | ``` 83 | 84 | * Gelen yeni verileri gösteren, **"MevcutDurumGosterici"** ismindeki sınıfımızı oluşturuyoruz. Bu sınıf, **"ObserverInterface"** ve **"DurumGostericiInterface"** sınıflarından miras almatka. 85 | 86 | ```cpp 87 | class MevcutDurumGosterici : public ObserverInterface, public DurumGostericiInterface 88 | { 89 | private: 90 | float nem; 91 | float sicaklik; 92 | float basinc; 93 | HavaDurumuVerileri &veri; 94 | 95 | public: 96 | MevcutDurumGosterici(HavaDurumuVerileri &veri) : veri(veri) 97 | { 98 | veri.kayitOb(this); 99 | } 100 | void goster() override 101 | { 102 | cout << "_____Hava Durum_____" << endl; 103 | cout << "Nem : " << nem << endl; 104 | cout << "Sıcaklık : " << sicaklik << endl; 105 | cout << "Basınç : " << basinc << endl; 106 | cout << "_______________________________" << endl; 107 | } 108 | 109 | void guncelle(float nem, float sicaklik, float basinc) override 110 | { 111 | this->nem = nem; 112 | this->sicaklik = sicaklik; 113 | this->basinc = basinc; 114 | } 115 | }; 116 | ``` 117 | 118 | * Gelen verilerin istatiğini tutan bir sınıf daha oluşturuyoruz. Bu sınıfta, **"ObserverInterface"** ve **"DurumGostericiInterface"** sınıflarından miras almatka. 119 | 120 | ```cpp 121 | class HavaIstatistik : public ObserverInterface, public DurumGostericiInterface 122 | { 123 | private: 124 | float enYuksekSicaklik; 125 | float enDusukSicaklik; 126 | float ortalamaSicaklik; 127 | 128 | float enYuksekNem; 129 | float enDusukNem; 130 | float ortalamaNem; 131 | 132 | float enYuksekBasinc; 133 | float enDusukBasinc; 134 | float ortalamaBasinc; 135 | 136 | int gelenVeriSayisi; 137 | HavaDurumuVerileri &havaDurumuVerileri; 138 | 139 | public: 140 | HavaIstatistik(HavaDurumuVerileri &gelenHavaDurumuVerileri) : havaDurumuVerileri(gelenHavaDurumuVerileri) 141 | { 142 | this->enYuksekSicaklik = -1000; 143 | this->enDusukSicaklik = 1000; 144 | this->ortalamaSicaklik = 0; 145 | 146 | this->enYuksekNem = -1000; 147 | this->enDusukNem = 1000; 148 | this->ortalamaNem = 0; 149 | 150 | this->enYuksekBasinc = -1000; 151 | this->enDusukBasinc = 1000; 152 | this->ortalamaBasinc = 0; 153 | 154 | this->gelenVeriSayisi = 0; 155 | 156 | havaDurumuVerileri.kayitOb(this); 157 | } 158 | 159 | void goster() override 160 | { 161 | cout << "________İstatistikler_________" << endl; 162 | cout << "En Düşük Sıcaklık : " << enDusukSicaklik << endl; 163 | cout << "En Yüksek Sıcaklık : " << enYuksekSicaklik << endl; 164 | cout << "Ortalama Sıcaklık : " << ortalamaSicaklik << endl; 165 | cout << "-------------------------------" << endl; 166 | cout << "En Düşük Nem : " << enDusukNem << endl; 167 | cout << "En Yüksek Nem : " << enYuksekNem << endl; 168 | cout << "Ortalama Nem : " << ortalamaNem << endl; 169 | cout << "-------------------------------" << endl; 170 | cout << "En Düşük Basınç : " << enDusukBasinc << endl; 171 | cout << "En Yüksek Basınç : " << enYuksekBasinc << endl; 172 | cout << "Ortalama Basınç : " << ortalamaBasinc << endl; 173 | cout << "_______________________________" << endl 174 | << endl; 175 | } 176 | 177 | void guncelle(float nem, float sicaklik, float basinc) override 178 | { 179 | ++gelenVeriSayisi; 180 | 181 | if (sicaklik > enYuksekSicaklik) 182 | { 183 | enYuksekSicaklik = sicaklik; 184 | } 185 | if (sicaklik < enDusukSicaklik) 186 | { 187 | enDusukSicaklik = sicaklik; 188 | } 189 | ortalamaSicaklik = (ortalamaSicaklik * (gelenVeriSayisi - 1) + sicaklik) / gelenVeriSayisi; 190 | 191 | if (nem > enYuksekNem) 192 | { 193 | enYuksekNem = nem; 194 | } 195 | if (nem < enDusukNem) 196 | { 197 | enDusukNem = nem; 198 | } 199 | ortalamaNem = (ortalamaNem * (gelenVeriSayisi - 1) + nem) / gelenVeriSayisi; 200 | 201 | if (basinc > enYuksekBasinc) 202 | { 203 | enYuksekBasinc = basinc; 204 | } 205 | if (basinc < enDusukBasinc) 206 | { 207 | enDusukBasinc = basinc; 208 | } 209 | ortalamaBasinc = (ortalamaBasinc * (gelenVeriSayisi - 1) + basinc) / gelenVeriSayisi; 210 | } 211 | }; 212 | ``` 213 | 214 | * Kullanım için, ilk olarak **"HavaDurumuVerileri"** nesnesi oluşturuyoruz. Bu nesne, **"yeniSensorVerisi"** methodu yardımı ile, sistemimize veri girişi sağlamaya yaramaktadır. Ardından göstericiler için **"MevcutDurumGosterici"** ve **"HavaIstatistik"** nesneleri oluşturup, işleyecekleri **"HavaDurumuVerileri"** nesnesini atıyoruz. Ardından veri girişi gerçekleştiriyoruz. Eğer hayıtı silmek istersek, yani dinleyeni silmek istersek, yani **"MevcutDurumGosterici"** ve **"HavaIstatistik"** sınıflarından birini devre dışı bırakmak istersek **"silOb"** yardımı ile bağlılığını kaldırıyoruz. 215 | 216 | ```cpp 217 | int main() 218 | { 219 | 220 | HavaDurumuVerileri *havaVerisi = new HavaDurumuVerileri; 221 | 222 | MevcutDurumGosterici *mevcutDurumGosterici = new MevcutDurumGosterici(*havaVerisi); 223 | HavaIstatistik *havaIstatistik = new HavaIstatistik(*havaVerisi); 224 | 225 | havaVerisi->yeniSensorVerisi(10.2, 28.2, 1001); 226 | havaVerisi->yeniSensorVerisi(12, 30.12, 1003); 227 | havaVerisi->yeniSensorVerisi(10.2, 26, 806); 228 | havaVerisi->yeniSensorVerisi(10.3, 35.9, 900); 229 | 230 | havaVerisi->silOb(mevcutDurumGosterici); 231 | 232 | havaVerisi->yeniSensorVerisi(100, 40, 1900); 233 | 234 | delete[] havaIstatistik; 235 | delete[] mevcutDurumGosterici; 236 | delete havaVerisi; 237 | 238 | return 0; 239 | } 240 | ``` -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/07_Observer/bin/Observer: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/07_Observer/bin/Observer -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/07_Observer/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 07_Observer 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Observer Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | // Abstract Observer 14 | class ObserverInterface 15 | { 16 | public: 17 | virtual void guncelle(float nem, float sicaklik, float basinc) = 0; 18 | }; 19 | 20 | // Abstract Interface for Displays 21 | class DurumGostericiInterface 22 | { 23 | public: 24 | virtual void goster() = 0; 25 | }; 26 | 27 | // The Abstract Subjectu 28 | class HavaDurumuVerisiInterface 29 | { 30 | public: 31 | virtual void kayitOb(ObserverInterface *ob) = 0; 32 | virtual void silOb(ObserverInterface *ob) = 0; 33 | virtual void bildiriOb() = 0; 34 | }; 35 | 36 | // The Concrete Subject 37 | class HavaDurumuVerileri : public HavaDurumuVerisiInterface 38 | { 39 | private: 40 | float nem; 41 | float sicaklik; 42 | float basinc; 43 | list observeInterfacesListe; 44 | 45 | protected: 46 | void bildiriOb() override 47 | { 48 | for (list::iterator it = observeInterfacesListe.begin(); it != observeInterfacesListe.end(); it++) 49 | { 50 | (*it)->guncelle(nem, sicaklik, basinc); 51 | (dynamic_cast(*it))->goster(); 52 | } 53 | } 54 | 55 | public: 56 | void yeniSensorVerisi(float nem, float sicaklik, float basinc) 57 | { 58 | this->nem = nem; 59 | this->sicaklik = sicaklik; 60 | this->basinc = basinc; 61 | bildiriOb(); 62 | } 63 | 64 | void kayitOb(ObserverInterface *ob) override 65 | { 66 | observeInterfacesListe.push_back(ob); 67 | } 68 | 69 | void silOb(ObserverInterface *ob) override 70 | { 71 | observeInterfacesListe.remove(ob); 72 | } 73 | }; 74 | 75 | // A Concrete Observer 76 | class MevcutDurumGosterici : public ObserverInterface, public DurumGostericiInterface 77 | { 78 | private: 79 | float nem; 80 | float sicaklik; 81 | float basinc; 82 | HavaDurumuVerileri &veri; 83 | 84 | public: 85 | MevcutDurumGosterici(HavaDurumuVerileri &veri) : veri(veri) 86 | { 87 | veri.kayitOb(this); 88 | } 89 | void goster() override 90 | { 91 | cout << "_____Hava Durum_____" << endl; 92 | cout << "Nem : " << nem << endl; 93 | cout << "Sıcaklık : " << sicaklik << endl; 94 | cout << "Basınç : " << basinc << endl; 95 | cout << "_______________________________" << endl; 96 | } 97 | 98 | void guncelle(float nem, float sicaklik, float basinc) override 99 | { 100 | this->nem = nem; 101 | this->sicaklik = sicaklik; 102 | this->basinc = basinc; 103 | } 104 | }; 105 | 106 | // A Concrete Observer 107 | class HavaIstatistik : public ObserverInterface, public DurumGostericiInterface 108 | { 109 | private: 110 | float enYuksekSicaklik; 111 | float enDusukSicaklik; 112 | float ortalamaSicaklik; 113 | 114 | float enYuksekNem; 115 | float enDusukNem; 116 | float ortalamaNem; 117 | 118 | float enYuksekBasinc; 119 | float enDusukBasinc; 120 | float ortalamaBasinc; 121 | 122 | int gelenVeriSayisi; 123 | HavaDurumuVerileri &havaDurumuVerileri; 124 | 125 | public: 126 | HavaIstatistik(HavaDurumuVerileri &gelenHavaDurumuVerileri) : havaDurumuVerileri(gelenHavaDurumuVerileri) 127 | { 128 | this->enYuksekSicaklik = -1000; 129 | this->enDusukSicaklik = 1000; 130 | this->ortalamaSicaklik = 0; 131 | 132 | this->enYuksekNem = -1000; 133 | this->enDusukNem = 1000; 134 | this->ortalamaNem = 0; 135 | 136 | this->enYuksekBasinc = -1000; 137 | this->enDusukBasinc = 1000; 138 | this->ortalamaBasinc = 0; 139 | 140 | this->gelenVeriSayisi = 0; 141 | 142 | havaDurumuVerileri.kayitOb(this); 143 | } 144 | 145 | void goster() 146 | { 147 | cout << "________İstatistikler_________" << endl; 148 | cout << "En Düşük Sıcaklık : " << enDusukSicaklik << endl; 149 | cout << "En Yüksek Sıcaklık : " << enYuksekSicaklik << endl; 150 | cout << "Ortalama Sıcaklık : " << ortalamaSicaklik << endl; 151 | cout << "-------------------------------" << endl; 152 | cout << "En Düşük Nem : " << enDusukNem << endl; 153 | cout << "En Yüksek Nem : " << enYuksekNem << endl; 154 | cout << "Ortalama Nem : " << ortalamaNem << endl; 155 | cout << "-------------------------------" << endl; 156 | cout << "En Düşük Basınç : " << enDusukBasinc << endl; 157 | cout << "En Yüksek Basınç : " << enYuksekBasinc << endl; 158 | cout << "Ortalama Basınç : " << ortalamaBasinc << endl; 159 | cout << "_______________________________" << endl 160 | << endl; 161 | } 162 | 163 | void guncelle(float nem, float sicaklik, float basinc) 164 | { 165 | ++gelenVeriSayisi; 166 | 167 | if (sicaklik > enYuksekSicaklik) 168 | { 169 | enYuksekSicaklik = sicaklik; 170 | } 171 | if (sicaklik < enDusukSicaklik) 172 | { 173 | enDusukSicaklik = sicaklik; 174 | } 175 | ortalamaSicaklik = (ortalamaSicaklik * (gelenVeriSayisi - 1) + sicaklik) / gelenVeriSayisi; 176 | 177 | if (nem > enYuksekNem) 178 | { 179 | enYuksekNem = nem; 180 | } 181 | if (nem < enDusukNem) 182 | { 183 | enDusukNem = nem; 184 | } 185 | ortalamaNem = (ortalamaNem * (gelenVeriSayisi - 1) + nem) / gelenVeriSayisi; 186 | 187 | if (basinc > enYuksekBasinc) 188 | { 189 | enYuksekBasinc = basinc; 190 | } 191 | if (basinc < enDusukBasinc) 192 | { 193 | enDusukBasinc = basinc; 194 | } 195 | ortalamaBasinc = (ortalamaBasinc * (gelenVeriSayisi - 1) + basinc) / gelenVeriSayisi; 196 | } 197 | }; 198 | 199 | int main() 200 | { 201 | 202 | HavaDurumuVerileri *havaVerisi = new HavaDurumuVerileri; 203 | MevcutDurumGosterici *mevcutDurumGosterici = new MevcutDurumGosterici(*havaVerisi); 204 | HavaIstatistik *havaIstatistik = new HavaIstatistik(*havaVerisi); 205 | 206 | havaVerisi->yeniSensorVerisi(10.2, 28.2, 1001); 207 | havaVerisi->yeniSensorVerisi(12, 30.12, 1003); 208 | havaVerisi->yeniSensorVerisi(10.2, 26, 806); 209 | havaVerisi->yeniSensorVerisi(10.3, 35.9, 900); 210 | 211 | havaVerisi->silOb(mevcutDurumGosterici); 212 | 213 | havaVerisi->yeniSensorVerisi(100, 40, 1900); 214 | 215 | delete[] havaIstatistik; 216 | delete[] mevcutDurumGosterici; 217 | delete havaVerisi; 218 | 219 | return 0; 220 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/08_State/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "State") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "State") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/08_State/README.md: -------------------------------------------------------------------------------- 1 | # State Pattern 2 | 3 | **"State Pattern"**, bir nesnenin iç durumu değiştiğinde davranışını da değiştirmesini sağlar. Bu durumda nesne, çalışma zamanında sınıfını değiştiriyormuş gibi davranır. Yani duruma göre farklı işlevleri yerine getirir. 4 | 5 | ## State Pattern Kullanım Adımları 6 | 7 | * İlk olarak **"Makine"** isminde bir sınıf oluşturuyoruz. Bu sınıf, işlem görecek ana sınıfımız. Bu sınıf içinde dikkat ederseniz **"class Durum *durum;"** diye bir tanımlama bulunmakta. Aslında asıl **"Durum"** sınıfı, daha sonra tanımlanacak. Eğer sınıfın yukarısında tanımlamazsak, içinde kullanacağımız zaman başına **"class"** ifadesini getirmek gerekmekte. Aksi taktirde **"error: ‘Durum’ does not name a type Durum *durum;"** hatası alacktı. 8 | 9 | ```cpp 10 | class Makine 11 | { 12 | private: 13 | class Durum *durum; 14 | 15 | public: 16 | Makine(); 17 | void setDurum(Durum *durum); 18 | void ac(); 19 | void kapat(); 20 | }; 21 | ``` 22 | 23 | * Şimdi ise **"Durum"** sınıfını tanımlıyoruz. Bu sınıf içinde 2 method bulunmakta. Bunlar **"ac"** ve **"kapat**". farkındaysanız bu methodlar **"virtual"** türünde. Yani miras kalınca tekrar tanımlanabilir. 24 | 25 | ```cpp 26 | class Durum 27 | { 28 | public: 29 | virtual void ac(Makine *makine) 30 | { 31 | cout << " şu anda açık\n"; 32 | } 33 | virtual void kapat(Makine *makine) 34 | { 35 | cout << " şu anda kapalı\n"; 36 | } 37 | }; 38 | ``` 39 | 40 | * Şimdi durumumuz değiştiğinde yapılacak olan işlemleri görelim. İlk olarak açık konum için **"AC"** isminde bir sınıf tanımlıyoruz. Bu sınıfın Constructor methoduna ve Deconstructor methodunda loglar bulunmakta. Aynı zamanda **"kapat"** isminde de bir method bulunmakta. Aynı şekilde **"KAPAT"** isminde de bir sınıd bulunmakta. Bu sınıftada aynı yapı bulunmakta. Fakat fark olarak içinde ac isminde bir komut bulunmakta. 41 | 42 | ```cpp 43 | class AC : public Durum 44 | { 45 | public: 46 | AC() 47 | { 48 | cout << " AC constructor. "; 49 | } 50 | 51 | ~AC() 52 | { 53 | cout << " AC de-constructor\n"; 54 | } 55 | 56 | void kapat(Makine *m); 57 | }; 58 | 59 | class KAPAT : public Durum 60 | { 61 | public: 62 | KAPAT() 63 | { 64 | cout << " KAPAT constructor. "; 65 | } 66 | ~KAPAT() 67 | { 68 | cout << " KAPAT de-constructor\n"; 69 | } 70 | void ac(Makine *makine); 71 | }; 72 | ``` 73 | 74 | * Şimdi tanımladığımız sınıflardaki methodların tanımlamalarını inceleyelim. İlk olarak **"Makine"** constructor girildiğinde **"durum = new KAPAT();"** satırı çalışıyor. Bu satır, Makinayı kapalı bir şekilde konumlandırmaya yarıyor. 75 | 76 | ```cpp 77 | Makine::Makine() 78 | { 79 | durum = new KAPAT(); 80 | cout << '\n'; 81 | } 82 | ``` 83 | * **"Makine"** sınıfının **"setDurum"** fonksiyonunu incelediğimizde, dışarıdan bir **"Durum"** alıyor ve sınıfa o durumun sınıfını atamasını sağlıyor. 84 | 85 | ```cpp 86 | void Makine::setDurum(Durum *durum) 87 | { 88 | this->durum = durum; 89 | } 90 | ``` 91 | 92 | * **"Makine"** sınıfında bulunan **"ac"** fonksiyonu çalıştırılınca, sınıfa atanan **"Durum"** nesnesinin **"ac"** fonksiyonunu çalıştırıyoruz. 93 | 94 | ```cpp 95 | void Makine::ac() 96 | { 97 | durum->ac(this); 98 | } 99 | ``` 100 | 101 | * **"Makine"** sınıfında bulunan **"kapat"** fonksiyonu çalıştırılınca, sınıfa atanan **"Durum"** nesnesinin **"kapat"** fonksiyonunu çalıştırıyoruz. 102 | 103 | ```cpp 104 | void Makine::kapat() 105 | { 106 | durum->kapat(this); 107 | } 108 | ``` 109 | 110 | * **"AC"** sınıfında bulunan **"kapat"** methodu kullanıcıdan **"Makine"** türünde nesne alır ve **" m->setDurum(new KAPAT());"** satırını çalıştırarak, komut değiştirir ve kendini siler. 111 | 112 | ```cpp 113 | void AC::kapat(Makine *m) 114 | { 115 | cout << " AC konumundan KAPAT konumuna geçildi"; 116 | m->setDurum(new KAPAT()); 117 | delete this; 118 | } 119 | ``` 120 | 121 | * **"KAPAT"** sınıfında bulunan **"ac"** methodu kullanıcıdan **"Makine"** türünde nesne alır ve **" makine->setDurum(new AC());"** satırını çalıştırarak, komut değiştirir ve kendini siler. 122 | 123 | ```cpp 124 | void KAPAT::ac(Makine *makine) 125 | { 126 | cout << " KAPAT konumundan AC konumuna geçildi"; 127 | makine->setDurum(new AC()); 128 | delete this; 129 | } 130 | 131 | ``` 132 | 133 | * Kullanım için ise; 134 | 135 | ```cpp 136 | int main() 137 | { 138 | void (Makine::*ptrs[])() = {&Makine::kapat, &Makine::ac}; 139 | Makine makine; 140 | int num; 141 | while (1) 142 | { 143 | cout << "Durum Giriniz : 0 - 1: "; 144 | cin >> num; 145 | (makine.*ptrs[num])(); 146 | } 147 | } 148 | ``` 149 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/08_State/bin/State: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/08_State/bin/State -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/08_State/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 08_State 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : State Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | class Makine 12 | { 13 | private: 14 | class Durum *durum; 15 | 16 | public: 17 | Makine(); 18 | void setDurum(Durum *durum); 19 | void ac(); 20 | void kapat(); 21 | }; 22 | 23 | class Durum 24 | { 25 | public: 26 | virtual void ac(Makine *makine) 27 | { 28 | cout << " şu anda açık\n"; 29 | } 30 | virtual void kapat(Makine *makine) 31 | { 32 | cout << " şu anda kapalı\n"; 33 | } 34 | }; 35 | 36 | class AC : public Durum 37 | { 38 | public: 39 | AC() 40 | { 41 | cout << " AC constructor. "; 42 | } 43 | 44 | ~AC() 45 | { 46 | cout << " AC de-constructor\n"; 47 | } 48 | 49 | void kapat(Makine *m); 50 | }; 51 | 52 | class KAPAT : public Durum 53 | { 54 | public: 55 | KAPAT() 56 | { 57 | cout << " KAPAT constructor. "; 58 | } 59 | ~KAPAT() 60 | { 61 | cout << " KAPAT de-constructor\n"; 62 | } 63 | void ac(Makine *makine); 64 | }; 65 | 66 | Makine::Makine() 67 | { 68 | durum = new KAPAT(); 69 | cout << '\n'; 70 | } 71 | 72 | void Makine::setDurum(Durum *durum) 73 | { 74 | this->durum = durum; 75 | } 76 | 77 | void Makine::ac() 78 | { 79 | durum->ac(this); 80 | } 81 | 82 | void Makine::kapat() 83 | { 84 | durum->kapat(this); 85 | } 86 | 87 | void AC::kapat(Makine *m) 88 | { 89 | cout << " AC konumundan KAPAT konumuna geçildi"; 90 | m->setDurum(new KAPAT()); 91 | delete this; 92 | } 93 | 94 | void KAPAT::ac(Makine *makine) 95 | { 96 | cout << " KAPAT konumundan AC konumuna geçildi"; 97 | makine->setDurum(new AC()); 98 | delete this; 99 | } 100 | 101 | int main() 102 | { 103 | void (Makine::*ptrs[])() = {&Makine::kapat, &Makine::ac}; 104 | Makine fsm; 105 | int num; 106 | while (1) 107 | { 108 | cout << "Durum Giriniz : 0 - 1: "; 109 | cin >> num; 110 | (fsm.*ptrs[num])(); 111 | } 112 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/09_Strategy/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Strategy") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Strategy") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/09_Strategy/README.md: -------------------------------------------------------------------------------- 1 | # Strategy Pattern 2 | 3 | **"Strategy Pattern"**, bir sınıfın işlevini çalışma zamanında değiştirmeyi sağlar. **"Strategy Pattern"** algoritmanın, onu kullanan istemcilerden bağımsız olarak değişmesine izin verir. 4 | 5 | 6 | ## Strategy Pattern Kullanım Adımları 7 | 8 | * İlk adım olarak soyut bir sınıf tanımlıyoruz. Sınıfımız **"OgretmenInterface"** ismini veriyoruz. 9 | 10 | ```cpp 11 | class OgretmenInterface 12 | { 13 | public: 14 | virtual void atama(string) const = 0; 15 | }; 16 | ``` 17 | 18 | * Ardından bu sınıfımızdan somut sınıflar yaratıyoruz. Bunlara **"OgretmenA"**, **"OgretmenB"**, **"OgretmenC"** isimlerini veriyoruz. 19 | ```cpp 20 | class OgretmenA : public OgretmenInterface 21 | { 22 | public: 23 | void atama(string okul) const override 24 | { 25 | cout << "Öğretmen A, " << okul << " okuluna atandı..." << endl; 26 | } 27 | }; 28 | 29 | class OgretmenB : public OgretmenInterface 30 | { 31 | public: 32 | void atama(string okul) const override 33 | { 34 | cout << "Öğretmen B, " << okul << " okuluna atandı..." << endl; 35 | } 36 | }; 37 | 38 | class OgretmenC : public OgretmenInterface 39 | { 40 | public: 41 | void atama(string okul) const override 42 | { 43 | cout << "Öğretmen C, " << okul << " okuluna atandı..." << endl; 44 | } 45 | }; 46 | ``` 47 | 48 | * Ardından **"Okul"** isminde bir sınıf yaratıyoruz. Bu sınıf, içinde **"OgretmenInterface"** nesnesi ve **"okulIsmi"** isminde **"string"** bir değişken bulunmakta. **Constructor** kısmında **"OgretmenInterface"** ve **"okulIsmi"** verilerini alıp, sınıfın başında tanımladığımız değişkenlere atama işlemi gerçekleştiriyoruz. Ardıdan **"setOgretmenDegistir"** fonksiyonumuz bulunmakta. Bu fonksiyon bizim için önemli. Çünkü, çalışma zamanında işlevi değiştiren kısım burada. Bu fonksiyon, sınıfın hangi **"OgretmenInterface"** tanımlı öğretmen ile işlem yapacağını belirliyor. En son olarak **"atama"** fonksiyonu ile, seçtiğimiz okula, seçtiğimiz öğretmeni aktarmış oluyoruz. 49 | 50 | ```cpp 51 | class Okul 52 | { 53 | private: 54 | OgretmenInterface *ogretmenInterface; 55 | string okulIsmi; 56 | 57 | public: 58 | Okul(OgretmenInterface *ogretmenInterface, string okulIsmi) : ogretmenInterface(ogretmenInterface), okulIsmi(okulIsmi) 59 | { 60 | } 61 | 62 | void setOgretmenDegistir(OgretmenInterface *ogretmenInterface) 63 | { 64 | this->ogretmenInterface = ogretmenInterface; 65 | } 66 | 67 | void atama() const 68 | { 69 | ogretmenInterface->atama(okulIsmi); 70 | } 71 | }; 72 | ``` 73 | 74 | * Kullanımına gelecek olursak, **"OgretmenInterface"** soyut sınıfından türettiğimiz **"OgretmenA"**, **"OgretmenB"**, **"OgretmenC"** sınıflarından nesne yaratıyoruz. Ardından **"Okul"** sınıfından nesne yaratıyoruz. Yaratırken **constructor** da hangi öğretmen, hangi okulda bilgilerini veriyoruz. Ve atama işlemini gerçekleştiriyoruz. Son olarak istediğimiz okulda farklı bir öğretmen atamak için **"setOgretmenDegistir"** methodu ile öğretmen değiştirip **"atama"** methodu ile işlemleri gerçekleştiriyoryuz. Bu sayede, çalışma zamanında ilgil sınıfın işleyişini değiştirmiş oluyoruz. 75 | 76 | ```cpp 77 | int main() 78 | { 79 | OgretmenA ogretmenA; 80 | OgretmenB ogretmenB; 81 | OgretmenC ogretmenC; 82 | 83 | Okul okul1(&ogretmenA, "Okul-1"); 84 | Okul okul2(&ogretmenB, "Okul-2"); 85 | Okul okul3(&ogretmenC, "Okul-3"); 86 | 87 | okul1.atama(); 88 | okul2.atama(); 89 | okul3.atama(); 90 | 91 | okul1.setOgretmenDegistir(&ogretmenB); 92 | okul1.atama(); 93 | okul1.setOgretmenDegistir(&ogretmenC); 94 | okul1.atama(); 95 | 96 | return 0; 97 | } 98 | ``` -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/09_Strategy/bin/Strategy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/09_Strategy/bin/Strategy -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/09_Strategy/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 09_Strategy 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Strategy Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | class OgretmenInterface 12 | { 13 | public: 14 | virtual void atama(string) const = 0; 15 | }; 16 | 17 | class OgretmenA : public OgretmenInterface 18 | { 19 | public: 20 | void atama(string okul) const override 21 | { 22 | cout << "Öğretmen A, " << okul << " okuluna atandı..." << endl; 23 | } 24 | }; 25 | 26 | class OgretmenB : public OgretmenInterface 27 | { 28 | public: 29 | void atama(string okul) const override 30 | { 31 | cout << "Öğretmen B, " << okul << " okuluna atandı..." << endl; 32 | } 33 | }; 34 | 35 | class OgretmenC : public OgretmenInterface 36 | { 37 | public: 38 | void atama(string okul) const override 39 | { 40 | cout << "Öğretmen C, " << okul << " okuluna atandı..." << endl; 41 | } 42 | }; 43 | 44 | class Okul 45 | { 46 | private: 47 | OgretmenInterface *ogretmenInterface; 48 | string okulIsmi; 49 | 50 | public: 51 | Okul(OgretmenInterface *ogretmenInterface, string okulIsmi) : ogretmenInterface(ogretmenInterface), okulIsmi(okulIsmi) 52 | { 53 | } 54 | 55 | void setOgretmenDegistir(OgretmenInterface *ogretmenInterface) 56 | { 57 | this->ogretmenInterface = ogretmenInterface; 58 | } 59 | 60 | void atama() const 61 | { 62 | ogretmenInterface->atama(okulIsmi); 63 | } 64 | }; 65 | 66 | int main() 67 | { 68 | OgretmenA ogretmenA; 69 | OgretmenB ogretmenB; 70 | OgretmenC ogretmenC; 71 | 72 | Okul okul1(&ogretmenA, "Okul-1"); 73 | Okul okul2(&ogretmenB, "Okul-2"); 74 | Okul okul3(&ogretmenC, "Okul-3"); 75 | 76 | okul1.atama(); 77 | okul2.atama(); 78 | okul3.atama(); 79 | 80 | okul1.setOgretmenDegistir(&ogretmenB); 81 | okul1.atama(); 82 | okul1.setOgretmenDegistir(&ogretmenC); 83 | okul1.atama(); 84 | 85 | return 0; 86 | } -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/10_Template/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Template") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Template") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/10_Template/README.md: -------------------------------------------------------------------------------- 1 | # Template Method Pattern 2 | **"Template Method Pattern"** ile bir algoritmanın veya işlemin adımları soyut bir sınıfta tanımlanır ve bu soyut sınıfın alt sınıflarının ilgili adımların gerçekleştirimlerini vermeleri beklenir. Davranışsal bir örüntüdür. 3 | 4 | Soyut sınıfın bir metodu algoritmanın adımlarını bir iskelet (kalıp) olarak gerçekleştirir, bunun için tanımlı diğer metotları çağırarak algoritmayı gerçekleştirir. Algoritma adımlarını gerçekleştiren metotlar soyut (abstract) olarak tanımlanır. Bazılarının gerçekleştirimleri de verilebilir. Bu soyut sınıftan türetilen alt sınıflar, soyut metotların gerçekleştirimlerini verirler. Birden fazla gerçekleştirim sınıfı olabilir, böylece algoritma adımlarının (soyut metotlar) farklı farklı gerçekleştirilmeleri mümkün olur. 5 | 6 | ## Template Method Pattern Kullanım Adımları 7 | 8 | * İlk önce soyut sınıfımızı oluşturuyoruz. Biz sınıfımızın ismini **"AbstractClass"** olarak belirledik. Sınıfımızda **"templateMethod"** ismidne bir method bulunmakta. Bu method, bu sınıftan türetilen sınıfların yapması gereken işlerin şablonlarını oluşturmaktadır. Ardından sınıfımızda **"islem1"**,**"islem2"**,**"tercihliIslem"**,**"sabitIslem"** adında methodlarımız bulunmakta. Bu methodlardan **"islem1"**,**"islem2"** kesinlikle alt sınıflarda tanımlanması gereken methodlar. **"tercihliIslem"** ise tanımlanması gerektiğinde isteğe bağlı method. **"sabitIslem"** ise, tanımlansada farketmeyecek, bütün sınıflarda aynı olacak işlem. 9 | 10 | 11 | ```cpp 12 | class AbstractClass 13 | { 14 | public: 15 | void templateMethod() 16 | { 17 | islem1(); 18 | islem2(); 19 | sabitIslem(); 20 | tercihliIslem(); 21 | } 22 | 23 | virtual void islem1() = 0; 24 | virtual void islem2() = 0; 25 | virtual void tercihliIslem() {} 26 | void sabitIslem() 27 | { 28 | cout << "Bu işlem sabit. Bütün sınıflarda aynı..." << endl; 29 | } 30 | }; 31 | ``` 32 | 33 | * Şimdiki adım olarak **"AbstractClass"** sınıfımızdan türetilen **"Sinif1"** ve **"Sinif2"** isimde sınıflar oluşturuyoruz. Dikkat edilmesi gereken husus, **"templateMethod"** çalıştırılınca sınıflarda tanımlanan **"islem1"**,**"islem2"**,**"tercihliIslem"** methodları çalışacak ama **"sabitIslem"** methodu **"AbstractClass"** sınıfındaki hali ile çalışacak. Bunun sebebi, diğer methodların **"virtual"** olması sebebidir. 34 | 35 | ```cpp 36 | class Sinif1 : public AbstractClass 37 | { 38 | public: 39 | void islem1() 40 | { 41 | cout << "Sinif1 - islem1 çalıştı..." << endl; 42 | } 43 | void islem2() 44 | { 45 | cout << "Sinif1 - islem2 çalıştı..." << endl; 46 | } 47 | void tercihliIslem() 48 | { 49 | cout << "Sinif1 - tercihliIslem çalıştı..." << endl; 50 | } 51 | void sabitIslem() 52 | { 53 | cout << "Bu baya sabit Sinif1" << endl; 54 | } 55 | }; 56 | 57 | class Sinif2 : public AbstractClass 58 | { 59 | public: 60 | void islem1() 61 | { 62 | cout << "Sinif2 - islem1 çalıştı..." << endl; 63 | } 64 | void islem2() 65 | { 66 | cout << "Sinif2 - islem2 çalıştı..." << endl; 67 | } 68 | void sabitIslem() 69 | { 70 | cout << "Bu baya sabit Sinif2 " << endl; 71 | } 72 | }; 73 | ``` 74 | 75 | * En son kullanım için, **"Sinif1"** ve **"Sinif2"** sınıflarından nesne üretip, **"templateMethod"** methodunu çağırıyoruz. 76 | 77 | ```cpp 78 | int main() 79 | { 80 | Sinif1 sinif1; 81 | Sinif2 sinif2; 82 | 83 | sinif1.templateMethod(); 84 | 85 | cout << "-------------------------------" << endl; 86 | sinif2.templateMethod(); 87 | 88 | return 0; 89 | } 90 | ``` -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/10_Template/bin/Template: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/10_Template/bin/Template -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/10_Template/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 10_Template 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Template Pattern 7 | //============================================================================ 8 | #include 9 | 10 | using namespace std; 11 | 12 | class AbstractClass 13 | { 14 | public: 15 | void templateMethod() 16 | { 17 | islem1(); 18 | islem2(); 19 | sabitIslem(); 20 | tercihliIslem(); 21 | } 22 | 23 | virtual void islem1() = 0; 24 | virtual void islem2() = 0; 25 | virtual void tercihliIslem() {} 26 | void sabitIslem() 27 | { 28 | cout << "Bu işlem sabit. Bütün sınıflarda aynı..." << endl; 29 | } 30 | }; 31 | 32 | class Sinif1 : public AbstractClass 33 | { 34 | public: 35 | void islem1() 36 | { 37 | cout << "Sinif1 - islem1 çalıştı..." << endl; 38 | } 39 | void islem2() 40 | { 41 | cout << "Sinif1 - islem2 çalıştı..." << endl; 42 | } 43 | void tercihliIslem() 44 | { 45 | cout << "Sinif1 - tercihliIslem çalıştı..." << endl; 46 | } 47 | void sabitIslem() 48 | { 49 | cout << "Bu baya sabit Sinif1" << endl; 50 | } 51 | }; 52 | 53 | class Sinif2 : public AbstractClass 54 | { 55 | public: 56 | void islem1() 57 | { 58 | cout << "Sinif2 - islem1 çalıştı..." << endl; 59 | } 60 | void islem2() 61 | { 62 | cout << "Sinif2 - islem2 çalıştı..." << endl; 63 | } 64 | void sabitIslem() 65 | { 66 | cout << "Bu baya sabit Sinif2 " << endl; 67 | } 68 | }; 69 | 70 | int main() 71 | { 72 | Sinif1 sinif1; 73 | Sinif2 sinif2; 74 | 75 | sinif1.templateMethod(); 76 | 77 | cout << "-------------------------------" << endl; 78 | sinif2.templateMethod(); 79 | 80 | return 0; 81 | } 82 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/11_Visitor/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Visitor") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Visitor") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/11_Visitor/README.md: -------------------------------------------------------------------------------- 1 | # Visitor Pattern 2 | 3 | **"Visitor Pattern"**, üzerinde çalıştığı öğelerin sınıflarını değiştirmeden yeni bir işlem tanımlamanıza izin vererek bir nesne yapısının öğeleri üzerinde gerçekleştirilecek bir işlemi temsil edecektir. 4 | 5 | ## Visitor Pattern Kullanım Adımları 6 | 7 | * İlk önce projede kullancağımız sınıfların şablonlarını tanımlıyoruz. 8 | ```cpp 9 | class Tekerlek; 10 | class Motor; 11 | class Govde; 12 | class Araba; 13 | ``` 14 | 15 | * Ardından **"ArabaBirlesenleriVisitor"** isminde soyut bir sınıf belirliyoruz. Bu sınıf içinde, bütün birleşenleri ekliyoruz. 16 | 17 | ```cpp 18 | class ArabaBirlesenleriVisitor 19 | { 20 | public: 21 | virtual void visit(Tekerlek &tekerlek) const = 0; 22 | virtual void visit(Motor &motor) const = 0; 23 | virtual void visit(Govde &govde) const = 0; 24 | virtual void visitAraba(Araba &car) const = 0; 25 | }; 26 | ``` 27 | 28 | * Sonra **"ArabaBirlesenleri"** isminde bir soyut sınıf oluşturuyoruz. Bu sınıfta **"onayla"** ismind ebir method bulunmakta. 29 | 30 | ```cpp 31 | class ArabaBirlesenleri 32 | { 33 | public: 34 | virtual void onayla(const ArabaBirlesenleriVisitor &visitor) = 0; 35 | }; 36 | ``` 37 | 38 | * Sonraki adım olarak birleşenleri somutlaştırıyoruz. Bizim arabamızın birleşenleri **"Tekerlek"**, **"Motor"**, **"Govde"** den oluşuyor. Bunun içinde ayrı ayrı tanımlamalar yapıyoruz. Bu sınıfları oluştururken **"ArabaBirlesenleri"** sınıfından miras alıyoruz. Burada dikkat edişmesi gereken husus **"onayla"** methodu. Bütün ontayla methodları içinde **"visitor.visit(*this);"** kodu bulunmakta. 39 | 40 | ```cpp 41 | class Tekerlek : public ArabaBirlesenleri 42 | { 43 | private: 44 | string isim; 45 | 46 | public: 47 | Tekerlek(const string &isim) : isim(isim) 48 | { 49 | } 50 | 51 | const string &getIsim() const 52 | { 53 | return isim; 54 | } 55 | 56 | void onayla(const ArabaBirlesenleriVisitor &visitor) override 57 | { 58 | visitor.visit(*this); 59 | } 60 | }; 61 | 62 | class Motor : public ArabaBirlesenleri 63 | { 64 | public: 65 | void onayla(const ArabaBirlesenleriVisitor &visitor) override 66 | { 67 | visitor.visit(*this); 68 | } 69 | }; 70 | 71 | class Govde : public ArabaBirlesenleri 72 | { 73 | public: 74 | void onayla(const ArabaBirlesenleriVisitor &visitor) override 75 | { 76 | visitor.visit(*this); 77 | } 78 | }; 79 | ``` 80 | 81 | * Ardından arabımızı oluşturmak için **"Araba"** sınıfımızı oluşturuyoruz. Bu sınıfta bir adet **"vector"** bulunmakta. Bu vektör, bizim birleşenlerimizi barındırıyor. Constructor yardımı ile bütün birleşenleri ekliyoruz. 82 | 83 | ```cpp 84 | class Araba 85 | { 86 | private: 87 | vector arabaBirlesenleri; 88 | 89 | public: 90 | vector &getBirlesen() 91 | { 92 | return arabaBirlesenleri; 93 | } 94 | 95 | Araba() 96 | { 97 | arabaBirlesenleri.push_back(new Tekerlek("Ön Sol")); 98 | arabaBirlesenleri.push_back(new Tekerlek("Ön Sağ")); 99 | arabaBirlesenleri.push_back(new Tekerlek("Arka SOl")); 100 | arabaBirlesenleri.push_back(new Tekerlek("Arka Sağ")); 101 | arabaBirlesenleri.push_back(new Govde()); 102 | arabaBirlesenleri.push_back(new Motor()); 103 | } 104 | ~Araba() 105 | { 106 | for (vector::iterator it = arabaBirlesenleri.begin(); it != arabaBirlesenleri.end(); ++it) 107 | { 108 | delete *it; 109 | } 110 | } 111 | }; 112 | ``` 113 | 114 | * Ardından **"ArabaBirlesenleriVisitor"** sınıfından miras alan **"ArabaBirlesemleriYazdirVisitor"** sınıfını oluşturuyrouz. Bu sınıf, bize tek tek bütün birleşenler için **"visit"** methodunu tanımlıyor. 115 | 116 | ```cpp 117 | class ArabaBirlesemleriYazdirVisitor : public ArabaBirlesenleriVisitor 118 | { 119 | public: 120 | void visit(Tekerlek &tekerlek) const override 121 | { 122 | cout << "Visiting " << tekerlek.getIsim() << " tekerlek" << endl; 123 | } 124 | void visit(Motor &motor) const override 125 | { 126 | cout << "Visiting motor" << endl; 127 | } 128 | void visit(Govde &govde) const override 129 | { 130 | cout << "Visiting govde" << endl; 131 | } 132 | void visitAraba(Araba &araba) const override 133 | { 134 | 135 | cout << "Visiting araba" << endl; 136 | 137 | vector &arabaElemanlari = araba.getBirlesen(); 138 | for (vector::iterator it = arabaElemanlari.begin(); it != arabaElemanlari.end(); ++it) 139 | { 140 | (*it)->onayla(*this); 141 | } 142 | cout << "Visited araba" << endl; 143 | } 144 | }; 145 | ``` 146 | 147 | * Son olarak yine **"ArabaBirlesenleriVisitor"** sınıfından miras alan **"ArabaBirlesemleriYapVisitor"** isminde bir sınıf oluşturuyoruz. Bu sınıf, artık araba montaj işlemini gerçekleştiriyor. 148 | 149 | ```cpp 150 | class ArabaBirlesemleriYapVisitor : public ArabaBirlesenleriVisitor 151 | { 152 | public: 153 | void visit(Tekerlek &tekerlek) const override 154 | { 155 | cout << "Tekerlek takılıyor : " << tekerlek.getIsim() << " tekerlek" << endl; 156 | } 157 | void visit(Motor &motor) const override 158 | { 159 | cout << "Motor Monteleniyor" << endl; 160 | } 161 | void visit(Govde &govde) const override 162 | { 163 | cout << "Gövde taşınıyor" << endl; 164 | } 165 | void visitAraba(Araba &araba) const override 166 | { 167 | cout << endl 168 | << "Arabaya başlanıyor" << endl; 169 | 170 | vector &arabaEleman = araba.getBirlesen(); 171 | for (vector::iterator it = arabaEleman.begin(); it != arabaEleman.end(); ++it) 172 | { 173 | (*it)->onayla(*this); 174 | } 175 | cout << "Araba yapımı bitti." << endl; 176 | } 177 | }; 178 | ``` 179 | 180 | * Kullanmak için bir **"Araba"** nesnesi üretiyoruz. Ardından **"ArabaBirlesemleriYazdirVisitor"** ve **"ArabaBirlesemleriYapVisitor"** nesneleri üretiyoruz. ardından **"visitAraba"** methodu ile, farklı işler yaptırabiliyoruz. 181 | 182 | ```cpp 183 | int main() 184 | { 185 | Araba araba; 186 | ArabaBirlesemleriYazdirVisitor arabaBirlesemleriYazdirVisitor; 187 | ArabaBirlesemleriYapVisitor arabaBirlesemleriYapVisitor; 188 | 189 | arabaBirlesemleriYazdirVisitor.visitAraba(araba); 190 | arabaBirlesemleriYapVisitor.visitAraba(araba); 191 | 192 | return 0; 193 | } 194 | ``` -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/11_Visitor/bin/Visitor: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/02_Behavioral_Davranissal/11_Visitor/bin/Visitor -------------------------------------------------------------------------------- /02_Behavioral_Davranissal/11_Visitor/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 11_Visitor 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Visitor Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | #include 11 | 12 | using namespace std; 13 | 14 | class Tekerlek; 15 | class Motor; 16 | class Govde; 17 | class Araba; 18 | 19 | // Araba Birleşenleri Soyut Sınıf 20 | class ArabaBirlesenleriVisitor 21 | { 22 | public: 23 | virtual void visit(Tekerlek &tekerlek) const = 0; 24 | virtual void visit(Motor &motor) const = 0; 25 | virtual void visit(Govde &govde) const = 0; 26 | virtual void visitAraba(Araba &car) const = 0; 27 | }; 28 | 29 | // ArabaBirlesenleri Yapım 30 | class ArabaBirlesenleri 31 | { 32 | public: 33 | virtual void onayla(const ArabaBirlesenleriVisitor &visitor) = 0; 34 | }; 35 | 36 | class Tekerlek : public ArabaBirlesenleri 37 | { 38 | private: 39 | string isim; 40 | 41 | public: 42 | explicit Tekerlek(const string &isim) : isim(isim) 43 | { 44 | } 45 | 46 | const string &getIsim() const 47 | { 48 | return isim; 49 | } 50 | 51 | void onayla(const ArabaBirlesenleriVisitor &visitor) override 52 | { 53 | visitor.visit(*this); 54 | } 55 | }; 56 | 57 | class Motor : public ArabaBirlesenleri 58 | { 59 | public: 60 | void onayla(const ArabaBirlesenleriVisitor &visitor) override 61 | { 62 | visitor.visit(*this); 63 | } 64 | }; 65 | 66 | class Govde : public ArabaBirlesenleri 67 | { 68 | public: 69 | void onayla(const ArabaBirlesenleriVisitor &visitor) override 70 | { 71 | visitor.visit(*this); 72 | } 73 | }; 74 | 75 | class Araba 76 | { 77 | private: 78 | vector arabaBirlesenleri; 79 | 80 | public: 81 | vector &getBirlesen() 82 | { 83 | return arabaBirlesenleri; 84 | } 85 | 86 | Araba() 87 | { 88 | arabaBirlesenleri.push_back(new Tekerlek("Ön Sol")); 89 | arabaBirlesenleri.push_back(new Tekerlek("Ön Sağ")); 90 | arabaBirlesenleri.push_back(new Tekerlek("Arka SOl")); 91 | arabaBirlesenleri.push_back(new Tekerlek("Arka Sağ")); 92 | arabaBirlesenleri.push_back(new Govde()); 93 | arabaBirlesenleri.push_back(new Motor()); 94 | } 95 | ~Araba() 96 | { 97 | for (vector::iterator it = arabaBirlesenleri.begin(); it != arabaBirlesenleri.end(); ++it) 98 | { 99 | delete *it; 100 | } 101 | } 102 | }; 103 | 104 | 105 | class ArabaBirlesemleriYazdirVisitor : public ArabaBirlesenleriVisitor 106 | { 107 | public: 108 | void visit(Tekerlek &tekerlek) const override 109 | { 110 | cout << "Visiting " << tekerlek.getIsim() << " tekerlek" << endl; 111 | } 112 | void visit(Motor &motor) const override 113 | { 114 | cout << "Visiting motor" << endl; 115 | } 116 | void visit(Govde &govde) const override 117 | { 118 | cout << "Visiting govde" << endl; 119 | } 120 | void visitAraba(Araba &araba) const override 121 | { 122 | 123 | cout << "Visiting araba" << endl; 124 | 125 | vector &arabaElemanlari = araba.getBirlesen(); 126 | for (vector::iterator it = arabaElemanlari.begin(); it != arabaElemanlari.end(); ++it) 127 | { 128 | (*it)->onayla(*this); 129 | } 130 | cout << "Visited araba" << endl; 131 | } 132 | }; 133 | 134 | class ArabaBirlesemleriYapVisitor : public ArabaBirlesenleriVisitor 135 | { 136 | public: 137 | void visit(Tekerlek &tekerlek) const override 138 | { 139 | cout << "Tekerlek takılıyor : " << tekerlek.getIsim() << " tekerlek" << endl; 140 | } 141 | void visit(Motor &motor) const override 142 | { 143 | cout << "Motor Monteleniyor" << endl; 144 | } 145 | void visit(Govde &govde) const override 146 | { 147 | cout << "Gövde taşınıyor" << endl; 148 | } 149 | void visitAraba(Araba &araba) const override 150 | { 151 | cout << endl 152 | << "Arabaya başlanıyor" << endl; 153 | 154 | vector &arabaEleman = araba.getBirlesen(); 155 | for (vector::iterator it = arabaEleman.begin(); it != arabaEleman.end(); ++it) 156 | { 157 | (*it)->onayla(*this); 158 | } 159 | cout << "Araba yapımı bitti." << endl; 160 | } 161 | }; 162 | 163 | int main() 164 | { 165 | Araba araba; 166 | ArabaBirlesemleriYazdirVisitor arabaBirlesemleriYazdirVisitor; 167 | ArabaBirlesemleriYapVisitor arabaBirlesemleriYapVisitor; 168 | 169 | arabaBirlesemleriYazdirVisitor.visitAraba(araba); 170 | arabaBirlesemleriYapVisitor.visitAraba(araba); 171 | 172 | return 0; 173 | } 174 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/01_Adapter/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Adapter") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Adapter") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/01_Adapter/README.md: -------------------------------------------------------------------------------- 1 | # Adapter Pattern 2 | 3 | **"Adapter Pattern"**, bir sınıfın arayüzünü istemcinin beklediği başka bir arayüze dönüştürür. Böylece istemci bu farklı sınıfla çalışabilir, aksi takdirde bilmediği bir arayüze sahip sınıfı kullanamaz. 4 | 5 | ## Adapter Pattern Kullanım Adımları 6 | 7 | * İlk önce soyut bir sınıf oluşturuyoruz. Sınıfımıza **"Daire"** ismini verdik. Bu sınıfın **"ciz"** adında bir methodu bulunmakta. 8 | 9 | ```cpp 10 | class Daire 11 | { 12 | public: 13 | virtual void ciz() = 0; 14 | }; 15 | ``` 16 | 17 | * Ardından **"StandardDaire"** isminde bir sınıf oluşturuyoruz. Bu sınıf, daire bilgilerini almaktadır. 18 | 19 | ```cpp 20 | class StandardDaire 21 | { 22 | private: 23 | double yariCap; 24 | 25 | public: 26 | StandardDaire(double yariCap) 27 | { 28 | this->yariCap = yariCap; 29 | cout << "StandardDaire: Yarat. Yarı Çapı = " << yariCap << endl; 30 | } 31 | void cizim() 32 | { 33 | cout << "StandardDaire: Yarı Çapı. " << yariCap << endl; 34 | } 35 | }; 36 | ``` 37 | 38 | * Ardından **"DaireAdapter"** isminde bir sınıf oluşturuyoruz. Bu sınıf, **"Daire"** ve **"StandardDaire"** sınıfından miras almakta. Bu dairenin içinde constructor olarak dairenin çap bilgisini almakta. Bu bilgiyi, **"StandardDaire"** sınıfına göndermekte. Ardından **"ciz"** methodu ile, **"cizim"** sınıfını çalıştırmakta. 39 | 40 | ```cpp 41 | class DaireAdapter : public Daire, private StandardDaire 42 | { 43 | public: 44 | DaireAdapter(double cap) 45 | : StandardDaire(cap / 2) 46 | { 47 | cout << "DaireAdapter: Yarat. Çapı = " << cap << endl; 48 | } 49 | virtual void ciz() override 50 | { 51 | cout << "DaireAdapter: Çiz." << endl; 52 | cizim(); 53 | } 54 | }; 55 | ``` 56 | 57 | * Kullanım için **"Daire"** türünde, bir nesne yaratıyoruz. Nesneyi, **"DaireAdapter"** sınıfından oluşturuyoruz. Oluştururken constructora dairenin çap bilgisini veriyoruz. En son olarak **"ciz"** methodu ile dairemizi çiziyoruz. 58 | 59 | ```cpp 60 | int main() 61 | { 62 | Daire *c = new DaireAdapter(18); 63 | c->ciz(); 64 | 65 | delete[] c; 66 | } 67 | ``` -------------------------------------------------------------------------------- /03_Structural_Yapisal/01_Adapter/bin/Adapter: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/03_Structural_Yapisal/01_Adapter/bin/Adapter -------------------------------------------------------------------------------- /03_Structural_Yapisal/01_Adapter/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 01_Adapter 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Adapter Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | class Daire 12 | { 13 | public: 14 | virtual void ciz() = 0; 15 | }; 16 | 17 | class StandardDaire 18 | { 19 | private: 20 | double yariCap; 21 | 22 | public: 23 | StandardDaire(double yariCap) 24 | { 25 | this->yariCap = yariCap; 26 | cout << "StandardDaire: Yarat. Yarı Çapı = " << yariCap << endl; 27 | } 28 | void cizim() 29 | { 30 | cout << "StandardDaire: Yarı Çapı. " << yariCap << endl; 31 | } 32 | }; 33 | 34 | class DaireAdapter : public Daire, private StandardDaire //Adapter Class 35 | { 36 | public: 37 | DaireAdapter(double cap) 38 | : StandardDaire(cap / 2) 39 | { 40 | cout << "DaireAdapter: Yarat. Çapı = " << cap << endl; 41 | } 42 | virtual void ciz() override 43 | { 44 | cout << "DaireAdapter: Çiz." << endl; 45 | cizim(); 46 | } 47 | }; 48 | 49 | int main() 50 | { 51 | Daire *c = new DaireAdapter(18); 52 | c->ciz(); 53 | 54 | delete[] c; 55 | } 56 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/02_Bridge/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Bridge") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Bridge") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/02_Bridge/README.md: -------------------------------------------------------------------------------- 1 | # Bridge Pattern 2 | 3 | **"Bridge Pattern"**, arabirimi uygulanmasından ayırmak için kullanılır. Bunu yapmak esneklik sağlar, böylece her ikisi de bağımsız olarak değişebilir. 4 | 5 | ## Bridge Pattern Kullanım Adımları 6 | 7 | * İlk olarak, **"CizimAPISablon"** isminde bir soyut sınıf tanımlıyoruz. 8 | 9 | ```cpp 10 | class CizimAPISablon 11 | { 12 | public: 13 | virtual void cemberCiz(double x, double y, double yaricap) = 0; 14 | }; 15 | ``` 16 | 17 | * Ardından bu sınıftan miras alan **"CizimAPI1"**, **"CizimAPI2"** sınıflarını oluşturuyoruz. Bu sınıflar, **"cemberCiz"** methodunu kendine göre yorumlamaya olanak sağlamaktadır. 18 | 19 | ```cpp 20 | class CizimAPI1 : public CizimAPISablon 21 | { 22 | public: 23 | void cemberCiz(double x, double y, double yaricap) override 24 | { 25 | cout << "CizimAPI1 Verileri x: " << x << " y :" << y << " yarı çap : " << yaricap << endl; 26 | } 27 | }; 28 | 29 | class CizimAPI2 : public CizimAPISablon 30 | { 31 | public: 32 | void cemberCiz(double x, double y, double yaricap) override 33 | { 34 | cout << "CizimAPI2 Verileri x: " << x << " y :" << y << " yarı çap : " << yaricap << endl; 35 | } 36 | }; 37 | ``` 38 | 39 | * Ardından **"Sekil"** isminde soyut bir sınıf oluşturyoruz. Bu sınıf, **"ciz"** ve **"boyutArttir"** isminde iki methodu bulunmakta. 40 | 41 | ```cpp 42 | class Sekil 43 | { 44 | public: 45 | virtual void ciz() = 0; 46 | virtual void boyutArttir(double boyutlandir) = 0; 47 | }; 48 | ``` 49 | 50 | * Son olarak **"Sekil"** sınıfından türetilen **"DaireSekil"** için gerekli sınıfı hazırlıyoruz. Bu sınıf constructor ile verileri almakta. Ardından soyut sınıftan gelen methodlar ile işlemlerimizi gerçekleştiriyoruz. 51 | 52 | ```cpp 53 | class DaireSekil : public Sekil 54 | { 55 | private: 56 | double m_x, m_y, yaricap; 57 | CizimAPISablon *cizimAPI; 58 | 59 | public: 60 | DaireSekil(double x, double y, double yaricap, CizimAPISablon *cizimAPI) : m_x(x), m_y(y), yaricap(yaricap), cizimAPI(cizimAPI) 61 | { 62 | } 63 | void ciz() override 64 | { 65 | cizimAPI->cemberCiz(m_x, m_y, yaricap); 66 | } 67 | void boyutArttir(double boyutlandir) override 68 | { 69 | yaricap *= boyutlandir; 70 | } 71 | }; 72 | ``` 73 | 74 | * Kullanım oldukça kolaydır. İlk olarak **"DaireSekil"** sınıfından nesne üretiyoruz. Nesne üretirken **"x"**, **"y"**, **"yarıçap"** ve **"CizimAPI"** türünde nesne veriyoruz. Ardından **"boyutArttir"** ve **"ciz"** methodlarını, verdiğimiz **""CizimAPI"** türünde işlemler etabi tutmuş oluyoruz. 75 | 76 | ```cpp 77 | int main() 78 | { 79 | DaireSekil daire1(1, 2, 3, new CizimAPI1()); 80 | DaireSekil daire2(5, 7, 11, new CizimAPI2()); 81 | daire1.boyutArttir(2.5); 82 | daire2.boyutArttir(2.5); 83 | daire1.ciz(); 84 | daire2.ciz(); 85 | return 0; 86 | } 87 | ``` -------------------------------------------------------------------------------- /03_Structural_Yapisal/02_Bridge/bin/Bridge: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/03_Structural_Yapisal/02_Bridge/bin/Bridge -------------------------------------------------------------------------------- /03_Structural_Yapisal/02_Bridge/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 02_Bridge 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Bridge Pattern 7 | //============================================================================ 8 | #include 9 | 10 | using namespace std; 11 | 12 | /* Uygulatıcı*/ 13 | class CizimAPISablon 14 | { 15 | public: 16 | virtual void cemberCiz(double x, double y, double yaricap) = 0; 17 | }; 18 | 19 | /* Somut Uygulatıcı A*/ 20 | class CizimAPI1 : public CizimAPISablon 21 | { 22 | public: 23 | void cemberCiz(double x, double y, double yaricap) override 24 | { 25 | cout << "CizimAPI1 Verileri x: " << x << " y :" << y << " yarı çap : " << yaricap << endl; 26 | } 27 | }; 28 | 29 | /* Somut Uygulatıcı B*/ 30 | class CizimAPI2 : public CizimAPISablon 31 | { 32 | public: 33 | void cemberCiz(double x, double y, double yaricap) override 34 | { 35 | cout << "CizimAPI2 Verileri x: " << x << " y :" << y << " yarı çap : " << yaricap << endl; 36 | } 37 | }; 38 | 39 | /* Soyutlama*/ 40 | class Sekil 41 | { 42 | public: 43 | virtual void ciz() = 0; 44 | virtual void boyutArttir(double boyutlandir) = 0; 45 | }; 46 | 47 | /* Soyut İşleme*/ 48 | class DaireSekil : public Sekil 49 | { 50 | private: 51 | double m_x, m_y, yaricap; 52 | CizimAPISablon *cizimAPI; 53 | 54 | public: 55 | DaireSekil(double x, double y, double yaricap, CizimAPISablon *cizimAPI) : m_x(x), m_y(y), yaricap(yaricap), cizimAPI(cizimAPI) 56 | { 57 | } 58 | void ciz() override 59 | { 60 | cizimAPI->cemberCiz(m_x, m_y, yaricap); 61 | } 62 | void boyutArttir(double boyutlandir) override 63 | { 64 | yaricap *= boyutlandir; 65 | } 66 | }; 67 | 68 | int main() 69 | { 70 | DaireSekil daire1(1, 2, 3, new CizimAPI1()); 71 | DaireSekil daire2(5, 7, 11, new CizimAPI2()); 72 | daire1.boyutArttir(2.5); 73 | daire2.boyutArttir(2.5); 74 | daire1.ciz(); 75 | daire2.ciz(); 76 | return 0; 77 | } 78 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/03_Composite/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Composite") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Composite") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/03_Composite/README.md: -------------------------------------------------------------------------------- 1 | # Composite Pattern 2 | **"Composite Pattern"**, belli bir türde olan nesnelerin tek tek veya eşit olarak ele almasını sağlar. **"Composite Pattern"**, her iki durumu da temsil edebilir. Bu modelde, bir bütün olarak hiyerarşileri temsil etmek için ağaç yapıları geliştirilebilir. 3 | 4 | ## Composite Pattern Kullanım Adımları 5 | 6 | * İlk önce **"Grafik"** isminde ana soyut sınıfımızı oluşturuyoruz. 7 | 8 | ```cpp 9 | class Grafik 10 | { 11 | public: 12 | virtual void yazdir() const = 0; 13 | }; 14 | ``` 15 | 16 | * Ardından bu sınıftan türeyecek olan **"Elips"**, **"Ucgen"**, **"Elips"**, türlerinde nesneler oluşturuyoruz. 17 | 18 | ```cpp 19 | class Elips : public Grafik 20 | { 21 | public: 22 | void yazdir() const override 23 | { 24 | cout << "Elips \n"; 25 | } 26 | }; 27 | 28 | class Kare : public Grafik 29 | { 30 | public: 31 | void yazdir() const override 32 | { 33 | cout << "Kare \n"; 34 | } 35 | }; 36 | 37 | class Ucgen : public Grafik 38 | { 39 | public: 40 | void yazdir() const override 41 | { 42 | cout << "Üçgen \n"; 43 | } 44 | }; 45 | ``` 46 | 47 | * Daha önce oluşturuduğumuz sınıfları tek tek kullanılabileceği gibi, **"CompositeGrafik"** olduğu gibi toplu işlerde yapılabilmektedir. Burada **"ekle"** methodu sayesinde, **"Grafik"** sınıf türündeki nesneleri ortak olarak kullanabilmekteyiz. 48 | 49 | ```cpp 50 | class CompositeGrafik : public Grafik 51 | { 52 | private: 53 | vector grafikListesi; 54 | 55 | public: 56 | void yazdir() const override 57 | { 58 | for (Grafik *grafik : grafikListesi) 59 | { 60 | grafik->yazdir(); 61 | } 62 | } 63 | 64 | void ekle(Grafik *grafik) 65 | { 66 | grafikListesi.push_back(grafik); 67 | } 68 | }; 69 | ``` 70 | 71 | * Kullanım için ilk önce **"Elips"**, **"Ucgen"**, **"Elips"**, türlerinden nesneler üretiyoruz. Ardından **"CompositeGrafik"** türünden nesneler üretiyoruz. Ürettiğimiz **"CompositeGrafik"** nesnelerine kendileri dahil olmak üzere istediğimiz verilileri ekleme ve eklediğimiz nenslerin **"yazdır"** methodunu çalıştırabiliğyoruz. 72 | 73 | ```cpp 74 | int main() 75 | { 76 | Elips *elips1 = new Elips(); 77 | Elips *elips2 = new Elips(); 78 | Kare *kare = new Kare(); 79 | Ucgen *ucgen = new Ucgen(); 80 | 81 | // Initialize three composite graphics 82 | CompositeGrafik *graphic1 = new CompositeGrafik(); 83 | CompositeGrafik *graphic2 = new CompositeGrafik(); 84 | CompositeGrafik *graphic3 = new CompositeGrafik(); 85 | 86 | // Composes the graphics 87 | graphic2->ekle(elips1); 88 | graphic2->ekle(elips2); 89 | graphic3->ekle(kare); 90 | graphic2->ekle(ucgen); 91 | 92 | graphic1->ekle(graphic2); 93 | graphic1->ekle(graphic3); 94 | 95 | // Prints the complete graphic (four times the string "Ellipse") 96 | graphic1->yazdir(); 97 | return 0; 98 | } 99 | ``` -------------------------------------------------------------------------------- /03_Structural_Yapisal/03_Composite/bin/Composite: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/03_Structural_Yapisal/03_Composite/bin/Composite -------------------------------------------------------------------------------- /03_Structural_Yapisal/03_Composite/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 03_Composite 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Composite Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | #include 11 | #include 12 | using namespace std; 13 | 14 | class Grafik 15 | { 16 | public: 17 | virtual void yazdir() const = 0; 18 | }; 19 | 20 | class Elips : public Grafik 21 | { 22 | public: 23 | void yazdir() const override 24 | { 25 | cout << "Elips \n"; 26 | } 27 | }; 28 | 29 | class Kare : public Grafik 30 | { 31 | public: 32 | void yazdir() const override 33 | { 34 | cout << "Kare \n"; 35 | } 36 | }; 37 | 38 | class Ucgen : public Grafik 39 | { 40 | public: 41 | void yazdir() const override 42 | { 43 | cout << "Üçgen \n"; 44 | } 45 | }; 46 | 47 | class CompositeGrafik : public Grafik 48 | { 49 | private: 50 | vector grafikListesi; 51 | 52 | public: 53 | void yazdir() const override 54 | { 55 | for (Grafik *grafik : grafikListesi) 56 | { 57 | grafik->yazdir(); 58 | } 59 | } 60 | 61 | void ekle(Grafik *grafik) 62 | { 63 | grafikListesi.push_back(grafik); 64 | } 65 | }; 66 | 67 | int main() 68 | { 69 | // Initialize four ellipses 70 | const unique_ptr elips1(new Elips()); 71 | const unique_ptr elips2(new Elips()); 72 | const unique_ptr kare(new Kare()); 73 | const unique_ptr ucgen(new Ucgen()); 74 | 75 | // Initialize three composite graphics 76 | const unique_ptr graphic1(new CompositeGrafik()); 77 | const unique_ptr graphic2(new CompositeGrafik()); 78 | const unique_ptr graphic3(new CompositeGrafik()); 79 | 80 | // Composes the graphics 81 | graphic2->ekle(elips1.get()); 82 | graphic2->ekle(elips2.get()); 83 | graphic2->ekle(ucgen.get()); 84 | 85 | graphic3->ekle(kare.get()); 86 | 87 | graphic1->ekle(graphic2.get()); 88 | graphic1->ekle(graphic3.get()); 89 | 90 | // Prints the complete graphic (four times the string "Ellipse") 91 | graphic1->yazdir(); 92 | return 0; 93 | } -------------------------------------------------------------------------------- /03_Structural_Yapisal/04_Decorator/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Decorator") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Decorator") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/04_Decorator/README.md: -------------------------------------------------------------------------------- 1 | # Decorator Pattern 2 | **"Decorator Pattern"**, bir nesneye dinamik olarak ek davranış veya sorumluluklar eklemesine yardımcı olur. Dekoratörler, genişletme işlevselliği için alt sınıflamaya esnek bir alternatif sunar. Buna “Wrapper” denir. Uygulamanız bir çeşit filtreleme yapıyorsa, Dekoratör iş için göz önünde bulundurulması gereken iyi bir model olabilir. 3 | 4 | ## Decorator Pattern Kullanım Adımları 5 | 6 | * İlk adım olarak soyut bir sınıf oluşturuyoruz. Bizim sınıfımızın ismi **"Araba"** olarak belirledik. 7 | 8 | ```cpp 9 | class Araba 10 | { 11 | protected: 12 | string aciklama; 13 | 14 | public: 15 | Araba() 16 | { 17 | aciklama = "Bilinmeyen Araba"; 18 | } 19 | 20 | virtual string getAciklama() 21 | { 22 | return aciklama; 23 | } 24 | 25 | virtual double getFiyat() = 0; 26 | }; 27 | ``` 28 | 29 | * Bir sonraki adım **Dekaratör** sınıfımızı oluşturmak. Bu sınıf ismi **"SecenekDecorator"** olarak belirledik ve **"Araba"** sınıfından miras alacak şekilde hazırladık. Bu sınıf, bir arabaya özelliklik ekleme için oluşturulmuş soyut bir sınıftır. 30 | 31 | ```cpp 32 | class SecenekDecorator : public Araba 33 | { 34 | public: 35 | virtual string getAciklama() = 0; 36 | }; 37 | ``` 38 | 39 | * Artık oluşturduğumuz soyut sınıfları somutlaştırma vakti. İlk olarak **"Araba"** sınıfından türeyen bir **"ArabaModel1"** adında sınıf oluşturuyoruz. Bu sınıf ana hattımızı, ürünümüzü belirtiyor. 40 | 41 | ```cpp 42 | class ArabaModel1 : public Araba 43 | { 44 | public: 45 | ArabaModel1() 46 | { 47 | aciklama = "Fiat Egea"; 48 | } 49 | 50 | virtual double getFiyat() override 51 | { 52 | return 56000.23; 53 | } 54 | }; 55 | ``` 56 | 57 | * Ardından **"SecenekDecorator"** sınıfından türetilen özellikleri oluşturuyoruz. İstediğimiz kadar özellik böylece **"SecenekDecorator"** sınıfı sayesinde ana hattımıza ekleyebilecek durumda olacağız. Biz proje kapsamında aracımıza **"Navigasyon"**, **"SesSistemi"**, **"OtomatikVites"** özelliklerini ekledik. 58 | 59 | ```cpp 60 | class Navigasyon : public SecenekDecorator 61 | { 62 | Araba *araba; 63 | 64 | public: 65 | Navigasyon(Araba *araba) 66 | { 67 | this->araba = araba; 68 | } 69 | string getAciklama() override 70 | { 71 | return araba->getAciklama() + ", Navigasyon"; 72 | } 73 | 74 | double getFiyat() override 75 | { 76 | return 300.56 + araba->getFiyat(); 77 | } 78 | ~Navigasyon() 79 | { 80 | cout << "~Navigasyon()\n"; 81 | delete araba; 82 | } 83 | }; 84 | 85 | class SesSistemi : public SecenekDecorator 86 | { 87 | Araba *araba; 88 | 89 | public: 90 | SesSistemi(Araba *araba) 91 | { 92 | this->araba = araba; 93 | } 94 | string getAciklama() override 95 | { 96 | return araba->getAciklama() + ", Süper ses sistemi"; 97 | } 98 | 99 | double getFiyat() override 100 | { 101 | return 250.60 + araba->getFiyat(); 102 | } 103 | ~SesSistemi() 104 | { 105 | cout << "~SesSistemi()\n"; 106 | delete araba; 107 | } 108 | }; 109 | 110 | class OtomatikVites : public SecenekDecorator 111 | { 112 | Araba *araba; 113 | 114 | public: 115 | OtomatikVites(Araba *araba) 116 | { 117 | this->araba = araba; 118 | } 119 | string getAciklama() override 120 | { 121 | return araba->getAciklama() + ", Otomatik Vites"; 122 | } 123 | 124 | double getFiyat() override 125 | { 126 | return 5450.25 + araba->getFiyat(); 127 | } 128 | ~OtomatikVites() 129 | { 130 | cout << "~OtomatikVites()\n"; 131 | delete araba; 132 | } 133 | ``` 134 | 135 | * Bu özellikleri kullanmak için ise ilk önce boş bir araba yaratıyoruz. Bunu **"Araba"** sınıfın türünde **"ArabaModel1"** sınıfından bir nesne yaratarak gerçekleştiriyoruz. Ardından oluşturduğumuz boş sınıfa özlelik eklemek için **"araba = new (araba);"** kalıbı ile, özelliklerinizi dahil ediyoruz. Böylece bir önceki sınıfta değişiklikler yapmadan yeni özellikler eklemesini gerçekleştiriyoruz. 136 | 137 | ```cpp 138 | int main() 139 | { 140 | Araba *araba = new ArabaModel1(); 141 | cout << "Araba Modeli " << araba->getAciklama() << " fiyatı " << araba->getFiyat() << "₺\n"; 142 | 143 | // Arabaya özellik ekliyoruz 144 | araba = new Navigasyon(araba); 145 | cout << araba->getAciklama() << " özelliği fiyatı " << araba->getFiyat() << "₺\n"; 146 | 147 | araba = new SesSistemi(araba); 148 | cout << araba->getAciklama() << " özelliği fiyatı " << araba->getFiyat() << "₺\n"; 149 | 150 | araba = new OtomatikVites(araba); 151 | cout << araba->getAciklama() << " özelliği fiyatı " << araba->getFiyat() << "₺\n"; 152 | 153 | cout << "----------------------------------------------" << endl; 154 | 155 | delete araba; 156 | 157 | return 0; 158 | } 159 | ``` -------------------------------------------------------------------------------- /03_Structural_Yapisal/04_Decorator/bin/Decorator: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/03_Structural_Yapisal/04_Decorator/bin/Decorator -------------------------------------------------------------------------------- /03_Structural_Yapisal/04_Decorator/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 04_Decorator 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Decorator Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | class Araba // Abstract 13 | { 14 | protected: 15 | string aciklama; 16 | 17 | public: 18 | Araba() 19 | { 20 | aciklama = "Bilinmeyen Araba"; 21 | } 22 | 23 | virtual string getAciklama() 24 | { 25 | return aciklama; 26 | } 27 | 28 | virtual double getFiyat() = 0; 29 | 30 | virtual ~Araba() 31 | { 32 | cout << "~Araba()\n"; 33 | } 34 | }; 35 | 36 | class SecenekDecorator : public Araba // Decorator 37 | { 38 | public: 39 | virtual string getAciklama() = 0; 40 | 41 | virtual ~SecenekDecorator() 42 | { 43 | cout << "~SecenekDecorator()\n"; 44 | } 45 | }; 46 | 47 | class ArabaModel1 : public Araba 48 | { 49 | public: 50 | ArabaModel1() 51 | { 52 | aciklama = "Fiat Egea"; 53 | } 54 | virtual double getFiyat() override 55 | { 56 | return 56000.23; 57 | } 58 | 59 | ~ArabaModel1() 60 | { 61 | cout << "~ArabaModel1()\n"; 62 | } 63 | }; 64 | 65 | class Navigasyon : public SecenekDecorator 66 | { 67 | Araba *araba; 68 | 69 | public: 70 | Navigasyon(Araba *araba) 71 | { 72 | this->araba = araba; 73 | } 74 | string getAciklama() override 75 | { 76 | return araba->getAciklama() + ", Navigasyon"; 77 | } 78 | 79 | double getFiyat() override 80 | { 81 | return 300.56 + araba->getFiyat(); 82 | } 83 | ~Navigasyon() 84 | { 85 | cout << "~Navigasyon()\n"; 86 | delete araba; 87 | } 88 | }; 89 | 90 | class SesSistemi : public SecenekDecorator 91 | { 92 | Araba *araba; 93 | 94 | public: 95 | SesSistemi(Araba *araba) 96 | { 97 | this->araba = araba; 98 | } 99 | string getAciklama() override 100 | { 101 | return araba->getAciklama() + ", Süper ses sistemi"; 102 | } 103 | 104 | double getFiyat() override 105 | { 106 | return 250.60 + araba->getFiyat(); 107 | } 108 | ~SesSistemi() 109 | { 110 | cout << "~SesSistemi()\n"; 111 | delete araba; 112 | } 113 | }; 114 | 115 | class OtomatikVites : public SecenekDecorator 116 | { 117 | Araba *araba; 118 | 119 | public: 120 | OtomatikVites(Araba *araba) 121 | { 122 | this->araba = araba; 123 | } 124 | string getAciklama() override 125 | { 126 | return araba->getAciklama() + ", Otomatik Vites"; 127 | } 128 | 129 | double getFiyat() override 130 | { 131 | return 5450.25 + araba->getFiyat(); 132 | } 133 | ~OtomatikVites() 134 | { 135 | cout << "~OtomatikVites()\n"; 136 | delete araba; 137 | } 138 | }; 139 | 140 | int main() 141 | { 142 | // Boş araba yaratıyoruz 143 | Araba *araba = new ArabaModel1(); 144 | cout << "Araba Modeli " << araba->getAciklama() << " fiyatı " << araba->getFiyat() << "₺\n"; 145 | 146 | // Arabaya özellik ekliyoruz 147 | araba = new Navigasyon(araba); 148 | cout << araba->getAciklama() << " özelliği fiyatı " << araba->getFiyat() << "₺\n"; 149 | 150 | araba = new SesSistemi(araba); 151 | cout << araba->getAciklama() << " özelliği fiyatı " << araba->getFiyat() << "₺\n"; 152 | 153 | araba = new OtomatikVites(araba); 154 | cout << araba->getAciklama() << " özelliği fiyatı " << araba->getFiyat() << "₺\n"; 155 | 156 | cout << "----------------------------------------------" << endl; 157 | 158 | delete araba; 159 | 160 | return 0; 161 | } 162 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/05_Facade/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Facade") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Facade") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/05_Facade/README.md: -------------------------------------------------------------------------------- 1 | # Facade Pattern 2 | 3 | **"Facade Pattern"** pek çok sınıftan oluşan karmaşık bir sistemin karmaşıklığını saklamak ve istemci daha basit ve kolay kullanılabilir bir arayüz sunmak için kullanılır. Yapısal bir örüntüdür. Basitçe bu örüntü sisteme bir arayüz ekler ve sistemin karmaşıklığını giderir. 4 | 5 | ## Facade Pattern Kullanım Adımları 6 | 7 | * İlk adım olarak yapılacak işlemleri, operasyonları tanımlıyoruz. Biz projemizde **"Alarm"**, **"Elektrik"**, **"Tv"** işlemleri tanımladık. 8 | 9 | ```cpp 10 | class Alarm 11 | { 12 | public: 13 | void alarmAc() 14 | { 15 | cout << "Alarm Açıldı. Eviniz güvende..." << endl; 16 | } 17 | 18 | void alarmKapat() 19 | { 20 | cout << "Alarm Kapatıldı..." << endl; 21 | } 22 | }; 23 | 24 | class Elektrik 25 | { 26 | public: 27 | void elektrikAc() 28 | { 29 | cout << "Elektrik Açık..." << endl; 30 | } 31 | 32 | void elektrikKapat() 33 | { 34 | cout << "Elektrik Kapalı..." << endl; 35 | } 36 | }; 37 | 38 | class Tv 39 | { 40 | public: 41 | void tvAc() 42 | { 43 | cout << "Tv Açık..." << endl; 44 | } 45 | 46 | void tvKapat() 47 | { 48 | cout << "TV Kapalı..." << endl; 49 | } 50 | }; 51 | 52 | ``` 53 | 54 | * Ardından **"EvFacade"** isminde bir sınıf oluşturduk. Bu sınıf içinde oluşturduğumuz **"Alarm"**, **"Elektrik"**, **"Tv"** sınıflarından nesneler yarattık. Bu sınıfımızda iki fonksiyonumuz bulunmakta. İlki **"evdenDisariCikinca"** methodu, ilk belirlediğimiz sınıflardan, evden çıkınca yapılacak olan işlemleri tanımlamakta. Diğeri **"eveDonunce"** methodu eve geri dönünce yapıalcak olan işlemleri barındırmaktadır. 55 | 56 | ```cpp 57 | class EvFacade 58 | { 59 | Alarm alarm; 60 | Elektrik elektrik; 61 | Tv tv; 62 | 63 | public: 64 | EvFacade() {} 65 | 66 | void evdenDisariCikinca() 67 | { 68 | elektrik.elektrikKapat(); 69 | tv.tvKapat(); 70 | alarm.alarmAc(); 71 | } 72 | 73 | void eveDonunce() 74 | { 75 | alarm.alarmKapat(); 76 | elektrik.elektrikAc(); 77 | tv.tvAc(); 78 | } 79 | }; 80 | ``` 81 | 82 | * Kullanımı da olduktça basittir. İlk olarak **"EvFacade"** sınıfından bir nesne üretiyoruz. Ardından **"evdenDisariCikinca"** yada **"eveDonunce"** methodlarını, isteğimize uygun bir şekilde gerçekleştiriyoruz. 83 | 84 | ```cpp 85 | int main() 86 | { 87 | EvFacade evFacade; 88 | 89 | cout << "Evden İşe Gidiliyor ..." << endl; 90 | evFacade.evdenDisariCikinca(); 91 | 92 | cout << "---------------------------------------------" << endl; 93 | 94 | cout << "Eve Giriliyor..." << endl; 95 | evFacade.eveDonunce(); 96 | } 97 | 98 | ``` -------------------------------------------------------------------------------- /03_Structural_Yapisal/05_Facade/bin/Facade: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/03_Structural_Yapisal/05_Facade/bin/Facade -------------------------------------------------------------------------------- /03_Structural_Yapisal/05_Facade/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 05_Facade 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Facade Pattern 7 | //============================================================================ 8 | #include 9 | #include 10 | 11 | using namespace std; 12 | 13 | class Alarm 14 | { 15 | public: 16 | void alarmAc() 17 | { 18 | cout << "Alarm Açıldı. Eviniz güvende..." << endl; 19 | } 20 | 21 | void alarmKapat() 22 | { 23 | cout << "Alarm Kapatıldı..." << endl; 24 | } 25 | }; 26 | 27 | class Elektrik 28 | { 29 | public: 30 | void elektrikAc() 31 | { 32 | cout << "Elektrik Açık..." << endl; 33 | } 34 | 35 | void elektrikKapat() 36 | { 37 | cout << "Elektrik Kapalı..." << endl; 38 | } 39 | }; 40 | 41 | class Tv 42 | { 43 | public: 44 | void tvAc() 45 | { 46 | cout << "Tv Açık..." << endl; 47 | } 48 | 49 | void tvKapat() 50 | { 51 | cout << "TV Kapalı..." << endl; 52 | } 53 | }; 54 | 55 | class EvFacade 56 | { 57 | Alarm alarm; 58 | Elektrik elektrik; 59 | Tv tv; 60 | 61 | public: 62 | EvFacade() {} 63 | 64 | void evdenDisariCikinca() 65 | { 66 | elektrik.elektrikKapat(); 67 | tv.tvKapat(); 68 | alarm.alarmAc(); 69 | } 70 | 71 | void eveDonunce() 72 | { 73 | alarm.alarmKapat(); 74 | elektrik.elektrikAc(); 75 | tv.tvAc(); 76 | } 77 | }; 78 | 79 | int main() 80 | { 81 | EvFacade evFacade; 82 | 83 | cout << "Evden İşe Gidiliyor ..." << endl; 84 | evFacade.evdenDisariCikinca(); 85 | 86 | cout << "---------------------------------------------" << endl; 87 | 88 | cout << "Eve Giriliyor..." << endl; 89 | evFacade.eveDonunce(); 90 | } 91 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/06_Flyweight/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Flyweight") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Flyweight") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/06_Flyweight/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 07_Flyweight 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Flyweight Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | } -------------------------------------------------------------------------------- /03_Structural_Yapisal/07_Proxy/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.9) 2 | 3 | # VARIABLES 4 | set(AUTHOR_NAME "Mert Acel") 5 | set(PROJECT_NAME "Proxy") 6 | 7 | # Project Information 8 | project (${PROJECT_NAME} VERSION 1.0.1 DESCRIPTION "Proxy") 9 | 10 | # Information 11 | message(STATUS "AUTHOR_NAME : ${AUTHOR_NAME}") 12 | message(STATUS "PROJECT_NAME : ${PROJECT_NAME}") 13 | message(STATUS "CMAKE_SOURCE_DIR : ${CMAKE_SOURCE_DIR}") 14 | message(STATUS "CMAKE_SYSTEM : ${CMAKE_SYSTEM}") 15 | 16 | # Set g++ Parameter 17 | set(CMAKE_CXX_FLAGS "-O2 -Wall -Wextra -std=c++17") 18 | set (CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin) 19 | 20 | add_executable(${PROJECT_NAME} src/main.cpp) 21 | -------------------------------------------------------------------------------- /03_Structural_Yapisal/07_Proxy/bin/Proxy: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/KMACEL/TR-Cpp-DesignPattern/e7f05904b8944f331aa8b2c04d520ce360e49773/03_Structural_Yapisal/07_Proxy/bin/Proxy -------------------------------------------------------------------------------- /03_Structural_Yapisal/07_Proxy/src/main.cpp: -------------------------------------------------------------------------------- 1 | //============================================================================ 2 | // İsim : 08_Proxy 3 | // Yazan : Mert AceL 4 | // Version : 1.0 5 | // Copyright : AceL 6 | // Açıklama : Proxy Pattern 7 | //============================================================================ 8 | #include 9 | using namespace std; 10 | 11 | class Person 12 | { 13 | string nameString; 14 | static string list[]; 15 | static int next; 16 | 17 | public: 18 | Person() 19 | { 20 | nameString = list[next++]; 21 | } 22 | string name() 23 | { 24 | return nameString; 25 | } 26 | }; 27 | string Person::list[] = 28 | { 29 | "Tom", "Dick", "Harry", "Bubba"}; 30 | int Person::next = 0; 31 | 32 | class PettyCashProtected 33 | { 34 | int balance; 35 | 36 | public: 37 | PettyCashProtected() 38 | { 39 | balance = 500; 40 | } 41 | bool withdraw(int amount) 42 | { 43 | if (amount > balance) 44 | return false; 45 | balance -= amount; 46 | return true; 47 | } 48 | int getBalance() 49 | { 50 | return balance; 51 | } 52 | }; 53 | 54 | class PettyCash 55 | { 56 | PettyCashProtected realThing; 57 | 58 | public: 59 | bool withdraw(Person &p, int amount) 60 | { 61 | if (p.name() == "Tom" || p.name() == "Harry" || p.name() == "Bubba") 62 | return realThing.withdraw(amount); 63 | else 64 | return false; 65 | } 66 | int getBalance() 67 | { 68 | return realThing.getBalance(); 69 | } 70 | }; 71 | 72 | int main() 73 | { 74 | PettyCash pc; 75 | Person workers[4]; 76 | for (int i = 0, amount = 100; i < 4; i++, amount += 100) 77 | if (!pc.withdraw(workers[i], amount)) 78 | cout << "No money for " << workers[i].name() << '\n'; 79 | else 80 | cout << amount << " dollars for " << workers[i].name() << '\n'; 81 | cout << "Remaining balance is " << pc.getBalance() << '\n'; 82 | } 83 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright 2018 Mert Acel 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # C++ ile Design Pattern (Tasarım Kalıpları (Örüntüleri)) 2 | 3 | ## Not 4 | Bu projedeki örnekler, daha anlaşılabilir olması için Türkçe yazılmaya çalışılmıştır. Bazı kalıplar ise İngilizce olarak bırakılmıştır(get,set...). Bu kalıpları çevirmek, ileride proje geliştirme sırasında zorlanılacağını düşündüğümüz için bu şekilde kullanım gerçekleştirilmektedir. 5 | 6 | ## **Creational** (Yaratılış) 7 | 8 | Yaratılış kalıpları, nesneleri doğrudan oluşturmanıza değil, sizin için nesneler yaratan kalıplardır. Bu, belirli bir durum için hangi nesnelerin yaratılması gerektiğine karar vermede programınıza daha fazla esneklik sağlar. 9 | 10 | * ✓✓ **Singleton** pattern, bir sınıf için sadece bir nesne oluşturmayı sağlar. 11 | * ✓✓ **Factory method** pattern, oluşturulacak tam sınıfı belirtmeden nesneleri oluşturur. 12 | * ✓✓ **Abstract factory** pattern, ortak gruplar, ortak bir temaya sahip olan sınıfların yaratılış biçimini hedefler. 13 | * ✓✓ **Builder** pattern, karmaşık nesneler inşa eder. 14 | * ✓✓ **Prototype** pattern, mevcut bir nesneyi klonlayarak nesneler oluşturur. 15 | 16 | ## **Behavioral** (Davranışsal) 17 | 18 | Bu tasarım desenlerinin çoğu, özellikle nesneler arasındaki iletişim ile ilgili yapılardır. 19 | 20 | * ✓✓ **Chain of Responsibility** delegates commands to a chain of processing objects. 21 | * ✓✓ **Command** creates objects which encapsulate actions and parameters. 22 | * ✓✓ **Interpreter** implements a specialized language. 23 | * ✓ **Iterator** accesses the elements of an object sequentially without exposing its underlying representation. 24 | * **Mediator** allows loose coupling between classes by being the only class that has detailed knowledge of their methods. 25 | * **Memento** provides the ability to restore an object to its previous state (undo). 26 | * ✓✓ **Observer** is a publish/subscribe pattern which allows a number of observer objects to see an event. 27 | * ✓✓ **State** allows an object to alter its behavior when its internal state changes. 28 | * ✓✓ **Strategy** allows one of a family of algorithms to be selected on-the-fly at runtime. 29 | * ✓✓ **Template** method defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior. 30 | * ✓✓ **Visitor** separates an algorithm from an object structure by moving the hierarchy of methods into one object. 31 | 32 | ## **Structural** 33 | These concern class and object composition. They use inheritance to compose interfaces and define ways to compose objects to obtain new functionality. 34 | 35 | * ✓✓ **Adapter** allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class. 36 | * ✓✓ **Bridge** decouples an abstraction from its implementation so that the two can vary independently. 37 | * ✓✓ **Composite** composes zero-or-more similar objects so that they can be manipulated as one object. 38 | * ✓✓ **Decorator** dynamically adds/overrides behaviour in an existing method of an object. 39 | * ✓✓ **Facade** provides a simplified interface to a large body of code. 40 | * **Flyweight** reduces the cost of creating and manipulating a large number of similar objects. 41 | * ✓ **Proxy** provides a placeholder for another object to control access, reduce cost, and reduce complexity. 42 | 43 | ## **Sistem Gereksinimleri** 44 | Bu örnekler Linux Mint 18.3 Slvia ve Ubuntu 18.04.1 LTS işletim sistemlerinde test edilmiştir. 45 | 46 | ```bash 47 | sudo apt-get install git -y 48 | sudo apt-get install build-essential -y 49 | sudo apt-get install cmake -y 50 | sudo apt-get install g++ -y 51 | ``` 52 | ## **Yükleme** 53 | ```bash 54 | git clone https://github.com/KMACEL/TR-Cpp-DesignPattern.git 55 | ``` 56 | ## **Çalıştırma** 57 | ```bash 58 | cd 59 | mkdir build 60 | cd build 61 | cmake .. 62 | make 63 | ./../bin/ 64 | ``` 65 | 66 | ```bash 67 | cd 01_Creational_Yaratilis/01_Singleton/01_Giris/ 68 | mkdir build 69 | cd build 70 | cmake .. 71 | make 72 | ./../bin/Singleton-01_Giris 73 | ``` 74 | 75 | ## **Kaynak** 76 | > https://en.wikipedia.org/wiki/Design_Patterns 77 | 78 | > https://sourcemaking.com/ 79 | 80 | > https://www.geeksforgeeks.org 81 | 82 | > https://cpppatterns.com 83 | 84 | > https://www.codeproject.com/ 85 | 86 | > https://en.wikibooks.org/wiki/C++_Programming/Code/Design_Patterns 87 | 88 | > http://simplestcodings.blogspot.com 89 | 90 | > http://www.turtep.edu.tr/ 91 | 92 | > https://goalkicker.com/ - C++ Notes for Professionals book 93 | 94 | > Design Patterns in Modern C++ - Dmitri Nesteruk 95 | 96 | > Design Patterns Explained Simply - Alexander Shvets 97 | 98 | > Modern C++ Design: Generic Programming and Design Patterns Applied - Andrei Alexandrescu 99 | --------------------------------------------------------------------------------