4.5 C++-Sprache Schneller Start

Zusammenfassung

C++ ist eine sehr schwierige Programmiersprache. Der schwierige Teil besteht hauptsächlich darin, tiefgründig zu lernen, aber wenn Sie nur Strategie-Logik mit C++ schreiben, benötigen Sie nicht viel tiefgründiges Wissen, solange es keine sehr komplizierte Strategie ist. Einige der Grundlagen zu lernen wird ausreichen.

Warum sollten wir C++ für den quantitativen Handel wählen?

Für manche Leute bedeutet die Verwendung von C++ nicht, dass es für jeden geeignet ist, es zu verwenden. Der Grund ist, dass die Programmiersprache nur ein Werkzeug ist. Im quantitativen Handel ist C++ nicht die must-required. Wenn Sie es vorziehen, die Skript-Programmiersprache wie Python oder C++ zu verwenden, können Sie viel Zeit und Energie sparen, die für die Konzentration auf das Strategiedesign verwendet werden können.

Bei den quantitativen Anlageinstituten wurde jedoch die meisten zugrunde liegenden quantitativen Handelssystemsoftware in C++ geschrieben, da ihre einzigartige Sprachspezifität sie in einigen Aspekten effizienter und schneller macht als andere Sprachen, insbesondere bei numerischen Berechnungen. Dies bedeutet auch, dass C++ für Finanzderivate und Hochfrequenzhandel geeigneter ist. Wenn Sie also eine schnellere Programmiersprache verwenden möchten, muss es die C++ sein.

Vollständige Strategie

Um jedem zu helfen, den Inhalt dieses Abschnitts schneller zu verstehen, schauen wir uns vor der Einführung der C++-Sprache die Strategie an, die von C++ geschrieben wurde, damit Sie ein vorläufiges Verständnis für das Substantivkonzept in diesem Abschnitt haben.

Wir alle wissen, dass der MACD zwei Kurven hat, nämlich die schnelle Linie und die langsame Linie, lassen Sie uns eine Handelslogik basierend auf diesen beiden Linien entwerfen. Wenn die schnelle Linie die langsame Linie überschreitet, öffnen Sie eine lange Position; wenn die schnelle Linie die langsame Linie überschreitet, öffnen Sie eine kurze Position.

• Offene lange Position: Wenn zurzeit keine Position besteht und die schnelle Linie größer ist als die langsame Linie.

• Offene Kurzposition: Wenn zurzeit keine Position besteht und die schnelle Linie kleiner als die langsame Linie ist.

• close Long Position: Wenn zurzeit eine Long Position gehalten wird und die schnelle Linie kleiner ist als die langsame Linie.

• close Short Position: Wenn die aktuelle Short Position gehalten wird und die schnelle Linie größer ist als die langsame Linie.

Mit der Sprache C++ wird die obige Strategie-Logik wie folgt geschrieben:

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

Der obige Code ist eine vollständige quantitative Handelsstrategie, die in C++ geschrieben wurde. Sie kann auf dem realen Markt angewendet werden und wird automatisch Aufträge platzieren. In Bezug auf die Codegröße ist sie komplizierter als andere Sprachen.

Obwohl der Codierungsteil ein wenig mehr ist als zuvor, wurden bereits so viele unnötige Handelsklassenbibliotheken reduziert, und die meisten der zugrunde liegenden Systemverarbeitung werden von der FMZ Quant-Plattform verpackt.

Für Anfänger bleibt der Entwurfsprozess der gesamten Strategie unverändert: Festlegung der Marktvariante, Erfassung von K-Liniendaten, Erfassung von Positionsinformationen, Berechnung der Handelslogik und Auftragserteilung.

Identifikator

Die Variablen und Funktionsnamen in C++ sind groß- und kleinfühlig, was bedeutet, dass der Variablen-Namen-Test und der Variablen-Namen-Test zwei verschiedene Variablen sind.

mohd    zara    abc    move_name    a_123
myname50    _temp    j    a23b9    retVal

Kommentar

Kommentare umfassen Kommentare in einer Zeile und Kommentare auf Blöckebene. Kommentare in einer Zeile beginnen mit zwei Schrägstücken, beginnend mit einem Schrägstück und einem Sternchen ( /* ), und enden mit einem Sternchen und einem Schrägstück ( */ ), wie in der folgenden Abbildung gezeigt:

// this is a single-line comment

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

Semikolon und Statement Block

In C++ ist das Semikolon der Statement-Terminator. Das heißt, jede Statement muss mit einem Semikolon enden. Es zeigt das Ende einer logischen Entität an. Zum Beispiel hier sind drei verschiedene Statements:

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

