14.5. Список инициализации членов

14.5. Список инициализации членов

Модифицируем наш класс Account, объявив член _name типа string:

#include string

class Account {

public:

// ...

private:

unsigned int _acct_nmbr;

double _balance;

string _name;

};

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

Исходный конструктор Account с двумя параметрами

Account( const char*, double = 0.0 );

не может инициализировать член типа string. Например:

string new_client( " Steve Hall" );

Account new_acct( new_client, 25000 );

не будет компилироваться, так как не существует неявного преобразования из типа string в тип char*. Инструкция

Account new_acct( new_client.c_str(), 25000 );

правильна, но вызовет у пользователей класса недоумение. Одно из решений - добавить новый конструктор вида:

Account( string, double = 0.0 );

Если написать:

Account new_acct( new_client, 25000 );

вызывается именно этот конструктор, тогда как старый код

Account *open_new_account( const char *nm )

{

Account *pact = new Account( nm );

// ...

return pacct;

}

по-прежнему будет приводить к вызову исходного конструктора с двумя параметрами.

Так как в классе string определено преобразование из типа char* в тип string (преобразования классов обсуждаются в этой главе ниже), то можно заменить исходный конструктор на новый, которому в качестве первого параметра передается тип string. В таком случае, когда встречается инструкция:

Account myAcct( " Tinkerbell" );

" Tinkerbell" преобразуется во временный объект типа string. Затем этот объект передается новому конструктору с двумя параметрами.

При проектировании приходится идти на компромисс между увеличением числа конструкторов класса Account и несколько менее эффективной обработкой аргументов типа char* из-за необходимости создавать временный объект. Мы предоставили две версии конструктора с двумя параметрами. Тогда модифицированный набор конструкторов Account будет таким:

#include string

class Account {

public:

Account();

Account( const char*, double=0.0 );

Account( const string&, double=0.0 );

Account( const Account& );

// ...

private:

// ...

};

* Как правильно инициализировать член, являющийся объектом некоторого класса с собственным набором конструкторов? Этот вопрос можно разделить на три: где вызывается конструктор по умолчанию? Внутри конструктора по умолчанию класса Account;

* где вызывается копирующий конструктор? Внутри копирующего конструктора класса Account и внутри конструктора с двумя параметрами, принимающего в качестве первого тип string;

* как передать аргументы конструктору класса, являющегося членом другого класса? Это необходимо делать внутри конструктора Account с двумя параметрами, принимающего в качестве первого тип char*.

Решение заключается в использовании списка инициализации членов (мы упоминали о нем в разделе 14.2). Члены, являющиеся классами, можно явно инициализировать с помощью списка, состоящего из разделенных запятыми пар "имя члена/значение". Наш конструктор с двумя параметрами теперь выглядит так (напомним, что _name - это член, являющийся объектом класса string):

inline Account::

Account( const char* name, double opening_bal )

: _name( name ), _balance( opening_bal )

{

_acct_nmbr = het_unique_acct_nmbr();

}

Список инициализации членов следует за сигнатурой конструктора и отделяется от нее двоеточием. В нем указывается имя члена, а в скобках - начальные значения, что аналогично синтаксису вызова функции. Если член является объектом класса, то эти значения становятся аргументами, передаваемыми подходящему конструктору, который затем и используется. В нашем примере значение name передается конструктору string, который применяется к члену _name. Член _balance инициализируется значением opening_bal.

Аналогично выглядит второй конструктор с двумя параметрами:

inline Account::

Account( const string& name, double opening_bal )

: _name( name ), _balance( opening_bal )

{

_acct_nmbr = het_unique_acct_nmbr();

}

В этом случае вызывается копирующий конструктор string, инициализирующий член _name значением параметра name типа string.

Часто у новичков возникает вопрос: в чем разница между использованием списка инициализации и присваиванием значений членам в теле конструктора? Например, в чем разница между

inline Account::

Account( const char* name, double opening_bal )

: _name( name ), _balance( opening_bal )

{

_acct_nmbr = het_unique_acct_nmbr();

}

и

Account( const char* name, double opening_bal )

{

_name = name;

_balance = opening_bal;

_acct_nmbr = het_unique_acct_nmbr();

}

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

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

