Kemahiran pengaturcaraan adalah lebih baik jika seorang pemrogram mempunyai program operasi kecil yang dilupuskannya. Untuk memahami keseluruhan program, adalah perlu untuk memeriksa secara menyeluruh semua komponennya dan mengesan langkahnya secara beransur-ansur. Sila ambil perhatian, sifat fungsi khas program aplikasi yang berlainan (EA, skrip, petunjuk) adalah berbeza. Di sini kita akan menganalisis bagaimana EA beroperasi.
Contoh EA yang mudah. (simple.mq4)
//-------------------------------------------------------------------- // simple.mq4 // To be used as an example in MQL4 book.
//--------------------------------------------------------------------
int Count=0; // Global variable
//--------------------------------------------------------------------
int init() // Spec. funct. init()
{ Alert ("Function init() triggered at start"); // Alert
return; // Exit init()
}
//--------------------------------------------------------------------
int start() // Spec. funct. start()
{ double Price = Bid; // Local variable
Count++; // Tick counter
Alert("New tick ",Count," Price = ",Price); // Alert
return; // Exit start()
}
//--------------------------------------------------------------------
int deinit() // Spec. funct. deinit()
{
Alert ("Function deinit() triggered at deinitialization"); // Alert return; // Exit deinit()
}
//--------------------------------------------------------------------
Selaras dengan peraturan pelaksanaan program (lihat struktur Program dan fungsi khas), EA ini akan berfungsi dengan cara berikut:1. Pada masa ini apabila program dilampirkan pada carta, terminal klien melewati kawalan ke program, dan sebagai hasilnya, program tersebut memulakan pelaksanaannya. Pelaksanaan program bermula dari bahagian kepala. Bahagian kepala hanya mengandungi satu baris.
int Count = 0; // Pembolehubah global
Dalam baris ini, Count pembolehubah global diisytiharkan dan dimulakan dengan nilai sifar. (Pemboleh ubah tempatan dan global dianalisis secara terperinci dalam Jenis pembolehubah. Perlu diingatkan di sini bahawa algoritma yang digunakan dalam program contoh terdahulu memerlukan pengisytiharan Pengira pemboleh ubah sebagai global. Itulah sebabnya ia tidak boleh diisytiharkan di dalam suatu fungsi, ia mesti diisytiharkan di luar perihal fungsi, yang berada di bahagian kepala, oleh itu, nilai dari pembolehubah global boleh didapati dari mana-mana bahagian program.)
2. Selepas pelaksanaan bahagian kepala program, init () akan dimulakan untuk pelaksanaan. Sila ambil perhatian, panggilan fungsi ini tidak terkandung dalam kod program. Permulaan pelaksanaan init () apabila EA dilampirkan pada carta ialah harta milik fungsi itu sendiri. Terminal pelanggan akan memanggil init () untuk pelaksanaan hanya kerana kod program mengandungi perihalannya. Dalam program yang dianalisis, perihalan init () adalah berikut.
int init () // Spec. fungsi. di dalamnya() { Alert (“Fungsi init () dicetuskan pada permulaan”); // Alert kembali; // Keluar init () }
Badan berfungsi hanya mengandungi dua operator.
2.1 Fungsi Pemberitahuan () menunjukkan tetingkap amaran:Fungsi init () dicetuskan pada permulaan
2.2 Operator return selesai operasi init ().
Akibat pelaksanaan init (), amaran akan ditulis. Dalam program yang biasa digunakan, algoritma semacam ini sangat jarang berlaku, kerana penggunaan init () seperti ini sedikit membantu. Sesungguhnya, tidak ada gunanya untuk menggunakan fungsi yang memberitahu pedagang bahawa ia sedang dilaksanakan. Di sini, algoritma hanya digunakan untuk visualisasi pelaksanaan init (). Perhatikan hakikat bahawa init () dijalankan dalam satu program sekali sahaja. Pelaksanaan fungsi berlaku pada permulaan operasi program selepas bahagian kepala telah diproses. Apabila pengendali pulih dilaksanakan dalam fungsi init khas (), program mengembalikan kawalan ke terminal klien.
3. Terminal klien mengesan penerangan awal () dalam program.
int start () // Special funct. mulakan () { double Price = Bid; // Pembolehubah tempatan Count ++; Pemberitahuan (“Tanda baru”, Kira, “Harga =”, Harga); // Alert kembali; // Keluar mula () }
3.1. Kawalan dipegang oleh terminal pelanggan. Terminal klien menunggu tanda semak baru dan tidak memulakan fungsi program sehingga satu tanda baru muncul. Ini bermakna bahawa program ini tidak beroperasi untuk beberapa waktu, iaitu tiada tindakan yang dilakukan di dalamnya. Jeda muncul, walaupun tidak ada langsung atau tidak langsung mendorong untuk melakukan jeda ini. Keperluan untuk menunggu tanda semak adalah sifat permulaan () fungsi sendiri, dan tidak ada cara untuk mempengaruhi program ini (contohnya, melumpuhkannya). Program ini akan menunggu kawalan sehingga satu tanda baru muncul. Apabila tanda semak baru muncul, terminal klien melewati kawalan ke program, iaitu memulakan () (dalam kes ini selaras dengan fungsi fungsi permulaan EA). Akibatnya, pelaksanaannya bermula.
3.2.1. double Price = Bid; // Pembolehubah tempatanTindakan berikut dilakukan.
3.2.1.1. Perisytiharan harga berubah tempatan (lihat Jenis pembolehubah). Nilai pembolehubah tempatan ini akan tersedia untuk apa-apa dalam permulaan ().
3.2.2. Pelaksanaan pengendali tugasan. Nilai Tawaran semasa akan diberikan kepada Harga. Nilai harga baru muncul setiap kali satu tanda baru muncul. (Sebagai contoh, pada tanda pertama harga keselamatan boleh sama dengan 1.2744.)
3.3. Kemudian, baris berikut dilaksanakan. Count ++;Count = Count + 1; adalah satu lagi cara untuk menulis ini.Pada saat kawalan lulus ke baris ini, Count sama dengan sifar. Sebagai akibat daripada pelaksanaan Count ++, nilai Count akan meningkat oleh satu. Jadi, pada masa kawalan lulus ke baris seterusnya, Count akan sama dengan 1.3.4. Baris seterusnya mengandungi panggilan Fungsi Alert (). Pemberitahuan (“Tanda baru”, Kira, “Harga =”, Harga); // AlertFungsi ini akan menulis semua pemalar dan pembolehubah yang dinyatakan dalam kurungan.
Pada permulaan pertama (), program ini akan menulis “Tick tick baru”, kemudian rujuk Count untuk mendapatkan nilainya (pada pelaksanaan pertama, nilai ini adalah satu), tulis nilai ini, kemudian tulis “Price =” dan rujuk Harga untuk mendapatkan nilainya (dalam contoh kita adalah 1.2744), dan akhirnya menulis nilai itu.Akibatnya, baris berikut akan ditulis:
Tanda baru 1 Harga = 1.27443.5. Operator ‘kembali’ selesai operasi permulaan (). kembali; // Keluar mula ()
3.6. Kawalan dikembalikan ke terminal pelanggan sehingga satu tanda baru muncul.Ini adalah bagaimana permulaan () fungsi EA dilaksanakan. Apabila pelaksanaan selesai, mula () mengembalikan kawalan ke terminal klien, dan apabila tanda centang baru muncul, panggilan terminal pelanggan mula () semula. Proses ini (memulakan pelaksanaan fungsi start () dan mengembalikan kawalan ke terminal klien) boleh berlangsung lama-beberapa hari atau minggu. Sepanjang masa ini, fungsi permulaan khas () akan dilaksanakan dari semasa ke semasa. Bergantung pada parameter persekitaran (harga baru, masa, keadaan perdagangan dan sebagainya), mulakan () boleh melakukan pelbagai tindakan seperti membuka atau meminda pesanan.
3.7. Dari saat penerimaan tanda semak baru, tindakan mata 3.2 hingga 3.6 diulangi. Walau bagaimanapun, hanya urutan operator yang dieksekusi diulangi, tetapi pembolehubah mendapatkan nilai baru setiap kali. Marilah kita melihat perbezaan antara permulaan pertama dan kedua permulaan ().3.2.1 (2). double Price = Bid; // Pembolehubah tempatanTindakan berikut dilakukan3.2.1.1 (2). Perisytiharan harga berubah tempatan (tidak berubah).3.2.2 (2). Pelaksanaan pengendali tugasan. Nilai Tawaran semasa akan diberikan kepada Harga. Nilai harga baru muncul setiap kali satu tanda baru muncul. Contohnya, pada tanda kedua, harga keselamatan adalah sama dengan 1.2745.3.3 (2). Baris berikut akan dilaksanakan. Count ++;Momen sebelum lulus kawalan ke baris ini, nilai Count (selepas pelaksanaan pertama fungsi mula () adalah sama dengan satu. Hasil daripada penghitungan Count ++, Kira meningkat oleh satu. Oleh itu, pada pelaksanaan kedua, Count akan sama dengan (berubah).3.4 (2). Pemberitahuan () menulis semua pemalar dan pemboleh ubah (nilai baru mereka) yang dinyatakan dalam kurungan. Pemberitahuan (“Tanda baru”, Kira, “Harga =”, Harga); // AlertPada permulaan kedua () pelaksanaan, program akan menulis “tick baru”, kemudian merujuk kepada Count untuk mendapatkan nilai (dalam pelaksanaan kedua, sama dengan dua), tulis nilai ini, tulis “Price =”, rujuk Harga untuk mendapatkan nilainya (dalam contoh kami 1.2745), dan tuliskan nilai itu (berubah).Akibatnya, baris berikut akan ditulis:Tanda baru 2 Harga = 1.27453.5 (2). Operator ‘pulangan’ selesai operasi permulaan () (tiada perubahan). kembali; / / Exit из start ()
3.6 (2). Kawalan dikembalikan ke terminal pelanggan untuk menunggu tanda semak baru.
3.7 (2). Kemudian ia diulang lagi. Dalam pelaksanaan awal (), pembolehubah akan memperoleh nilai-nilai baru dan akan ditulis oleh Alert (). Iaitu, program mengulangi mata 3.2 hingga 3.6 (3). Dan, sekali lagi dan lagi: 3.2-3.6 (4), 3.2-3.6 (5), .. (6) .. (7) .. (8) … Jika pengguna tidak mengambil sebarang tindakan, proses ini akan diulang tanpa henti. Berikutan operasi awal () dalam program ini, kami akan melihat sejarah perubahan harga.Acara seterusnya akan berlaku hanya apabila pengguna memutuskan untuk menamatkan program dan secara paksa dapat menyembunyikan program dari carta secara manual.
4. Terminal pelanggan melewati kawalan ke deinit () (mengikut sifatnya).int deinit () // Special funct. deinit () { Pemberitahuan (“Fungsi deinit () dicetuskan di keluar”); // Amaran kembali; // Keluar deinit () }Terdapat hanya dua operator dalam badan berfungsi.
4.1. Pemberitahuan () akan menulis:Fungsi deinit () dicetuskan pada deinitialization
4.2. Operator ‘kembali’ selesai menjalankan deinit ().Fungsi deinit () bermula untuk dilaksanakan oleh terminal pelanggan hanya sekali. Selepas itu, amaran sebelumnya akan muncul, dan program akan dikeluarkan dari carta.
5. Di sini kisah pelaksanaan EA berakhir.Lampirkan program contoh ini ke mana-mana carta, dan mulakannya. Program pengendalian akan memaparkan tetingkap yang mengandungi semua makluman yang dihasilkan oleh Alert (). Dengan kandungan isyarat, mudah difahami apa fungsi khas berkaitan dengan ini atau entri itu.
Dari contoh ini, anda dapat dengan mudah melihat bahawa program dijalankan mengikut fungsi fungsi khas yang diterangkan dalam fungsi Khas. Tamatkan program, dan mulakannya semula. Setelah melakukan ini beberapa kali, anda akan mendapat pengalaman menggunakan program pertama anda. Ia akan berfungsi dengan baik sekarang dan pada masa akan datang. Program-program selanjutnya yang akan anda tulis sendiri juga akan dibina mengikut struktur yang dijelaskan, dan untuk memulakan pelaksanaan anda, anda juga perlu melampirkannya ke carta.Jika anda memahami semua konsep dan peraturan, maka proses membuat program di MQL4 akan menjadi mudah dan menyenangkan.