Стенли Липпман - Язык программирования C++. Пятое издание

Новый стандарт вводит второй способ определения псевдонима типа при помощи объявления псевдонима (alias declaration) и знака =.

using SI = Sales_item; // SI - синоним для Sales_item

Объявление псевдонима задает слева от оператора =имя псевдонима типа, который расположен справа.

Псевдоним типа — это имя типа, оно может присутствовать везде, где присутствует имя типа.

wages hourly, weekly; // то же, что и double hourly, weekly;

SI item; // то же, что и Sales_item item

Указатели, константы и псевдонимы типа

Объявления, использующие псевдонимы типа, представляющие составные типы и константы, могут приводить к удивительным результатам. Например, следующие объявления используют тип pstring, который является псевдонимом для типа char*.

typedef char *pstring;

const pstring cstr = 0; // cstr - константный указатель на char

const pstring *ps; // ps - указатель на константный указатель

// на тип char

Базовым типом в этих объявлениях является const pstring. Как обычно, модификатор constв базовом типе модифицирует данный тип. Тип pstring— это указатель на тип char, a const pstring— это константный указатель на тип char, но не указатель на тип const char.

Заманчиво, хоть и неправильно, интерпретировать объявление, которое использует псевдоним типа как концептуальную замену псевдонима, соответствующим ему типом:

const char *cstr = 0; // неправильная интерпретация const pstring cstr

Однако эта интерпретация неправильна. Когда используется тип pstringв объявлении, базовым типом объявления является тип указателя. При перезаписи объявления с использованием char*, базовым типом будет char, а *будет частью оператора объявления. В данном случае базовый тип — это const char. Перезапись объявляет cstrуказателем на тип const char, а не константным указателем на тип char.

Нет ничего необычного в желании сохранить значение выражения в переменной. Чтобы объявить переменную, нужно знать тип этого выражения. Когда мы пишем программу, может быть на удивление трудно (а иногда даже невозможно) определить тип выражения. По новому стандарту можно позволить компилятору самому выяснять этот тип. Для этого используется спецификатор типа auto. В отличие от таких спецификаторов типа, как double, задающих определенный тип, спецификатор auto приказывает компилятору вывести тип из инициализатора. Само собой разумеется, у переменной, использующей спецификатор типа auto, должен быть инициализатор.

// тип item выводится из типа результата суммы val1 и val2

auto item = val1 + val2; // item инициализируется результатом val1 + val2

Здесь компилятор выведет тип переменной itemиз типа значения, возвращенного при применении оператора +к переменным val1и val2. Если переменные val1и val2— объекты класса Sales_item(см. раздел 1.5), типом переменной itemбудет класс Sales_item. Если эти переменные имеют тип double, то у переменной itemбудет тип doubleи т.д.

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

auto i = 0, *p = &i; // ok: i - int, а p - указатель на int

auto sz = 0, pi = 3.14; // ошибка: несовместимые типы у sz и pi

Выводимый компилятором тип для спецификатора autoне всегда точно совпадает с типом инициализатора. Компилятор корректирует тип так, чтобы он соответствовал обычным правилам инициализации.

Во-первых, как уже упоминалось, при использовании ссылки в действительности используется объект, на который она ссылается. В частности, при использовании ссылки как инициализатора им является соответствующий объект. Компилятор использует тип этого объекта для выведения типа auto.

int i = 0, &r = i;

auto a = r; // a - int (r - псевдоним для i, имеющий тип int)

Во-вторых, выведение типа autoобычно игнорирует спецификаторы constверхнего уровня (см. раздел 2.4.3). Как обычно в инициализациях, спецификаторы constнижнего уровня учитываются в случае, когда инициализатор является указателем на константу.

const int ci = i, &cr = ci;

auto b = ci; // b - int (const верхнего уровня в ci отброшен)

auto с = cr; // с - int (cr - псевдоним для ci с const верхнего

// уровня)

auto d = &i; // d - int* (& объекта int - int*)

auto e = &ci; // e - const int* (& константного объекта - const нижнего

// уровня)

Если необходимо, чтобы у выведенного типа был спецификатор constверхнего уровня, его следует указать явно.

const auto f = ci; // выведенный тип ci - int; тип f - const int

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

auto &g = ci; // g - const int&, связанный с ci

auto &h = 42; // ошибка: нельзя связать простую ссылку с литералом

const auto &j = 42; // ok: константную ссылку с литералом связать можно

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

При определении нескольких переменных в том же операторе важно не забывать, что ссылка или указатель — это часть специфического оператора объявления, а не часть базового типа объявления. Как обычно, инициализаторы должны быть совместимы с автоматически выведенными типами:

auto k = ci, &l = i; // k - int; l - int&

auto &m = ci, *p = &ci; // m - const int& p - указатель на const int

// ошибка: выведение типа из i - int;

// тип, выведенный из &ci - const int

auto &n = i, *p2 = &ci;

Упражнение 2.33. С учетом определения переменных из этого раздела укажите то, что происходит в каждом из этих присвоений.

а = 42; b = 42; с = 42;

d = 42; е = 42; g = 42;

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