Первая фаза может быть явной или неявной в зависимости от того, имеется ли список инициализации членов. При неявной инициализации сначала вызываются конструкторы по умолчанию всех базовых классов в порядке их объявления, а затем конструкторы по умолчанию всех членов, являющихся объектами классов. (Базовые классы мы будем рассматривать в главе 17 при обсуждении объектно-ориентированного программирования.) Например, если написать:

inline Account::

Account()

{

_name = "";

_balance = 0.0;

_acct_nmbr = 0;

}

то фаза инициализации будет неявной. Еще до выполнения тела конструктора вызывается конструктор по умолчанию класса string, ассоциированный с членом _name. Это означает, что присваивание _name пустой строки излишне.

Для объектов классов различие между инициализацией и присваиванием существенно. Член, являющийся объектом класса, всегда следует инициализировать с помощью списка, а не присваивать ему значение в теле конструктора. Более правильной является следующая реализация конструктора по умолчанию класса Account:

inline Account::

Account() : _name( string() )

{

_balance = 0.0;

_acct_nmbr = 0;

}

Мы удалили ненужное присваивание _name из тела конструктора. Явный же вызов конструктора по умолчанию string излишен. Ниже приведена эквивалентная, но более компактная версия:

inline Account::

Account()

{

_balance = 0.0;

_acct_nmbr = 0;

}

Однако мы еще не ответили на вопрос об инициализации двух членов встроенных типов. Например, так ли существенно, где происходит инициализация _balance: в списке инициализации или в теле конструктора? Инициализация и присваивание членам, не являющимся объектами классов, эквивалентны как с точки зрения результата, так и с точки зрения производительности (за двумя исключениями). Мы предпочитаем использовать список:

// предпочтительный стиль инициализации

inline Account::

Account() : _balance( 0.0 ), _acct_nmbr( 0 )

{}

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

class ConstRef {

public:

ConstRef(int ii );

private:

int i;

const int ci;

int

};

ConstRef::

ConstRef( int ii )

{ // присваивание

i = ii; // правильно

ci = ii; // ошибка: нельзя присваивать константному члену

ri = i; // ошибка: ri не инициализирована

}

К началу выполнения тела конструктора инициализация всех константных членов и членов-ссылок должна быть завершена. Для этого нужно указать их в списке инициализации. Правильная реализация предыдущего примера такова:

// правильно: инициализируются константные члены и ссылки

ConstRef::

ConstRef( int ii )

: ci( ii ), ri ( i )

{ i = ii; }

Каждый член должен встречаться в списке инициализации не более одного раза. Порядок инициализации определяется не порядком следования имен в списке, а порядком объявления членов. Если дано следующее объявление членов класса Account:

class Account {

public:

// ...

private:

unsigned int _acct_nmbr;

double _balance;

string _name;

};

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

inline Account::

Account() : _name( string() ), _balance( 0.0 ), _acct_nmbr( 0 )

{}

будет следующим: _acct_nmbr, _balance, _name. Однако члены, указанные в списке (или в неявно инициализируемом члене-объекте класса), всегда инициализируются раньше, чем производится присваивание членам в теле конструктора. Например, в следующем конструкторе:

inline Account::

Account( const char* name, double bal )

: _name( name ), _balance( bal )

{

_acct_nmbr = get_unique_acct_nmbr();

}

порядок инициализации такой: _balance, _name, _acct_nmbr.

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

class X {

int i;

int j;

public:

// видите проблему?

X( int val )

: j( val ), i( j )

{}

// ...

};

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

// предпочтительная идиома

X::X( int val ) : i( val ) { j = i; }

Упражнение 14.12

Что неверно в следующих определениях конструкторов? Как бы вы исправили обнаруженные ошибки?

(a) Word::Word( char *ps, int count = 1 )

: _ps( new char[strlen(ps)+1] ),

_count( count )

{

if ( ps )

strcpy( _ps, ps );

else {

_ps = 0;

_count = 0;

}

}

(b) class CL1 {

public:

CL1() { c.real(0.0); c.imag(0.0); s = " not set" ; }

// ...

private:

complex c;

string s;

}

(c) class CL2 {

public:

CL2( mapstring,location *pmap, string key )

: _text( key ), _loc( (*pmap)[key] ) {}

// ...

private:

location _loc;

string _text;

};

