D (язык программирования)

Чтобы узнать о других языках программирования с именем D, см. D (значения) § Вычисления . Чтобы узнать о других значениях, см. D (значения) .

язык программирования D

Парадигма	Мультипарадигмальность : функциональная , императивная , объектно-ориентированная.
Разработано	Уолтер Брайт , Андрей Александреску (с 2007 г.)
Разработчик	Языковой фонд D
Впервые появился	8 декабря 2001 г ( 08.12.2001 )
Стабильная версия	2.108.0  / 1 апреля 2024 г ( 1 апреля 2024 г. )
Дисциплина набора текста	Предполагаемый , статичный , сильный
ТЫ	FreeBSD , Linux , MacOS , Windows
Лицензия	Способствовать росту
Расширения имен файлов	.д
Веб-сайт	дланг .org
Основные реализации
DMD ( эталонная реализация ), GCC , ГДК , НРС , СЗС
Под влиянием
БАЗОВЫЙ , C , C++ , C# , Эйфель , Ява , Питон
Под влиянием
Джинн , MiniD, Писатель , Свифт , Vala , C++11 , C++14 , C++17 , C++20 , Go , C# и другие.
D Программирование в Wikibooks

D , также известный как dlang , — это мультипарадигмальный язык системного программирования , созданный Уолтером Брайтом из Digital Mars и выпущенный в 2001 году. Андрей Александреску присоединился к проектированию и разработке в 2007 году. Хотя он возник как реинжиниринг C++ , D теперь это совершенно другой язык, черпающий вдохновение из других языков программирования высокого уровня, в частности Java , Python , Ruby , C# и Eiffel .

Справочник по языку D описывает это следующим образом:

D — это язык системного программирования общего назначения с синтаксисом, подобным C, который компилируется в собственный код. Он статически типизирован и поддерживает как автоматическое (сбор мусора), так и ручное управление памятью. Программы D структурированы как модули, которые можно компилировать отдельно и связывать с внешними библиотеками для создания собственных библиотек или исполняемых файлов.

Особенности

D не совместим с исходным кодом C и C++ в целом. Однако любой код, который допустим как для C, так и для D, должен вести себя одинаково.

Как и в C++, в D есть замыкания , анонимные функции , выполнение функций во время компиляции , диапазоны, встроенные концепции итерации контейнеров и вывод типов . В отличие от C++, D также реализует проектирование по контракту , модули , сборку мусора , первого класса массивы , нарезку массива , вложенные функции и отложенное вычисление . в стиле Java D использует одиночное наследование с интерфейсами и примесями, а не множественное наследование в стиле C++ . С другой стороны, синтаксис объявлений, операторов и выражений D очень похож на синтаксис C++.

D — язык системного программирования. Как и C++, D поддерживает низкоуровневое программирование, включая встроенный ассемблер , который символизирует различия между D и языками приложений, такими как Java и C# . Встроенный ассемблер позволяет программистам вводить ассемблерный код , специфичный для машины , в стандартный код D — метод, используемый системными программистами для доступа к низкоуровневым функциям процессора, необходимым для запуска программ, которые напрямую взаимодействуют с базовым оборудованием , например, с операционными системами и драйверами устройств. , а также написание высокопроизводительного кода (т. е. с использованием векторных расширений, SIMD ), который сложно сгенерировать компилятору автоматически.

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

В D строки текстовых символов представляют собой массивы символов, а массивы в D проверяются по границам. D имеет типы первого класса для комплексных и мнимых чисел.

Парадигмы программирования

D поддерживает пять основных парадигм программирования :

• Параллельный ( модель актера )
• Объектно-ориентированный
• Императив
• Функциональный
• Metaprogramming

Императив

Императивное программирование на D почти идентично программированию на C. Функции, данные, операторы, объявления и выражения работают так же, как и в C, и к библиотеке времени выполнения C можно получить прямой доступ. С другой стороны, некоторые заметные различия между D и C в области императивного программирования включают в себя foreach конструкция цикла, позволяющая выполнять цикл по коллекции, и вложенные функции , которые объявляются внутри других функций и могут обращаться к локальным переменным включающей функции .

импорт   стандартный  .   стдио  ; 

  void   main  ()   { 
     int   multiplier   =   10  ; 
      int   Scaled  (  int   x  )   {   return   x   *   multiplier  ;    } 

     foreach   (  i  ;   0   ..   10  )   { 
         writefln  (  «Привет, мир %d! Scaled = %d»  ,   i  ,   Scaled  (  i  )); 
      } 
 } 

Объектно-ориентированный

Объектно-ориентированное программирование в D основано на единой иерархии наследования, все классы которой являются производными от класса Object. D не поддерживает множественное наследование; в стиле Java вместо этого он использует интерфейсы , которые сравнимы с чистыми абстрактными классами C++, и миксины , которые отделяют общую функциональность от иерархии наследования. D также позволяет определять статические и финальные (не виртуальные) методы в интерфейсах.

