dlang
/
dlang-book
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

3.1-3.4

This commit is contained in:
Alexander Zhirov 2023-01-24 10:03:07 +03:00
parent 371a379eb6
commit 235bd723c2
1 changed files with 212 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

212
03-инструкция/README.md
View File

@ -47,3 +47,215 @@ transmogrify(a + b);
то компилятор диагностирует ошибку. то компилятор диагностирует ошибку.
[В начало ⮍](#3-1-инструкция-выражение) [Наверх ⮍](#3-инструкции) [В начало ⮍](#3-1-инструкция-выражение) [Наверх ⮍](#3-инструкции)
## 3.2. Составная инструкция
Составная инструкция – это (возможно, пустая) последовательность инструкций, заключенных в фигурные скобки. Инструкции исполняются по порядку. Скобки ограничивают лексический контекст (пространство имен): идентификаторы, определенные внутри такого блока, не видны за его пределами.
Идентификатор, определенный внутри данного пространства имен, перекрывает одноименный идентификатор, определенный вне этого пространства:
```d
uint widgetCount;
...
void main()
{
writeln(widgetCount); // Выводит значение глобальной переменной
auto widgetCount = getWidgetCount();
writeln(widgetCount); // Выводит значение локальной переменной
}
```
При первом вызове функции `writeln` будет напечатано значение глобальной переменной `widgetCount`, при втором происходит обращение к локальной переменной `widgetCount`. Для доступа к глобальному идентификатору после того, как был определен перекрывающий его локальный идентификатор, служит точка, поставленная перед идентификатором (как уже говорилось в разделе 2.2.1), например `writeln(.widgetCount)`. Тем не менее запрещается определять идентификатор, если он перекрывает идентификатор, определенный в блоке верхнего уровня:
```d
void main()
{
auto widgetCount = getWidgetCount();
// Откроем вложенный блок
{
auto widgetCount = getWidgetCount(); // Ошибка!
}
}
```
Если идентификаторы не перекрываются, то один и тот же идентификатор можно использовать внутри разных составных инструкций:
```d
void main()
{
{
auto i = 0;
...
}
{
auto i = "eye"; // Без проблем
...
}
double i = 3.14; // Тоже без проблем
}
```
Такой подход объясняется просто. Возможность перекрывать глобальные идентификаторы необходима, чтобы писать качественный модульный код, который собирается из нескольких отдельно скомпилированных частей; вы же не хотите, чтобы добавленная в локальное пространство имен глобальная переменная внезапно спутала все карты, запретив компиляцию невинных локальных переменных. С другой стороны, перекрытие локальных идентификаторов бесполезно с точки зрения модульности (поскольку в D составная инструкция никогда не простирается на несколько модулей) и обычно указывает либо на недосмотр (который вот-вот превратится в ошибку), либо на злокачественную функцию, вышедшую из-под контроля.
## 3.3. Инструкция if
Во многих примерах уже встречалась условная инструкция D `if`, которая очень похожа на то, чего вы могли от нее ожидать:
```d
if (‹выражение›) ‹инструкция1›
```
или
```d
if (‹выражение›) ‹инструкция1› else ‹инструкция2›
```
Достойна внимания одна деталь относительно инструкций, которыми управляет `if`. В отличие от других языков, в D нет «пустой инструкции», то есть отдельно точка с запятой сама по себе *не является* инструкцией и порождает ошибку. Это правило автоматически ограждает программистов от ошибок вроде следующей:
```d
if (a == b);
writeln("a и b равны");
```
В коротком коде подобная глупость очевидна, и вы легко ее устраните, но все меняется, когда выражение длиннее, сама инструкция затерялась в дебрях кода, а на часах полвторого ночи. Если вы действительно хотите применить `if` к пустой инструкции, то можете использовать наиболее близкий аналог – пустую составную инструкцию:
```d
if (a == b) {}
```
Это очень полезно, когда вы переделываете код, то и дело заключая фрагменты кода в комментарии и возвращая их обратно.
Часть условной инструкции с ключевым словом `else` всегда привязана к ближайшей части с ключевым словом `if`, так что отступы в следующем коде сделаны верно:
```d
if (a == b)
if (b == c)
writeln("Все равны");
else
writeln("a не равно b. Но так ли это?");
```
Вторая функция `writeln` вызывается, когда `a == b` и `b != c`, потому что часть `else` привязана к внутреннему (второму) условию `if`. Если вы, напротив, хотите связать `else` с первым `if`, «буферизуйте» второе выражение с `if` с помощью пары фигурных скобок:
```d
if ( a == b )
{
if ( b == с )
writeln("Все одинаковое");
}
else
writeln("a отличается от b. Или это не так?");
```
Каскадные множественные конструкции `if-else` задаются в проверенном временем стиле C:
```d
auto opt = getOption();
if (opt == "help")
{
...
}
else if (opt == "quiet")
{
...
}
else if (opt == "verbose")
{
...
}
else
{
stderr.writefln("Неизвестная опция '%s'", opt);
}
```
## 3.4. Инструкция static if
Теперь, когда вы уже разогрелись на нескольких простых инструкциях (спасибо, что подавили этот зевок), можно взглянуть на нечто более необычное.
Если вы хотите «закомментировать» (или оставить) какие-то инструкции в зависимости от проверяемого во время компиляции логического условия, то вам пригодится инструкция `static if`[^1]. Например[^2]:
```d
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` срезает внешние скобки, если они есть (их необязательно ставить, если с помощью условной инструкции контролируется только одна инструкция; в нашем примере выше они используются только для того, чтобы не нарушить обязательство насчет стиля). Если вы действительно хотите поставить скобки (в их традиционном значении), просто добавьте еще одну пару:
```d
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`:
```d
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`:
```d
if (a)
static if (b) writeln("a и b ненулевые");
else writeln("b равно нулю");
```
[^1]: Да-да, это «еще одно место, где используется ключевое слово `static»`.
[^2]: Тип `enum` будет рассмотрен позже. Для понимания примера надо знать, что значения объявленные как `enum`, определены на этапе компиляции, неизменны и могут использоваться в конструкциях, вычисляемых на этапе компиляции. – *Прим. науч. ред.*