Локальные и глобальные переменные в советнике

Полный разбор области видимости переменных в MQL5 для начинающего разработчикаКогда торговый советник растёт, всё чаще возникает один и тот же вопрос: где объявить переменную, чтобы она вела себя предсказуемо? Ответ зависит от области видимости (scope) — то есть от того, из какого места программы переменную можно видеть и как долго она существует. Понимание этого механизма отделяет аккуратный, надёжный робот от кода, который «иногда работает, а иногда нет». В этой статье мы подробно разберём локальные и глобальные переменные программы, особенность функции OnTick, отличие от глобальных переменных терминала и типичные ошибки, которые встречаются у новичков.

Что такое область видимости переменнойОбласть видимости определяет, в каких местах кода доступна переменная. В MQL5, как и в языке C, действует правило блочной видимости: переменная видна внутри того блока, где она объявлена, и во всех вложенных блоках. Блок — это код, заключённый в фигурные скобки: тело функции, ветка условия, тело цикла.

Из этого правила следуют два следствия. Первое: переменная, объявленная внутри функции, недоступна за её пределами — компилятор просто не знает о ней в другом месте. Второе: две переменные с одинаковым именем в разных блоках никак не связаны между собой. Область видимости — это не про тип данных и не про значение, а именно про то, где имя переменной «действует».

Глобальные переменные программыГлобальные переменные программы объявляются вне функций — обычно в самом начале файла советника. Их видит любая функция, а существуют они всё время, пока советник загружен в память терминала. Именно поэтому здесь удобно хранить настройки, счётчики и состояние робота.

// =============================================================================================== //// = Глобальные переменные программы: доступны всем функциям советника = //// =============================================================================================== //int g_openedTrades = 0; // счётчик открытых роботом сделокdouble g_lastTradePrice = 0.0; // цена последней сделкиbool g_enteredThisBar = false; // флаг входа в текущем баре

// === Функция увеличивает счётчик сделок ===void RegisterTrade(double price) { g_openedTrades++; g_lastTradePrice = price; Print("Сделок открыто: ", g_openedTrades, ", цена: ", g_lastTradePrice); }

Здесь переменные g_openedTrades, g_lastTradePrice и g_enteredThisBar объявлены вне функций, поэтому любые изменения, сделанные внутри RegisterTrade, сохраняются и видны другим функциям. Префикс g_ — популярное соглашение об именовании, которое сразу подсказывает, что переменная глобальная.

Локальные переменныеЛокальные переменные объявляются внутри функции или блока. Они создаются в момент входа в блок и уничтожаются при выходе из него. Вне этого блока к ним обратиться нельзя.

// =============================================================================================== //// = Локальные переменные живут только во время выполнения функции = //// =============================================================================================== //double CalcRiskMoney(double percent) { double balance = AccountInfoDouble(ACCOUNT_BALANCE); // локальная double riskMoney = balance * percent / 100.0; // локальная

// === Возвращаем результат, локальные переменные прекращают существование === return riskMoney; }

Переменные balance и riskMoney существуют только внутри CalcRiskMoney. Это хорошо: они не засоряют пространство имён и не могут быть случайно изменены из другого места программы. Обратная сторона — их значение нигде не сохраняется.

Почему в OnTick нельзя обойтись локальными переменнымиГлавная особенность советника — в том, как работает функция OnTick. Она вызывается терминалом заново на каждом новом тике. Каждый такой вызов — отдельный проход: вошли в функцию, выполнили код, вышли. Значит, обычная локальная переменная внутри OnTick при каждом вызове создаётся заново.

Посмотрите на типичную ошибку новичка:

// === НЕПРАВИЛЬНО: счётчик всегда покажет 1 ===void OnTick() { int counter = 0; // создаётся заново на каждом тике counter++; Print(counter); // всегда 1 }

Значение counter сбрасывается на каждом тике, поэтому счётчик бесполезен. Счётчики открытых сделок, флаг «уже входили в этом баре», время последней сделки — всё это относится к состоянию робота, которое должно пережить вызов функции. Хранить такое состояние в обычной локальной переменной нельзя: на следующем тике оно обнулится.

Как сохранить состояние: static-переменныеПервое решение — ключевое слово static. Статическая переменная объявляется внутри функции, но, в отличие от обычной локальной, создаётся один раз и сохраняет значение между вызовами. При этом снаружи функции её по-прежнему не видно.

// =============================================================================================== //// = static-переменная помнит значение между вызовами OnTick = //// =============================================================================================== //bool IsNewBar() { static datetime lastBar = 0; datetime currentBar = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);

// === Первый вызов: запоминаем бар === if (lastBar == 0) { lastBar = currentBar; return false; }

// === Бар изменился — значит, новый === if (currentBar != lastBar) { lastBar = currentBar; return true; }

return false; }

