4.5 Bahasa C ++ Permulaan Cepat

Ringkasan

C++ adalah bahasa pengaturcaraan yang sangat sukar. Bahagian yang sukar terutamanya adalah untuk belajar secara mendalam, tetapi jika anda hanya menulis logika strategi dengan C ++, ia tidak akan memerlukan pengetahuan yang mendalam, selagi ia bukan strategi yang sangat rumit. Belajar beberapa asas akan cukup.

Kenapa kita perlu memilih C++ untuk perdagangan kuantitatif?

Bagi sesetengah orang menggunakan C ++ tidak bermakna ia sesuai untuk semua orang menggunakannya. alasannya adalah, bahasa pengaturcaraan hanyalah alat. Dalam perdagangan kuantitatif, C ++ bukan must-required. Jika anda lebih suka menggunakan bahasa pengaturcaraan skrip, seperti Python atau C ++, anda boleh menjimatkan banyak masa dan tenaga, yang boleh digunakan untuk memberi tumpuan kepada reka bentuk strategi.

Tetapi di kalangan institusi pelaburan kuantitatif, kebanyakan perisian sistem perdagangan kuantitatif yang mendasari ditulis dengan C ++, kerana spesifisiti bahasa uniknya menjadikannya lebih cekap dan lebih cepat daripada bahasa lain dalam beberapa aspek, terutama dalam pengiraan berangka. Ini juga bermakna bahawa C ++ lebih sesuai untuk derivatif kewangan dan perdagangan frekuensi tinggi.

Strategi Lengkap

Untuk membantu semua orang memahami kandungan bahagian ini dengan lebih cepat, sebelum memperkenalkan bahasa C ++, mari kita lihat strategi yang ditulis oleh C ++, supaya anda mempunyai pemahaman awal konsep kata benda dalam bahagian ini.

Kita semua tahu bahawa MACD mempunyai dua lengkung, iaitu garis pantas dan garis perlahan, mari kita merancang logik perdagangan berdasarkan kedua-dua garis ini. Apabila garis pantas melintasi garis perlahan, buka kedudukan panjang; apabila garis pantas melintasi garis perlahan, buka kedudukan pendek. Logik strategi lengkap adalah:

• Posisi panjang terbuka: Jika pada masa ini tidak ada kedudukan, dan garis cepat lebih besar daripada garis perlahan.

• Posisi pendek terbuka: Jika pada masa ini tidak ada kedudukan, dan garis cepat adalah kurang daripada garis perlahan.

• close Long position: Jika kini memegang long position, dan garis cepat adalah kurang daripada garis perlahan.

• close Short position: Jika kedudukan pendek yang sedang berlangsung, dan garis cepat lebih besar daripada garis perlahan.

Menggunakan bahasa C ++ untuk menulis logik strategi di atas, akan seperti:

double position = 0;  //Position status parameter, the default position is 0
uint64_t lastSignalTime = 0; // Last signal trigger time

bool onTick(string symbol) { // onTick function, inside the function is the strategy logic
    auto ct = exchange.SetContractType(symbol); // set the trading variety
    if (ct == false) { // if setting the trading variety is not successful 
        return false; // return false
    }
    auto r = exchange.GetRecords(); // get the k line array
    if (!r.Valid || r.sizeO < 20) { // if get the k line array is not successful or the number of k line is less than 20 
        return false; // return false
    }
    auto signalTime = r[r.size() - 2].Time; // get the previous k line time
    if (signalTime <= lastSignalTime) { // if the previous k line time is less than or equal to the last trigger signal time
        return false; // return false
    }
    auto macd = TA.MACD(r); // calculate the MACD indicator
    auto slow = macd[0][macd[0].size() - 2]; // get the previous k line MACD value 
    auto fast = macd[l][macd[l].size() - 2]; // get the previous k line MACD average value
    string action; // define a string variable action
    if (fast >= slow && position <= 0) { // if the previous k line macd value is greater than or equal to the previous k line macd average value, and there are no long position holding
        action = "buy"; // assign buy to the variable action
    } else if (fast <= slow && position >= 0) { // if the previous k line macd value is less than or equal to the previous k line macd average value, and there are no short position holding
        action = "sell"; // assign sell to the variable action
    }
    if (actton.size() > 0) { // If there are orders for placing order
        If (position != 0) { // If there are holding position
            ext::Trade("cover", symbol); // call the C++ trading class library and close all position
        }
        position = ext::Trade(action, symbol, 1); // call the C++ trading class library, placing orders according the direction of variable "action", and renew the position status
        lastSignalTime = signalTime; // reset the time of last trigger signal
    }
    return true; // return true
}

