Selamat datang, gladiator MQL4. Anda adalah seorang veteran. Anda telah menaklukkan ribuan baris kode `OnTick()`. Anda punya 50 variabel global di atas EA Anda dan Anda (setidaknya) tahu 40 di antaranya buat apa. Anda bisa membuat EA *grid* atau *martingale* yang rumit hanya dengan Notepad dan kopi hitam.
Anda adalah seorang "skripter" ulung. Anda menulis kode secara prosedural: "Lakukan A, lalu lakukan B, jika C terjadi, lakukan D." Sederhana. Efektif. Berantakan.
Lalu Anda membuka MQL5. Anda mencoba mem-porting EA MQL4 kesayangan Anda. Anda mulai membaca tentang `CTrade`, `CExpert`, `CObject`. Anda melihat kata-kata menakutkan seperti `class`, `public`, `private`, `virtual`, `inheritance`, dan `polymorphism`. Tiba-tiba, Anda merasa seperti seorang koki warteg yang disuruh mengoperasikan reaktor nuklir.
Ini adalah Object-Oriented Programming (OOP). Dan ya, ini adalah cara MetaQuotes "memaksa" kita untuk tumbuh dewasa. Ini adalah cara mereka berkata, "Berhentilah menulis kode seperti di tahun 1990-an."
Artikel ini adalah panduan Anda untuk selamat dari "terapi kejut" ini. Kita akan membedah apa itu OOP, mengapa Anda *harus* peduli, dan bagaimana cara kerjanya tanpa bahasa akademis yang membuat Anda ingin tidur. Ini adalah OOP untuk kita: para *coder* trading yang sinis tapi praktis.
Pertanyaan pertama dan paling jujur: "Kenapa saya harus belajar omong kosong rumit ini? EA MQL4 saya jalan kok!"
Benar. Dia "jalan". Tapi coba kita lihat "jeroan" EA MQL4 Anda yang sudah berumur 2 tahun itu.
Itu namanya "Spaghetti Code". Kode yang alurnya berantakan, saling terkait, dan tidak mungkin di-debug. Mengubah satu hal akan merusak lima hal lainnya. Itu rapuh. Itu mimpi buruk.
OOP adalah solusinya. Ini bukan tentang membuat kode Anda lebih *fancy*. Ini tentang membuat kode Anda terorganisir, bisa dipakai ulang (reusable), dan mudah dirawat (maintainable). OOP adalah tentang berhenti membangun gubuk dari ranting, dan mulai membangun gedung pencakar langit dari LEGO yang terstandarisasi.
Lupakan semua jargonnya sejenak. Pikirkan "Objek" sebagai sebuah "benda" pintar yang mandiri.
Contoh:
Bayangkan Anda ingin membuat logika sinyal RSI.
CSignalRSI. "Cetakan" ini (disebut Class) punya datanya sendiri (m_rsi_period, m_upper, m_lower) dan logikanya sendiri (CheckSignal()).
Saat Anda ingin *menggunakan* sinyal RSI itu, Anda "mencetak" sebuah objek dari cetakan itu: CSignalRSI* MyRSI = new CSignalRSI(14, 70, 30);
Sekarang, MyRSI adalah "benda" pintar Anda. Dia menyimpan *setting*-nya sendiri. Anda tinggal panggil: if(MyRSI.CheckSignal() == SIGNAL_BUY) { ... }
Mau 3 sinyal RSI berbeda? Gampang. Cetak saja 3 objek. CSignalRSI* RsiCepat = new CSignalRSI(5, 80, 20); CSignalRSI* RsiLambat = new CSignalRSI(50, 70, 30);
Lihat? Tidak ada variabel global yang bertabrakan. Masing-masing objek mandiri. Itulah intinya.
Para akademisi bilang OOP berdiri di atas 4 pilar. Mari kita terjemahkan ke bahasa manusia.
Apa katanya: "Membungkus data (properti) dan fungsi (metode) ke dalam satu unit (kelas), dan menyembunyikan detail internal dari dunia luar."
Apa artinya: Ini adalah konsep "black box" (kotak hitam). Bayangkan sebuah mobil. Anda (si pengguna) punya akses ke hal-hal public: setir, pedal gas, rem. Anda tidak perlu tahu (dan tidak boleh tahu) *bagaimana* mesin di dalam (hal-hal private) bekerja. Anda cukup injak gas, mobil jalan.
Di MQL5:
public: Ini adalah "tombol" yang boleh disentuh orang luar. Contoh: fungsi CheckSignal().private: Ini adalah "jeroan" internal. Variabel-variabel internal, fungsi-fungsi pembantu yang rumit. Jika Anda paksakan akses dari luar, *compiler* akan menampar Anda. Ini bagus. Ini mencegah Anda (atau orang lain) merusak logika internal objek Anda secara tidak sengaja.protected: Ini "jeroan" yang boleh dilihat oleh "anak-anak" si kelas (lihat pilar Inheritance).
Kenapa ini bagus? Kode Anda jadi lebih aman. Anda tidak bisa lagi *tidak sengaja* mengubah variabel g_RSI_Value dari fungsi Martingale Anda. Anda harus memanggil fungsi public yang sah, misal MyRSI.GetValue(). Ini memaksakan disiplin.
Apa katanya: "Mekanisme di mana sebuah kelas baru (anak) bisa mewarisi properti dan metode dari kelas yang sudah ada (induk)."
Apa artinya: Ini persis seperti warisan di dunia nyata. Anda (anak) mewarisi rumah dan mobil (properti) dan nama keluarga (metode) dari orang tua Anda. Anda tidak perlu membangun rumah itu dari nol. Anda *mendapatkannya secara gratis*.
Di MQL5, seluruh Standard Library bergantung pada ini. class CExpert : public CExpertBase class CMyAwesomeEA : public CExpert
Saat EA Anda mewarisi (: public CExpert), Anda tiba-tiba "GRATIS" mendapatkan puluhan fungsi yang sudah jadi: fungsi manajemen *trading*, fungsi sinyal, fungsi *money management*. Anda tidak perlu menulisnya dari nol. Anda tinggal *pakai*.
Kenapa ini bagus? Ini adalah prinsip "Don't Repeat Yourself" (DRY) level dewa. Anda bisa membuat kelas "Induk" bernama CSignalBase yang punya fungsi-fungsi dasar. Lalu, CSignalRSI, CSignalMA, CSignalStoch semuanya bisa *mewarisi* dari CSignalBase. Hemat ribuan baris kode.
Apa katanya: "Kemampuan objek untuk mengambil banyak bentuk. Sering diimplementasikan menggunakan fungsi virtual."
Apa artinya: Ini adalah pilar yang paling "ajaib" sekaligus paling membingungkan. "Poly" artinya banyak. "Morph" artinya bentuk. "Banyak bentuk".
Analogi: Bayangkan Anda punya tombol "Bicara()" pada remote universal.
Anda memanggil fungsi yang *sama* (Bicara()), tapi hasilnya *berbeda* tergantung *objek*-nya.
Di MQL5: Inilah guna kata kunci virtual dan override.
CSignalBase), Anda membuat fungsi "kosong": virtual bool CheckSignal() { return(false); }CSignalRSI), Anda "mengganti" fungsi itu: override bool CheckSignal() { /* ... logika RSI rumit di sini ... */ }CSignalMA), Anda "mengganti"-nya juga: override bool CheckSignal() { /* ... logika MA cross di sini ... */ }
Kenapa ini bagus? (Bagian Ajaibnya) Sekarang, Anda bisa membuat "kumpulan" sinyal. Anda tidak peduli lagi itu RSI atau MA. CSignalBase* MySignals[2]; MySignals[0] = new CSignalRSI(14, 70, 30); MySignals[1] = new CSignalMA(10, 20);
Lalu di `OnTick()`, Anda tinggal panggil dalam *loop*: for(int i=0; i<2; i++) { MySignals[i].CheckSignal(); }
MQL5 akan cukup pintar untuk tahu: "Oh, `MySignals[0]` itu RSI, jalankan kode `CheckSignal` punya RSI. `MySignals[1]` itu MA, jalankan kode `CheckSignal` punya MA."
Ini GILA. Kode `OnTick()` Anda jadi bersih total. Anda bisa menambah 100 sinyal baru tanpa mengubah 1 baris pun kode di `OnTick()`.
Apa katanya: "Menyembunyikan detail implementasi yang kompleks dan hanya mengekspos fungsionalitas esensial kepada pengguna."
Apa artinya: Ini adalah *hasil* dari Encapsulation dan Polymorphism. Ini adalah "antarmuka pengguna" (User Interface) dari kode Anda. Dashboard mobil adalah abstraksi dari mesin. Anda hanya melihat speedometer dan bensin, bukan pergerakan piston dan semprotan injektor.
Contoh terbaik di MQL5 adalah CTrade. #include <Trade/Trade.mqh> CTrade trade; ... trade.Buy(0.1, _Symbol, ...);
Saat Anda memanggil trade.Buy(), Anda tidak tahu (dan tidak perlu tahu) betapa rumitnya kode di baliknya. Anda tidak tahu bahwa CTrade sedang mengisi 15 *field* di `MqlTradeRequest`, mengirimnya ke server, menerima `MqlTradeResult`, mengecek 5 kode *error*... Anda tidak peduli. Anda hanya tahu "Saya mau Beli". Itulah abstraksi. Anda menggunakan objek yang dibuat orang lain tanpa harus tahu jeroannya.
Mari kita lihat bagaimana OOP membersihkan kode Anda.
//--- 50 variabel global di atas double g_rsi_period=14; double g_ma_fast=10; double g_ma_slow=20; ... void OnTick() { //--- Logika RSI double rsi_val = iRSI(_Symbol, _Period, g_rsi_period, PRICE_CLOSE, 0); bool rsi_buy = rsi_val < 30; bool rsi_sell = rsi_val > 70; //--- Logika MA Cross double ma_fast_now = iMA(_Symbol, _Period, g_ma_fast, ... , 0); double ma_slow_now = iMA(_Symbol, _Period, g_ma_slow, ... , 0); double ma_fast_prev = iMA(_Symbol, _Period, g_ma_fast, ... , 1); double ma_slow_prev = iMA(_Symbol, _Period, g_ma_slow, ... , 1); bool ma_buy = ma_fast_now > ma_slow_now && ma_fast_prev < ma_slow_prev; ... //--- Logika Trading (200 baris lagi) if(rsi_buy && ma_buy && ...) { ... OrderSend() ... } }
Berantakan. `OnTick` tahu *semua* detail cara kerja RSI dan MA. Menjijikkan.
//--- Termasuk class-class kita #include "CSignalRSI.mqh" #include "CSignalMA.mqh" #include "CTradeManager.mqh" //--- "Benda" kita (dideklarasi sebagai pointer) CSignalRSI* m_rsi; CSignalMA* m_ma; CTradeManager* m_trader; void OnInit() { //--- "Mencetak" objek kita m_rsi = new CSignalRSI(14, 70, 30); m_ma = new CSignalMA(10, 20); m_trader = new CTradeManager(); } void OnTick() { int rsi_signal = m_rsi.CheckSignal(); // Mengembalikan -1, 0, 1 &n-sp;int ma_signal = m_ma.CheckSignal(); // Mengembalikan -1, 0, 1 if(rsi_signal == 1 && ma_signal == 1) { m_trader.OpenBuyPosition(0.1); } else if(rsi_signal == -1 && ma_signal == -1) { m_trader.OpenSellPosition(0.1); } } void OnDeinit(const int reason) { //--- Jangan lupa bersihkan memori! delete m_rsi; delete m_ma; delete m_trader; }
Lihat `OnTick()`-nya! Bersih! Singkat! Bisa dibaca! `OnTick` tidak perlu tahu *bagaimana* `m_rsi.CheckSignal()` bekerja. Itu bukan urusannya. Urusannya adalah *mengambil keputusan* berdasarkan sinyal yang sudah jadi. Inilah tujuan OOP.
Belajar OOP itu seperti belajar bahasa baru. Minggu pertama Anda akan pusing, maki-maki, dan kangen dengan "bahasa ibu" (MQL4) Anda yang simpel. Anda akan error karena lupa `delete` *pointer* (kebocoran memori). Anda akan bingung bedanya `private` dan `protected`. Anda akan salah `override` fungsi `virtual`.
Tapi MQL4 sudah mati. Itu fakta. Semua pengembangan baru, Strategy Tester *multi-core* yang gila, integrasi Python, dan akses ke pasar Saham/Futures... semuanya ada di MQL5.
Dan bahasa MQL5 *adalah* OOP. MQL5 Standard Library *adalah* OOP. Anda tidak bisa menghindarinya. Semakin cepat Anda "menelan pil pahit" ini dan mulai membangun EA Anda pakai LEGO, semakin cepat Anda akan menjadi developer yang lebih baik, lebih cepat, dan lebih rapi. Kode Anda akan jadi aset, bukan bom waktu.
Tentu saja, perjalanan ini panjang. Ada banyak konsep lanjutan, *design patterns*, dan "jebakan" lain yang menunggu. Jika Anda menikmati bedah teknis yang mendalam, jujur, dan tanpa basa-basi seperti ini...
...maka Anda wajib follow akun sosial media INVEZTO. Kami tidak hanya bicara soal "sinyal". Kami membedah "mesin"-nya. Dapatkan info menarik, tips *coding* tingkat lanjut, dan diskusi cerdas seputar dunia *algorithmic trading* yang rumit ini. Berhentilah jadi *skripter*, mulailah jadi *arsitek*.
Multi-Level Grid Trading M...
Bitcoin: Asia Serves Toxic...
Pasar Forex Curang? ...
Gartley Pattern MQL5: The ...