Ketahui strategi tegar “strategi lindung nilai kontrak OKEX dalam C++”

Apabila bercakap tentang strategi lindung nilai, terdapat pelbagai strategi, pelbagai kombinasi dan pelbagai idea dalam pelbagai pasaran. Kami akan mula meneroka idea reka bentuk dan konsep strategi lindung nilai daripada lindung nilai rentas tempoh yang paling klasik. Hari ini, pasaran mata wang digital jauh lebih aktif berbanding ketika pasaran mula-mula dibentuk, dan banyak pertukaran kontrak telah muncul, memberikan sejumlah besar peluang arbitraj dan lindung nilai. Terdapat strategi yang tidak berkesudahan, seperti arbitraj rentas pasaran lani, arbitraj lindung nilai niaga hadapan lani, arbitraj rentas tempoh hadapan, arbitraj merentas pasaran niaga hadapan, dsb. Seterusnya, mari kita lihat strategi lindung nilai rentas tempoh “tegar” yang ditulis dalam bahasa C++, dengan pasaran dagangan ialah pertukaran kontrak OKEX Strategi ini ditulis berdasarkan “Platform Dagangan Kuantitatif Pencipta”.

• ### Prinsip Strategi

Sebab strateginya agak tegar ialah strategi ditulis dalam bahasa C++, yang menyukarkan sedikit untuk dibaca. Walau bagaimanapun, ia tidak menghalang pembaca daripada mempelajari intipati reka bentuk dan idea strategi ini. Strategi ini agak ringkas di seluruh, dan panjang kod adalah sederhana, hanya lebih daripada 500 baris. Dari segi pemerolehan data pasaran, tidak seperti strategi sebelumnya yang menggunakan antara muka selebihnya, strategi ini menggunakan antara muka websocket untuk menerima tolakan data pasaran daripada bursa. Dari segi reka bentuk, struktur strategi adalah munasabah, gandingan kod adalah sangat rendah, dan ia sangat mudah untuk dikembangkan atau dioptimumkan. Pemikiran logiknya jelas, dan reka bentuk ini bukan sahaja mudah digunakan dan dikembangkan. Sebagai strategi pengajaran, reka bentuk strategi pembelajaran juga merupakan contoh yang baik. Prinsip strategi ini agak mudah, iaitu, menggunakan kontrak hadapan dan kontrak jangka terdekat untuk lindung nilai positif dan negatif, yang pada asasnya sama dengan lindung nilai merentas tempoh niaga hadapan komoditi. Arbitraj positif, kontrak hadapan pendek dan kontrak jangka pendek yang panjang. Lindung nilai, jangka panjang pada kontrak hadapan dan pendek pada kontrak jangka pendek. Memandangkan prinsip asas sudah jelas, apa yang tinggal ialah bagaimana strategi mencetuskan kedudukan lindung nilai, cara menutup kedudukan dan cara meningkatkan kedudukan. Kaedah kawalan kedudukan dan pemprosesan butiran strategi. Strategi lindung nilai terutamanya tertumpu pada turun naik perbezaan harga aset asas dan melakukan perdagangan regresi pada perbezaan harga. Walau bagaimanapun, penyebaran mungkin turun naik sedikit, atau mendadak, atau dalam satu arah. Ini membawa ketidakpastian dalam melindung nilai keuntungan dan kerugian, tetapi risiko masih jauh lebih rendah daripada trend unilateral. Banyak daripada pelbagai pengoptimuman strategi merentas tempoh memilih untuk bermula dari tahap kawalan kedudukan, bermula dari pencetus pembukaan dan penutupan. Sebagai contoh, penunjuk Bollinger klasik digunakan sebagai titik pembukaan dan penutupan arbitraj positif dan negatif apabila perbezaan harga berubah-ubah. Disebabkan reka bentuk yang munasabah dan gandingan yang rendah, strategi ini juga boleh diubah suai dengan mudah menjadi strategi lindung nilai merentas tempoh penunjuk Bollinger.

• ### Analisis Kod Strategi

#### Melihat kod secara umum, kita boleh menyimpulkan bahawa kod itu terbahagi kepada empat bahagian.

