dlang
/
dlang-book
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
dlang-book/03-инструкция/README.md

30 KiB
Raw Blame History

3. Инструкции

Эта глава содержит обязательные определения всех инструкций языка D. D наследует внешний вид и функциональность языков семейства C – в нем есть привычные инструкции if, while, for и другие. Наряду с этим D предлагает ряд новых интересных инструкций и некоторое усовершенствование старых. Если неизбежное перечисление с подробным описанием каждой инструкции заранее нагоняет на вас скуку, то вот вам несколько «отступлений» – любопытных отличий D от других языков.

Если вы желаете во время компиляции проверять какие-то условия, то вас, скорее всего, заинтересует инструкция static if (см. раздел 3.4). Ее возможности гораздо шире, чем просто настройка набора флагов; тем, кто каким-либо образом использует обобщенный код, static if принесет ощутимую пользу. Инструкция switch (см. раздел 3.5) выглядит и действует в основном так же, как и ее тезка из языка C, но оперирует также строками, позволяя одновременно сопоставлять целые диапазоны. Для корректной обработки небольших конечных множеств значений пригодится инструкция final switch (см. разд. 3.6), которая работает с перечисляемыми типами и заставит вас реализовать обработчик абсолютно для каждого возможного значения. Инструкция foreach (см. разделы 3.7.4 и 3.7.5) помогает организовывать последовательные итерации; классическая инструкция for предоставляет больше возможностей, но и более многословна. Инструкция mixin (см. раздел 3.12) вставляет заранее определенный шаблонный код. Инструкция scope (см. раздел 3.13) значительно облегчает написание корректного безотказного кода с правильной обработкой ошибок, заменяя сумбурную конструкцию try/catch/finally, которой иначе вам пришлось бы воспользоваться.

В начало ⮍

3.1. Инструкция-выражение

Как уже говорилось (см. раздел 1.2), достаточно в конце выражения поставить точку с запятой, чтобы получить инструкцию:

a = b + c;
transmogrify(a + b);

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

1 + 1 == 2; // Абсолютная истина

то компилятор диагностирует ошибку.

В начало ⮍ Наверх ⮍

3.2. Составная инструкция

Составная инструкция – это (возможно, пустая) последовательность инструкций, заключенных в фигурные скобки. Инструкции исполняются по порядку. Скобки ограничивают лексический контекст (пространство имен): идентификаторы, определенные внутри такого блока, не видны за его пределами.

Идентификатор, определенный внутри данного пространства имен, перекрывает одноименный идентификатор, определенный вне этого пространства:

uint widgetCount;
...
void main()
{
    writeln(widgetCount); // Выводит значение глобальной переменной
    auto widgetCount = getWidgetCount();
    writeln(widgetCount); // Выводит значение локальной переменной
}

При первом вызове функции writeln будет напечатано значение глобальной переменной widgetCount, при втором происходит обращение к локальной переменной widgetCount. Для доступа к глобальному идентификатору после того, как был определен перекрывающий его локальный идентификатор, служит точка, поставленная перед идентификатором (как уже говорилось в разделе 2.2.1), например writeln(.widgetCount). Тем не менее запрещается определять идентификатор, если он перекрывает идентификатор, определенный в блоке верхнего уровня:

void main()
{
    auto widgetCount = getWidgetCount();
    // Откроем вложенный блок
    {
        auto widgetCount = getWidgetCount(); // Ошибка!
    }
}

Если идентификаторы не перекрываются, то один и тот же идентификатор можно использовать внутри разных составных инструкций:

void main()
{
    {
        auto i = 0;
        ...
    }
    {
        auto i = "eye"; // Без проблем
    ...
    }
    double i = 3.14; // Тоже без проблем
}

Такой подход объясняется просто. Возможность перекрывать глобальные идентификаторы необходима, чтобы писать качественный модульный код, который собирается из нескольких отдельно скомпилированных частей; вы же не хотите, чтобы добавленная в локальное пространство имен глобальная переменная внезапно спутала все карты, запретив компиляцию невинных локальных переменных. С другой стороны, перекрытие локальных идентификаторов бесполезно с точки зрения модульности (поскольку в D составная инструкция никогда не простирается на несколько модулей) и обычно указывает либо на недосмотр (который вот-вот превратится в ошибку), либо на злокачественную функцию, вышедшую из-под контроля.