Интерфейсы и наследование в D поддерживают ковариантные типы для возвращаемых типов переопределенных методов.

D поддерживает пересылку типов, а также дополнительную пользовательскую динамическую отправку .

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

Многие аспекты классов (и структур) могут автоматически анализироваться во время компиляции (форма отражения с использованием type traits) и во время выполнения (RTTI/ TypeInfo), чтобы облегчить общий код или автоматическую генерацию кода (обычно с использованием методов времени компиляции).

Функционал

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

 int  функция  (  int  )   g  ; 
  г   знак равно   (  Икс  )   {   вернуть   Икс   *   Икс  ;    };    // от руки 
 g   =   (  x  )   =>   x   *   x  ;             // сокращение 

Существует два встроенных типа функциональных литералов: function, который является просто указателем на функцию, выделенную в стеке, и delegate, который также включает указатель на соответствующий кадр стека , окружающую «среду», содержащую текущие локальные переменные. Вывод типа может использоваться с анонимной функцией, и в этом случае компилятор создает delegateесли только он не сможет доказать, что указатель среды не нужен. Аналогично, чтобы реализовать замыкание, компилятор помещает вложенные локальные переменные в кучу только в случае необходимости (например, если замыкание возвращается другой функцией и выходит из области действия этой функции). При использовании вывода типа компилятор также добавит такие атрибуты, как pure и nothrow к типу функции, если можно доказать их применимость.

Другие функциональные возможности, такие как каррирование и общие функции высшего порядка, такие как карта , фильтр и сокращение, доступны через модули стандартной библиотеки. std.functional и std.algorithm.

импорт   стандартный  .   стдио  ,   станд  .   алгоритм  ,   стандарт  .   диапазон  ; 

  void   main  () 
 { 
     int  []   a1   =   [  0  ,   1  ,   2  ,   3  ,   4  ,   5  ,   6  ,   7  ,   8  ,   9  ]; 
      int  []   a2   =   [  6  ,   7  ,   8  ,   9  ]; 

      // должен быть неизменяемым, чтобы обеспечить доступ изнутри чистой функции 
     immutable   Pivot   =   5  ; 

      int   mySum  (  int   a  ,   int   b  )   pure   nothrow   // чистая функция 
     { 
         if   (  b   <=   Pivot  )   // ссылка на охватывающую область 
             return   a   +   b  ; 
          иначе 
             вернуть  ​  ; 
      } 

     // передача делегата (закрытие) 
     автоматический   результат   =   сокращение  !   mySum  (  цепочка  (  a1  ,   a2  )); 
      writeln  (  "Результат:"  ,   результат  );    // Результат: 15 

     // передача литерала делегата 
     result   =   уменьшить  !((  a  ,   b  )   =>   (  b   <=   Pivot  )   ?   a   +   b   :   a  )(  Chain  (  a1  ,   a2  )); 
      writeln  (  "Результат:"  ,   результат  );    // Результат: 15 
 } 

Альтернативно, приведенные выше композиции функций могут быть выражены с использованием унифицированного синтаксиса вызова функций (UFCS) для более естественного чтения слева направо:

    автоматический   результат   =   a1  .   цепочка  (  а2  ).   уменьшать  !   мояСумма  (); 
      writeln  (  "Результат:"  ,   результат  ); 

      результат   =   а1  .   цепочка  (  а2  ).   уменьшить  !((  a  ,   b  )   =>   (  b   <=   пивот  )   ?   a   +   b   :   a  )(); 
      writeln  (  "Результат:"  ,   результат  ); 

Параллелизм

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

импорт   стандартный  .   stdio   :   writeln  ; 
  импорт   стандартный  .   диапазон   :   йота  ; 
  импорт   стандартный  .   параллелизм   :   параллельный  ; 

  void   main  () 
 { 
     foreach   (  i  ;   iota  (  11  ).parallel  )  {   // 
         Тело цикла foreach выполняется параллельно для каждого i 
         writeln  (  "processing"  ,   i  ); 
      } 
 } 

iota(11).parallel эквивалентно std.parallelism.parallel(iota(11)) с помощью UFCS.

Этот же модуль также поддерживает taskPool который можно использовать для динамического создания параллельных задач, а также операций отображения-фильтрации-уменьшения и свертывания стилей над диапазонами (и массивами), что полезно в сочетании с функциональными операциями. std.algorithm.mapвозвращает лениво вычисляемый диапазон, а не массив. Таким образом, элементы автоматически вычисляются каждой рабочей задачей параллельно.