• 1. Takrif nilai pengiraan, tentukan beberapa nilai status, digunakan untuk menandakan status. Sesetengah fungsi fungsian yang tidak berkaitan dengan strategi, seperti fungsi pengekodan URL, fungsi penukaran masa, dsb., tiada kaitan dengan strategi dan hanya digunakan untuk pemprosesan data.
• 2. Kelas penjana data K-line: Strategi didorong oleh data K-line yang dijana oleh objek kelas penjana.
• 3. Kelas lindung nilai: Objek kelas ini boleh melaksanakan logik transaksi tertentu, operasi lindung nilai, mekanisme pemprosesan butiran strategi, dsb.
• 4. Fungsi utama strategi iaitumain fungsi.main Fungsi ini adalah fungsi kemasukan strategi Gelung utama dilaksanakan dalam fungsi ini Selain itu, fungsi ini juga melakukan operasi penting, iaitu, mengakses antara muka websocket pertukaran untuk mendapatkan data pasaran tanda yang ditolak. bahan penjana data K-line.

#### Dengan memahami kod strategi secara keseluruhan, kami kini boleh menganalisis secara beransur-ansur setiap pautan untuk mempelajari sepenuhnya reka bentuk, idea dan teknik strategi.

• Definisi nilai pengiraan, fungsi lain

  1. Jenis penghitunganState kenyataan

  enum State {                    // 枚举类型  定义一些 状态
      STATE_NA,                   // 非正常状态
      STATE_IDLE,                 // 空闲
      STATE_HOLD_LONG,            // 持多仓
      STATE_HOLD_SHORT,           // 持空仓
  };
  

  Oleh kerana beberapa fungsi dalam kod mengembalikan status tertentu, keadaan ini ditakrifkan dalam jenis penghitunganStatetengah. Lihat kod munculSTATE_NA Iaitu, ia adalah keadaan yang tidak normal.STATE_IDLE Ia berada dalam keadaan terbiar, iaitu keadaan di mana operasi lindung nilai boleh dilakukan.STATE_HOLD_LONG Keadaan memegang kedudukan lindung nilai positif.STATE_HOLD_SHORT Keadaan memegang kedudukan lindung nilai.

  1. Penggantian rentetan: Fungsi ini tidak dipanggil dalam strategi ini Ia adalah fungsi alat ganti yang terutamanya memproses rentetan.

  string replace(string s, const string from, const string& to)   
  

  1. Berfungsi untuk menukar kepada aksara heksadesimaltoHex

  inline unsigned char toHex(unsigned char x)
  

  1. Fungsi untuk memproses pengekodan URL

  std::string urlencode(const std::string& str)
  

  1. Fungsi penukaran masa, menukar masa dalam format rentetan ke dalam cap masa.

  uint64_t _Time(string &s)
  

