std.conv

Универсальный инструмент для преобразования значений из одного типа в другой.

Лицензия:

Лицензия Boost 1.0.

Авторы:

Уолтер Брайт, Андрей Александреску, Шин Фуджиширо, Адам Д. Руппе, Кенджи Хараву

Исходный код

std/conv.d

class ConvException: object.Exception;

Выбрасывается при ошибках преобразования.

Примеры:

import std.exception : assertThrown;
assertThrown!ConvException(to!int("abc"));

class ConvOverflowException: std.conv.ConvException;

Выбрасывается при ошибках переполнения при преобразовании.

Примеры:

import std.exception : assertThrown;
assertThrown!ConvOverflowException(to!ubyte(1_000_000));

шаблон to(T)

Шаблон to преобразует значение из одного типа в другой. Тип источника определяется автоматически, а целевой тип необходимо указать. Например, выражение to!int(42.0) преобразует число 42 из double в int. Преобразование «безопасное», т.е. проверяет переполнение; to!int(4.2e10) выбросит исключение ConvOverflowException. Проверки на переполнение вставляются только при необходимости, например, to!double(42) не выполняет никаких проверок, так как любое int помещается в double.

Преобразования из строки в числовые типы отличаются от C-эквивалентов atoi() и atol() тем, что проверяют переполнение и не допускают пробелов.

Для преобразования строк в знакомые типы распознаётся грамматика:

Integer: Sign UnsignedInteger
UnsignedInteger
Sign:
    +
    -

Для преобразования в беззнаковые типы распознаётся грамматика:

UnsignedInteger:
    DecimalDigit
    DecimalDigit UnsignedInteger

Примеры:

Преобразование значения в его собственный тип (полезно в основном для обобщённого кода) просто возвращает его аргумент.

int a = 42;
int b = to!int(a);
double c = to!double(3.14); // c is double with value 3.14

Примеры:

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

import std.exception : assertThrown;

int a = 420;
writeln(to!long(a)); // a
assertThrown!ConvOverflowException(to!byte(a));

writeln(to!int(4.2e6)); // 4200000
assertThrown!ConvOverflowException(to!uint(-3.14));
writeln(to!uint(3.14)); // 3
writeln(to!uint(3.99)); // 3
writeln(to!int(-3.99)); // -3

Примеры:

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

auto str = to!string(42, 16);
writeln(str); // "2A"
auto i = to!int(str, 16);
writeln(i); // 42

Примеры:

Преобразования целых типов в типы с плавающей точкой всегда происходят успешно, но могут привести к потере точности. Наибольшие целые числа с предшественником, представимым в формате с плавающей точкой, составляют 2^24-1 для float, 2^53-1 для double, и 2^64-1 для real (когда real составляет 80 бит, например, на машинах Intel).

// 2^24 - 1, largest proper integer representable as float
int a = 16_777_215;
writeln(to!int(to!float(a))); // a
writeln(to!int(to!float(-a))); // -a

Примеры:

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

import std.exception : assertThrown;

writeln(to!char("a")); // 'a'
assertThrown(to!char("ñ")); // 'ñ' does not fit into a char
writeln(to!wchar("ñ")); // 'ñ'
assertThrown(to!wchar("😃")); // '😃' does not fit into a wchar
writeln(to!dchar("😃")); // '😃'

// Using wstring or dstring as source type does not affect the result
writeln(to!char("a"w)); // 'a'
writeln(to!char("a"d)); // 'a'

// Two code points cannot be converted to a single one
assertThrown(to!char("ab"));

Примеры:

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

import std.string : split;

int[] a = [1, 2, 3];
auto b = to!(float[])(a);
writeln(b); // [1.0f, 2, 3]
string str = "1 2 3 4 5 6";
auto numbers = to!(double[])(split(str));
writeln(numbers); // [1.0, 2, 3, 4, 5, 6]
int[string] c;
c["a"] = 1;
c["b"] = 2;
auto d = to!(double[wstring])(c);
assert(d["a"w] == 1 && d["b"w] == 2);

Примеры:

Преобразования работают транзитивно, то есть они работают с массивами и ассоциативными массивами любой сложности. Это преобразование работает, потому что to!short применяется к int, to!wstring применяется к string, to!string применяется к double, и to!(double[]) применяется к int[]. Преобразование может вызвать исключение, потому что to!short может не пройти проверку диапазона.

int[string][double[int[]]] a;
auto b = to!(short[wstring][string[double[]]])(a);

Примеры:

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

import std.exception : assertThrown;
// Testing object conversions
class A {}
class B : A {}
class C : A {}
A a1 = new A, a2 = new B, a3 = new C;
assert(to!B(a2) is a2);
assert(to!C(a3) is a3);
assertThrown!ConvException(to!B(a3));

Примеры:

Поддерживается преобразование в строку из всех типов.

• Преобразование строки в строку работает для любых двух строковых типов, имеющих (char, wchar, dchar) ширину символов и любые сочетания квалификаторов (изменяемый, const, или immutable).
• Преобразует массив (кроме строк) в строку. Каждый элемент преобразуется путем вызова to!T.
• Преобразование ассоциативного массива в строку. Каждый элемент преобразуется путем вызова to!T.
• Преобразование объекта в строку вызывает toString для объекта или возвращает "null", если объект равен null.
• Преобразование структуры в строку вызывает toString для структуры, если она определена.
• Для структур, не определяющих toString, преобразование в строку генерирует список полей.
• Перечисления преобразуются в строки в виде их символических имен.
• Булевы значения преобразуются в "true" или "false".
• char, wchar, dchar в строковый тип.
• Беззнаковые или знакомые целые числа в строки.

  [специальный случай]

  Преобразует целое значение в строку в системе счисления radix. radix должно быть значением от 2 до 36. значение обрабатывается как знаковое только если radix равно 10. Символы от A до Z используются для представления значений от 10 до 36, и их регистр определяется параметром letterCase.

• Все типы чисел с плавающей точкой во все строковые типы.
• Преобразования указателей в строки преобразуют указатель в size_t значение. Если указатель char*, рассматривайте его как строку в стиле C. В этом случае эта функция @system.

См. std.format.formatValue о том, как должно быть определено toString.

// Conversion representing dynamic/static array with string
long[] a = [ 1, 3, 5 ];
writeln(to!string(a)); // "[1, 3, 5]"

// Conversion representing associative array with string
int[string] associativeArray = ["0":1, "1":2];
assert(to!string(associativeArray) == `["0":1, "1":2]` ||
       to!string(associativeArray) == `["1":2, "0":1]`);

// char* to string conversion
writeln(to!string(cast(char*)null)); // ""
writeln(to!string("foo\0".ptr)); // "foo"

// Conversion reinterpreting void array to string
auto w = "abcx"w;
const(void)[] b = w;
writeln(b.length); // 8

auto c = to!(wchar[])(b);
writeln(c); // "abcx"

шаблон roundTo(Target)

Округленное преобразование из чисел с плавающей точкой в целые.

Округленные преобразования не работают с нецелыми целевыми типами.

Примеры:

writeln(roundTo!int(3.14)); // 3
writeln(roundTo!int(3.49)); // 3
writeln(roundTo!int(3.5)); // 4
writeln(roundTo!int(3.999)); // 4
writeln(roundTo!int(-3.14)); // -3
writeln(roundTo!int(-3.49)); // -3
writeln(roundTo!int(-3.5)); // -4
writeln(roundTo!int(-3.999)); // -4
writeln(roundTo!(const int)(to!(const double)(-3.999))); // -4

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source source)
Constraints: if (isInputRange!Source && isSomeChar!(ElementType!Source) && is(immutable(Target) == immutable(bool)));

Семейство функций parse работает очень похоже на семейство to функций, за исключением:

1. Она работает только с диапазонами символов в качестве входных данных.
2. Она принимает входные данные по ссылке. (Это означает, что rvalues, такие как строковые литералы, не принимаются: используйте to вместо этого.)
3. Она перемещает входной поток в позицию, следующую за преобразованием.
4. Она не выбрасывает исключение, если не смогла преобразовать весь вход.

Этот перегруз преобразует диапазон символов во входные данные в bool.

Параметры:

Target	тип, в который нужно преобразовать
Source source	ссылка на диапазон входных данных
doCount	флаг для указания на необходимость отслеживания числа израсходованных символов

Возвращаемое значение:

• Значение типа bool если doCount установлено в No.doCount
• Структура tuple содержащая значение типа bool и значение size_t если doCount установлено в Yes.doCount

Исключения:

Исключение ConvException если диапазон не представляет bool.

Примечание

Все преобразования входных диапазонов символов с помощью to передаются в parse и не требуют lvalues.

Примеры:

import std.typecons : Flag, Yes, No;
auto s = "true";
bool b = parse!bool(s);
assert(b);
auto s2 = "true";
bool b2 = parse!(bool, string, No.doCount)(s2);
assert(b2);
auto s3 = "true";
auto b3 = parse!(bool, string, Yes.doCount)(s3);
assert(b3.data && b3.count == 4);
auto s4 = "falSE";
auto b4 = parse!(bool, string, Yes.doCount)(s4);
assert(!b4.data && b4.count == 5);

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
Constraints: if (isSomeChar!(ElementType!Source) && isIntegral!Target && !is(Target == enum));

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source source, uint radix)
Constraints: if (isSomeChar!(ElementType!Source) && isIntegral!Target && !is(Target == enum));

Разбирает диапазон символов входных данных в целое значение.

Параметры:

Target	целочисленный тип для преобразования
Source s	ссылка на диапазон входных данных
doCount	флаг для указания на необходимость отслеживания числа израсходованных символов

Возвращаемое значение:

• Число типа Target если doCount установлено в No.doCount
• Структура tuple содержащая число типа Target и значение size_t если doCount установлено в Yes.doCount

Исключения:

Исключение ConvException Если во время преобразования произошло переполнение или ни один символ входных данных не был осмысленно преобразован.

Примеры:

import std.typecons : Flag, Yes, No;
string s = "123";
auto a = parse!int(s);
writeln(a); // 123

string s1 = "123";
auto a1 = parse!(int, string, Yes.doCount)(s1);
assert(a1.data == 123 && a1.count == 3);

// parse only accepts lvalues
static assert(!__traits(compiles, parse!int("123")));

Примеры:

import std.string : tr;
import std.typecons : Flag, Yes, No;
string test = "123 \t  76.14";
auto a = parse!uint(test);
writeln(a); // 123
assert(test == " \t  76.14"); // parse bumps string
test = tr(test, " \t\n\r", "", "d"); // skip ws
writeln(test); // "76.14"
auto b = parse!double(test);
writeln(b); // 76.14
writeln(test); // ""

string test2 = "123 \t  76.14";
auto a2 = parse!(uint, string, Yes.doCount)(test2);
assert(a2.data == 123 && a2.count == 3);
assert(test2 == " \t  76.14");// parse bumps string
test2 = tr(test2, " \t\n\r", "", "d"); // skip ws
writeln(test2); // "76.14"
auto b2 = parse!(double, string, Yes.doCount)(test2);
assert(b2.data == 76.14 && b2.count == 5);
writeln(test2); // ""

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
Constraints: if (isSomeString!Source && !is(Source == enum) && is(Target == enum));

Принимает строку, представляющую тип enum, и возвращает этот тип.

Параметры:

Target	тип enum для преобразования
Source s	ссылка на диапазон для разбора
doCount	флаг для указания на необходимость отслеживания числа израсходованных символов

Возвращаемое значение:

• Значение типа enum если doCount установлено в No.doCount
• Структура tuple содержащая значение типа Target и значение size_t если doCount установлено в Yes.doCount

Исключения:

Исключение ConvException если тип Target не имеет члена, представленного s.

Примеры:

import std.typecons : Flag, Yes, No, tuple;
enum EnumType : bool { a = true, b = false, c = a }

auto str = "a";
writeln(parse!EnumType(str)); // EnumType.a
auto str2 = "a";
writeln(parse!(EnumType, string, No.doCount)(str2)); // EnumType.a
auto str3 = "a";
writeln(parse!(EnumType, string, Yes.doCount)(str3)); // tuple(EnumType.a, 1)

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source source)
Constraints: if (isInputRange!Source && isSomeChar!(ElementType!Source) && !is(Source == enum) && isFloatingPoint!Target && !is(Target == enum));

