From 7efb460b75e5168537f932526e0f2b00101ef190 Mon Sep 17 00:00:00 2001 From: Muh Yusuf <79491810+yusuf601@users.noreply.github.com> Date: Tue, 17 Dec 2024 23:05:41 +0700 Subject: [PATCH 1/3] add:linear regression # Deskripsi (Description) Pada kode **Least Square Method Linear Regression** ini, saya telah melakukan beberapa perubahan dan penambahan untuk meningkatkan keterbacaan, efisiensi, dan struktur program. Berikut adalah perubahan yang dilakukan: ### **1. Menambahkan Struct `DataStatistic`** - Dibuat untuk menyimpan hasil kalkulasi statistik seperti: - `SumX`: Jumlah total elemen pada dataset independen. - `SumY`: Jumlah total elemen pada dataset dependen. - `Xsquared`: Total kuadrat elemen independen. - `Ysquared`: Total kuadrat elemen dependen. - `multiply`: Total hasil perkalian elemen independen dan dependen. - Hal ini dilakukan untuk mempermudah passing data antar fungsi tanpa harus menghitung ulang. --- ### **2. Memecah Perhitungan ke dalam Beberapa Fungsi Void** - **`sum()`**: Menghitung jumlah total elemen dalam dataset `independen` dan `dependen` lalu menyimpan hasilnya di `stats`. - **`Squared()`**: Menghitung kuadrat setiap elemen dataset `independen` dan `dependen` menggunakan metode manual dan fungsi bawaan `pow()` dari STL. - **`multiple()`**: Menghitung hasil perkalian elemen `independen` dan `dependen` serta menjumlahkan totalnya. - **`LinearRegression()`**: Menghitung slope (kemiringan) dan intercept (titik potong) berdasarkan data statistik yang telah dihitung sebelumnya. Pemecahan ini dilakukan untuk meningkatkan modularitas kode, sehingga fungsi menjadi lebih spesifik dan mudah dipahami. --- # Checklist: ##### Umum: - [x] Saya menambah algoritma terbaru. ##### Contributor Requirements (Syarat Kontributor) dan Lain-Lain: - [x] Saya sudah membaca (I have read) [CONTRIBUTING](https://github.com/bellshade/CPP/blob/main/CONTRIBUTING.md) dan sudah menyetujui semua syarat. - [x] Saya telah menambahkan komentar kode yang memberikan penjelasan maksud dari kode yang saya buat. - [x] Saya menggunakan bahasa Indonesia untuk memberikan penjelasan dari kode yang saya buat. # Environment Saya menggunakan (I'm using): - ``OS`` = `Linux` - ``g++`` = '14.0' This Commit License https://github.com/bellshade/CPP/blob/main/license Co-authored-by: bellshadebot --- math/linear_regression.cpp | 116 +++++++++++++++++++++++++++++++++++++ 1 file changed, 116 insertions(+) create mode 100644 math/linear_regression.cpp diff --git a/math/linear_regression.cpp b/math/linear_regression.cpp new file mode 100644 index 0000000..7059590 --- /dev/null +++ b/math/linear_regression.cpp @@ -0,0 +1,116 @@ +#include +#include +#include + +/*pilihan pertama buat dalam 1 void function +pilihan kedua adalah buat dalam beberapa void + function di ikuti dengan penggunaaan struct +*/ +// sumber soal: https://mathcyber1997.com/regresi-linear-sederhana/ - > nomor 1 +struct DataStatistic{ + float SumX; + float SumY; + float Xsquared; + float Ysquared; + float multiply; +}; +void Squared(std::vector& independen, std::vector& dependen,DataStatistic &stats){ + // bisa menggunakan pow bawaan STL cmath atau langsung dengan metode manual + //contoh menggunakan pow + float SumSquared = 0; + float XSquared; + for(int i = 0; i <= independen.size() - 1; i++){ + XSquared = pow(independen[i],2); // variabel ,pangkat + SumSquared += XSquared; + } + stats.Xsquared = SumSquared; + std::cout << "Hasil X squared " << stats.Xsquared << std::endl; + //contoh metode manual + float SumYSquared = 0; + float Ysquared; + for(int i = 0; i <= dependen.size() - 1;i++){ + Ysquared = dependen[i] * dependen[i]; + SumYSquared = SumYSquared + Ysquared; // bisa juga dengan += + } + stats.Ysquared = SumYSquared; + std::cout << "Hasil Y squared " << stats.Ysquared << std::endl; + +} +void sum(std::vector& independen, std::vector& dependen,DataStatistic &stats){ + float sumx = 0; + float sumy = 0; + for(int i = 0; i <= independen.size() - 1;i++){ + // karena panjang data sama maka cukup 1 for loop + sumx += independen[i]; + sumy += dependen[i]; + } + stats.SumX = sumx; + stats.SumY = sumy; + std::cout << "SumX: " << stats.SumX << std::endl; + std::cout << "SumY: " << stats.SumY << std::endl; +} +void multiple(std::vector& independen, std::vector& dependen,DataStatistic &stats){ + float multiply; + float SumMultiply = 0; + for(int i = 0; i <= independen.size() - 1; i++){ + multiply = independen[i] * dependen[i]; + SumMultiply += multiply; + } + stats.multiply = SumMultiply; + std::cout << "Hasil Kali: " << stats.multiply << std::endl; +} + + +void LinearRegression(std::vector& independen, std::vector& dependen,DataStatistic &stats){ + double SumSquareXX; + double SumSquareXY; + + + SumSquareXY = stats.multiply - ((stats.SumX * stats.SumY)/ independen.size()); + SumSquareXX = stats.Xsquared - (pow(stats.SumX,2)/independen.size()); + // print untuk memastikan hasil nya benar + std::cout << "Hasil SumSquareXY: " << SumSquareXY << std::endl; + std::cout << "Hasil SumSquareXX: " << SumSquareXX << std::endl; + + + // b0 = intercept + // b1 = gradient atau slope + + double Slope,Intercept; + + Slope = SumSquareXY / SumSquareXX; + + Intercept = (stats.SumY - (Slope * stats.SumX)) / independen.size(); + + std::cout << "Model Regresi Linear = " << Intercept << " + " << Slope << "x "; +} + +int main(){ + DataStatistic stats; + std::vector independen = {1,1.1,1.2,1.3,1.4,1.5,1.6,1.7,1.8,1.9,2}; + std::vector dependen = {8.1,7.8,8.5,9.8,9.5,8.9,8.6,10.2,9.3,9.2,10.5}; + int count,IndependenValue,DependenValue; + + //karena tahap production kita akan memakai data yg sudah ada saja + //anda dapat men uncomment code dibawah dan menghapus data pada vector dependen dan dependen + + + + // std::cout << "Masukkan panjang data: "; + // std::cin >> count; + // for(int i = 0; i <= count - 1; i++){ + // std::cout << "Masukkan data x: "; + // std::cin >> IndependenValue; + // independen.push_back(IndependenValue); + // std::cout << "Masukkan data y: "; + // std::cin >> DependenValue; + // dependen.push_back(DependenValue); + // } + float sum_x = independen.size(); + float sum_y = dependen.size(); + sum(independen,dependen,stats); + Squared(independen,dependen,stats); + multiple(independen,dependen,stats); + LinearRegression(independen,dependen,stats); + std::cin.get(); +} \ No newline at end of file From e6f8f1c3cf263a822b5ce79ae8f713637bc5bfd2 Mon Sep 17 00:00:00 2001 From: FaizCan <147566170+RhapsodyInBlueMelody@users.noreply.github.com> Date: Mon, 30 Dec 2024 00:42:44 +0700 Subject: [PATCH 2/3] docs: fixing typo in readme.md at `basic/04_operator` # Deskripsi (Description) Saya memperbaiki dokumentasi pada `basic/04_operator`, terdapat typo pada table operator bitwise yang menyebabkan table tidak terstruktur # Checklist: ##### Umum: - [ ] Saya menambah algoritma terbaru. - [ ] Saya memperbaiki algoritma yang sudah ada. - [x] Saya memperbaiki dokumentasi. - [ ] Saya menambah dokumentasi. ##### Contributor Requirements (Syarat Kontributor) dan Lain-Lain: - [x] Saya sudah membaca (I have read) [CONTRIBUTING](https://github.com/bellshade/CPP/blob/main/CONTRIBUTING.md) dan sudah menyetujui semua syarat. - [x] Saya telah menambahkan komentar kode yang memberikan penjelasan maksud dari kode yang saya buat. - [x] Saya menggunakan bahasa Indonesia untuk memberikan penjelasan dari kode yang saya buat. # Environment Saya menggunakan (I'm using): - ``OS`` = `Linux` - ``g++`` = `11.4.0` # Link Issues Issues : # This Commit License https://github.com/bellshade/CPP/blob/main/license Co-authored-by: bellshadebot --- basic/04_operator/readme.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/basic/04_operator/readme.md b/basic/04_operator/readme.md index 553995e..f5aaf4a 100644 --- a/basic/04_operator/readme.md +++ b/basic/04_operator/readme.md @@ -78,7 +78,7 @@ Operator Bitwise adalah operator yang melakukan operasi pada level bit (biner) d Operator ini bekerja dengan mengoperasikan bit per bit dari dua operand. | Operator | Nama Operasi | Keterangan | -| - | - | - |h +| - | - | - | | `&` | AND | Menghasilkan 1 jika kedua bit bernilai 1 | | `\|` | OR | Menghasilkan 1 jika salah satu bit bernilai 1 | | `^` | XOR | Menghasilkan 1 jika kedua bit bernilai berbeda | From ffb5dbefdfa5675ee3d3ea0876dda0a7042232fc Mon Sep 17 00:00:00 2001 From: Berigoo <52880852+Berigoo@users.noreply.github.com> Date: Tue, 7 Jan 2025 17:02:36 +0700 Subject: [PATCH 3/3] feat: menambahkan materi design patterns>singleton # Deskripsi (Description) menambahkan materi mengenai **Singleton** pattern, menambahkan dokumentasi untuk `design_patterns`, menambahkan dan mengubah `CMakeLists.txt` # Checklist: ##### Umum: - [x] Saya menambah algoritma terbaru. - [ ] Saya memperbaiki algoritma yang sudah ada. - [ ] Saya memperbaiki dokumentasi. - [x] Saya menambah dokumentasi. ##### Contributor Requirements (Syarat Kontributor) dan Lain-Lain: - [x] Saya sudah membaca (I have read) [CONTRIBUTING](https://github.com/bellshade/CPP/blob/main/CONTRIBUTING.md) dan sudah menyetujui semua syarat. - [x] Saya telah menambahkan komentar kode yang memberikan penjelasan maksud dari kode yang saya buat. - [x] Saya menggunakan bahasa Indonesia untuk memberikan penjelasan dari kode yang saya buat. # Environment Saya menggunakan (I'm using): - ``OS`` = `Linux` - ``g++`` = `14.2.1` This Commit License https://github.com/bellshade/CPP/blob/main/license Co-authored-by: bellshadebot --- CMakeLists.txt | 1 + design_patterns/readme.md | 38 ++++++ design_patterns/singleton/CMakeLists.txt | 22 ++++ design_patterns/singleton/readme.md | 114 ++++++++++++++++++ .../singleton/singleton_another_example.cpp | 48 ++++++++ design_patterns/singleton/singleton_basic.cpp | 33 +++++ .../singleton/static_class_scope.cpp | 27 +++++ .../singleton/static_file_scope/another.cpp | 9 ++ .../singleton/static_file_scope/main.cpp | 13 ++ .../singleton/static_file_scope/readme.md | 14 +++ 10 files changed, 319 insertions(+) create mode 100644 design_patterns/readme.md create mode 100644 design_patterns/singleton/CMakeLists.txt create mode 100644 design_patterns/singleton/readme.md create mode 100644 design_patterns/singleton/singleton_another_example.cpp create mode 100644 design_patterns/singleton/singleton_basic.cpp create mode 100644 design_patterns/singleton/static_class_scope.cpp create mode 100644 design_patterns/singleton/static_file_scope/another.cpp create mode 100644 design_patterns/singleton/static_file_scope/main.cpp create mode 100644 design_patterns/singleton/static_file_scope/readme.md diff --git a/CMakeLists.txt b/CMakeLists.txt index d61a6df..80e740e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -33,6 +33,7 @@ add_subdirectory(artificial_intelligence) add_subdirectory(strings) add_subdirectory(geometri) add_subdirectory(graf) +add_subdirectory(design_patterns/singleton) # FIXME: ada beberapa fungsi header math terkhusus untuk # windows, oleh karena itu maka setting kompilasi diff --git a/design_patterns/readme.md b/design_patterns/readme.md new file mode 100644 index 0000000..056baf0 --- /dev/null +++ b/design_patterns/readme.md @@ -0,0 +1,38 @@ +# Design patterns + +Seiring waktu yang terus berjalan, software pun akan terus mengalami +pengembangan, agar komunikasi antar *objects*, pembuatan *objects*, +dan struktur atau relasi antar *classes* dalam aplikasi tersebut +berjalan lancar, *elegant*, dan mudah di-*track*, maka ada yang +dinamakan **Design Patterns**. + +## Apa itu Design patterns + +Adalah sebuah solusi agar saat kamu mengemmbangkan sebuah software, +*code* software tersebut mudah dipahami, mudah dikelola, dan memiliki +skalabilitas yang tinggi, bisa buat jaga-jaga jika kamu ingin serius +dengan pengembangan software tersebut. **Design patterns** bukanlah +sebuah *code* yang bisa kamu *plek-ketiplek* salin layaknya algoritma, +melainkan sebuah *template* yang bisa kamu gunakan sebagai acuan saat +mengembangkan software-mu. + +## Kategori Design patterns + +Sebenarnya banyak sekali *patterns* yang digunakan saat proses pengembangan +software, namun ada 23 jenis *patterns* yang umumnya digunakan sebagai pondasi +dari *patterns* lainnya, 23 *patterns* itulah yang umum disebut dengan istilah +**The Gang of Four (GoF)**, **GoF** memiliki 3 kategori, yaitu: + +- *Creational*, adalah bagaimana cara *objects* dibuat. + - [Singleton](singleton/) + - *... TODO* +- *Structural*, adalah bagaimana cara menyusun dan hubungan dari *class-class* mu. + - *... TODO* +- *Behavioral*, adalah bagaimana cara komunikasi antar *objects*. + - *... TODO* + +Bagus dan buruknya *patterns* bersifat *relative* terhadap sesuatu yang kamu +ingin buat atau apa yang ingin kamu selesaikan. + +> [!NOTE] +> disarankan lihat terlebih dahulu [OOP](../object_oriented_programming/) diff --git a/design_patterns/singleton/CMakeLists.txt b/design_patterns/singleton/CMakeLists.txt new file mode 100644 index 0000000..3fb7c23 --- /dev/null +++ b/design_patterns/singleton/CMakeLists.txt @@ -0,0 +1,22 @@ +cmake_minimum_required(VERSION 3.1) +set (CMAKE_CXX_STANDARD 11) +file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp ) +foreach( testsourcefile ${APP_SOURCES} ) + string( REPLACE ".cpp" "" testname ${testsourcefile} ) + add_executable( ${testname} ${testsourcefile} ) + + set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX) + if(OpenMP_CXX_FOUND) + target_link_libraries(${testname} OpenMP::OpenMP_CXX) + endif() + install(TARGETS ${testname} DESTINATION "bin/singleton") + +endforeach( testsourcefile ${APP_SOURCES} ) + +file( GLOB FILE_SCOPE_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/static_file_scope/*.cpp" ) +add_executable( "static_file_scope" ${FILE_SCOPE_SOURCES} ) +set_target_properties( "static_file_scope" PROPERTIES LINKER_LANGUAGE CXX ) +if(OpenMP_CXX_FOUND) + target_link_libraries( "static_file_scope" OpenMP::OpenMP_CXX ) +endif() +install( TARGETS "static_file_scope" DESTINATION "bin/singleton" ) diff --git a/design_patterns/singleton/readme.md b/design_patterns/singleton/readme.md new file mode 100644 index 0000000..25ba8f1 --- /dev/null +++ b/design_patterns/singleton/readme.md @@ -0,0 +1,114 @@ +# Singleton + +Adalah salah satu **Design Pattern** di kategori *Creational*. Sederhananya +*pattern* ini hanya membolehkan sebuah *class* memiliki +**hanya satu instance**, dan *instance* tesebut *Global Accessible* +(artinya *instance* atau *object* tersebut dapat diakses oleh *unit* lain, +atau katakanlah file `.cpp` lain dalam *project* yang sama). Terlepas +dari baik dan buruknya *pattern* ini bisa dibilang banyak digunakan +karena kesederhaannya dan kemudahannya dalam pengaplikasiannya. + +## Kapan menggunakan Singleton ? + +Saat kamu ingin suatu *object* dapat diakses secara global, +dan tidak ada duplikasi dari *object* tersebut. + +## Cara kerja Singleton + +Singleton memiliki `contructor` yang bersifat `private` atau `protected`, +hal ini mencegah *class* tersebut dapat di-insialisasi (dibuat object) secara biasa +(`Class objek;`), lalu bagaimana cara mengakses *object* atau *instance* dari +*class* tersebut ?. Umumnya setiap Singleton memiliki 1 *function* public `static` +dengan return datatype class nya sendiri. [contoh code](singleton_basic.cpp) + +### mengenai `static` keyword + +dalam CPP terdapat 3 kondisi `static` keyword, setiap kondisi dia bertingkah +berbeda baik itu untuk variable ataupun untuk fingsi. +1. ketika digunakan di *file scope*, maka variable tersebut global namun +hanya sebatas dalam file dimana ia di-deklarasikan. [contoh kode](static_file_scope/) +2. ketika digunakan di *function scope*, maka variable tersebut global, +namun hanya bisa diakses oleh atau melalui fungsi tersebut saja. Contohnya +seperti yang [awal-awal](singleton_basic.cpp) +> [!NOTE] +> - variable tersebut belum akan di inisialisasi sampai fungsi tersebut +dipanggil pertama kali. (bagus untuk menghemat resources, namun eksekusi +task kamu akan butuh extra waktu saat eksekusi pertama kali) +> - tidak ada inisialisasi ulang, meskipun fungsi dipanggil beberapa kali +3. ketika digunakan di *struct* atau *class scope*, maka variable tersebut +bukan sembarang member, melainkan member yang global, dapat diakses meskipun +belum dibuat *object*-nya (tergantung level visibilitas), dan setiap *object* +mendapatkan *share* akan variable tersebut (jika *object* kesatu mengubah +nilai variable tersebut maka *object* kedua pun merasakan perubahannya). +Sederhananya variable tersebut milik *class* dan bukan milik *object* +[contoh code](static_class_scope.cpp) + +## Catatan + +Hindari penggunaan Singleton secara berlebihan, contoh saat kamu +ingin cek apakah *Plane* yang dibuat itu memiliki bentuk *square*: + +```cpp +class Plane { + public: + Plane (int x0, int y0, int x1, int y1) { + this->x0 = x0; + this->y0 = y0; + this->x1 = x1; + this->y1 = y1; + } + int x0, y0, x1, y1; +}; + +class PlaneManager { + private: + PlaneManager () = default; + public: + static PlaneManager& getInstance () { + static PlaneManager instance; + return instance; + } + + Plane* createPlane (int x0, int y0, int x1, int y1) { + Plane* plane = new Plane(x0, y0, x1, y1); + return plane; + } + bool isSquareShaped (Plane& plane) { + return (plane.x1 - plane.x0) == (plane.y1 - plane.y0); + } +}; +``` + +bagaiman kalau begini + +```cpp +class Plane { + public: + Plane (int x0, int y0, int x1, int y1) { + this->x0 = x0; + this->y0 = y0; + this->x1 = x1; + this->y1 = y1; + } + int x0, y0, x1, y1; + + bool isSquareShaped() { + return (x1 - x0) == (y1 - y0); + } +}; +``` + +lalu insialisasi objek dengan cara yang biasa, lebih simple +dan masalah terselesaikan. + +## Contoh kode + +- [basic singleton](singleton_basic.cpp) +- [basic singleton 2](singleton_another_example.cpp) + +--- + +- static + - [static di file scope](static_class_scope/) + - [static di function scope](singleton_basic.cpp) + - [static di class scope](static_class_scope.cpp) diff --git a/design_patterns/singleton/singleton_another_example.cpp b/design_patterns/singleton/singleton_another_example.cpp new file mode 100644 index 0000000..c6791bf --- /dev/null +++ b/design_patterns/singleton/singleton_another_example.cpp @@ -0,0 +1,48 @@ +#include + +// deklarasi class Logger, sebagai wrapper +class Logger { + protected: + Logger (); + + public: + static Logger& getInstance (); + virtual std::string log (std::string message) = 0; +}; + +// definisi class Logger untuk Windows +class WindowLogger : public Logger { + public: + std::string log(std::string message) override { + // lakukan Windows spesific task + + return "[WINDOWS] INFO: " + message; + } +}; + +// definisi class Logger untuk Unix +class UnixLogger : public Logger { + public: + std::string log(std::string message) override { + // lakukan Unix spesific task + + return "[UNIX] INFO: " + message; + } +}; + +// definisi class Logger +Logger::Logger () = default; +Logger& Logger::getInstance () { + // lazy intialize (di inisialisasi saat fungsi dipanggil pertama kali) +#ifdef _WIN32 + static WindowLogger* instance = new WindowLogger(); +#else + static UnixLogger* instance = new UnixLogger(); +#endif // _WIN32 + return *instance; +} + +int main () { + std::cout << "Logging menggunakan `Logger` class: \n"; + std::cout << "\t" << Logger::getInstance().log("Hello World") << std::endl; +} diff --git a/design_patterns/singleton/singleton_basic.cpp b/design_patterns/singleton/singleton_basic.cpp new file mode 100644 index 0000000..2f24fa9 --- /dev/null +++ b/design_patterns/singleton/singleton_basic.cpp @@ -0,0 +1,33 @@ +#include + +class Singleton { + private: + Singleton () = default; + + public: + static Singleton& getInstance () { + static Singleton instance; // lazy intialize, memory belum dialokasikan sampai fungsi ini dipanggil pertama kali + return instance; + } + + Singleton (const Singleton& obj) = delete; // mencegah instance assignable + + // definisikan non-static fungsi-fungsi dan variable-variable + // lalu akses seperti biasa. +}; + +// nilai address dari instace Singleton pasti selalu sama, +// yang berarti bahwa object yang dipanggil merupakan object yang sama. +int main () { + std::cout << "Pemanggilan instance pertama: \n"; + std::cout << "\tInstance address: "; + std::cout << &Singleton::getInstance() << '\n'; + + std::cout << "Pemanggilan instance kedua: \n"; + std::cout << "\tInstance address: "; + std::cout << &Singleton::getInstance() << '\n'; + + std::cout << "Pemanggilan instance ketiga: \n"; + std::cout << "\tInstance address: "; + std::cout << &Singleton::getInstance() << '\n'; +} diff --git a/design_patterns/singleton/static_class_scope.cpp b/design_patterns/singleton/static_class_scope.cpp new file mode 100644 index 0000000..5dcfaeb --- /dev/null +++ b/design_patterns/singleton/static_class_scope.cpp @@ -0,0 +1,27 @@ +#include + +class ClassScope { + public: + ClassScope () = default; + + static int sharedVar; // definisi, memori dialokasikan +}; + +int ClassScope::sharedVar = 5; // insialisasi + +int main () { + ClassScope obj1; + ClassScope obj2; + + std::cout << "Akses langsung nilai variable tanpa perantara object\n"; + std::cout << "\tNilai: " << ClassScope::sharedVar << '\n'; + std::cout << "Akses langsung nilai variable melalui object\n"; + std::cout << "\tNilai: " << obj1.sharedVar << '\n'; + + obj1.sharedVar = 10; + std::cout << "\nObject 1 mengubah nilai variable-nya, menjadi: "; + std::cout << obj1.sharedVar << '\n'; + + std::cout << "Maka object 2 pun merasakan perubahannya\n"; + std::cout << "\tNilai: " << obj2.sharedVar << '\n'; +} diff --git a/design_patterns/singleton/static_file_scope/another.cpp b/design_patterns/singleton/static_file_scope/another.cpp new file mode 100644 index 0000000..605b157 --- /dev/null +++ b/design_patterns/singleton/static_file_scope/another.cpp @@ -0,0 +1,9 @@ +static int var = 5; // untuk pembuktian lebih lanjut kamu bisa hilangkan `static` keyword-nya, + // kemudian lakukan kompilasi ulang, + // maka akan muncul error, karena tidah boleh ada 2 global variable (real) + // yang bernama sama. + +// fungsi yang me-return nilai `var` di file ini +int getVar () { + return var; +} diff --git a/design_patterns/singleton/static_file_scope/main.cpp b/design_patterns/singleton/static_file_scope/main.cpp new file mode 100644 index 0000000..a9c1b6d --- /dev/null +++ b/design_patterns/singleton/static_file_scope/main.cpp @@ -0,0 +1,13 @@ +#include + +extern int getVar(); // deklarasi, memberitahu compiler bahwa fungsi ini di definisikan di file lain + +int var = 10; // intsialisasi global variable (real) + +int main () { + std::cout << "Nilai variable dengan name 'var': "; + std::cout << var << std::endl; + std::cout << "Nilai variable dengan name 'var' di file lain: "; + std::cout << getVar() << std::endl; // tidak bisa akses secara langsung variable `var` + // di file lain karena ekslusif untuk file tersebut saja +} diff --git a/design_patterns/singleton/static_file_scope/readme.md b/design_patterns/singleton/static_file_scope/readme.md new file mode 100644 index 0000000..5d9a070 --- /dev/null +++ b/design_patterns/singleton/static_file_scope/readme.md @@ -0,0 +1,14 @@ +# Kompilasi + +Compile dengan menjalankan perintah + +```shell +g++ *.cpp -o nama_executable +./nama_executable +``` +atau + +```shell +g++ *.cpp -o nama_executable.exe +.\nama_executable.exe +```