4.5 सी++ भाषा त्वरित प्रारंभ

सारांश

C++ एक बहुत ही कठिन प्रोग्रामिंग भाषा है। कठिन हिस्सा मुख्य रूप से गहराई से सीखना है, लेकिन यदि आप केवल C++ द्वारा रणनीति तर्क लिखते हैं, तो बहुत गहरा ज्ञान की आवश्यकता नहीं होगी, जब तक कि यह बहुत जटिल रणनीति नहीं है। कुछ मूल बातें सीखना पर्याप्त होगा।

हमें मात्रात्मक व्यापार के लिए C++ क्यों चुनना चाहिए?

कुछ लोगों के लिए C++ का उपयोग करने का मतलब यह नहीं है कि यह सभी के लिए उपयुक्त है। इसका कारण यह है कि प्रोग्रामिंग भाषा केवल एक उपकरण है। मात्रात्मक व्यापार में, C++ अनिवार्य नहीं है। यदि आप स्क्रिप्ट प्रोग्रामिंग भाषा का उपयोग करना पसंद करते हैं, जैसे कि पायथन या C++, तो आप बहुत समय और ऊर्जा बचा सकते हैं, जिसका उपयोग रणनीति डिजाइन पर ध्यान केंद्रित करने के लिए किया जा सकता है।

लेकिन मात्रात्मक निवेश संस्थानों के बीच, अधिकांश अंतर्निहित मात्रात्मक ट्रेडिंग सिस्टम सॉफ्टवेयर को सी ++ द्वारा लिखा गया था, क्योंकि इसकी अनूठी भाषा विशिष्टता इसे कुछ पहलुओं में अन्य भाषाओं की तुलना में अधिक कुशल और तेज़ बनाती है, खासकर संख्यात्मक गणनाओं में। इसका मतलब यह भी है कि सी ++ वित्तीय व्युत्पन्न और उच्च आवृत्ति व्यापार के लिए अधिक उपयुक्त है। इसलिए, यदि आप एक तेज़ प्रोग्रामिंग भाषा का उपयोग करना चाहते हैं, तो यह सी ++ होना चाहिए।

पूर्ण रणनीति

इस अनुभाग की सामग्री को तेजी से समझने में सभी की मदद करने के लिए, सी ++ भाषा का परिचय देने से पहले, आइए हम उस रणनीति को देखें जो सी ++ द्वारा लिखी गई है, ताकि आपको इस अनुभाग में संज्ञा अवधारणा की प्रारंभिक समझ हो। आइए हम सबसे सरल एमएसीडी रणनीति को एक उदाहरण के रूप में लेंः

हम सभी जानते हैं कि एमएसीडी में दो वक्र हैं, अर्थात् फास्ट लाइन और स्लो लाइन, आइए इन दो लाइनों के आधार पर एक ट्रेडिंग तर्क डिजाइन करें। जब फास्ट लाइन ऊपर धीमी रेखा को पार करती है, तो लंबी स्थिति खोलें; जब तेजी से लाइन नीचे धीमी रेखा को पार करती है, तो छोटी स्थिति खोलें। पूर्ण रणनीति तर्क हैंः

• खुली लंबी स्थितिः यदि वर्तमान में कोई स्थिति नहीं है, और तेज रेखा धीमी रेखा से अधिक है।

• शॉर्ट पोजीशन ओपनः यदि वर्तमान में कोई पोजीशन नहीं है, और फास्ट लाइन स्लो लाइन से कम है।

• बंद करें लंबी स्थितिः यदि वर्तमान में लंबी स्थिति रख रही है, और तेज रेखा धीमी रेखा से कम है।

• बंद शॉर्ट पोजीशनः यदि वर्तमान शॉर्ट पोजीशन में है, और फास्ट लाइन स्लो लाइन से अधिक है।

उपरोक्त रणनीति तर्क लिखने के लिए सी ++ भाषा का उपयोग करना, जैसा होगाः

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

उपरोक्त कोड सी ++ में लिखी गई एक पूरी मात्रात्मक ट्रेडिंग रणनीति है। इसे वास्तविक बाजार में लागू किया जा सकता है और स्वचालित रूप से आदेश देगा। कोड आकार के मामले में, यह अन्य भाषाओं की तुलना में अधिक जटिल है। क्योंकि एफएमजेड क्वांट प्लेटफॉर्म पर मुख्य रूप से उच्च आवृत्ति रणनीति विकास के लिए सी ++ भाषा।

यद्यपि कोडिंग का हिस्सा पहले की तुलना में थोड़ा अधिक है, लेकिन पहले से ही बहुत सारे अनावश्यक ट्रेडिंग क्लास लाइब्रेरी को कम कर दिया गया है, और अधिकांश अंतर्निहित सिस्टम स्तर प्रसंस्करण एफएमजेड क्वांट प्लेटफॉर्म द्वारा पैक किया गया है।