Парсит диапазон символов в число с плавающей точкой.

Параметры:

Target	тип с плавающей точкой
Source source	lvalue диапазона для парсинга
doCount	флаг для указания необходимости отслеживания количества прочитанных символов

Возвращает:

• Число с плавающей точкой типа Target если doCount установлено в No.doCount
• Объект tuple, содержащий число с плавающей точкой типа Target и количество прочитанных символов, если doCount установлено в Yes.doCount

Выбрасывает:

Исключение ConvException, если диапазон пуст, если число не удалось распарсить или произошел переполнение.

Примеры:

import std.math : approxEqual;
import std.typecons : Flag, Yes, No;
import std.math : isNaN, isInfinity;
auto str = "123.456";
assert(parse!double(str).approxEqual(123.456));
auto str2 = "123.456";
assert(parse!(double, string, No.doCount)(str2).approxEqual(123.456));
auto str3 = "123.456";
auto r = parse!(double, string, Yes.doCount)(str3);
assert(r.data.approxEqual(123.456));
writeln(r.count); // 7
auto str4 = "-123.456";
r = parse!(double, string, Yes.doCount)(str4);
assert(r.data.approxEqual(-123.456));
writeln(r.count); // 8
auto str5 = "+123.456";
r = parse!(double, string, Yes.doCount)(str5);
assert(r.data.approxEqual(123.456));
writeln(r.count); // 8
auto str6 = "inf0";
r = parse!(double, string, Yes.doCount)(str6);
assert(isInfinity(r.data) && r.count == 3 && str6 == "0");
auto str7 = "-0";
auto r2 = parse!(float, string, Yes.doCount)(str7);
assert(r2.data.approxEqual(0.0) && r2.count == 2);
auto str8 = "nan";
auto r3 = parse!(real, string, Yes.doCount)(str8);
assert(isNaN(r3.data) && r3.count == 3);

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
Constraints: if (isSomeString!Source && !is(Source == enum) && (staticIndexOf!(immutable(Target), immutable(dchar), immutable(ElementEncodingType!Source)) >= 0));

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
Constraints: if (!isSomeString!Source && isInputRange!Source && isSomeChar!(ElementType!Source) && isSomeChar!Target && (Target.sizeof >= ElementType!Source.sizeof) && !is(Target == enum));

Парсинг одного символа из диапазона возвращает первый элемент и вызывает popFront.

Параметры:

Target	тип для преобразования
Source s	lvalue входного диапазона
doCount	флаг для указания необходимости отслеживания количества прочитанных символов

Возвращает:

• Символ типа Target если doCount установлено в No.doCount
• Объект tuple, содержащий символ типа Target и количество прочитанных символов, если doCount установлено в Yes.doCount

Выбрасывает:

Исключение ConvException, если диапазон пуст.

Примеры:

import std.typecons : Flag, Yes, No;
auto s = "Hello, World!";
char first = parse!char(s);
writeln(first); // 'H'
writeln(s); // "ello, World!"
char second = parse!(char, string, No.doCount)(s);
writeln(second); // 'e'
writeln(s); // "llo, World!"
auto third = parse!(char, string, Yes.doCount)(s);
assert(third.data == 'l' && third.count == 1);
writeln(s); // "lo, World!"

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s)
Constraints: if (isInputRange!Source && isSomeChar!(ElementType!Source) && is(immutable(Target) == immutable(typeof(null))));

Парсинг диапазона символов в typeof(null) возвращает null, если диапазон содержит "null". Функция нечувствительна к регистру.

Параметры:

Target	тип для преобразования
Source s	lvalue входного диапазона
doCount	флаг для указания необходимости отслеживания количества прочитанных символов

Возвращает:

• null если doCount установлено в No.doCount
• Объект tuple, содержащий null и количество прочитанных символов, если doCount установлено в Yes.doCount

Выбрасывает:

Исключение ConvException, если диапазон не представляет null.

Примеры:

import std.exception : assertThrown;
import std.typecons : Flag, Yes, No;

alias NullType = typeof(null);
auto s1 = "null";
assert(parse!NullType(s1) is null);
writeln(s1); // ""

