Программистский юмор... / перенос кода Mql в C++ / С++

Новый комментарий
 

Этот код скомпилируется в Mql4 ;-)
Раз компилятор не ловит- будьте бдительны )

-- этот пост с юмором- касательно С++ см. 3й пост.

                        if(wantBuy)
                        {
                                // промежуточный минимум
                                double dInterMin = 0;
                                int whereInterMin = 0;

                                double dDummyMax = 0;
                                int whereDummyMax = 0;

                                findMinMax( startBar, whereMax,
                                        dDummyMax, dInterMin, 
                                        whereDummyMax, whereInterMin);

                                // подменяем минимум 
                                // промежуточным минимумом
                                dMin = dInterMin;
                                whereMin = whereInterMin;
                        }

                        if(wantSell)
                        {
                                // промежуточный максимум
                                double dInterMax = 0;
                                int whereInterMax = 0;

                                double dDummyMin = 0;
                                int whereDummyMin = 0;

                                // здесь случился Copy-Paste
                                findMinMax( startBar, whereMin, 
                                        dInterMax, dDummyMin, 
                                        whereInterMin , whereDummyMin);

                                // подменяем максимум 
                                // промежуточным максимумом
                                dMax = dInterMax;

                                // использование переменной = 0...
                                whereMax = whereInterMax;
                        }
 

Видимо вы редко кодите на MQL4 :) Здесь к такому давно уже все привыкли, я думаю. Аналогично можно объявить переменную внутри цикла, и она будет видна за пределами этого цикла, в отличие от С/С++.

 

Конкретно эта тема родилась потому, что я сейчас этот индикатор перенёс в С++.
Поэтому эта ошибка и нашлась. А так все работает ))

Кстати, кому интересно- вот пример оболочки для кода Mql.
Могут быть неточности, но идея доступна.

В коде ф-ций будут доступны Open[], Close[], etc., Buffer1[], Buffer2[].

class CIndicator
{
public:
        const std::vector<RateInfo> & m_rates;
        const int    Parameter;

        std::vector<int> m_Buffer1;
        std::vector<int> m_Buffer2;

        CIndicator(
                        const std::vector<RateInfo> & rates,
                        const bool   in_OrderBehaviour,
                        const int    inParameter
                        )
                        :
                        m_rates(rates),
                        Bars(rates.size()),

                        Parameter(inParameter),
                        
                        Open(this), High(this), Low(this), Close(this),
                        Buffer1(this), Buffer2(this)
        {
        }

        // этот метод вызывать для рассчетов
        void doIt()
        {
                m_Buffer1.resize(m_rates.size());
                m_Buffer2.resize(m_rates.size());

                start();
        }

        std::vector<int> & getBuffer1()
        {
                return m_Buffer1;
        }

        std::vector<int> & getBuffer2()
        {
                return m_Buffer2;
        }

        // ----------------------------------------------------------
        // сращиваем с Mql

        const int Bars;

        class CLow {
        public:
                CIndicator & m;
                CLow(CIndicator * i) : m(*i) {
                }
                const double & operator [](int bar) {
                        int index = (m.Bars-1) - bar;
                        return m.m_rates.at(index).low;
                }
        } Low;

        class CHigh {
        public:
                CIndicator & m;
                CHigh(CIndicator * i) : m(*i) {
                }
                const double & operator [](int bar) {
                        int index = (m.Bars-1) - bar;
                        return m.m_rates.at(index).high;
                }
        } High;

        class CClose {
        public:
                CIndicator & m;
                CClose(CIndicator * i) : m(*i) {
                }
                const double & operator [](int bar) {
                        int index = (m.Bars-1) - bar;
                        return m.m_rates.at(index).close;
                }
        } Close;

        class COpen {
        public:
                CIndicator & m;
                COpen(CIndicator * i) : m(*i) {
                }
                const double & operator [](int bar) {
                        int index = (m.Bars-1) - bar;
                        return m.m_rates.at(index).open;
                }
        } Open;

        class CBuffer1 {
        public:
                CIndicator & m;
                CBuffer1(CIndicator * i) : m(*i) {
                }
                int & operator [](int bar) {
                        int index = (m.Bars-1) - bar;
                        return m.m_Buffer1.at(index);
                }
        } Buffer1;

        class CBuffer2 {
        public:
                CIndicator & m;
                CBuffer2(CIndicator * i) : m(*i) {
                }
                int & operator [](int bar) {
                        int index = (m.Bars-1) - bar;
                        return m.m_Buffer2.at(index);
                }
        } Buffer2;

        // ----------------------------------------------------------
        // Mql -->

        int start()
        {
                // code

                return(0);
        }
};
Новый комментарий