शुरुआती लोगों के लिए, पूरी रणनीति की डिजाइन प्रक्रिया अपरिवर्तित रहती हैः बाजार की विविधता निर्धारित करना, के-लाइन डेटा प्राप्त करना, स्थिति की जानकारी प्राप्त करना, ट्रेडिंग लॉजिक की गणना करना और ऑर्डर देना।

पहचानकर्ता

पहचानकर्ता भी नाम है। C++ में चर और फ़ंक्शन नाम केस-सेंसिटिव होते हैं, जिसका अर्थ है कि चर नाम परीक्षण और चर नाम परीक्षण दो अलग-अलग चर हैं। पहचानकर्ता का पहला वर्ण एक अक्षर, एक रेखांकित होना चाहिए _, और निम्नलिखित वर्ण संख्या भी हो सकते हैं, जैसा कि निम्नलिखित में दिखाया गया हैः

mohd    zara    abc    move_name    a_123
myname50    _temp    j    a23b9    retVal

टिप्पणी

टिप्पणियों में एकल-पंक्ति टिप्पणियां और ब्लॉक-स्तरीय टिप्पणियां शामिल हैं। एकल-पंक्ति टिप्पणियां दो स्लैश के साथ शुरू होती हैं, एक स्लैश और एक तारांकन (/* ) से शुरू होती हैं, एक तारांकन और एक स्लैश (*/ ) के साथ समाप्त होती हैं, जैसा कि नीचे दिखाया गया हैः

// this is a single-line comment

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

सेमीकोलन और स्टेटमेंट ब्लॉक

C++ में, अर्धविराम वाक्य समाप्तकर्ता है। यानी, प्रत्येक कथन को अर्धविराम के साथ समाप्त होना चाहिए। यह एक तार्किक इकाई के अंत को इंगित करता है। उदाहरण के लिए, यहां तीन अलग-अलग कथन हैंः

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

चर

एक चर एक परिचालन भंडारण क्षेत्र है। C++ में एक चर को परिभाषित करने के लिए, आपको पहले चर के प्रकार को परिभाषित करना होगा। मात्रात्मक ट्रेडिंग रणनीतियों के विकास में, हम आमतौर पर उपयोग किए जाने वाले प्रकार हैंः पूर्णांक (int ), फ्लोट (डबल ), स्ट्रिंग (स्ट्रिंग) और स्वचालित व्युत्पन्न प्रकार (ऑटो ).

पूर्णांक पूर्णांक संख्याओं के रूप में समझा जा सकता है; फ्लोटिंग पॉइंट प्रकार दशमलव बिंदुओं के साथ संख्याओं के रूप में समझा जा सकता है; स्ट्रिंग्स शाब्दिक हैं, अंग्रेजी या अन्य भाषा वर्ण हो सकते हैं।

कभी कभी जब हम एक एपीआई कॉल करते हैं, लेकिन हम नहीं जानते कि यह एपीआई हमें कौन सा प्रकार का डेटा लौटाएगा, इसलिए स्वचालित व्युत्पन्न प्रकार (ऑटो) का उपयोग करने से हमें स्वचालित रूप से डेटा प्रकार निर्धारित करने में मदद मिलेगी। जैसा कि नीचे दिखाया गया हैः

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

सरणी

एक सरणी डेटा संग्रहीत करने के लिए एक कंटेनर है। एक सी ++ सरणी एक निश्चित आकार के साथ एक ही प्रकार के तत्वों के एक निश्चित क्रम संग्रह को संग्रहीत कर सकती है। इसलिए सी ++ में, एक सरणी घोषित करने के लिए, आपको तत्व के प्रकार और तत्वों की संख्या निर्दिष्ट करने की आवश्यकता है। सभी सरणी के पहले तत्व के रूप में 0 का सूचकांक होता है। सरणी में पहला डेटा " [0] " प्राप्त करने के लिए, दूसरा डेटा " [1] " है, और इसी तरह, निम्नानुसार दिखाता हैः

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

कार्य

एक फ़ंक्शन एक साथ एक कार्य निष्पादित करने वाले कथनों का एक सेट है। एक फ़ंक्शन की घोषणा में शामिल हैंः फ़ंक्शन का नाम, रिटर्न का प्रकार, और पैरामीटर। रिटर्न प्रकार वह डेटा प्रकार है जो फ़ंक्शन चलाए जाने पर लौटाया जाता है जब मैं इस फ़ंक्शन को कॉल करता हूं; पैरामीटर वैकल्पिक है, और फ़ंक्शन में कोई पैरामीटर भी नहीं हो सकता है। जब फ़ंक्शन को बुलाया जाता है, तो आप फ़ंक्शन को एक पैरामीटर भी पास कर सकते हैं। निम्नलिखित उदाहरण देखेंः

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