импорт   стандартный  .   stdio   :   writeln  ; 
  импорт   стандартный  .   алгоритм   :   карта  ; 
  импорт   стандартный  .   диапазон   :   йота  ; 
  импорт   стандартный  .   параллелизм   :   TaskPool  ; 

  /* На Intel i7-3930X и gdc 9.3.0: 
 * 5140 мс при использовании std.algorithm.reduce 
 * 888 мс при использовании std.parallelism.taskPool.reduce 
 * 
 * На AMD Threadripper 2950X и gdc 9.3.0: 
 * 2864 мс при использовании std.algorithm .reduce 
 * 95 мс с использованием std.parallelism.taskPool.reduce 
 */ 
 void   main  () 
 { 
   auto   nums   =   iota  (  1.0  ,   1_000_000_000.0  ); 

    авто   x   =   TaskPool  .   уменьшать  !   "a + b"  ( 
       0.0  ,   карта  !  "1.0 / (a ​​* a)"  (  nums  ) 
   ); 

    writeln  (  "Сумма:"  ,   x  ); 
  } 

Параллельность

Параллелизм полностью реализован в библиотеке и не требует поддержки со стороны компилятора. Возможны альтернативные реализации и методологии написания параллельного кода. Использование системы типизации D действительно помогает обеспечить безопасность памяти.

импорт   стандартный  .   стдио  ,   станд  .   параллелизм  ,   стандарт  .   вариант  ; 

  void   foo  () 
 { 
     bool   cont   =   true  ; 

      while   (  cont  ) 
     { 
         receive  (   //Делегаты используются для соответствия типу сообщения. 
             (  int   msg  )   =>   writeln  (  "int полученное: "  msg   )  , 
             (  Tid   sender  )   {   cont   =   false  ;   sender.send  ,  (  -  1  );   }, 
             (  Variant   v  )   =>   writeln  (  "huh?"  )   // Вариант соответствует любому типу 
         ); 
      } 
 } 

 void   main  () 
 { 
     auto   tid   =   spawn  (&  foo  );    // создаем новый поток, выполняющий foo() 

     foreach   (  i  ;   0   ..   10  ) 
         tid  .   отправить  (  я  );      // отправляем несколько целых чисел 

     tid  .   отправить  (  1.0f  );       // отправляем плавающий 
     tid  .   отправить  (  «привет»  );    // отправляем строку 
     tid  .   отправить  (  этотид  );    // отправляем структуру (Tid) 

     получения  ((  int   x  )   =>   writeln  (  «Основной поток получил сообщение: «  ,   x  )); 
  } 

Metaprogramming

Метапрограммирование поддерживается посредством шаблонов, выполнения функций во время компиляции, кортежей и строковых миксинов. Следующие примеры демонстрируют некоторые возможности D во время компиляции.

Шаблоны в D могут быть написаны в более императивном стиле по сравнению с функциональным стилем шаблонов C++. Это обычная функция, вычисляющая факториал числа:

ulong   факториал  (  ulong   n  )   { 
     if   (  n   <   2  ) 
         вернуть   1  ; 
      иначе 
         вернуть   n   *   факториал  (  n  -  1  ); 
  } 

Здесь использование static if, условная конструкция D во время компиляции, демонстрируется для создания шаблона, который выполняет те же вычисления с использованием кода, аналогичного коду функции выше:

шаблон   Factorial  (  ulong   n  )   { 
     static   if   (  n   <   2  ) 
         enum   Factorial   =   1  ; 
      else 
         enum   Factorial   =   n   *   Факториал  !(  n  -  1  ); 
  } 

В следующих двух примерах шаблон и функция, определенные выше, используются для вычисления факториалов. Типы констант не обязательно указывать явно, поскольку компилятор определяет их типы из правых частей присваивания:

enum   fact_7   =   Факториал  !(  7  ); 

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

перечисление   факт_9   =   факториал  (  9  ); 

The std.string.format функция выполняет printf-подобное форматированию данных (также во время компиляции, через CTFE), а прагма «msg» отображает результат во время компиляции:

импорт   стандартный  .   строка   :   формат  ; 
  прагма  (  msg  ,   format  (  «7! = %s»  ,   fact_7  )); 
  прагма  (  сообщение  ,   формат  (  «9! = %s»  ,   fact_9  )); 

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

импортировать   ФуТоД  ;    // гипотетический модуль, который содержит функцию, которая анализирует исходный код Foo 
                // и возвращает эквивалентный код D 
 void   main  ()   { 
     mixin  (  fooToD  (  import  (  "example.foo"  ))); 
  } 

Управление памятью

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

Если требуется больший контроль над расположением памяти и более высокая производительность, возможно явное управление памятью с помощью перегруженного оператора. new, путем прямого вызова C языка malloc и free или реализации пользовательских схем распределения (т. е. в стеке с резервным копированием, распределение в стиле RAII, подсчет ссылок, общий подсчет ссылок). Сборкой мусора можно управлять: программисты могут добавлять и исключать диапазоны памяти из наблюдения сборщика, могут отключать и включать сборщик, а также принудительно запускать либо генерационный, либо полный цикл сбора. В руководстве приведено множество примеров того, как реализовать различные высокооптимизированные схемы управления памятью, когда в программе неадекватна сборка мусора.