auto s2 = "NUll"d;
assert(parse!NullType(s2) is null);
writeln(s2); // ""

auto s3 = "nuLlNULl";
assert(parse!(NullType, string, No.doCount)(s3) is null);
auto r = parse!(NullType, string, Yes.doCount)(s3);
assert(r.data is null && r.count == 4);

auto m = "maybe";
assertThrown!ConvException(parse!NullType(m));
assertThrown!ConvException(parse!(NullType, string, Yes.doCount)(m));
assert(m == "maybe");  // m shouldn't change on failure

auto s = "NULL";
assert(parse!(const NullType)(s) is null);

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s, dchar lbracket = '[', dchar rbracket = ']', dchar comma = ',')
Constraints: if (isSomeString!Source && !is(Source == enum) && isDynamicArray!Target && !is(Target == enum));

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s, dchar lbracket = '[', dchar rbracket = ']', dchar comma = ',')
Constraints: if (isExactSomeString!Source && isStaticArray!Target && !is(Target == enum));

Парсит массив из строки, используя заданные левую скобку (по умолчанию '['), правую скобку (по умолчанию ']') и разделитель элементов (по умолчанию ','). Разделитель в конце разрешен.

Параметры:

Source s	Строка для парсинга
dchar lbracket	Символ, начинающий массив
dchar rbracket	Символ, завершающий массив
dchar comma	Символ, разделяющий элементы массива
doCount	флаг для указания необходимости отслеживания количества прочитанных символов

Возвращает:

• Массив типа Target если doCount установлено в No.doCount
• Объект tuple, содержащий массив типа Target и количество прочитанных символов, если doCount установлено в Yes.doCount

Примеры:

import std.typecons : Flag, Yes, No;
auto s1 = `[['h', 'e', 'l', 'l', 'o'], "world"]`;
auto a1 = parse!(string[])(s1);
writeln(a1); // ["hello", "world"]

auto s2 = `["aaa", "bbb", "ccc"]`;
auto a2 = parse!(string[])(s2);
writeln(a2); // ["aaa", "bbb", "ccc"]

auto s3 = `[['h', 'e', 'l', 'l', 'o'], "world"]`;
auto len3 = s3.length;
auto a3 = parse!(string[], string, Yes.doCount)(s3);
writeln(a3.data); // ["hello", "world"]
writeln(a3.count); // len3

auto parse(Target, Source, Flag!"doCount" doCount = No.doCount)(ref Source s, dchar lbracket = '[', dchar rbracket = ']', dchar keyval = ':', dchar comma = ',')
Constraints: if (isSomeString!Source && !is(Source == enum) && isAssociativeArray!Target && !is(Target == enum));

Парсит ассоциативный массив из строки, используя заданные левую скобку (по умолчанию '['), правую скобку (по умолчанию ']'), разделитель ключ-значение (по умолчанию ':') и разделитель элементов (по умолчанию ',').

Параметры:

Source s	Строка для парсинга
dchar lbracket	Символ, начинающий ассоциативный массив
dchar rbracket	Символ, завершающий ассоциативный массив
dchar keyval	Символ, разделяющий ключ и значение
dchar comma	Символ, разделяющий элементы ассоциативного массива
doCount	флаг для указания необходимости отслеживания количества прочитанных символов

Возвращает:

• Ассоциативный массив типа Target если doCount установлено в No.doCount
• Объект tuple, содержащий ассоциативный массив типа Target и количество прочитанных символов, если doCount установлено в Yes.doCount

Примеры:

import std.typecons : Flag, Yes, No, tuple;
import std.range.primitives : save;
import std.array : assocArray;
auto s1 = "[1:10, 2:20, 3:30]";
auto copyS1 = s1.save;
auto aa1 = parse!(int[int])(s1);
writeln(aa1); // [1:10, 2:20, 3:30]
// parse!(int[int], string, Yes.doCount)(copyS1)
writeln(tuple([1:10, 2:20, 3:30], copyS1.length));