В начало ⮍ Наверх ⮍

3.3. Инструкция if

Во многих примерах уже встречалась условная инструкция D if, которая очень похожа на то, чего вы могли от нее ожидать:

if (‹выражение›) ‹инструкция1›

или

if (‹выражение›) ‹инструкция1› else ‹инструкция2›

Достойна внимания одна деталь относительно инструкций, которыми управляет if. В отличие от других языков, в D нет «пустой инструкции», то есть отдельно точка с запятой сама по себе не является инструкцией и порождает ошибку. Это правило автоматически ограждает программистов от ошибок вроде следующей:

if (a == b);
    writeln("a и b равны");

В коротком коде подобная глупость очевидна, и вы легко ее устраните, но все меняется, когда выражение длиннее, сама инструкция затерялась в дебрях кода, а на часах полвторого ночи. Если вы действительно хотите применить if к пустой инструкции, то можете использовать наиболее близкий аналог – пустую составную инструкцию:

if (a == b) {}

Это очень полезно, когда вы переделываете код, то и дело заключая фрагменты кода в комментарии и возвращая их обратно.

Часть условной инструкции с ключевым словом else всегда привязана к ближайшей части с ключевым словом if, так что отступы в следующем коде сделаны верно:

if (a == b)
    if (b == c)
        writeln("Все равны");
    else
        writeln("a не равно b. Но так ли это?");

Вторая функция writeln вызывается, когда a == b и b != c, потому что часть else привязана к внутреннему (второму) условию if. Если вы, напротив, хотите связать else с первым if, «буферизуйте» второе выражение с if с помощью пары фигурных скобок:

if ( a == b )
{
    if ( b == с )
        writeln("Все одинаковое");
}
else
    writeln("a отличается от b. Или это не так?");

Каскадные множественные конструкции if-else задаются в проверенном временем стиле C:

auto opt = getOption();
if (opt == "help")
{
    ...
}
else if (opt == "quiet")
{
    ...
}
else if (opt == "verbose")
{
    ...
}
else
{
    stderr.writefln("Неизвестная опция '%s'", opt);
}

В начало ⮍ Наверх ⮍

3.4. Инструкция static if

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

Если вы хотите «закомментировать» (или оставить) какие-то инструкции в зависимости от проверяемого во время компиляции логического условия, то вам пригодится инструкция static if1. Например2:

enum size_t
    g_maxDataSize = 100_000_000,
    g_maxMemory = 1_000_000_000;
...
double transmogrify(double x)
{
    static if (g_maxMemory / 4 > g_maxDataSize)
    {
        alias double Numeric;
    }
    else
    {
        alias float Numeric;
    }
    Numeric[] y;
    ... // Сложные вычисления
    return y[0];
}

Инструкция static if позволяет осуществлять выбор во время компиляции и очень похожа на директиву #if языка C. Встречая static if, компилятор вычисляет условие. Если оно ненулевое, компилируется соответствующий код; иначе компилируется код, соответствующий выражению else (если таковое присутствует). В рассмотренном примере static if используется для переключения между экономичным (в отношении памяти) режимом работы (благодаря применению типа float, занимающего меньше места) и более точным режимом (благодаря применению более точного типа double). В обобщенном коде можно встретить и более мощные и выразительные примеры использования инструкции static if.

Выражение, проверяемое в static if, – это любое логическое выражение, которое можно вычислить во время компиляции. К разрешенным выражениям относится большое подмножество выражений языка, включая арифметические операции со значениями любых числовых типов, манипуляции с массивами, выражения is с типами в качестве аргументов (см. раздел 2.3.4.3) и даже вызовы функций (вычисление функций во время компиляции – действительно выдающееся средство). Вычисления во время компиляции подробно описаны в главе 5.

Срезание скобок