Variable

Eine Variable ist ein operationeller Speicherbereich. Um eine Variable in C++ zu definieren, müssen Sie zuerst den Typ der Variable definieren. Bei der Entwicklung quantitativer Handelsstrategien verwenden wir häufig Typen wie: ganzzahl (int ), float (double ), string (string) und automatischer Ableitungstyp (auto ).

Ganzzahlen können als ganze Zahlen verstanden werden; Flüssigerzeichenarten können als Zahlen mit Dezimalstellen verstanden werden; Zeichenfolgen sind Literalen, können englische oder andere Sprachzeichen sein.

Manchmal, wenn wir eine API aufrufen, aber wir wissen nicht, ob diese API uns geben wird, welche Art von Daten zurückzugeben ist, wird uns die Verwendung des automatischen Ableitungstyps (auto) helfen, den Datentyp automatisch zu bestimmen. Wie unten gezeigt:

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

Ein Array ist ein Container für die Speicherung von Daten. Ein C++-Array kann eine feste Reihenfolge von Elementen desselben Typs mit einer festen Größe speichern. In C++ müssen Sie also, um ein Array zu deklarieren, den Typ des Elements und die Anzahl der Elemente angeben. Alle Arrays haben einen Index von 0 als erstes Element.

// 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

Funktion

Eine Funktion ist ein Satz von Anweisungen, die eine Aufgabe zusammen ausführen. Die Erklärung einer Funktion umfasst: den Namen der Funktion, den Typ der Rückgabe und die Parameter. Der Rückgabeart ist der Datentyp, der zurückgegeben wird, wenn die Funktion ausgeführt wird, wenn ich diese Funktion aufrufe; der Parameter ist optional, und die Funktion kann auch keine Parameter enthalten. Wenn die Funktion aufgerufen wird, können Sie auch einen Parameter an die Funktion weitergeben. Schauen Sie sich das folgende Beispiel an:

// 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
}

Betreiber

Mit C++ werden drei häufig verwendete Operatoren verwendet: arithmetische Operatoren, relationelle Operatoren, logische Operatoren und Zuweisungsoperatoren. Der arithmetische Operator ist die mathematische Operation der Addition, Subtraktion, Multiplikation und Division. Der relationelle Operator kann vergleichen, ob die beiden Werte kleiner oder größer sind. Logische Operatoren umfassen hauptsächlich: logische AND, logische OR und logische Non. Der Zuweisungsoperator ist die Variablenzuweisung, über die wir zuvor gesprochen haben. Wie unten gezeigt:

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

Priorität

Wenn es einen Ausdruck 100*(10-1)/(10+5) gibt, welchen Schritt berechnet das Programm zuerst? Mittelschullehrer Mathematik sagt uns: Wenn es sich um die gleiche Ebene der Operation handelt, wird sie im Allgemeinen von links nach rechts berechnet; Wenn es Hinzufügen und Subtraktionen und Multiplikation und Division gibt, berechnen Sie zuerst die Multiplikation und Division, dann addieren und subtrahieren; Wenn es Klammern gibt, berechnen Sie zuerst das Innere der Klammern; Wenn das Betriebsgesetz erfüllt ist, kann das Berechnungsgesetz für die Berechnung verwendet werden. Das gleiche obige Prinzip für C ++, wie unten gezeigt:

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

Bedingte Angaben

Normalerweise müssen wir beim Schreiben von Code immer verschiedene Aktionen für verschiedene Entscheidungen ausführen. Wir können bedingte Statements in unserem Code verwenden, um diese Aufgabe zu erfüllen. In C++ können wir folgende bedingte Statements verwenden:

• Wenn Anweisung - Verwenden Sie diese Anweisung, um Code nur auszuführen, wenn die angegebene Bedingung wahr ist

• Wenn...anders Anweisung - Code ausführen, wenn die angegebene Bedingung wahr ist, der andere Code ausgeführt, wenn die Bedingung falsch ist

• Wenn...anders wenn...anders Anweisung - verwenden Sie diese Anweisung, um einen von mehreren Code-Blöcken auszuwählen, um ausgeführt werden

• Switch-Anweisung - Verwenden Sie diese Anweisung, um einen der mehreren zu ausführenden Codeblöcke auszuwählen

Wenn Erklärung

Diese Anweisung führt den Code nur aus, wenn die angegebene Bedingung wahr ist. Bitte verwenden Sie einen Kleingedruckten, wenn. Mit einem Großbuchstaben (IF) wird ein C++-Fehler erzeugt! Wie unten gezeigt:

// 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
}

Wenn... sonst eine Aussage

Ausführungscode, wenn die angegebene Bedingung wahr ist, der andere Code, der ausgeführt wird, wenn die Bedingung falsch ist, wie unten gezeigt:

//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
}

Wechselstatement

Verwenden Sie diese Anweisung, um einen der mehreren Codeblöcke auszuwählen, die ausgeführt werden sollen

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
}

Für die Schleife

Die For-Schleife kann N-fache Codeblöcke wiederholt ausführen, und ihr Ausführungsfluss ist wie folgt (wie unten gezeigt):

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

• Schritt 1: Ausführen int a = 0 und nur einmal ausführen. Sein Zweck ist es, eine ganzzahlige Variable zu deklarieren und auf 0 zu initialisieren, um die For-Schleife zu steuern.

• Schritt 2: Ausführen von a<20. Wenn es wahr ist, wird der Codeblock der Zeile 2 ausgeführt.

• Schritt 3: Ausführen von a++, nach Ausführen von a++, wird a 11.

• Schritt 4: Führen Sie a<20 erneut aus, und die zweiten, dritten und vierten Schritte werden wiederholt ausgeführt. Bis a<20 falsch ist, wird der Codeblock der Zeile 2 nicht ausgeführt und die gesamte For-Schleife ist beendet.

Während Loop

Wir alle wissen, dass sich der Markt ständig ändert. Wenn Sie das neueste K-Line-Array erhalten möchten, müssen Sie ständig den gleichen Code immer wieder ausführen. Dann ist die while-Schleife die beste Wahl. Solange die angegebene Bedingung wahr ist, wird die Schleife weiterhin die neuesten K-Line-Array-Daten erhalten.

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

Auskunft über die Unterbrechung

Loops haben Voraussetzungen. Nur wenn diese Voraussetzung "true" ist, beginnt die Schleife wiederholt etwas zu tun, bis die Voraussetzung "false" ist, endet die Schleife. Aber mit der Break-Anweisung kann man während der Ausführung der Schleife sofort aus der Schleife springen;

# 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

Fortsetzung der Erklärung

Die continue-Anweisung springt auch aus der Schleife, aber sie springt nicht aus der ganzen Schleife. Stattdessen unterbrechen Sie eine Schleife und fahren Sie zur nächsten Schleife weiter. Wie unten gezeigt, wenn a gleich 2 ist, wird die Schleife unterbrochen und die nächste Schleife wird fortgesetzt, bis die Voraussetzung der Schleife "falsch" ist, um aus der ganzen Schleife zu springen.

# 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

Rücksendeerklärung

Die return-Anweisung beendet die Ausführung der Funktion und gibt den Wert der Funktion zurück. Die return-Anweisung kann nur im Körper der Funktion erscheinen, und jeder andere Ort im Code wird einen Syntaxfehler verursachen!

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

Strategie-Architektur

Auf der FMZ Quant Plattform wäre es sehr praktisch, eine Strategie in C++ zu schreiben. Die FMZ Quant verfügt über viele offiziell integrierte Standard-Strategie-Frameworks und Trading-Klassen-Bibliotheken, wie zum Beispiel:

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

Wie oben gezeigt, ist dies ein Standard-Strategie-Framework, und diese Formate sind festgelegt. Verwenden Sie das Framework, um eine Strategie zu schreiben. Sie müssen nur die Strategie-Logik aus der zweiten Zeile schreiben. Andere Marktübernahme und Auftragsverarbeitung werden vom Framework und den Handelsklassen-Bibliotheken verarbeitet, Sie müssen sich nur auf die Strategieentwicklung konzentrieren.

Zusammenfassend

Die oben beschriebene ist der Inhalt der C++-Sprache Quick Start. Wenn Sie eine komplexere Strategie schreiben möchten, wenden Sie sich bitte an die FMZ Quant-Plattform C++-Sprache API-Dokumentation oder wenden Sie sich direkt an den offiziellen Kundenservice über den Schreibservice.

Ankündigung zum nächsten Abschnitt

Der Schlüssel zum quantitativen Handel ist die Handelsstrategie, nicht die Handelswerkzeuge (Programmiersprache).

Nachschulübungen

• Versuchen Sie, historische K-Liniendaten mit der C++-Sprache auf der FMZ Quant-Plattform zu erhalten.
• Versuchen Sie, den Strategiecode zu Beginn dieses Abschnitts aufzuschreiben, gefolgt von spezifischen Kommentaren.