В функциях struct экземпляры по умолчанию размещаются в стеке, а classэкземпляры по умолчанию размещаются в куче (с ссылкой только на экземпляр класса, находящийся в стеке). Однако это можно изменить для классов, например, используя шаблон стандартной библиотеки. std.typecons.scopedили с помощью new для структур и присвоения указателю вместо переменной, основанной на значении.

В функциях статические массивы (известного размера) размещаются в стеке. Для динамических массивов можно использовать core.stdc.stdlib.alloca функция (аналогично allocaв C), чтобы выделить память в стеке. Возвращенный указатель может быть использован (переведен) в (типизированный) динамический массив посредством среза (однако следует избегать изменения размера массива, включая добавление; и по очевидным причинам они не должны возвращаться из функции).

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

std.experimental.allocator содержит модульные и компонуемые шаблоны распределителей для создания пользовательских высокопроизводительных распределителей для особых случаев использования.

СафеД

СейфД это имя, присвоенное подмножеству D, которое может быть гарантированно безопасным для памяти (без записи в память, которая не была выделена или была переработана). Функции отмечены @safe проверяются во время компиляции, чтобы гарантировать, что они не используют какие-либо функции, которые могут привести к повреждению памяти, такие как арифметика указателей и непроверяемые приведения типов, а любые другие вызываемые функции также должны быть помечены как @safe или @trusted. Функции могут быть отмечены @trusted для случаев, когда компилятор не может отличить безопасное использование функции, отключенной в SafeD, от потенциального повреждения памяти.

Безопасность на весь срок службы

Изначально под баннерами ДИП1000 и ДИП25 (теперь часть спецификации языка ), D обеспечивает защиту от некоторых некорректных конструкций, включающих время жизни данных.

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

Пожизненная безопасность заданий

В коде @safe проверяется время существования назначения, включающего ссылочный тип , чтобы убедиться, что время жизни правопреемника больше, чем время жизни назначенного.

Например:

@safe   void   test  () 
 { 
     int   tmp   =   0  ;    // #1 
     int  *   рад  ;       // #2 
     рад   =   &  tmp  ;     // Если порядок объявлений №1 и №2 обратный, это не удастся. 
      { 
    	 интервал   плохо   =   45  ;    // Время жизни "плохого" распространяется только на ту область, в которой оно определено. 
          *  рад   =   плохо  ;      // Это действительно. 
          рад   =   &  плохо  ;      // Срок жизни рад больше, чем плохой, поэтому это неверно. 
      } 
 } 

Аннотации времени жизни параметров функции в коде @safe

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

Стандарт языка диктует следующее поведение:

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

Аннотированный пример приведен ниже.

@safe  : 

 int  *   gp  ; 
  void   Thorin  (  scope   int  *); 
  пустота   глоин  (  int  *); 
  int  *   balin  (  возвращает   область действия   int  *   p  ,   область действия   int  *   q  ,   int  *   r  ) 
 { 
      gp   =   p  ;    // Ошибка, p переходит в глобальную переменную gp. 
       гп   =   q  ;    // Ошибка, q переходит в глобальную переменную gp. 
       гп   =   р  ;    // ХОРОШО. 

       Торин  (  р  );    // Хорошо, p не экранирует функцию Thorin(). 
       Торин  (  q  );    // ХОРОШО. 
       Торин  (  р  );    // ХОРОШО. 

       глоин  (  р  );    // Ошибка, p выходит за пределы globin(). 
       глоин  (  q  );    // Ошибка, q выходит из globin(). 
       глоин  (  р  );    // Хорошо, что r экранирует globin(). 

       вернуть   п  ;    // ХОРОШО. 
       вернуть   д  ;    // Ошибка, невозможно вернуть 'scope' q. 
       вернуть   р  ;    // ХОРОШО. 
  } 

Взаимодействие с другими системами

а , двоичный интерфейс приложений C (ABI) Поддерживается D также все фундаментальные и производные типы C, что обеспечивает прямой доступ к существующему коду и библиотекам C. Привязки доступны для многих популярных библиотек C. C Кроме того, стандартная библиотека является частью стандарта D.

В Microsoft Windows D может получить доступ к коду модели компонентных объектов (COM).

Если об управлении памятью позаботиться должным образом, многие другие языки могут быть смешаны с D в одном двоичном файле. Например, компилятор GDC позволяет связывать и смешивать C, C++ и другие поддерживаемые языковые коды, такие как Objective-C. Код D (функции) также может быть помечен как использующий ABI C, C++, Pascal и, таким образом, передаваться в библиотеки, написанные на этих языках, в качестве обратных вызовов . Аналогичным образом данные могут обмениваться между кодами, написанными на этих языках, обоими способами. Обычно это ограничивает использование примитивных типов, указателей, некоторых форм массивов, объединений , структур и только некоторых типов указателей на функции.