В примере с функцией transmogrify хорошо заметна одна странная особенность, а именно: тип Numeric определен внутри пары скобок { и }. Из-за этого он должен быть виден только локально, внутри пространства имен, созданного при помощи этих скобок (и, следовательно, недоступен внутри включающей этот блок функции), что подрывает наш план на корню. Такое поведение также показало бы, насколько практически бесполезна многообещающая инструкция static if. Поэтому static if использует скобки для группирования, а не для управления пространствами имен. Там, где в фокус внимания попадают пространства имен и области видимости, static if срезает внешние скобки, если они есть (их необязательно ставить, если с помощью условной инструкции контролируется только одна инструкция; в нашем примере выше они используются только для того, чтобы не нарушить обязательство насчет стиля). Если вы действительно хотите поставить скобки (в их традиционном значении), просто добавьте еще одну пару:

import std.stdio;

void main()
{
    static if (real.sizeof > double.sizeof)
    {{
        auto maximorum = real.max;
        writefln("Действительно большие числа - до %s!", maximorum);
    }}
    ... /* maximorum здесь не виден */ ...
}

Не только инструкция

Эта глава называется «Инструкции», а раздел – «Инструкция static if». Поэтому вы вправе немного удивиться, узнав, что static if – это не только инструкция, но и объявление (declaration). О «неинструкционности» static if свидетельствует не только срезание скобок, но и то, что static if может располагаться везде, где может быть расположено объявление, в том числе на недоступных инструкциям уровнях модулей, структур и классов. Например, мы можем определить Numeric глобально, просто вынеся соответствующий код за пределы функции transmogrify:

enum size_t
    g_maxDataSize = 100_000_000,
    g_maxMemory = 1_000_000_000;
...
// Объявление Numeric будет видно в контексте модуля
static if (g_maxMemory / 4 > g_maxDataSize)
{
    alias double Numeric;
}
else
{
    alias float Numeric;
}

double transmogrify(double x)
{
    Numeric[] y;
    ... // Сложные вычисления
    return y[0];
}

На два вида if – один else

У static if нет пары в виде static else. Вместо этого просто используется обычное ключевое слово else. В соответствии с логикой else привязывается к ближайшему if независимо от того, static if это или просто if:

if (a)
    static if (b) writeln("a и b ненулевые");
    else writeln("b равно нулю");

В начало ⮍ Наверх ⮍

3.5. Инструкция switch

Лучше всего сразу проиллюстрировать работу инструкции switch примером:

import std.stdio;

void classify(char c)
{
    write("Вы передали ");
    switch (c)
    {
        case '#':
            writeln("знак решетки.");
            break;
        case '0': .. case '9':
            writeln("цифру.");
            break;
        case 'A': .. case 'Z': case 'a': .. case 'z':
            writeln("ASCII-знак.");
            break;
        case '.', ',', ':', ';', '!', '?':
            writeln("знак препинания.");
            break;
        default:
            writeln("всем знакам знак!");
            break;
    }
}

В общем виде инструкция switch выглядит так:

switch (‹выражение›) ‹инструкция›

‹выражение› может иметь числовой, перечисляемый или строковый тип; ‹инструкция› может содержать метки (ярлыки, labels), определенные следующим образом:

  1. case ‹в›: Перейти сюда, если ‹выражение› == ‹в›. Чтобы можно было использовать внутри в запятые (см. раздел 2.3.18), все выражение требуется заключить в круглые скобки.
  2. case ‹в1›, ‹в2›, … , ‹вn›: Каждая запись вида ‹вk› обозначает выражение. Рассматриваемая инструкция эквивалентна инструкции case ‹элемент1›: case ‹элемент2›:, ... , case ‹элементn›:.
  3. case ‹в1›: .. case ‹в2›: Перейти сюда, если ‹выражение› >= ‹в1› и ‹выражение› <= ‹в2›.
  4. default: Перейти сюда, если никакой другой переход невозможен.

