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

Видимо вы редко кодите на 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);
        }
};