4.5 C++ Bahasa Cepat Mulai

Ringkasan

C++ adalah bahasa pemrograman yang sangat sulit. Bagian yang sulit terutama adalah belajar secara mendalam, tetapi jika Anda hanya menulis logika strategi dengan C++, itu tidak akan membutuhkan pengetahuan yang mendalam, selama itu bukan strategi yang sangat rumit. Belajar beberapa dasar akan cukup.

Mengapa kita harus memilih C ++ untuk perdagangan kuantitatif?

Untuk beberapa orang menggunakan C++ tidak berarti itu cocok untuk semua orang untuk menggunakannya. alasannya adalah, bahasa pemrograman hanyalah sebuah alat. Dalam perdagangan kuantitatif, C++ bukan must-required. Jika Anda lebih suka menggunakan bahasa pemrograman skrip, seperti Python atau C++, Anda dapat menghemat banyak waktu dan energi, yang dapat digunakan untuk fokus pada desain strategi.

Tetapi di antara lembaga investasi kuantitatif, sebagian besar perangkat lunak sistem perdagangan kuantitatif yang mendasarinya ditulis dengan C ++, karena spesifisitas bahasa uniknya membuatnya lebih efisien dan lebih cepat daripada bahasa lain dalam beberapa aspek, terutama dalam perhitungan numerik.

Strategi Lengkap

Untuk membantu semua orang memahami isi bagian ini lebih cepat, sebelum memperkenalkan bahasa C++, mari kita lihat strategi yang ditulis oleh C++, sehingga Anda memiliki pemahaman awal tentang konsep kata benda dalam bagian ini.

Kita semua tahu bahwa MACD memiliki dua kurva, yaitu garis cepat dan garis lambat, mari kita merancang logika perdagangan berdasarkan dua garis ini. Ketika garis cepat melintasi garis lambat, buka posisi panjang; ketika garis cepat melintasi garis lambat, buka posisi pendek. Logika strategi lengkap adalah:

• Posisi panjang terbuka: Jika saat ini tidak ada posisi, dan garis cepat lebih besar dari garis lambat.

• Posisi pendek terbuka: Jika saat ini tidak ada posisi, dan garis cepat lebih kecil dari garis lambat.

• close Long position: Jika saat ini memegang long position, dan fast line lebih kecil dari slow line.

• close short position: Jika posisi pendek saat ini ditahan, dan garis cepat lebih besar dari garis lambat.

Menggunakan bahasa C ++ untuk menulis logika 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
        }
    }
}

Kode di atas adalah strategi perdagangan kuantitatif lengkap yang ditulis dalam C ++. Ini dapat diterapkan di pasar nyata dan akan secara otomatis menempatkan pesanan. Dalam hal ukuran kode, itu lebih rumit daripada bahasa lain. Karena bahasa C ++ terutama untuk pengembangan strategi frekuensi tinggi pada platform FMZ Quant.

Meskipun bagian pengkodean sedikit lebih dari sebelumnya, begitu banyak perpustakaan kelas perdagangan yang tidak perlu telah dikurangi, dan sebagian besar pemrosesan tingkat sistem yang mendasari dikemas oleh platform FMZ Quant.

Untuk pemula, proses desain dari seluruh strategi tetap tidak berubah: mengatur varietas pasar, memperoleh data K-line, memperoleh informasi posisi, menghitung logika perdagangan, dan menempatkan pesanan.

Pengidentifikasi

Variabel dan nama fungsi dalam C++ bersifat case-sensitive, yang berarti bahwa variable name test dan variable name test adalah dua variabel yang berbeda. Karakter pertama dari identifier harus huruf, underscore _, dan karakter berikut juga bisa angka, seperti yang ditunjukkan di bawah ini:

mohd    zara    abc    move_name    a_123
myname50    _temp    j    a23b9    retVal

Komentar

Komentar termasuk komentar baris tunggal dan komentar tingkat blok. Komentar baris tunggal dimulai dengan dua garis miring, dimulai dengan garis miring dan tanda bintang ( /* ), berakhir dengan tanda bintang dan tanda garis miring ( */ ), seperti yang ditunjukkan di bawah ini:

// this is a single-line comment

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

Semikolon & blok pernyataan

Dalam bahasa C++, semikolon adalah terminator statement. Artinya, setiap statement harus berakhir dengan semikolon. Ini menunjukkan akhir dari entitas logis. Misalnya, berikut adalah tiga statement yang berbeda:

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

Variabel

Variabel adalah area penyimpanan operasional. Untuk mendefinisikan variabel dalam C++, Anda harus terlebih dahulu mendefinisikan jenis variabel. Dalam pengembangan strategi perdagangan kuantitatif, jenis yang biasa kita gunakan adalah: integer (int ), float (double ), string (string) dan jenis turunan otomatis (auto ).

Bilangan bulat dapat dipahami sebagai bilangan bulat; jenis titik terapung dapat dipahami sebagai angka dengan titik desimal; string adalah literal, dapat menjadi karakter bahasa Inggris atau bahasa lainnya.

Kadang-kadang ketika kita memanggil API, tetapi kita tidak tahu apakah API ini akan memberi kita jenis data apa yang harus dikembalikan, jadi menggunakan jenis turunan otomatis (auto ) akan membantu kita secara otomatis menentukan jenis data. Seperti yang ditunjukkan di bawah:

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++ dapat menyimpan koleksi urutan tetap elemen dari jenis yang sama dengan ukuran yang tetap. Jadi dalam C++, untuk mendeklarasikan array, Anda perlu menentukan jenis elemen dan jumlah elemen. Semua array memiliki indeks 0 sebagai elemen pertama mereka. Untuk mendapatkan data pertama dalam array adalah " [0] ", data kedua adalah " [1] ", dan seterusnya, seperti yang ditunjukkan sebagai berikut:

// 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 seperangkat pernyataan yang mengeksekusi tugas bersama. Deklarasi fungsi mencakup: nama fungsi, jenis pengembalian, dan parameter. Jenis pengembalian adalah jenis data yang dikembalikan ketika fungsi dijalankan ketika saya memanggil fungsi ini; parameter adalah opsional, dan fungsi juga tidak dapat berisi parameter. Ketika fungsi dipanggil, Anda juga dapat memberikan parameter ke 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
}

Operator

Dengan menggunakan C++ untuk menulis strategi perdagangan kuantitatif, ada tiga operator yang umum digunakan: operator aritmatika, operator relasional, operator logis, dan operator penugasan. Operator aritmatika adalah operasi matematika penjumlahan, pengurangan, perkalian, dan pembagian. Operator relasional dapat membandingkan apakah dua nilai lebih kecil atau lebih besar. Operator logis terutama meliputi: logis AND, logis OR, dan logis non. Operator penugasan adalah penugasan variabel yang kita bicarakan 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;
}

Prioritas

Jika ada ekspresi 100*(10-1)/(10+5), langkah mana yang pertama dihitung oleh program? Matematika sekolah menengah memberi tahu kita: Jika itu adalah tingkat operasi yang sama, umumnya dihitung dari kiri ke kanan; Jika ada penjumlahan dan pengurangan, dan perkalian dan pembagian, perhitungkan perkalian dan pembagian terlebih dahulu, kemudian tambahkan dan kurangi; Jika ada tanda kurung, perhitungkan terlebih dahulu bagian dalam tanda kurung; Jika hukum operasi terpenuhi, hukum perhitungan dapat digunakan untuk perhitungan. prinsip yang sama di atas untuk C ++, seperti yang ditunjukkan di bawah ini:

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 ketika kita menulis kode, kita selalu perlu melakukan tindakan yang berbeda untuk keputusan yang berbeda. kita dapat menggunakan pernyataan bersyarat dalam kode kita untuk menyelesaikan tugas ini. di C ++, kita dapat menggunakan pernyataan bersyarat berikut:

• if statement - Gunakan statement ini untuk mengeksekusi kode hanya jika kondisi yang ditentukan benar

• Jika...jika pernyataan - mengeksekusi kode jika kondisi yang ditentukan adalah benar, kode lain dijalankan ketika kondisi adalah salah