‹выражение› вычисляется один раз для всех этих проверок. Выражение в каждой метке case – это любое не противоречащее правилам языка выражение, которое можно проверить на равенство выражению ‹выражение›, а также на неравенство в случае использования синтаксиса с интервалом. Обычно case-выражения представлены константами, вычисляемыми во время компиляции, но D разрешает использовать и переменные, гарантируя, что вычисления будут производиться в порядке следования альтернатив до первого совпадения. По завершении вычислений выполняется переход к соответствующей метке case или default и выполнение программы продолжается из этой точки. Для того чтобы покинуть ветвление, используется инструкция break, осуществляющая выход из инструкции switch. В отличие от языков C и C++, D запрещает неявный переход к следующей метке и требует инструкции break или return после кода, соответствующего метке.

switch (s)
{
    case 'a': writeln("a"); // Вывести "a" и перейти к следующей метке
    case 'b': writeln("b"); // Ошибка! Неявный переход запрещен!
    default: break;
}

Если вы действительно хотите, чтобы после кода метки 'a' выполнился код метки 'b', вам придется явно указать это компилятору с помощью особой формы инструкции goto:

switch (s)
{
    case 'a': writeln("a"); goto case; // Вывести "a" и перейти к следующей метке
    case 'b': writeln("b");            // После выполнения 'a' мы попадем сюда
    default: break;
}

Если же вы случайно забыли написать break или return, компилятор любезно напомнит вам об этом. Можно было бы вообще отказаться от использования инструкции break в конструкции switch, но это нарушило бы обязательство компилировать C-подобный код по правилам языка C либо не компилировать его вообще.

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

switch (s)
{
    case 'a' .. case 'z': ... break;
    // Попытка задать особую обработку для 'w'
    case 'w': ... break; // Ошибка! Case-метки не могут пересекаться!
    default: break;
}

Метка default должна быть обязательно объявлена. Если она не объявлена, компилятор сообщит об ошибке. Это сделано для того, чтобы предотвратить типичную для программистов ошибку – пропуск некоторого подмножества значений по недосмотру. Если такой опасности не существует, используйте default: break;, таким образом, аккуратно оформив ваше предположение. В следующем разделе описано, как статически гарантировать обработку всех возможных значений switch-условия.

В начало ⮍ Наверх ⮍

3.6. Инструкция final switch

Инструкция switch обычно используется в связке с перечисляемым типом для обработки каждого из всех его возможных значений. Если во время эксплуатации число вариантов меняется, все зависимые переключатели неожиданно перестают соответствовать новому положению дел; каждую такую инструкцию необходимо вручную найти и изменить.

Теперь очевидно, что для получения масштабируемого решения следует заменить «переключение» на основе меток виртуальными функциями; в этом случае нет необходимости обрабатывать различные случаи в одном месте, но вместо этого обработка распределяется по разным реализациям интерфейса. Но в жизни не бывает все идеально: определение интерфейсов и классов требует серьезных усилий на начальном этапе работы над программой, чего можно избежать, остановившись на альтернативном решении с переключателем switch. В таких ситуациях может пригодиться инструкция final switch, статически «принуждающая» метки case покрывать все возможные значения перечисляемого типа:

enum DeviceStatus { ready, busy, fail }
...
void process(DeviceStatus status)
{
    final switch (status)
    {
        case DeviceStatus.ready:
            ...
        case DeviceStatus.busy:
            ...
        case DeviceStatus.fail:
            ...
    }
}

Предположим, что при эксплуатации кода было добавлено еще одно возможное состояние устройства:

enum DeviceStatus { ready, busy, fail, initializing /* добавлено */ }

После этого изменения попытка перекомпилировать функцию process будет встречена отказом на следующем основании:

Error: final switch statement must handle all values

(Ошибка: инструкция final switch должна обрабатывать все значения)

Инструкция final switch требует, чтобы все значения типа enum были явно обработаны. Метки с интервалами вида case ‹в1›: .. case ‹в2›:, а также метку default: использовать запрещено.

В начало ⮍ Наверх ⮍

  1. Да-да, это «еще одно место, где используется ключевое слово static». ↩︎

  2. Тип enum будет рассмотрен позже. Для понимания примера надо знать, что значения объявленные как enum, определены на этапе компиляции, неизменны и могут использоваться в конструкциях, вычисляемых на этапе компиляции. – Прим. науч. ред. ↩︎