auto s2 = `["aaa":10, "bbb":20, "ccc":30]`;
auto copyS2 = s2.save;
auto aa2 = parse!(int[string])(s2);
writeln(aa2); // ["aaa":10, "bbb":20, "ccc":30]
assert(tuple(["aaa":10, "bbb":20, "ccc":30], copyS2.length) ==
    parse!(int[string], string, Yes.doCount)(copyS2));

auto s3 = `["aaa":[1], "bbb":[2,3], "ccc":[4,5,6]]`;
auto copyS3 = s3.save;
auto aa3 = parse!(int[][string])(s3);
writeln(aa3); // ["aaa":[1], "bbb":[2, 3], "ccc":[4, 5, 6]]
assert(tuple(["aaa":[1], "bbb":[2,3], "ccc":[4,5,6]], copyS3.length) ==
    parse!(int[][string], string, Yes.doCount)(copyS3));

auto s4 = `[]`;
int[int] emptyAA;
writeln(tuple(emptyAA, s4.length)); // parse!(int[int], string, Yes.doCount)(s4)

string text(T...)(T args)
Constraints: if (T.length > 0);

wstring wtext(T...)(T args)
Constraints: if (T.length > 0);

dstring dtext(T...)(T args)
Constraints: if (T.length > 0);

Функции для преобразования одного или нескольких аргументов любого типа в текст (с тремя видами ширины символов).

Примеры:

writeln(text(42, ' ', 1.5, ": xyz")); // "42 1.5: xyz"c
writeln(wtext(42, ' ', 1.5, ": xyz")); // "42 1.5: xyz"w
writeln(dtext(42, ' ', 1.5, ": xyz")); // "42 1.5: xyz"d

template octal(string num) if (isOctalLiteral(num))

template octal(alias decimalInteger) if (is(typeof(decimalInteger)) && isIntegral!(typeof(decimalInteger)))

Вспомогательная возможность octal предоставляет способ объявления числа в восьмеричной системе. Используйте octal!177 или octal!"177" для представления 127 в восьмеричной системе (аналогично 0177 в C).

Правила для строк — обычные правила для литералов: Если число помещается в int, это восьмеричная константа. Иначе — десятичная. Но если пользователь явно запросил long с суффиксом L, всегда возвращается long. Беззнаковое целое возвращается, если запрос сделан с суффиксом U или u. Восьмеричные значения, созданные из целых чисел, сохраняют тип переданного целого.

См. также:

parse для парсинга восьмеричных строк во время выполнения.

Примеры:

// same as 0177
auto x = octal!177;
// octal is a compile-time device
enum y = octal!160;
// Create an unsigned octal
auto z = octal!"1_000_000u";

pure nothrow @safe T* emplace(T)(T* chunk);

Принимая указатель chunk на неинициализированную память (но уже типизированную как T), создаёт объект неклассового типа T по этому адресу. Если T — класс, инициализирует ссылку класса значением null.

Возвращает:

Указатель на вновь созданный объект (который совпадает с chunk).

Примеры:

static struct S
{
    int i = 42;
}
S[2] s2 = void;
emplace(&s2);
assert(s2[0].i == 42 && s2[1].i == 42);

Примеры:

interface I {}
class K : I {}

K k = void;
emplace(&k);
assert(k is null);

I i = void;
emplace(&i);
assert(i is null);

T* emplace(T, Args...)(T* chunk, auto ref Args args)
Constraints: if (is(T == struct) || Args.length == 1);

Принимая указатель chunk на неинициализированную память (но уже типизированную как неклассовый тип T), создаёт объект типа T по этому адресу из аргументов args. Если T — класс, инициализирует ссылку класса значением args[0].

Эта функция может быть @trusted, если соответствующий конструктор T является @safe.

Возвращает:

Указатель на вновь созданный объект (который совпадает с chunk).

Примеры:

int a;
int b = 42;
writeln(*emplace!int(&a, b)); // 42

T emplace(T, Args...)(T chunk, auto ref Args args)
Constraints: if (is(T == class));

Принимая область необработанной памяти chunk (но уже типизированную как тип класса T), создает объект типа class T по этому адресу. Конструктор получает аргументы Args.

Если T является внутренним классом, чьё поле outer может быть использовано для доступа к экземпляру внешнего класса, то Args не должно быть пустым, и первый его член должен быть допустимым инициализатором для поля outer. Правильная инициализация этого поля необходима для доступа к членам внешнего класса внутри методов T.