Поскольку многие другие языки программирования часто предоставляют API C для написания расширений или запуска интерпретатора языков, D также может напрямую взаимодействовать с этими языками, используя стандартные привязки C (с тонким файлом интерфейса D). Например, существуют двунаправленные привязки для таких языков, как Python , Два и другие языки, часто использующие методы генерации кода и отражения типов во время компиляции.

Взаимодействие с кодом C++

Для кода D, отмеченного как extern(C++), указаны следующие особенности:

• Соглашения об изменении имен должны соответствовать соглашениям C++ в целевой системе.
• Для вызовов функций ABI должен быть эквивалентным.
• Виртуальная таблица должна соответствовать одиночному наследованию (единственному уровню, поддерживаемому спецификацией языка D).

Пространства имен C++ используются через синтаксис extern(C++, namespace) где пространство имен — это имя пространства имен C++.

Пример взаимодействия C++

Сторона C++

#include   <iostream> 
 с использованием   пространства имен   std  ; 
  класс   Base 
 { 
     public  : 
         virtual   void   print3i  (  int   a  ,   int   b  ,   int   c  )   =   0  ; 
  }; 

  класс   Произведенный   :   public   Base 
 { 
     public  : 
         int   field  ; 
          Derived  (  int   field  )   :   field  (  field  )   {} 

         ​​void   print3i  (  int   a  ,   int   b  ,   int   c  ) 
         { 
             cout   <<   "a = "   <<   a   <<   endl  ; 
              cout   <<   "b = "   <<   b   <<   endl  ; 
              cout   <<   "c = "   <<   c   <<   endl  ; 
          } 

         Int   mul  (  инт-   коэффициент  ); 
  }; 

  int   Derived::mul  (  int   Factor  ) 
 { 
     возвращаемое   поле   *   Factor  ; 
  } 

 Derived   *  createInstance  (  int   i  ) 
 { 
     return   new   Derived  (  i  ); 
  } 

 void   deleteInstance  (  Derived   *&  d  ) 
 { 
     delete   d  ; 
      д   =   0  ; 
  } 

Сторона D

extern  (  C  ++) 
 { 
     абстрактный   класс   Base 
     { 
         void   print3i  (  int   a  ,   int   b  ,   int   c  ); 
      } 

     класс   Производный   :   Base 
     { 
         int   field  ; 
          @отключить   это  (); 
          переопределить   void   print3i  (  int   a  ,   int   b  ,   int   c  ); 
          окончательный   int   mul  (  int   коэффициент  ); 
      } 

     Производное   createInstance  (  int   i  ); 
      void   deleteInstance  (  ref   Derived   d  ); 
  } 

 void   main  () 
 { 
     import   std  .   стдио  ; 

      авто   d1   =   createInstance  (  5  ); 
      writeln  (  d1  .  поле  ); 
      writeln  (  d1  .  mul  (  4  )); 

      База   b1   =   d1  ; 
      б1  .   print3i  (  1  ,   2  ,   3  ); 

      удалитьэкземпляр  (  d1  ); 
      утверждать  (  d1   имеет   значение null  ); 

      авто   d2   =   createInstance  (  42  ); 
      writeln  (  d2  .  поле  ); 

      удалитьэкземпляр  (  d2  ); 
      утверждать  (  d2   имеет   значение null  ); 
  } 

Лучше C

Язык программирования D имеет официальное подмножество, известное как Better C. Это подмножество запрещает доступ к функциям D, требующим использования библиотек времени выполнения, отличных от библиотеки C.

Включенный с помощью флагов компилятора «-betterC» в DMD и LDC и «-fno-druntime» в GDC, Better C может вызывать только код D, скомпилированный под тем же флагом (и связанный код, отличный от D), но код, скомпилированный без Вариант Better C может вызывать код, скомпилированный с его помощью: однако это приведет к несколько другому поведению из-за различий в том, как C и D обрабатывают утверждения.

включенные в Better

• Неограниченное использование функций времени компиляции (например, функции динамического выделения D можно использовать во время компиляции для предварительного выделения данных D)
• Полные возможности метапрограммирования
• Вложенные функции, вложенные структуры, делегаты и лямбды.
• Функции-члены, конструкторы, деструкторы, операционная перегрузка и т. д.
• Полная модульная система
• Нарезка массива и проверка границ массива
• РАИИ
• область действия (выход)
• Защита памяти
• Взаимодействие с C++
• COM-классы и классы C++
• ошибки подтверждения направляются в библиотеку времени выполнения C
• переключатель с помощью струн
• окончательный переключатель
• юниттеста блоки
• printf проверка формата