void main() { // program starts from here
    while (true) { // enter the loop
        if (exchange.IO("status") == 0) { // if the connection with the exchange is not successful
            Sleep(1000); // pause for 1 second
            continue; // skip this loop, continue to the next loop
        }
        if (!onTtck("this_week")) { // if the connection is ok, enter the if loop and start to execute the onTick function
            Sleep(1000); // pause for 1 second
        }
    }
}

Kod di atas adalah strategi perdagangan kuantitatif lengkap yang ditulis dalam C ++. Ia boleh digunakan di pasaran sebenar dan akan meletakkan pesanan secara automatik. Dari segi saiz kod, ia lebih rumit daripada bahasa lain. Kerana bahasa C ++ terutamanya untuk pembangunan strategi frekuensi tinggi pada platform FMZ Quant.

Walaupun bahagian pengekodan adalah sedikit lebih daripada sebelumnya, begitu banyak perpustakaan kelas perdagangan yang tidak perlu telah dikurangkan, dan kebanyakan pemprosesan peringkat sistem yang mendasari dikemas oleh platform FMZ Quant.

Bagi pemula, proses reka bentuk keseluruhan strategi tetap tidak berubah: menetapkan pelbagai pasaran, mendapatkan data K-line, mendapatkan maklumat kedudukan, mengira logik perdagangan, dan meletakkan pesanan.

Pengenali

Pengiktirafan juga merupakan nama. Variabel dan nama fungsi dalam C++ adalah sensitif huruf besar, yang bermaksud bahawa ujian nama pembolehubah dan ujian nama pembolehubah adalah dua pembolehubah yang berbeza. Watak pertama pengiktirafan mestilah huruf, tanda bawah _, dan watak berikut juga boleh menjadi nombor, seperti yang ditunjukkan di bawah:

mohd    zara    abc    move_name    a_123
myname50    _temp    j    a23b9    retVal

Komen

Komen termasuk komen baris tunggal dan komen peringkat blok. Komen baris tunggal bermula dengan dua garis miring, bermula dengan garis miring dan tanda bintang ( / * ), berakhir dengan tanda bintang dan tanda garis miring ( * / ), seperti yang ditunjukkan di bawah:

// this is a single-line comment

/*
 * this is a multiple-line comment
 * block-level comments
 *
 */

Semikolon & Pengumuman Blok

Dalam C++, semikolon adalah terminator statement. Maksudnya, setiap statement mesti berakhir dengan semikolon. Ia menunjukkan akhir entiti logik. Sebagai contoh, berikut adalah tiga statement yang berbeza:

x = y;
y = y + 1;
add(x, y);

Variabel

Variabel adalah kawasan penyimpanan operasi. Untuk menentukan pembolehubah dalam C ++, anda mesti terlebih dahulu menentukan jenis pembolehubah. Dalam pembangunan strategi perdagangan kuantitatif, kita biasanya menggunakan jenis adalah: integer (int ), float (ganda ), rentetan (rantai) dan jenis turunan automatik (auto ).

Bilangan bulat boleh difahami sebagai nombor bulat; jenis titik terapung boleh difahami sebagai nombor dengan titik perpuluhan; rentetan adalah literal, boleh menjadi aksara bahasa Inggeris atau bahasa lain.