Примечание

Эта функция может быть @safe если соответствующий конструктор T является @safe.

Возвращает:

Новый созданный объект.

Примеры:

() @safe {
    class SafeClass
    {
        int x;
        @safe this(int x) { this.x = x; }
    }

    auto buf = new void[__traits(classInstanceSize, SafeClass)];
    auto support = (() @trusted => cast(SafeClass)(buf.ptr))();
    auto safeClass = emplace!SafeClass(support, 5);
    writeln(safeClass.x); // 5

    class UnsafeClass
    {
        int x;
        @system this(int x) { this.x = x; }
    }

    auto buf2 = new void[__traits(classInstanceSize, UnsafeClass)];
    auto support2 = (() @trusted => cast(UnsafeClass)(buf2.ptr))();
    static assert(!__traits(compiles, emplace!UnsafeClass(support2, 5)));
    static assert(!__traits(compiles, emplace!UnsafeClass(buf2, 5)));
}();

T emplace(T, Args...)(void[] chunk, auto ref Args args)
Constraints: if (is(T == class));

Принимая область необработанной памяти chunk, создает объект типа class T по этому адресу. Конструктор получает аргументы Args.

Если T является внутренним классом, чьё поле outer может быть использовано для доступа к экземпляру внешнего класса, то Args не должно быть пустым, и первый его член должен быть допустимым инициализатором для поля outer. Правильная инициализация этого поля необходима для доступа к членам внешнего класса внутри методов T.

Предпосылки

chunk должна быть как минимум такой же большой, как T и должна иметь выравнивание, кратное выравниванию T. (Размер экземпляра class получается с помощью _traits(classInstanceSize, T)).

Примечание

Эта функция может быть @trusted если соответствующий конструктор T является @safe.

Возвращает:

Новый созданный объект.

Примеры:

static class C
{
    int i;
    this(int i){this.i = i;}
}
auto buf = new void[__traits(classInstanceSize, C)];
auto c = emplace!C(buf, 5);
writeln(c.i); // 5

T* emplace(T, Args...)(void[] chunk, auto ref Args args)
Constraints: if (!is(T == class));

Принимая область необработанной памяти chunk, создает объект типа не-class T по этому адресу. Конструктору передаются аргументы args, если они есть.

Предпосылки

chunk должна быть как минимум такой же большой, как T и должна иметь выравнивание, кратное выравниванию T.

Примечание

Эта функция может быть @trusted если соответствующий конструктор T является @safe.

Возвращает:

Указатель на новый созданный объект.

Примеры:

struct S
{
    int a, b;
}
auto buf = new void[S.sizeof];
S s;
s.a = 42;
s.b = 43;
auto s1 = emplace!S(buf, s);
assert(s1.a == 42 && s1.b == 43);

auto unsigned(T)(T x)
Constraints: if (isIntegral!T);

auto unsigned(T)(T x)
Constraints: if (isSomeChar!T);

Возвращает соответствующее беззнаковое значение для x (например, если x имеет тип int, оно возвращает cast(uint) x). Преимущество по сравнению с приведением типа заключается в том, что вам не нужно переписывать приведение, если x позже изменит тип (например, с int на long).

Обратите внимание, что результат всегда изменяемый, даже если исходный тип был const или неизменяемый. Для сохранения const-ности используйте std.traits.Unsigned.

Примеры:

import std.traits : Unsigned;
immutable int s = 42;
auto u1 = unsigned(s); //not qualified
static assert(is(typeof(u1) == uint));
Unsigned!(typeof(s)) u2 = unsigned(s); //same qualification
static assert(is(typeof(u2) == immutable uint));
immutable u3 = unsigned(s); //explicitly qualified

auto signed(T)(T x)
Constraints: if (isIntegral!T);

Возвращает соответствующее знаковое значение для x (например, если x имеет тип uint, оно возвращает cast(int) x). Преимущество по сравнению с приведением типа заключается в том, что вам не нужно переписывать приведение, если x позже изменит тип (например, с uint на ulong).