• If...else if...else statement - gunakan statement ini untuk memilih salah satu dari beberapa blok kode untuk dijalankan

• Switch statement - Gunakan statement ini untuk memilih salah satu dari beberapa blok kode untuk dijalankan

Jika pernyataan

Perintah ini mengeksekusi kode hanya jika kondisi yang ditentukan benar. Silakan gunakan huruf kecil jika. Menggunakan huruf besar (IF) akan menghasilkan kesalahan 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

Mengeksekusi kode jika kondisi yang ditentukan benar, kode lain yang dieksekusi ketika kondisi itu 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 pernyataan ini untuk memilih salah satu dari beberapa blok kode 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 loop

For loop dapat mengeksekusi N kali blok kode berulang kali, dan aliran eksekusi seperti ini (seperti yang ditunjukkan di bawah):

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

• Langkah 1: Eksekusi int a = 0 dan hanya eksekusi sekali. Tujuannya adalah untuk mendeklarasikan variabel integer dan menginisialisasikannya ke 0 untuk mengontrol loop for.

• Langkah 2: Eksekusi a<20. Jika benar, eksekusi blok kode baris 2.

• Langkah 3: Melakukan a ++, setelah melakukan a ++, a menjadi 11.

• Langkah 4: Eksekusi a<20 lagi, dan langkah kedua, ketiga, dan keempat akan dieksekusi berulang kali. Sampai a<20 salah, jika salah, blok kode baris 2 tidak akan dieksekusi, dan seluruh loop for selesai.

Sementara Loop

Kita semua tahu bahwa pasar terus berubah. Jika Anda ingin mendapatkan array K-line terbaru, Anda harus terus menjalankan kode yang sama berulang-ulang. Kemudian menggunakan loop sementara adalah pilihan terbaik. Selama kondisi yang ditentukan benar, loop akan terus mendapatkan data array k-line terbaru.

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

Pernyataan Pelanggaran

Loop memiliki prasyarat. Hanya ketika prasyarat ini adalah "benar", loop akan mulai melakukan sesuatu berulang kali, sampai prasyarat adalah "salah", loop akan berakhir. Tapi menggunakan pernyataan break dapat melompat keluar dari loop segera selama eksekusi loop;

# 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 dari loop, tetapi tidak melompat keluar dari seluruh loop. Sebaliknya, mengganggu loop dan melanjutkan ke loop berikutnya. Seperti yang ditunjukkan di bawah ini, ketika a sama dengan 2, loop terganggu, dan loop berikutnya dilanjutkan sampai prasyarat loop adalah "salah" untuk melompat keluar dari seluruh loop.

# 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

Pernyataan Pengembalian

Pernyataan return mengakhiri eksekusi fungsi dan mengembalikan nilai fungsi. Pernyataan return hanya dapat muncul di tubuh fungsi, dan tempat lain dalam kode akan menyebabkan kesalahan sintaksis!

# 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;
}

Arsitektur Strategi

Pada platform FMZ Quant, akan sangat nyaman untuk menulis strategi dengan C ++. FMZ Quant memiliki banyak kerangka strategi standar yang dibangun secara resmi 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 standar, dan format ini tetap. Gunakan kerangka untuk menulis strategi. Anda hanya perlu menulis logika strategi dari baris kedua. Akuisisi pasar lainnya dan pemrosesan pesanan ditangani oleh kerangka dan perpustakaan kelas perdagangan, Anda hanya perlu fokus pada pengembangan strategi.

Untuk meringkas

Di atas adalah isi dari bahasa C ++ awal cepat. Jika Anda perlu menulis strategi yang lebih kompleks, silakan lihat FMZ Quant platform C ++ bahasa API dokumentasi, atau langsung berkonsultasi dengan layanan pelanggan resmi tentang layanan penulisan

Pemberitahuan bagian berikutnya

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

Latihan Setelah Sekolah

• Cobalah untuk mendapatkan data K-line historis menggunakan bahasa C ++ pada platform FMZ Quant.
• Cobalah untuk menulis kode strategi di awal bagian ini dan diikuti dengan komentar tertentu.

Lebih banyak