ऑपरेटर

परिमाणात्मक व्यापार रणनीतियों को लिखने के लिए सी ++ का उपयोग करते हुए, तीन आम तौर पर उपयोग किए जाने वाले ऑपरेटर हैंः अंकगणितीय ऑपरेटर, संबंधपरक ऑपरेटर, तार्किक ऑपरेटर और असाइनमेंट ऑपरेटर। अंकगणितीय ऑपरेटर जोड़ने, घटाने, गुणा करने और विभाजित करने का गणितीय ऑपरेशन है। संबंधपरक ऑपरेटर तुलना कर सकता है कि क्या दो मान छोटे या बड़े हैं। तार्किक ऑपरेटरों में मुख्य रूप से शामिल हैंः तार्किक और, तार्किक या, और तार्किक गैर। असाइनमेंट ऑपरेटर चर असाइनमेंट है जिसके बारे में हमने पहले बात की थी। जैसा कि नीचे दिखाया गया हैः

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

प्राथमिकता

यदि 100*(10-1)/(10+5) अभिव्यक्ति है, तो प्रोग्राम पहले किस चरण की गणना करता है? मिडिल स्कूल गणित हमें बताता हैः यदि यह ऑपरेशन का एक ही स्तर है, तो यह आमतौर पर बाईं ओर से दाईं ओर गणना की जाती है; यदि जोड़ और घटाव, और गुणा और विभाजन हैं, तो पहले गुणा और विभाजन की गणना करें, फिर जोड़ें और घटाएं; यदि कोष्ठक हैं, तो पहले कोष्ठक के अंदर की गणना करें; यदि ऑपरेशन का नियम पूरा किया जाता है, तो गणना के लिए गणना कानून का उपयोग किया जा सकता है। उपरोक्त सिद्धांत सी ++ के लिए समान है, जैसा कि नीचे दिखाया गया हैः

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

सशर्त कथन

आम तौर पर जब हम कोड लिखते हैं, तो हमें हमेशा अलग-अलग निर्णयों के लिए अलग-अलग क्रियाएं करने की आवश्यकता होती है। हम इस कार्य को पूरा करने के लिए अपने कोड में सशर्त कथन का उपयोग कर सकते हैं। C ++ में, हम निम्नलिखित सशर्त कथन का उपयोग कर सकते हैंः

• यदि कथन - इस कथन का उपयोग केवल तभी करें जब निर्दिष्ट स्थिति सही हो

• यदि...अन्यथा कथन - कोड निष्पादित यदि निर्दिष्ट शर्त सच है, अन्य कोड निष्पादित जब शर्त गलत है

• यदि...अन्यथा यदि...अन्यथा कथन - इस कथन का उपयोग करने के लिए निष्पादित करने के लिए कई कोड ब्लॉक में से एक का चयन करने के लिए

• स्विच कथन - निष्पादित करने के लिए कई कोड ब्लॉक में से एक का चयन करने के लिए इस कथन का उपयोग करें

यदि कथन

यह कथन कोड को तभी निष्पादित करता है जब निर्दिष्ट शर्त सही हो. कृपया एक छोटा अक्षर का उपयोग करें यदि. एक बड़े अक्षर (IF) का उपयोग करने से एक C ++ त्रुटि उत्पन्न होगी! जैसा कि नीचे दिखाया गया हैः

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

यदि... अन्यथा कथन

कोड निष्पादित करें यदि निर्दिष्ट शर्त सही है, अन्य कोड निष्पादित जब शर्त गलत है, जैसा कि नीचे दिखाया गया है:

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

स्विच स्टेटमेंट

निष्पादित करने के लिए कई कोड ब्लॉक में से एक का चयन करने के लिए इस कथन का उपयोग करें

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
}

लूप के लिए

For लूप कोड ब्लॉक के N बार बार निष्पादित कर सकता है, और इसका निष्पादन प्रवाह इस प्रकार है (जैसा कि नीचे दिखाया गया है):

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

• चरण 1: इंट ए = 0 निष्पादित करें और केवल एक बार निष्पादित करें। इसका उद्देश्य एक पूर्णांक चर घोषित करना और इसे 0 पर आरंभ करना है ताकि फॉर लूप को नियंत्रित किया जा सके।

• चरण 2: a<20 निष्पादित करें. यदि यह सच है, तो पंक्ति 2 के कोड ब्लॉक को निष्पादित करें.