Kadang-kadang apabila kita memanggil API, tetapi kita tidak tahu sama ada API ini akan memberi kita jenis data yang akan dikembalikan, jadi menggunakan jenis turunan automatik (auto ) akan membantu kita menentukan jenis data secara automatik.

int numbers = 10; // use int to define a integer variable and assign 10 to this variable
double PI = 3.14159; // use double to define a float variable and assign 10 to this variable
string name = "FMZ Quant"; // use string to define a string variable and assign "FMZ Quant" to this variable
auto bar = exchange.GetRecords(); // use auto to define a variable (automatic derivation type) and assign k line array to this variable

Array

Array adalah wadah untuk menyimpan data. Array C++ boleh menyimpan koleksi unsur yang tetap dengan saiz tetap. Jadi dalam C++, untuk mengisytiharkan array, anda perlu menentukan jenis elemen dan bilangan elemen. Semua array mempunyai indeks 0 sebagai elemen pertama mereka. Untuk mendapatkan data pertama dalam array adalah " [0] ", data kedua adalah " [1] ", dan seterusnya, seperti yang ditunjukkan di bawah:

// define a array, array name is balance. there are 5 floating(double) type data inside it
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

double salary = balance[0];  // get the first data in the array, the result is : 1000.0
double salary = balance[1];  // get the second data in the array, the result is : 2.0

Fungsi

Fungsi adalah satu set pernyataan yang melaksanakan tugas bersama-sama. Deklarasi fungsi termasuk: nama fungsi, jenis pulangan, dan parameter. Jenis pulangan adalah jenis data yang dikembalikan apabila fungsi dijalankan apabila saya memanggil fungsi ini; parameter adalah pilihan, dan fungsi juga tidak boleh mengandungi parameter. Apabila fungsi dipanggil, anda juga boleh lulus parameter kepada fungsi. Lihat contoh berikut:

// create a function called "max"
// when this function is called, it returns the int type data
// this function has 2 parameters, and they both are int type
// this function is for passing 2 int type numbers, and return the bigger one

int max(int num1, int num2) {
    int result; // define a int variable result
    if (num1 > num2) // if the num1 > num2
        result = num1; // assign the value of num1 to result
    else // otherwise
        result = num2; // assign the value of num2 to result
    return result; // return the value of result
}

Pengendali

Menggunakan C ++ untuk menulis strategi perdagangan kuantitatif, terdapat tiga pengendali yang biasa digunakan: pengendali aritmetik, pengendali relasional, pengendali logik, dan pengendali penugasan. Pengendali aritmetik adalah operasi matematik penambahan, pengurangan, perkalian, dan pembahagian. Pengendali relasional dapat membandingkan sama ada dua nilai lebih kecil atau lebih besar. Pengendali logik terutamanya termasuk: AND logik, OR logik, dan bukan logik. Pengendali penugasan adalah penugasan pembolehubah yang kita bincangkan sebelumnya. Seperti yang ditunjukkan di bawah:

int main() {
    // arithmetic operator
    int a = 10;
    int b = 5;
    a + b; // the result is 15
    a - b; // the result is 5
    a * b; // the result is 50
    a / b; // the result is 2
    a % b; // the result is 0
    a++; // the result is 11
    a--; // the result is 9

    // relational operators
    a == b; // the result is false
    a != b; // the result is true
    a >= b; // the result is true
    a <= b; // the result is false

    logical operators
    true && true // the result is true
    true && false // the result is false
    false || false // the result is false
    true || false // the result is true
    !(true) // the result is false
    !(false) // the result is true
    return 0;
}

Keutamaan

Jika terdapat ungkapan 100*(10-1)/(10+5), langkah mana yang pertama dikira oleh program? Matematik sekolah menengah memberitahu kita: Jika ia adalah tahap operasi yang sama, ia biasanya dikira dari kiri ke kanan; Jika terdapat penambahan dan pengurangan, dan perkalian dan pembahagian, pertama kira perkalian dan pembahagian, kemudian tambah dan tolak; Jika terdapat kurung, pertama kira bahagian dalam kurung; Jika undang-undang operasi dipenuhi, undang-undang pengiraan boleh digunakan untuk pengiraan. prinsip yang sama di atas untuk C ++, seperti yang ditunjukkan di bawah:

auto num = 100*(10-1)/(10+5); // the value of num is 60
1 > 2 && (2 > 3 || 3 < 5); // the result is : false
1 > 2 && 2 > 3 || 3 < 5; // the result is : true

Pernyataan bersyarat

Biasanya apabila kita menulis kod, kita sentiasa perlu melakukan tindakan yang berbeza untuk keputusan yang berbeza. kita boleh menggunakan pernyataan bersyarat dalam kod kita untuk mencapai tugas ini. dalam C ++, kita boleh menggunakan pernyataan bersyarat berikut:

• If statement - Gunakan statement ini untuk menjalankan kod hanya jika keadaan yang ditentukan adalah benar

• If...else statement - pelaksanaan kod jika keadaan yang ditentukan adalah benar, kod lain dijalankan apabila keadaan adalah salah

• If...else if...else statement - gunakan statement ini untuk memilih salah satu daripada pelbagai blok kod untuk dijalankan

• Switch statement - Gunakan statement ini untuk memilih salah satu daripada beberapa blok kod untuk dijalankan

Jika kenyataan

Perintah ini menjalankan kod hanya jika keadaan yang dinyatakan adalah benar. Sila gunakan huruf kecil jika. Menggunakan huruf besar (IF) akan menghasilkan ralat C ++! Seperti yang ditunjukkan di bawah:

// grammar
if (condition) {
    //execute code only if the condition is true
}
 
//example
if (time<20) { // if current time is less than 20:00
    x = "Good day"; // when the time is less that 20:00, assign the "good day" to x
}

Jika... pernyataan lain

menjalankan kod jika keadaan yang ditentukan adalah benar, kod lain dijalankan apabila keadaan itu adalah salah, seperti yang ditunjukkan di bawah:

//grammar
if (condition) {
    // execute code if the condition is true
} else {
    // the other code executed when the condition is false
}
 
//example
if (time<20) { // if current time is less than 20:00
    x = "Good day"; // when the time is less that 20:00, assign the "good day" to x
} else { // otherwise
    x = "Good evening"; // assign the "Good evening" to x
}

Pernyataan Switch

Gunakan statement ini untuk memilih salah satu daripada beberapa blok kod untuk dijalankan

switch (condition)
{
    case 1: // code to be executed if condition = 1;
        break;
    case 2: // code to be executed if condition = 2;
        break;
    default: // code to be executed if condition doesn't match any cases
}

Untuk gelung

Garis lingkaran For boleh melaksanakan N kali blok kod berulang kali, dan aliran pelaksanaannya seperti ini (seperti yang ditunjukkan di bawah):

for (int a = 10; a < 20; a++){
    // code block
}

• Langkah 1: Jalankan int a = 0 dan hanya jalankan sekali. tujuannya adalah untuk mengisytiharkan pembolehubah bilangan bulat dan memulakannya kepada 0 untuk mengawal gelung for.

• Langkah 2: Melakukan a<20. Jika benar, pelakukan blok kod baris 2.

• Langkah 3: Melakukan a ++, selepas menjalankan a ++, a menjadi 11.

• Langkah 4: Jalankan a<20 lagi, dan langkah kedua, ketiga, dan keempat akan dijalankan berulang kali. Sehingga a<20 adalah palsu, jika salah, blok kod baris 2 tidak akan dijalankan, dan keseluruhan untuk gelung selesai.

Sementara Loop

Kita semua tahu bahawa pasaran sentiasa berubah. Jika anda ingin mendapatkan array K-line terkini, anda perlu terus menjalankan kod yang sama berulang kali. Kemudian gunakan gelung sementara adalah pilihan terbaik. Selagi keadaan yang ditentukan benar, gelung akan terus mendapatkan data array k-line terkini.