• Kelas penjana data talian K

  class BarFeeder {                                                                       // K线 数据生成器类
      public:
          BarFeeder(int period) : _period(period) {                                       // 构造函数，参数为 period 周期， 初始化列表中初始化
              _rs.Valid = true;                                                           // 构造函数体中初始化 K线数据的 Valid属性。
          }    
  
  
          void feed(double price, Chart *c=nullptr, int chartIdx=0) {                     // 输入数据，nullptr 空指针类型，chartIdx 索引默认参数为 0
              uint64_t epoch = uint64_t(Unix() / _period) * _period * 1000;               // 秒级时间戳祛除不完整时间周期（不完整的_period 秒数），转为 毫秒级时间戳。
              bool newBar = false;                                                        // 标记 新K线Bar 的标记变量
              if (_rs.size() == 0 || _rs[_rs.size()-1].Time < epoch) {                    // 如果 K线数据 长度为 0 。 或者 最后一bar 的时间戳小于 epoch（K线最后一bar 比当前最近的周期时间戳还要靠前）
                  Record r;                                                               // 声明一个 K线bar 结构
                  r.Time = epoch;                                                         // 构造当前周期的K线bar 
                  r.Open = r.High = r.Low = r.Close = price;                              // 初始化 属性
                  _rs.push_back(r);                                                       // K线bar 压入 K线数据结构
                  if (_rs.size() > 2000) {                                                // 如果K线数据结构长度超过 2000 ， 就剔除最早的数据。
                      _rs.erase(_rs.begin());
                  }
                  newBar = true;                                                          // 标记
              } else {                                                                    // 其它情况，不是出现新bar 的情况下的处理。
                  Record &r = _rs[_rs.size() - 1];                                        // 引用 数据中最后一bar 的数据。
                  r.High = max(r.High, price);                                            // 对引用数据的最高价更新操作。
                  r.Low = min(r.Low, price);                                              // 对引用数据的最低价更新操作。
                  r.Close = price;                                                        // 对引用数据的收盘价更新操作。
              }
  
  
              auto bar = _rs[_rs.size()-1];                                               // 取最后一柱数据 ，赋值给 bar 变量
              json point = {bar.Time, bar.Open, bar.High, bar.Low, bar.Close};            // 构造一个 json 类型数据
              if (c != nullptr) {                                                         // 图表对象指针不等于 空指针，执行以下。
                 if (newBar) {                                                            // 根据标记判断，如果出现新Bar 
                      c->add(chartIdx, point);                                            // 调用图表对象成员函数add,向图表对象中插入数据（新增K线bar）
                      c->reset(1000);                                                     // 只保留1000 bar的数据
                  } else {
                      c->add(chartIdx, point, -1);                                        // 否则就更新（不是新bar），这个点（更新这个bar）。
                  } 
              }
          }
          Records & get() {                                                               // 成员函数，获取K线数据的方法。
              return _rs;                                                                 // 返回对象的私有变量 _rs 。（即 生成的K线数据）
          }
      private:
          int _period;
          Records _rs;
  };
  

  Kelas ini bertanggungjawab terutamanya untuk memproses data tanda yang diperoleh kepada garis K perbezaan harga untuk memacu logik lindung nilai strategi. Sesetengah pembaca mungkin tertanya-tanya mengapa kita perlu menggunakan data semak? Mengapa kita perlu membina penjana data K-line sedemikian? Bukankah lebih baik menggunakan data K-line secara langsung? Tiga soalan ini timbul dalam fikiran saya semasa saya menulis beberapa strategi lindung nilai. Saya menemui jawapannya apabila saya menulis strategi lindung nilai Bollinger spread. Kerana data K-line bagi satu kontrak adalah statistik perubahan harga kontrak ini dalam tempoh tertentu. Data K-line bagi perbezaan harga antara dua kontrak ialah statistik perbezaan harga dalam tempoh tertentu Oleh itu, kita tidak boleh mengambil data garis-K bagi kedua-dua kontrak untuk penolakan dan mengira perbezaan setiap data pada setiap satu Nilai Bar K-line, sebagai perbezaan harga. Kesilapan yang paling ketara ialah harga tertinggi dan harga terendah dua kontrak tidak semestinya pada masa yang sama. Oleh itu, nilai yang ditolak tidak masuk akal. Oleh itu, kita perlu menggunakan data tanda masa nyata, mengira perbezaan harga dalam masa nyata dan membuat statistik tentang perubahan harga dalam tempoh tertentu dalam masa nyata (iaitu pembukaan tinggi dan penutupan rendah pada lajur K-line). Dengan cara ini, kami memerlukan penjana data talian K sebagai kelas berasingan untuk memisahkan logik pemprosesan.

• Lindung nilai

  class Hedge {                                                                           // 对冲类，策略主要逻辑。
    public:
      Hedge() {                                                                           // 构造函数
          ...
      };
  
  
      State getState(string &symbolA, Depth &depthA, string &symbolB, Depth &depthB) {        // 获取状态，参数： 合约A名称 、合约A深度数据， 合约B名称、 合约B深度数据
  
  
          ...
      }
      bool Loop(string &symbolA, Depth &depthA, string &symbolB, Depth &depthB, string extra="") {       // 开平仓 策略主要逻辑
  
  
          ...
      }    
  
  
    private:
      vector<double> _addArr;                                     // 对冲加仓列表
      string _state_desc[4] = {"NA", "IDLE", "LONG", "SHORT"};    // 状态值 描述信息
      int _countOpen = 0;                                 // 开仓次数
      int _countCover = 0;                                // 平仓次数
      int _lastCache = 0;                                 // 
      int _hedgeCount = 0;                                // 对冲次数
      int _loopCount = 0;                                 // 循环计数（循环累计次数）
      double _holdPrice = 0;                              // 持仓价格
      BarFeeder _feederA = BarFeeder(DPeriod);            // A合约 行情 K线生成器
      BarFeeder _feederB = BarFeeder(DPeriod);            // B合约 行情 K线生成器
      State _st = STATE_NA;                               // 对冲类型 对象的 对冲持仓状态
      string _cfgStr;                                     // 图表配置 字符串
      double _holdAmount = 0;                             // 持仓量
      bool _isCover = false;                              // 是否平仓 标记
      bool _needCheckOrder = true;                        // 设置是否 检查订单
      Chart _c = Chart("");                               // 图表对象，并初始化
  };
  
  
  

  Memandangkan kod itu agak panjang, sebahagian daripadanya ditinggalkan. Ia terutamanya menunjukkan struktur kelas lindung nilai. Lindung nilai pembina tidak disebut, kerana ia adalah untuk permulaan objek. Terdapat dua fungsi yang tinggal.

  • getState

  Fungsi ini terutamanya mengendalikan pengesanan pesanan, pembatalan pesanan, pengesanan kedudukan, pengimbangan kedudukan, dsb. Kerana dalam proses transaksi lindung nilai, situasi satu kaki (iaitu, satu kontrak didagangkan dan satu lagi tidak) tidak dapat dielakkan Jika ia dikesan dalam logik pesanan dan kemudian pesanan susulan atau penutupan kedudukan diproses , logik strategi akan menjadi huru-hara. Jadi kami mengambil pendekatan lain apabila mereka bentuk bahagian ini. Jika operasi lindung nilai dicetuskan, pesanan dibuat sekali Tidak kira sama ada lindung nilai satu kaki berlaku, lindung nilai dianggap berjaya secara lalai Kemudian baki kedudukan disemak dalam fungsi getState, dan logik untuk menyemak dan memproses baki diasingkan.

  • Loop

  Logik perdagangan strategi terkandung dalam fungsi ini, di mana panggilangetState , gunakan objek penjana data K-line untuk menjana data K-line bagi perbezaan harga, dan membuat pertimbangan tentang logik lindung nilai pembukaan, penutupan dan penambahan kedudukan. Terdapat juga beberapa operasi kemas kini data untuk carta.