Обратите внимание, что результат всегда изменяемый, даже если исходный тип был const или неизменяемый. Для сохранения const-ности используйте std.traits.Signed.

Примеры:

import std.traits : Signed;

immutable uint u = 42;
auto s1 = signed(u); //not qualified
static assert(is(typeof(s1) == int));
Signed!(typeof(u)) s2 = signed(u); //same qualification
static assert(is(typeof(s2) == immutable int));
immutable s3 = signed(u); //explicitly qualified

OriginalType!E asOriginalType(E)(E value)
Constraints: if (is(E == enum));

Возвращает представление перечислимого значения, т.е. значение, преобразованное к базовому типу перечисления.

Примеры:

enum A { a = 42 }
static assert(is(typeof(A.a.asOriginalType) == int));
writeln(A.a.asOriginalType); // 42
enum B : double { a = 43 }
static assert(is(typeof(B.a.asOriginalType) == double));
writeln(B.a.asOriginalType); // 43

template castFrom(From)

Обёртка поверх встроенного оператора приведения, которая позволяет ограничить приведение исходного типа значения.

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

Параметры:

From	Тип, с которого производится приведение. Разработчик должен убедиться, что такое приведение корректно.

Примеры:

// Regular cast, which has been verified to be legal by the programmer:
{
    long x;
    auto y = cast(int) x;
}

// However this will still compile if 'x' is changed to be a pointer:
{
    long* x;
    auto y = cast(int) x;
}

// castFrom provides a more reliable alternative to casting:
{
    long x;
    auto y = castFrom!long.to!int(x);
}

// Changing the type of 'x' will now issue a compiler error,
// allowing bad casts to be caught before it's too late:
{
    long* x;
    static assert(
        !__traits(compiles, castFrom!long.to!int(x))
    );

    // if cast is still needed, must be changed to:
    auto y = castFrom!(long*).to!int(x);
}

ref @system auto to(To, T)(auto ref T value);

Параметры:

To	Тип, к которому производится приведение.
T value	Значение, подлежащее приведению. Оно должно иметь тип From, в противном случае будет выдано ошибка во время компиляции.

Возвращает:

Значение после приведения, возвращаемое по ссылке, если это возможно.

template hexString(string hexData) if (hexData.isHexLiteral)

template hexString(wstring hexData) if (hexData.isHexLiteral)

template hexString(dstring hexData) if (hexData.isHexLiteral)

Преобразует шестнадцатеричную литерал в строку во время компиляции.

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

Функция предназначена для замены шестнадцатеричных литеральных строк, начинающихся с 'x', что может упростить базовый язык.

Параметры:

hexData

Строка для преобразования.

Возвращает:

строку, строку wstring или dstring, в зависимости от типа hexData.

Примеры:

// conversion at compile time
auto string1 = hexString!"304A314B";
writeln(string1); // "0J1K"
auto string2 = hexString!"304A314B"w;
writeln(string2); // "0J1K"w
auto string3 = hexString!"304A314B"d;
writeln(string3); // "0J1K"d

pure nothrow @nogc @safe auto toChars(ubyte radix = 10, Char = char, LetterCase letterCase = LetterCase.lower, T)(T value)
Constraints: if ((radix == 2 || radix == 8 || radix == 10 || radix == 16) && (is(immutable(T) == immutable(uint)) || is(immutable(T) == immutable(ulong)) || radix == 10 && (is(immutable(T) == immutable(int)) || is(immutable(T) == immutable(long)))));

Преобразование целого числа в диапазон символов. Предполагается лёгкость и скорость.

Параметры:

radix	2, 8, 10, 16
Char	тип символа для вывода
letterCase	lower для deadbeef, upper для DEADBEEF
T value	целое число для преобразования. Может быть uint или ulong. Если radix равен 10, также может быть int или long.

Возвращает:

Диапазон произвольного доступа с нарезкой и всем остальным

Примеры:

import std.algorithm.comparison : equal;

assert(toChars(1).equal("1"));
assert(toChars(1_000_000).equal("1000000"));

assert(toChars!(2)(2U).equal("10"));
assert(toChars!(16)(255U).equal("ff"));
assert(toChars!(16, char, LetterCase.upper)(255U).equal("FF"));