Поделитесь на страничке

Следующая глава >

Похожие главы из других книг

8.5.9 Видимость Имен Членов

Из книги C++ автора Хилл Мюррей

8.5.9 Видимость Имен Членов Члены класса, описанные с ключевым словом class, являюся закрытыми, то есть, их имена могут использоваться только функциями членами (#8.5.2) и друзьями (см. #8.5.10), если они не стоят после метки «public:». В этом случае они являются открытыми. Открытый член


R.12.6.2 Инициализация членов и базовых классов

Из книги Справочное руководство по C++ автора Страустрап Бьярн

R.12.6.2 Инициализация членов и базовых классов В определении конструктора можно задать инициализацию прямых базовых классов и членов, не наследуемых из базовых классов. Это особенно полезно для тех объектов, констант и ссылок, для которых различаются семантики


Доступность членов

Из книги Язык программирования С# 2005 и платформа .NET 2.0. [3-е издание] автора Троелсен Эндрю

Доступность членов Прежде чем двигаться дальше, мы должны обсудить вопрос доступности, или "видимости" членов. Члены (методы, поля, конструкторы и т.д.) данного класса или структуры должны указать свой уровень доступности. Если член определяется без указания ключевого


Синтаксис инициализации членов-переменных

Из книги Пишем драйвер Windows на ассемблере автора Компьютеры Автор неизвестен -

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


Тестирование переопределенных членов

Из книги Delphi. Учимся на примерах автора Парижский Сергей Михайлович

Тестирование переопределенных членов Теперь можно проверить обновленный класс Person. Добавьте следующий программный код в метод Main() и сравните результат его выполнения с тем, что показано на рис. 3.18.static void Main (string[] args) { // ВНИМАНИЕ: эти объекты должны быть идентичными. Person


Определение членов типов в CIL

Из книги Основы объектно-ориентированного программирования автора Мейер Бертран

Определение членов типов в CIL Вы уже знаете, что типы .NET могут определить различные члены. Перечни содержат некоторый набор пар имен и значений. Структуры и классы могут иметь конструкторы, поля, методы, свойства, статические члены и т.д. В предыдущих 14 главах вы уже могли


Определение параметров членов

Из книги VBA для чайников автора Каммингс Стив

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


3.2. Процедура инициализации

Из книги C++. Сборник рецептов автора Диггинс Кристофер

3.2. Процедура инициализации Каждый драйвер имеет процедуру инициализации . Эта процедура вызывается системой сразу после загрузки драйвера в память.У нас такая процедура называется DriverEntry. Объявим её какDriver Entry proc near public, DriverObject:PDRIVER_OBJECT, RegistryPath:PUNICODE_STRINGDriverObject – это


Определение членов класса

Из книги C++ для начинающих автора Липпман Стенли

Определение членов класса Все члены класса по характеру доступа к ним делятся на четыре категории: закрытые (private), защищенные (protected), открытые (public) и опубликованные (published).Элементы класса, определенные в разделе public, без каких-либо ограничений открыты для доступа извне


Перекрытие инициализации по умолчанию

Из книги автора

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


Поиск членов

Из книги автора

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


9.3. Создание безопасного при исключениях списка инициализации

Из книги автора

9.3. Создание безопасного при исключениях списка инициализации ПроблемаНеобходимо инициализировать ваши данные-члены в списке инициализации конструктора, и поэтому вы не можете воспользоваться подходом, описанным в рецепте 9.2.РешениеИспользуйте специальный формат


17.2. Идентификация членов иерархии

Из книги автора

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


18.3.2. Открытие отдельных членов

Из книги автора

18.3.2. Открытие отдельных членов Когда мы применили закрытое наследование класса PeekbackStack от IntArray, то все защищенные и открытые члены IntArray стали закрытыми членами PeekbackStack. Было бы полезно, если бы пользователи PeekbackStack могли узнать размер стека с помощью такой


18.5.2. Специальная семантика инициализации

Из книги автора

18.5.2. Специальная семантика инициализации Наследование, в котором присутствует один или несколько виртуальных базовых классов, требует специальной семантики инициализации. Взгляните еще раз на реализации Bear и Raccoon в предыдущем разделе. Видите ли вы, какая проблема