Функции, исключенные из Better C

• Вывоз мусора
• Информация о типе и информация о модуле
• Встроенная резьба (например, core.thread)
• Динамические массивы (хотя части статических массивов работают) и ассоциативные массивы
• Исключения
• синхронизированы и core.sync
• Конструкторы или деструкторы статических модулей

История

Уолтер Брайт начал работу над новым языком в 1999 году. Впервые D был выпущен в декабре 2001 года. и достиг версии 1.0 в январе 2007 года. Первая версия языка (D1) была сосредоточена на императивной, объектно-ориентированной и метапрограммной парадигмах. похож на С++.

Некоторые члены сообщества D, недовольные Phobos, официальной средой выполнения и стандартной библиотекой D , создали альтернативную среду выполнения и стандартную библиотеку под названием Tango. Первое публичное объявление о Tango произошло через несколько дней после выпуска D 1.0. Tango принял другой стиль программирования, включающий ООП и высокую модульность. Будучи проектом под руководством сообщества, Tango был более открыт для вкладов, что позволяло ему развиваться быстрее, чем официальная стандартная библиотека. В то время Tango и Phobos были несовместимы из-за разных API-интерфейсов поддержки времени выполнения (сборщик мусора, поддержка потоков и т. д.). Это сделало невозможным использование обеих библиотек в одном проекте. Существование двух библиотек, обе широко используемых, привело к серьезным спорам из-за того, что некоторые пакеты используют Phobos, а другие - Tango.

В июне 2007 года была выпущена первая версия D2. Начало развития D2 ознаменовало стабилизацию D1. Первая версия языка была помещена на обслуживание, в нее вносились только исправления и исправления ошибок реализации. D2 внесла критические изменения в язык , начиная со своей первой экспериментальной системы const . Позже в D2 были добавлены многочисленные другие функции языка, такие как замыкания , чистота и поддержка парадигм функционального и параллельного программирования. D2 также решил проблемы стандартной библиотеки, отделив среду выполнения от стандартной библиотеки. О завершении порта D2 Tango было объявлено в феврале 2012 года.

Выпуск Андрея Александреску книги «Язык программирования D» 12 июня 2010 года ознаменовал стабилизацию языка D2, который сегодня обычно называют просто «D».

В январе 2011 года разработка D перешла с системы отслеживания ошибок/отправки исправлений на GitHub . Это привело к значительному увеличению вклада в компилятор, среду выполнения и стандартную библиотеку.

В декабре 2011 года Андрей Александреску объявил, что поддержка D1, первой версии языка, будет прекращена 31 декабря 2012 года. Последний выпуск D1, D v1.076, вышел 31 декабря 2012 года.

Код официального компилятора D, компилятора Digital Mars D Уолтера Брайта, изначально был выпущен под специальной лицензией , квалифицируясь как доступный исходный код , но не соответствующий определению открытого исходного кода . компилятора В 2014 году интерфейс был повторно лицензирован как открытый исходный код по лицензии Boost Software License . Этот повторно лицензированный код исключил серверную часть, которая была частично разработана в Symantec . 7 апреля 2017 года весь компилятор стал доступен по лицензии Boost после того, как Symantec разрешила также повторно лицензировать серверную часть. 21 июня 2017 года язык D был принят для включения в GCC.

Реализации

Большинство современных реализаций D компилируются непосредственно в машинный код .

Готовые к производству компиляторы:

• DMD - Компилятор Digital Mars D Уолтера Брайта является официальным компилятором D; с открытым исходным кодом под лицензией Boost Software License . Интерфейс DMD используется GDC (теперь в GCC) и LDC, чтобы улучшить совместимость между компиляторами. Изначально интерфейс был написан на C++, но сейчас большая его часть написана на самом D (самостоятельный хостинг). Оптимизаторы серверной части и машинного кода основаны на компиляторе Symantec. Сначала он поддерживал только 32-битную версию x86, а Уолтер Брайт добавил поддержку 64-битной версии AMD64 и PowerPC. Позже бэкэнд и почти весь компилятор были перенесены с C++ на D для полного самостоятельного размещения.
• GCC — Коллекция компиляторов GNU , объединенная с GDC. в GCC 9 29 октября 2018 г. Первые рабочие версии GDC с GCC на базе GCC 3.3 и GCC 3.4 на 32-битной версии x86 для Linux и macOS. был выпущен 22 марта 2004 года. С тех пор GDC получил поддержку дополнительных платформ, улучшенную производительность и исправленные ошибки, одновременно отслеживая исходный код DMD для интерфейса и спецификации языка.
• LDC — компилятор, основанный на интерфейсе DMD, который использует LLVM в качестве серверной части компилятора. Первая версия релизного качества была опубликована 9 января 2009 года. Он поддерживает версию 2.0.