• चरण 3: a++ निष्पादित करें, a++ निष्पादित करने के बाद, a 11 हो जाता है।

• चरण 4: a<20 को फिर से निष्पादित करें, और दूसरा, तीसरा, और चौथा चरण बार-बार निष्पादित होगा। जब तक a<20 गलत नहीं है, यदि यह गलत है, तो पंक्ति 2 का कोड ब्लॉक निष्पादित नहीं किया जाएगा, और संपूर्ण लूप समाप्त हो गया है।

जबकि लूप

हम सभी जानते हैं कि बाजार लगातार बदल रहा है. यदि आप नवीनतम के-लाइन सरणी प्राप्त करना चाहते हैं, तो आपको लगातार एक ही कोड को बार-बार चलाना होगा. फिर जबकि लूप का उपयोग करना सबसे अच्छा विकल्प है. जब तक निर्दिष्ट शर्त सही है, तब तक लूप नवीनतम के-लाइन सरणी डेटा प्राप्त करना जारी रखेगा.

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

ब्रेक स्टेटमेंट

लूप में पूर्व शर्तें होती हैं। केवल जब यह पूर्व शर्त "सही" होती है, तब लूप कुछ बार-बार करना शुरू कर देगा, जब तक कि पूर्व शर्त "गलत" नहीं हो जाती, तब तक लूप समाप्त हो जाएगा। लेकिन ब्रेक स्टेटमेंट का उपयोग करके लूप के निष्पादन के दौरान तुरंत लूप से बाहर कूद सकते हैं;

# 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

बयान जारी रखें

continue कथन भी लूप से बाहर कूदता है, लेकिन यह पूरे लूप से बाहर नहीं कूदता है। इसके बजाय, एक लूप को बाधित करें और अगले लूप पर जारी रखें। जैसा कि नीचे दिखाया गया है, जब a 2 के बराबर होता है, तो लूप बाधित हो जाता है, और अगले लूप को तब तक जारी रखा जाता है जब तक कि लूप की पूर्व शर्त पूरे लूप से बाहर कूदने के लिए "गलत" न हो जाए।

# 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

वापसी विवरण

return कथन फ़ंक्शन के निष्पादन को समाप्त करता है और फ़ंक्शन का मान लौटाता है. return कथन केवल फ़ंक्शन के शरीर में दिखाई दे सकता है, और कोड में कोई अन्य स्थान वाक्य रचना त्रुटि का कारण होगा!

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

रणनीति वास्तुकला

एफएमजेड क्वांट प्लेटफॉर्म पर, सी ++ द्वारा रणनीति लिखना बहुत सुविधाजनक होगा। एफएमजेड क्वांट में बहुत सारे आधिकारिक रूप से अंतर्निहित मानक रणनीति ढांचे और ट्रेडिंग क्लास लाइब्रेरी हैं, जैसेः

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

जैसा कि ऊपर दिखाया गया है, यह एक मानक रणनीति ढांचा है, और ये प्रारूप तय हैं। एक रणनीति लिखने के लिए ढांचे का उपयोग करें। आपको केवल दूसरी पंक्ति से रणनीति तर्क लिखने की आवश्यकता है। अन्य बाजार अधिग्रहण और ऑर्डर प्रसंस्करण ढांचे और ट्रेडिंग वर्ग पुस्तकालयों द्वारा संभाले जाते हैं, आपको केवल रणनीति विकास पर ध्यान केंद्रित करने की आवश्यकता है।

संक्षेप में

उपरोक्त सी ++ भाषा त्वरित शुरुआत की सामग्री है। यदि आपको अधिक जटिल रणनीति लिखने की आवश्यकता है, तो कृपया एफएमजेड क्वांट प्लेटफॉर्म सी ++ भाषा एपीआई प्रलेखन देखें, या सीधे लेखन सेवा के बारे में आधिकारिक ग्राहक सेवा से परामर्श करें

अगला अनुभाग सूचना

मात्रात्मक व्यापार की कुंजी व्यापार रणनीति है, व्यापार उपकरण (प्रोग्रामिंग भाषा) नहीं। अगले खंड में, चलो एक व्यवहार्य सी ++ व्यापार रणनीति लिखते हैं। अभी भी सबसे सरल तकनीकी विश्लेषण संकेतकों का उपयोग उदाहरण के रूप में करते हैं।

स्कूल के बाद व्यायाम

• एफएमजेड क्वांट प्लेटफॉर्म पर सी ++ भाषा का उपयोग करके ऐतिहासिक के-लाइन डेटा प्राप्त करने का प्रयास करें।
• इस अनुभाग की शुरुआत में रणनीति कोड लिखने का प्रयास करें और उसके बाद निर्दिष्ट टिप्पणियां करें।

अधिक