void main() {
    auto ct = exchange.SetContractType(symbol); //set the trading variety
    while(true) {
        auto r = exchange.GetRecords(); // constantly getting k-line arrays
    }
} 

Pernyataan Pecahkan

Loop mempunyai prasyarat. Hanya apabila prasyarat ini adalah "benar", gelung akan mula melakukan sesuatu berulang kali, sehingga prasyarat adalah "salah", gelung akan berakhir. Tetapi menggunakan pernyataan break boleh melompat keluar dari gelung segera semasa pelaksanaan gelung;

# including <iostream>
using namespace std;
int main() {
    for(int a = 0; a < 5; a++) {
        if(a == 2) break;
        cout << a << endl;
    }
    return 0;
}

// print out : 0, 1

Lanjutkan Pernyataan

Perintah terus juga melompat keluar daripada gelung, tetapi ia tidak melompat keluar dari keseluruhan gelung. Sebaliknya, mengganggu gelung dan meneruskan ke gelung seterusnya. Seperti yang ditunjukkan di bawah, apabila a sama dengan 2, gelung terganggu, dan gelung seterusnya diteruskan sehingga prasyarat gelung adalah "salah" untuk melompat keluar dari keseluruhan gelung.

# including <iostream>
using namespace std;
int main() {
    for(int a = 0; a < 5; a++) {
        if(a == 2) continue;
        cout << a << endl;
    }
    return 0;
}

// print out : 0, 1, 3, 4

Penyata Kembali

Perintah balik menamatkan pelaksanaan fungsi dan mengembalikan nilai fungsi. Perintah balik hanya boleh muncul dalam badan fungsi, dan mana-mana tempat lain dalam kod akan menyebabkan ralat sintaks!

# including <iostream>
using namespace std;

int add(int num1, int num2) {
    return num1 + num2;  // The add function returns the sum of two parameters
}
 
int main()
{
    cout << add(5, 10); // call the add function, and print out the result:50
    return 0;
}

Senibina Strategi

Pada platform FMZ Quant, sangat mudah untuk menulis strategi dengan C ++. FMZ Quant mempunyai banyak kerangka strategi standard yang dibina secara rasmi dan perpustakaan kelas perdagangan, seperti berikut:

bool onTick() { //onTick function
    // strategy logic
}

void main() { // program starts from here
    while (true) { // enter the loop
        if (exchange.IO("status") == 0) { // if the exchange connection is not stable
            sleep(1000); // pause for 1 second
            continue; // skip this loop, enter the next loop
        }
        if (!onTick()) { // if the exchange connection is stable, enter this if statement, start to execute the onTick function
            sleep(1000);// pause for 1 second
        }
    }
}

Seperti yang ditunjukkan di atas, ini adalah kerangka strategi standard, dan format ini tetap. Gunakan kerangka untuk menulis strategi. Anda hanya perlu menulis logik strategi dari baris kedua. Pemerolehan pasaran lain dan pemprosesan pesanan ditangani oleh kerangka dan perpustakaan kelas perdagangan, anda hanya perlu memberi tumpuan kepada pembangunan strategi.

Ringkasnya

Di atas adalah kandungan bahasa C ++ permulaan cepat. Jika anda perlu menulis strategi yang lebih kompleks, sila rujuk FMZ Quant platform C ++ dokumen bahasa API, atau terus berunding dengan perkhidmatan pelanggan rasmi mengenai perkhidmatan penulisan

Pengumuman Bahagian Seterusnya

Kunci untuk perdagangan kuantitatif adalah strategi perdagangan, bukan alat perdagangan (bahasa pengaturcaraan).

Latihan Selepas Sekolah

• Cuba mendapatkan data K-line sejarah menggunakan bahasa C ++ pada platform FMZ Quant.
• Cuba menulis kod strategi di awal bahagian ini dan diikuti dengan komen tertentu.

Lebih lanjut