Метапрограммирование в C++ и D

Я считаю, что нет ничего лучше, чтобы показать невероятную силу (TM) системы шаблонов D, чем Этот визуализатор, который я нашел много лет назад:

Да! Это фактически то, что генерируется компилятором ... это" программа", причем довольно красочная.

Edit

Источник, кажется, снова в сети.

Лучшими примерами D-метапрограммирования являются модули библиотеки D standard, которые интенсивно используют it по сравнению с модулями C++ Boost и STL. Проверьте d'S std.диапазон, ЗППП.алгоритм, ЗППП.функциональные и СТД.параллелизм . Ни один из них не был бы легко реализован в C++, по крайней мере, с таким чистым, выразительным API, который есть у модулей D.

Лучший способ научиться D-метапрограммированию, ИМХО, заключается в таких примерах. Я учился в основном, читая код для ЗППП.алгоритм и std.range, которые были написаны Андреем Александреску (гуру метапрограммирования шаблонов C++, который стал активно заниматься D). Затем я использовал то, что узнал, и внес свой вклад в ЗППП.модуль параллелизма.

Также обратите внимание, что у D есть функция оценки времени компиляции (CTFE), которая похожа на C++1x constexpr, но гораздо более общая в том, что большое и растущее подмножество функций, которые могут быть оценены во время выполнения, могут быть оценены немодифицированными во время компиляции. Это полезно для генерации кода во время компиляции, и сгенерированный код может быть скомпилирован с помощью string mixins .

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

Одна вещь, которую C++ действительно просто не может сделать, - это сложная генерация кода во время компиляции.

Вот фрагмент кода D, который делает заказ map(), которыйвозвращает свои результаты по ссылке .

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

Следует отметить следующие важные особенности:

• Шаблоны являются вариадическими: map() может принимать любое число аргументы.

• Код является (относительно) коротким ! Структура Mapper, которая является основной логикой, состоит всего из 15 строк-и все же она может сделать так много с таким малым. Я не говорю, что это невозможно в C++, но это, конечно, не так компактно и чисто.

---

import std.metastrings, std.typetuple, std.range, std.stdio;

void main() {
    auto arr1 = [1, 10, 5, 6], arr2 = [3, 9, 80, 4];

    foreach (ref m; map!min(arr1, arr2)[1 .. 3])
        m *= 50;

    writeln(arr1, arr2); // Voila! You get:  [1, 10, 250, 6][3, 450, 80, 4]
}

auto ref min(T...)(ref T values) {
    auto p = &values[0];
    foreach (i, v; values)
        if (v < *p)
            p = &values[i];
    return *p;
}

Mapper!(F, T) map(alias F, T...)(T args) { return Mapper!(F, T)(args); }

struct Mapper(alias F, T...) {
    T src;  // It's a tuple!

    @property bool empty() { return src[0].empty; }

    @property auto ref front() {
        immutable sources = FormatIota!(q{src[%s].front}, T.length);
        return mixin(Format!(q{F(%s)}, sources));
    }

    void popFront() { foreach (i, x; src) { src[i].popFront(); } }

    auto opSlice(size_t a, size_t b) {
        immutable sliced = FormatIota!(q{src[%s][a .. b]}, T.length);
        return mixin(Format!(q{map!F(%s)}, sliced));
    }
}


// All this does is go through the numbers [0, len),
// and return string 'f' formatted with each integer, all joined with commas
template FormatIota(string f, int len, int i = 0) {
    static if (i + 1 < len)
        enum FormatIota = Format!(f, i) ~ ", " ~ FormatIota!(f, len, i + 1);
    else
        enum FormatIota = Format!(f, i);
}

Я описал свой опыт работы с шаблонами D, строковыми миксинами и шаблонными миксинами: http://david.rothlis.net/d/templates/

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

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

Манипуляции со строками, даже синтаксический анализ строк.

Это библиотека MP , которая генерирует рекурсивные приличные Парсеры на основе грамматик, определенных в строках с использованием (более или менее) BNF. Я не прикасался к нему много лет, но раньше он работал.

В D вы можете проверить размер типа и доступные методы на нем и решить, какую реализацию вы хотите использовать

Это используется, например, в core.atomic модуль

bool cas(T,V1,V2)( shared(T)* here, const V1 ifThis, const V2 writeThis ){
    static if(T.sizeof == byte.sizeof){
       //do 1 byte CaS
    }else static if(T.sizeof == short.sizeof){
       //do 2 byte CaS
    }else static if( T.sizeof == int.sizeof ){
       //do 4 byte CaS
    }else static if( T.sizeof == long.sizeof ){
       //do 8 byte CaS
    }else static assert(false);
}

Просто для того, чтобы противостоять посту трассировки D-лучей, вот c++ compile time ray tracer (metatrace):

(Кстати, он использует в основном метапрограммирование C++2003; Это было бы более читаемым с новым constexprs)

Есть несколько вещей, которые вы можете сделать в шаблоне метапрограммирования в D, которые вы не можете сделать в C++. Самое главное, что вы можете делать шаблонное метапрограммирование без такой боли!