Здесь lastBar — статическая переменная. Она сохраняет время последнего бара между вызовами, и именно поэтому функция может определить появление новой свечи. Если бы lastBar была обычной локальной переменной, она каждый раз обнулялась бы и сравнение теряло смысл.

Поля класса как альтернативаВторое решение — хранить состояние в полях класса. Когда советник оформлен как класс, его поля существуют вместе с объектом и доступны всем методам. Это более структурированный подход, чем разрозненные глобальные переменные.

// =============================================================================================== //// = Класс хранит состояние робота в своих полях = //// =============================================================================================== //class CTradeState {private: int m_trades; // число открытых сделок datetime m_lastTrade; // время последней сделки bool m_enteredBar; // входили ли в текущем баре

public: CTradeState() { m_trades = 0; m_lastTrade = 0; m_enteredBar = false; }

// === Метод обновляет состояние при открытии сделки === void OnTradeOpened() { m_trades++; m_lastTrade = TimeCurrent(); m_enteredBar = true; } };

Поля класса m_trades, m_lastTrade и m_enteredBar живут столько, сколько живёт объект класса. Такой код проще читать: видно, какие данные относятся к состоянию робота, а какие — временные.

Глобальные переменные терминала — это другой механизмОтдельно существуют глобальные переменные терминала. Несмотря на похожее название, это совершенно другой инструмент. Они хранятся не в памяти советника, а в самом терминале MetaTrader, доступны разным программам и переживают перезапуск. Для работы с ними есть отдельные функции: GlobalVariableSet, GlobalVariableGet, GlobalVariableCheck, GlobalVariableDel.

// =============================================================================================== //// = Глобальные переменные терминала: хранятся в терминале и переживают перезапуск = //// =============================================================================================== //void SaveState() { GlobalVariableSet("MyEA_Trades", 5); // записать значение }

// === Чтение значения с проверкой существования ===int ReadTrades() { if (GlobalVariableCheck("MyEA_Trades")) return (int)GlobalVariableGet("MyEA_Trades"); return 0; }

// === Удаление переменной терминала ===void ClearState() { GlobalVariableDel("MyEA_Trades"); }

Важно не путать эти два уровня. Глобальная переменная программы (g_openedTrades) существует только пока советник загружен, и её не видит никакая другая программа. Глобальная переменная терминала (MyEA_Trades) живёт в терминале, её видит любой советник и скрипт, и она сохраняется после перезапуска. Первые — для состояния внутри одного робота, вторые — для обмена данными и долговременного хранения.

Инициализация переменныхГлобальные переменные программы инициализируются один раз — в момент загрузки советника, ещё до первого вызова OnTick. Если при объявлении не задать значение, целочисленные переменные получат ноль, вещественные — тоже ноль, а строки останутся пустыми. Но полагаться на это не стоит: начальные значения лучше присваивать явно, чтобы намерение было очевидным.

Чего делать нельзя, так это инициализировать глобальную переменную значением, которое зависит от рыночных данных, прямо в строке объявления. Записать в глобальную переменную текущую цену инструмента при объявлении не получится надёжно: на момент запуска торговые данные могут быть ещё не готовы. Для таких значений служит функция OnInit — она вызывается при инициализации советника, в том числе после смены настроек и таймфрейма.

// =============================================================================================== //// = Инициализация глобального состояния в OnInit, а не при каждом тике = //// =============================================================================================== //datetime g_sessionStart = 0;double g_startPrice = 0.0;

// === OnInit вызывается один раз при загрузке советника ===int OnInit() { g_sessionStart = TimeCurrent(); g_startPrice = SymbolInfoDouble(_Symbol, SYMBOL_BID); Print("Старт сессии: ", g_sessionStart, ", цена: ", g_startPrice); return INIT_SUCCEEDED; }

Такой подход гарантирует, что начальные значения вычисляются один раз и корректно, а не заново на каждом тике.

Префиксы и правила именованияАккуратные префиксы почти полностью снимают риск перекрытия имён. Договоритесь с собой о простых правилах: глобальные переменные программы начинайте с g_, поля класса — с m_, а параметры функций и локальные переменные оставляйте без префикса. Тогда даже в большом проекте по одному имени видно, где и как долго живёт переменная.

Полезно отражать в имени смысл, а не тип. Переменная g_tradesOpened читается лучше, чем g_count, а m_lastTradeTime понятнее, чем m_time. Компилятор не подскажет, что g_count считает именно сделки, — а вам через полгода это может понадобиться.

И наоборот, никогда не давайте двум сущностям одно имя. Именно так и рождается эффект перекрытия: локальная переменная с именем глобальной молча скрывает её внутри функции, и вы меняете не то, что думали.

Типичные ошибки при работе с переменнымиПерекрытие имён (shadowing)Если локальная переменная названа так же, как глобальная, локальная «затеняет» глобальную внутри своей функции. Это классическая ловушка.