Игрушечные и экспериментальные компиляторы:

• D Compiler for .NET — серверная часть для компилятора языка программирования D 2.0. Он компилирует код в байт-код Common Intermediate Language (CIL), а не в машинный код. Затем CIL можно запустить через Common Language Infrastructure (CLI) виртуальную машину . Проект не обновлялся годами, и автор указал, что проект больше не активен.
• SDC – шикарный компилятор D использует собственный интерфейс и LLVM в качестве серверной части компилятора. Он написан на D и использует планировщик для обработки разрешения символов, чтобы элегантно обрабатывать функции D во время компиляции. В настоящее время этот компилятор поддерживает ограниченное подмножество языка.

Используя вышеуказанные компиляторы и наборы инструментов, можно скомпилировать программы D для множества различных архитектур, включая IA-32 , amd64 , AArch64 , PowerPC , MIPS64 , DEC Alpha , Motorola m68k , SPARC , s390 , WebAssembly . Основными поддерживаемыми операционными системами являются Windows и Linux , но различные компиляторы также поддерживают Mac OS X , FreeBSD , NetBSD , AIX , Solaris/OpenSolaris и Android либо в качестве хоста, либо в качестве целевого устройства, либо в обоих случаях. Цель WebAssembly (поддерживается через LDC и LLVM) может работать в любой среде WebAssembly, например в современном веб-браузере ( Google Chrome , Mozilla Firefox , Microsoft Edge , Apple Safari ) или выделенных виртуальных машинах Wasm.

Инструменты разработки

Редакторы и интегрированные среды разработки (IDE), поддерживающие подсветку синтаксиса и частичное завершение кода для языка, включают SlickEdit , Emacs , vim , SciTE , Smultron , Zeus, и Гиани среди других.

• Dexed (ранее совместное редактирование), графическая среда разработки, ориентированная на D, написанная на Object Pascal.
• Моно-Д — это многофункциональная кроссплатформенная графическая среда разработки, ориентированная на D, основанная на MonoDevelop /Xamarin Studio, написанная в основном на C Sharp.
• Eclipse для D включают DDT Плагины и Descent (мертвый проект).
• Интеграция Visual Studio обеспечивается VisualD.
• Интеграция кода Visual Studio с расширениями, такими как Dlang-Vscode. или Код-D.
• доступен пакет Для TextMate , а IDE Code::Blocks включает частичную поддержку этого языка. Однако стандартные функции IDE, такие как завершение кода или рефакторинг, пока недоступны, хотя они частично работают в Code::Blocks (из-за сходства D с C).
• Плагин Xcode 3 «D for Xcode» позволяет создавать проекты и разработку на основе D.
• KDevelop (а также его текстовый редактор Kate). Доступен плагин автозаполнения

Существуют IDE D с открытым исходным кодом для Windows , некоторые из них написаны на D, например Poseidon, Д-IDE, и Entice Designer.

Приложения D можно отлаживать с помощью любого отладчика C/C++, например GDB или WinDbg , хотя поддержка различных функций языка, специфичных для D, крайне ограничена. В Windows программы D можно отлаживать с помощью Ddbg или инструментов отладки Microsoft (WinDBG и Visual Studio) после преобразования отладочной информации с помощью cv2pdb . ZeroBUGS , заархивированный 23 декабря 2017 года в отладчике Wayback Machine для Linux, имеет экспериментальную поддержку языка D. Ddbg можно использовать с различными IDE или из командной строки; ZeroBUGS имеет собственный графический интерфейс пользователя (GUI).

DustMite — это инструмент для минимизации исходного кода D, полезный при обнаружении проблем с компилятором или тестированием.

dub — популярный менеджер пакетов и сборки для приложений и библиотек D, который часто интегрируется в поддержку IDE.

Примеры

Пример 1

Этот пример программы печатает аргументы командной строки. main функция является точкой входа в программу D, и argsпредставляет собой массив строк, представляющих аргументы командной строки. А string в D — это массив символов, представленный immutable(char)[].

импорт   стандартный  .   stdio  :   writefln  ; 

  void   main  (  string  []   args  )   { 
     foreach   (  i  ,   arg  ;   args  ) 
         writefln  (  «args[%d] = '%s'»  ,   i  ,   arg  ); 
  } 

The foreachоператор может перебирать любую коллекцию. В этом случае он создает последовательность индексов ( i) и ценности ( arg) из массива args. Индекс i и ценность arg их типы выводятся из типа массива args.

Пример 2

Ниже показаны некоторые возможности D и компромиссы при проектировании D в короткой программе. Он перебирает строки текстового файла с именем words.txt, который содержит разные слова в каждой строке и печатает все слова, являющиеся анаграммами других слов.