• Fungsi utama strategi

  void main() {  
  
  
      ...
  
  
      string realSymbolA = exchange.SetContractType(symbolA)["instrument"];    // 获取设置的A合约（this_week / next_week / quarter ） ，在 OKEX 合约 当周、次周、季度 对应的真实合约ID 。
      string realSymbolB = exchange.SetContractType(symbolB)["instrument"];    // ...
  
  
      string qs = urlencode(json({{"op", "subscribe"}, {"args", {"futures/depth5:" + realSymbolA, "futures/depth5:" + realSymbolB}}}).dump());    // 对 ws 接口的要传的参数进行 json 编码、 url 编码
      Log("try connect to websocket");                                                                                                            // 打印连接 WS接口的信息。
      auto ws = Dial("wss://real.okex.com:10442/ws/v3|compress=gzip_raw&mode=recv&reconnect=true&payload="+qs);     // 调用FMZ API Dial 函数 访问  OKEX 期货的 WS 接口
      Log("connect to websocket success");
  
  
      Depth depthA, depthB;                               // 声明两个 深度数据结构的变量 用于储存A合约和B合约 的深度数据
      auto fillDepth = [](json &data, Depth &d) {         // 用接口返回的json 数据，构造 Depth 数据的代码。
          d.Valid = true;
          d.Asks.clear();
          d.Asks.push_back({atof(string(data["asks"][0][0]).c_str()), atof(string(data["asks"][0][1]).c_str())});
          d.Bids.clear();
          d.Bids.push_back({atof(string(data["bids"][0][0]).c_str()), atof(string(data["bids"][0][1]).c_str())});
      };
      string timeA;   // 时间 字符串 A 
      string timeB;   // 时间 字符串 B 
      while (true) {
          auto buf = ws.read();                           // 读取 WS接口 推送来的数据
  
  
          ...
  
  
  }
  

  Selepas strategi dimulakan, ia mula melaksanakan dari fungsi utama Semasa pemulaan fungsi utama, strategi melanggan pasaran semak antara muka websocket. Tugas utama fungsi utama adalah untuk membina gelung utama, terus menerima maklumat tanda yang ditolak oleh antara muka websoket pertukaran, dan kemudian memanggil fungsi ahli objek kelas lindung nilai: fungsi Gelung. Logik dagangan dalam fungsi Gelung didorong oleh data pasaran. Satu perkara yang perlu dijelaskan ialah pasaran semak yang disebutkan di atas sebenarnya adalah antara muka data kedalaman buku pesanan yang dilanggan, yang memperoleh data buku pesanan setiap peringkat. Walau bagaimanapun, strategi ini hanya menggunakan data dari peringkat pertama, yang sebenarnya serupa dengan data pasaran semak Strategi ini tidak menggunakan data dari peringkat lain, dan tidak juga menggunakan nilai volum pesanan dari peringkat pertama. Mari kita lihat dengan lebih dekat cara strategi melanggan data antara muka websocket dan cara ia ditetapkan.

  string qs = urlencode(json({{"op", "subscribe"}, {"args", {"futures/depth5:" + realSymbolA, "futures/depth5:" + realSymbolB}}}).dump());    
  Log("try connect to websocket");                                                                                                            
  auto ws = Dial("wss://real.okex.com:10442/ws/v3|compress=gzip_raw&mode=recv&reconnect=true&payload="+qs);     
  Log("connect to websocket success");
  

  Pertama, anda perlu mengekod URL mesej langganan parameter json yang dihantar oleh antara muka langganan, iaitu,payload Nilai parameter. Kemudian langkah yang lebih penting ialah memanggil fungsi antara muka API Platform Dagangan Kuantitatif PenciptaDial fungsi.Dial Fungsi boleh digunakan untuk mengakses antara muka websocket pertukaran. Kami membuat beberapa tetapan di sini untuk membolehkan objek kawalan sambungan soket ws dicipta untuk menyambung semula secara automatik selepas diputuskan sambungan (mesej langganan masih menggunakan rentetan nilai qs parameter muatan Untuk mencapai fungsi ini, anda perlu).Dial Tambahkan pilihan konfigurasi pada rentetan parameter fungsi.

  DialParameter fungsi bermula seperti berikut:

  wss://real.okex.com:10442/ws/v3
  

  Adakah alamat antara muka websocket yang perlu diakses, dan kemudian digunakan| Perpisahan. compress=gzip_raw&mode=recv&reconnect=true&payload="+qs Ini semua adalah parameter konfigurasi.

  Nama parameter	Penerangan
  compress	compress ialah kaedah mampatan Antara muka websoket OKEX menggunakan gzip_raw, jadi ia ditetapkan kepada gzip_raw
  mod	mod ialah mod dan pilihannya adalah dwi, ​​hantar dan recv. dwi bermaksud dua arah, menghantar data mampat dan menerima data mampat. hantar adalah untuk menghantar data termampat. recv menerima data yang dimampatkan dan menyahmampatnya secara setempat.
  reconnect	reconnect ialah sama ada untuk menetapkan penyambungan semula=true membolehkan penyambungan semula Jika ia tidak ditetapkan, penyambungan semula dilumpuhkan secara lalai.
  payload	Payload ialah mesej langganan yang perlu dihantar apabila ws menyambung semula.

  Selepas tetapan ini, walaupun sambungan soket web diputuskan, sistem asas penjaga Platform Dagangan Kuantitatif Pencipta akan menyambung semula secara automatik dan mendapatkan data pasaran terkini tepat pada masanya. Rebut setiap turun naik perbezaan harga dan cepat tangkap pasaran lindung nilai yang sesuai.

• Kawalan Kedudukan

Kawalan kedudukan menggunakan nisbah kedudukan lindung nilai yang serupa dengan siri “Porfinacci” untuk dikawal.

  for (int i = 0; i < AddMax + 1; i++) {                                          // 构造 控制加仓数量的数据结构，类似 波菲纳契数列 对冲数量 比例。
      if (_addArr.size() < 2) {                                                   // 前两次加仓量变化为： 加一倍对冲数量 递增
          _addArr.push_back((i+1)*OpenAmount);
      }
      _addArr.push_back(_addArr[_addArr.size()-1] + _addArr[_addArr.size()-2]);   // 最后 两个加仓数量相加，算出当前的加仓数量储存到 _addArr数据结构中。
  }

Dapat dilihat bahawa bilangan jawatan yang ditambah setiap kali adalah jumlah dua jawatan terkini. Kawalan kedudukan sedemikian boleh mencapai bahawa semakin besar perbezaan harga, semakin besar jumlah lindung nilai arbitraj, dan kedudukan boleh tersebar, supaya dapat memahami turun naik perbezaan harga yang kecil dengan kedudukan yang kecil, dan meningkatkan kedudukan dengan sewajarnya dengan perbezaan harga yang besar turun naik.

• ### Menutup kedudukan: Hentikan kerugian, ambil untung

Spread take profit tetap, spread stop loss. Apabila perbezaan harga kedudukan mencapai kedudukan ambil untung atau kedudukan henti rugi, ambil untung atau henti rugi akan dilaksanakan.

• ### Memasuki dan keluar dari reka bentuk kitaran pasaran

Tempoh yang dikawal oleh parameter NPeriod menyediakan tahap kawalan dinamik tertentu ke atas pembukaan dan penutupan kedudukan strategi.

• ### Carta Strategi

Strategi ini secara automatik menjana carta candlestick perbezaan harga dan menandakan maklumat transaksi yang berkaitan.

Operasi lukisan carta tersuai strategi C++ juga sangat mudah Anda boleh melihat bahawa dalam pembina kelas lindung nilai, kami menggunakan rentetan konfigurasi carta bertulis _cfgStr untuk mengkonfigurasi objek carta _c._c ialah kelas lindung nilai Apabila ahli persendirian dimulakan, fungsi antara muka API carta tersuai kuantitatif pencipta dipanggil.Chart Objek carta yang dibina oleh fungsi.

  _cfgStr = R"EOF(
  [{
  "extension": { "layout": "single", "col": 6, "height": "500px"},
  "rangeSelector": {"enabled": false},
  "tooltip": {"xDateFormat": "%Y-%m-%d %H:%M:%S, %A"},
  "plotOptions": {"candlestick": {"color": "#d75442", "upColor": "#6ba583"}},
  "chart":{"type":"line"},
  "title":{"text":"Spread Long"},
  "xAxis":{"title":{"text":"Date"}},
  "series":[
      {"type":"candlestick", "name":"Long Spread","data":[], "id":"dataseriesA"},
      {"type":"flags","data":[], "onSeries": "dataseriesA"}
      ]
  },
  {
  "extension": { "layout": "single", "col": 6, "height": "500px"},
  "rangeSelector": {"enabled": false},
  "tooltip": {"xDateFormat": "%Y-%m-%d %H:%M:%S, %A"},
  "plotOptions": {"candlestick": {"color": "#d75442", "upColor": "#6ba583"}},
  "chart":{"type":"line"},
  "title":{"text":"Spread Short"},
  "xAxis":{"title":{"text":"Date"}},
  "series":[
      {"type":"candlestick", "name":"Long Spread","data":[], "id":"dataseriesA"},
      {"type":"flags","data":[], "onSeries": "dataseriesA"}
      ]
  }
  ]
  )EOF";
  _c.update(_cfgStr);                 // 用图表配置 更新图表对象
  _c.reset();                         // 重置图表数据。