// === ОПАСНО: локальная переменная перекрывает глобальную ===int g_count = 100;

void Shadow() { int g_count = 0; // эта переменная перекрывает глобальную g_count++; // изменяется только локальная копия, глобальная остаётся 100 }

Чтобы избежать путаницы, придерживайтесь префиксов g_ для глобальных и m_ для полей класса, а локальным переменным давайте говорящие имена.

Случайное обнуление состоянияСамая частая ошибка — держать состояние робота в обычной локальной переменной внутри OnTick. Значение сбрасывается на каждом тике, и робот ведёт себя непредсказуемо. Всегда проверяйте: должна ли эта переменная помнить, что было на предыдущем тике? Если да — она обязана быть глобальной, статической или полем класса.

Конфликты при перезапускеЕсли хранить состояние в глобальных переменных программы, при перезапуске советника они сбрасываются. Если робот уже имел открытые позиции, его «внутренняя память» о них пропадёт. В таких случаях состояние лучше восстанавливать по фактическим позициям терминала или хранить в глобальных переменных терминала. При этом помните про конфликты: два экземпляра советника с одинаковыми именами глобальных переменных терминала будут мешать друг другу.

Глобальные переменные там, где нужны поля классаРазрозненные глобальные переменные удобны в маленьком советнике, но плохо масштабируются. Когда их становится десятки, отследить, кто и когда их изменяет, очень трудно. Если состояние логически связано с объектом стратегии, его стоит держать в полях класса, давая осмысленные имена.

Практические примерыСчётчик открытых сделокРоботу часто нужно ограничить число одновременных позиций. Надёжнее не хранить счётчик в памяти, а восстанавливать его из фактического состояния терминала.

// =============================================================================================== //// = Считаем число позиций робота по Magic Number = //// =============================================================================================== //int CountOwnPositions(long magic) { int count = 0;

// === Перебираем позиции терминала === for (int i = 0; i < PositionsTotal(); i++) { if (PositionGetTicket(i) == 0) continue; if (PositionGetInteger(POSITION_MAGIC) == magic) count++; }

return count; }

Такой счётчик не теряет данные при перезапуске, потому что каждый раз берётся из реальных позиций, а не из переменной в памяти.

Флаг «уже входили в этом баре»Часто нужно входить не более одного раза за свечу. Флаг должен сбрасываться при появлении нового бара и сохраняться между тиками, поэтому его держат глобально.

// === Глобальный флаг входа в текущем баре ===bool g_enteredThisBar = false;

void OnTick() { static datetime lastBar = 0; datetime currentBar = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);

// === Новый бар — сбрасываем флаг === if (currentBar != lastBar) { lastBar = currentBar; g_enteredThisBar = false; }

// === Вход только один раз за бар === if (!g_enteredThisBar) { // === ... здесь логика входа === g_enteredThisBar = true; } }

Время последней сделкиЕщё одно частое состояние — время последней сделки. Оно позволяет выдерживать паузу между входами.

// === Хранение времени последней сделки между тиками ===datetime g_lastTradeTime = 0;

// =============================================================================================== //// = Проверяем, прошёл ли заданный интервал с момента последней сделки = //// =============================================================================================== //bool CanTrade(int minSeconds) { return (TimeCurrent() - g_lastTradeTime >= minSeconds); }

Переменная g_lastTradeTime объявлена глобально, поэтому значение не теряется между тиками. После открытия очередной сделки достаточно присвоить ей TimeCurrent().

Что выбрать: глобальные переменные, поля класса или staticНебольшой советник вполне обходится глобальными переменными программы — это просто и наглядно. Когда логика усложняется, состояние стоит переносить в поля класса: так данные сгруппированы и защищены от случайных изменений. Статические переменные идеальны для небольших локальных «памятей» внутри одной функции, например для времени последнего бара. А для обмена данными между программами и хранения, не зависящего от жизненного цикла советника, используйте глобальные переменные терминала.

ЗаключениеОбласть видимости — это фундамент, на котором держится надёжность советника. Глобальные переменные программы видны всем функциям и живут, пока робот загружен. Локальные существуют только во время выполнения блока. Из-за того, что OnTick вызывается на каждом тике заново, состояние — счётчики, флаги, время — нельзя держать в обычных локальных переменных; для этого подходят глобальные переменные, статические переменные и поля класса. А глобальные переменные терминала — отдельный механизм для межпрограммного обмена и долговременного хранения.

Разберитесь с этими понятиями один раз, и вы перестанете удивляться «магическому» поведению робота: код станет предсказуемым, а ошибки с обнулением состояния исчезнут. Больше учебных материалов — на https://max.ru/channel_mqlmasters, а короткие практические разборы выходят в Телеграме: https://t.me/mqlmasters.

#MQL5 #переменные #программирование #MetaTrader5 #MQLMaster