импорт   стандартный  .   стдио  ,   станд  .   алгоритм  ,   стандарт  .   диапазон  ,   стандарт  .   нить  ; 

  void   main  ()   { 
     dstring  []   [  dstring  ]   Signature2words  ; 

      foreach   (  dchar  []   w  ;   линии  (  Файл  (  "words.txt"  )))   { 
         w   =   w  .   чавкать  ().   понижать  (); 
          неизменяемая   подпись   =   w  .   дуп  .   Сортировать  ().   выпускать  ().   идентификатор  ; 
          подпись2слова  [  подпись  ]   ~=   w  .   идентификатор  ; 
      } 

     foreach   (  words  ;   Signature2words  )   { 
         if   (  words  .  length   >   1  )   { 
             writeln  (  words  .  join  (  " "  )); 
          } 
     } 
 } 

1. signature2words— это встроенный ассоциативный массив, который сопоставляет ключи dstring (32-битные / символьные) с массивами dstrings. Это похоже на defaultdict(list) в Питоне .
2. lines(File())выдает строки лениво, с переводом строки. Затем его необходимо скопировать с помощью idup чтобы получить строку, которая будет использоваться для значений ассоциативного массива (теперь idup свойство arrays возвращает неизменяемый дубликат массива, который необходим, поскольку dstring тип на самом деле immutable(dchar)[]). Встроенные ассоциативные массивы требуют неизменяемых ключей.
3. The ~= Оператор добавляет новую строку значений к значениям связанного динамического массива.
4. toLower, join и chompпредставляют собой строковые функции, которые D позволяет использовать с синтаксисом метода. Имена таких функций часто похожи на строковые методы Python. toLower преобразует строку в нижний регистр, join(" ") объединяет массив строк в одну строку, используя один пробел в качестве разделителя, и chompудаляет новую строку из конца строки, если она присутствует. w.dup.sort().release().idup более читабелен, но эквивалентен release(sort(w.dup)).idupнапример. Эта функция называется UFCS (унифицированный синтаксис вызова функций) и позволяет расширять любые встроенные или сторонние типы пакетов функциональностью, подобной методу. Подобный стиль написания кода часто называют конвейерным (особенно когда используемые объекты лениво вычисляются, например итераторы/диапазоны) или интерфейсом Fluent .
5. The sort— это функция std.algorithm, которая сортирует массив на месте, создавая уникальную подпись для слов, которые являются анаграммами друг друга. release() метод для возвращаемого значения sort() удобно хранить код в виде одного выражения.
6. Второй foreach перебирает значения ассоциативного массива, он может определить тип words.
7. signature присваивается неизменяемой переменной, выводится ее тип.
8. UTF-32 dchar[] используется вместо обычного UTF-8 char[] в противном случае sort()отказывается сортировать. Есть более эффективные способы написать эту программу, используя только UTF-8.

Использует

Известные организации, использующие язык программирования D для проектов, включают Facebook , eBay , и Нетфликс .

D успешно использовался для ААА-игр , языковые переводчики, виртуальные машины, ядро операционной системы , графического процессора , программирование Веб-разработка , численный анализ , приложения с графическим интерфейсом , пассажиров информационная система для , машинное обучение, обработка текста, веб-серверы и серверы приложений, а также исследования.

Пресловутая северокорейская хакерская группа, известная как Lazarus, использовала CVE-2021-44228, также известную как « Log4Shell », для развертывания трех семейств вредоносных программ , написанных на DLang.

Обзор

Отсутствие прозрачности, гибкости и предсказуемости в процессе внесения исправлений известных недостатков и ошибок, а также сложность внесения мелких и крупных изменений в язык D, немедленно описываются в статье в блоге. от бывшего участника. Описанное там явное разочарование привело к OpenD. форку 1 января 2024 года.

См. также

• Док
• Языковой фонд D

Дальнейшее чтение

• Александреску, Андрей (4 января 2010 г.). Язык программирования D (1-е изд.). Аддисон-Уэсли Профессионал. ISBN  978-0-321-63536-5 .
• Александреску, Андрей (15 июня 2009 г.). «Дело Д» . Журнал доктора Добба.
• Брайт, Уолтер (8 апреля 2014 г.). «Как я пришел к написанию D» . Журнал доктора Добба.
• Чехрели, Али (1 февраля 2012 г.). «Программирование на D» . (распространяется по лицензии CC-BY-NC-SA). Эта книга обучает программированию новичков, но также охватывает многие сложные темы D.
• Мец, Кейд (7 июля 2014 г.). «Следующий большой язык программирования, о котором вы никогда не слышали» . Проводной .
• Руппе, Адам (май 2014 г.). D Поваренная книга (1-е изд.). ПАКТ Издательство. ISBN  978-1-783-28721-5 .

Внешние ссылки

• Официальный веб-сайт
• Цифровой Марс
• Турецкий форум
• Дланг на GitHub