Инициализация объекта: параметры и инициализаторы

Совместно используемые функции различаются списками параметров. В этом смысле конструкторы подобны функциям. Рассмотрим определение конструктора с параметрами. Мы расположим его за пределами класса. При этом в классе располагается прототип конструктора, а его имя при определении заменяется квалифицированным именем:

class ComplexType {
:::::
public:
ComplexType(double keyReal,
            double keyImag,
            char keyCTcharVal,
            int keyX);
:::::
};
:::::
ComplexType::ComplexType(double keyReal,
            double keyImag,
            char keyCTcharVal,
            int keyX)
 {
  cout << "This is ComplexType("
       << keyReal << ","
       << keyImag << ","
       << (int)keyCTcharVal << ","
       << keyX << ")" << endl;
  real = keyReal;
  imag = keyImag;
  CTcharVal = keyCTcharVal;
  x = keyX;
 };

А вот и подходящее определение. Мы расположим его в функции main:

ComplexType CDw2(100,100,0,0);
/* Создаётся объект типа ComplexType под именем CDw2 с
определёнными значениями. */
int iVal(10);
/* Аналогичным образом может быть определён и проинициализирован
объект основного типа */

Заметим, что к такому же результату (но только окольными путями) приводит и такая форма оператора определения:

ComplexType CDw2 = ComplexType(100,100,0,0);

И снова мы встречаем случай определения объекта посредством постфиксного выражения. Здесь опять можно говорить о явном обращении к конструктору с передачей ему параметров. Выражения явного приведения типа здесь построить невозможно, поскольку за заключённым в скобочки именем типа должно стоять унарное выражение.

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

ComplexType CDw1(); // Это ошибка!
int xVal();         // Это тоже не определение.

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

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

ComplexType(double keyReal = 0,
            double keyImag = 0,
            char keyCTcharVal = 0,
            int keyX = 0);

Но при этом программист должен быть готовым к самым неожиданным ситуациям. Последняя модификация прототипа вызывает протест со стороны транслятора. Он не может теперь однозначно соотнести оператор определения объекта с одним из вариантов конструктора. Перед нами тривиальный случай проявления проблемы сопоставления. Мы закомментируем определение самого первого конструктора (конструктора без параметров) и опять всё будет хорошо. Теперь вся работа по определению и инициализации объектов обеспечивается единственным конструктором с проинициализированными параметрами.

Конструктор, управление которому передаётся в результате выполнения оператора определения без параметров, называется конструктором умолчания. К конструкторам умолчания относятся следующие конструкторы:

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

Внесём ещё одно изменение в текст нашей программы. На этот раз мы добавим спецификатор const в объявление данного-члена класса x:

class ComplexType
{
:::::
const int x;
:::::
}

И опять возникают новые проблемы. На этот раз они связаны с попыткой присвоения значения константе. Как известно, объявление данного-члена класса не допускает инициализации, а для того, чтобы константный член класса в процессе создания объекта всё же мог получить требуемое значение, в C++ используется так называемый ctorИнициализатор (именно так называется эта конструкция в справочном руководстве по C++ Б.Строуструппа). Мы не будем гадать, в чём заключается смысл этого названия, а лучше заново воспроизведем несколько форм Бэкуса-Наура.

ОпределениеФункции ::= [СписокСпецификаторовОбъявления]
                                                Описатель
                                                 [ctorИнициализатор]
                                                          ТелоФункции

ctorИнициализатор ::= : СписокИнициализаторовЧленовКласса

СписокИнициализаторовЧленовКласса ::= ИнициализаторЧленаКласса
                                [, СписокИнициализаторовЧленовКласса]

ИнициализаторЧленаКласса ::= ПолноеИмяКласса([СписокВыражений])
                         ::= Идентификатор([СписокВыражений])

ПолноеИмяКласса ::= КвалифицированноеИмяКласса
                ::= :: КвалифицированноеИмяКласса

Для исследования свойств ctorИнициализатора, подвергнем нашу программу очередной модификации. Мы закомментируем все ранее построенные объявления и определения конструкторов и те из операторов определения объектов класса ComplexType, которые содержали значения, определяющие начальные значения данных-членов. И сразу же начинаем определение новых вариантов конструкторов.

ComplexType():x(1)
 {
  cout << "Здесь ComplexType():x(" << x << ")" << endl;
 };

Перед нами конструктор с ctorИнициализатором. Эта конструкция позволяет решать проблемы начальной инициализации константных данных-членов. При работе с данными-членами класса транслятор рассматривает операцию присвоения как изменение начального значения члена. Инициализатор же отвечает непосредственно за установку этого САМОГО ПЕРВОГО значения.

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

ComplexType():x(1), x(2) // Ошибка.
{
:::::
}

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

Добавим в объявление нашего класса объявление массива. Инициализация массива-члена класса при определении объекта не вызывает особых проблем (здесь следует вспомнить раздел, посвящённый массивам-параметрам). Однако в C++ отсутствует возможность инициализации нестатического константного массива-члена класса. Так что можно не стараться выписывать подобные объявления:

const int xx[2]; // Бессмысленное объявление.

всё равно массив xx[2] невозможно проинициализировать. Все варианты инициализации константного нестатического массива будут отвергнуты.

ComplexType():xx(1,2) {/*…*/};
ComplexType():xx({1,2}) {/*…*/};
ComplexType():xx[0](1), xx[1](2) {/*…*/};

Согласно БНФ, в состав инициализатора могут входить только имена или квалифицированные имена. Для обозначения элемента массива этого недостаточно. Как минимум, здесь требуется выражение индексации, которое указывало бы номер элемента массива.

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

:::::
const int DefVal[2] = {1,2};
class ComplexType
{
:::::
const int const * px;
/* Объявили константный указатель на константу. */
:::::
ComplexType():px(DefVal) {/*…*/};
:::::
};

Окольными путями мы всё же достигаем желаемого результата. Константный указатель на константу контролирует константный массив.

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

ComplexType():px(DefVal),
              x(px[0]), // Транслятор уже знает, что такое px.
             CTcharVal(32),
             real(100),
             imag(real/25) // И здесь тоже всё в порядке.
{
// Здесь располагается тело конструктора.
:::::
}

Назад | Содержание | Вперед