• Panggil_c.update(_cfgStr); guna_cfgStr Konfigurasi kepada objek carta.
• Panggil_c.reset(); Tetapkan semula data carta.

Apabila kod strategi perlu memasukkan data ke dalam carta, ia juga dipanggil terus_c fungsi ahli objek, atau_Rujukan c diluluskan sebagai parameter, dan kemudian fungsi ahli objek (kaedah) _c dipanggil untuk melaksanakan kemas kini data carta dan operasi sisipan. Contohnya:

  _c.add(chartIdx, {{"x", UnixNano()/1000000}, {"title", action},  {"text", format("diff: %f", opPrice)}, {"color", color}});

Selepas membuat pesanan, tandakannya pada carta candlestick.

Seperti yang ditunjukkan di bawah, lukisan garisan K dilakukan dengan memanggil fungsi ahli kelas BarFeederfeed Apabila objek carta_Rujukan kepada c diluluskan sebagai parameter .

  void feed(double price, Chart *c=nullptr, int chartIdx=0)

Sekarang nifeedParameter fungsi c .

  json point = {bar.Time, bar.Open, bar.High, bar.Low, bar.Close};            // 构造一个 json 类型数据
  if (c != nullptr) {                                                         // 图表对象指针不等于 空指针，执行以下。
     if (newBar) {                                                            // 根据标记判断，如果出现新Bar 
          c->add(chartIdx, point);                                            // 调用图表对象成员函数add,向图表对象中插入数据（新增K线bar）
          c->reset(1000);                                                     // 只保留1000 bar个数据
      } else {
          c->add(chartIdx, point, -1);                                        // 否则就更新（不是新bar），这个点（更新这个bar）。
      } 
  }

Dengan memanggil objek carta_caddFungsi ahli, memasukkan data Bar K-line baharu ke dalam carta. Kod:c->add(chartIdx, point);

• ### Ujian belakang

Strategi ini hanya untuk pembelajaran dan komunikasi Apabila menggunakannya dalam perdagangan sebenar, sila ubah suai dan optimumkannya mengikut situasi sebenar perdagangan.

Alamat strategi: https://www.fmz.com/strategy/163447

Lebih banyak strategi menarik boleh didapati di “Platform Dagangan Kuantitatif Pencipta”: https://www.fmz.com