int x ; // no initializer. x value is indeterminate.
std::string s ; // no initializer, s is default-constructed.

int y = int() ; 
// y is initialized using copy-initialization
// but the temporary uses an empty set of parentheses as the initializer,
// so it is default-constructed.
// A default constructed POD type is zero-initialized,
// therefore, y == 0.

void foo ( std::string ) ;
foo ( std::string() ) ; 
// the temporary string is default constructed 
// as indicated by the initializer ()  

value-initialization

Первоетехническое исправление стандарта C++(TC1), проект которого был опубликован в ноябре 2001 года, представилоCore Issue 178(среди многих других вопросов, конечно).

В этом вопросе была введена новая концепция<value-initialization>(она также закрепила формулировку для нулевой инициализации). Неофициально инициализация значения аналогична инициализации по умолчанию, за исключением того, что в некоторых случаях нестатические элементы данных и подобъекты базового класса также инициализируются значения. Разница заключается в том, что объект, который инициализируется значением, не будет иметь (или, по крайней мере, с меньшей вероятностью будет иметь) неопределенные значения для членов данных и подобъектов базового класса; в отличие от случая объекта, построенного по умолчанию. (см. Основной выпуск 178 для нормативного описания).

Для определения инициализации значения объекта необходимо использовать инициализатор с пустым набором: ().

Как и прежде, декларация без инициализатора указывает инициализацию по умолчанию, а декларация с непустым инициализатором указывает инициализацию копии (=xxx) или прямой (xxx).

template<class T> void eat(T);
int x ; // indeterminate initial value.
std::string s; // default-initialized.
eat ( int() ) ; // value-initialized
eat ( std::string() ) ; // value-initialized

value-initialization syntax

Инициализация значения определяется с помощью (). Однако пустой набор скобок не допускается синтаксисом инициализаторов, поскольку он разбирается как декларация функции, не принимающая аргументов:

int x() ; // declares function int(*)()

Таким образом, пустое () должно быть помещено в другой контекст инициализации.

Альтернативой является использование синтаксиса инициализации копирования:

int x = int() ;

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

Одним из возможных общих решений является использование инициализации стоимости нестатического элемента данных:

template<class T> 
struct W 
{
  // value-initialization of 'data' here.
  W() : data() {}
  T data ;
} ;
W<int> w ;
// w.data is value-initialized for any type. 

Это решение было предложено более ранними версиями класса шаблонов<value_initialized<T>>. К сожалению, этот подход страдал от различных проблем с компилятором.

compiler issues

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

• Microsoft Visual Studio Feedback ID 100744, Value-initialization in new-expression
  Павел Кузнецов (MetaCommunications Engineering), 2005
• Идентификатор шаблона Идентификатора обратно в Microsoft Visual Studio 484295, VC++ в строке «Путеводитель» в строке «Путеводитель» WEB
  Репортер Сильвестр Хесп, 2009
• Идентификатор обратной связи Microsoft Visual Studio Feedback ID 499606, Адъюнкт-лицензия LEGRAPA CONTAGE FIGHTA
  Алекс Вакуленко, 2009
• Embarcadero/C++Builder Report 83751, Value-initialization: массивная инициализация значения
  Отчет Нильса Деккера (LKEB), 2010
• Embarcadero/C++Builder Report 83851, Value-initialized temporary triggers internal backend error C1798
  Сообщено Нильсом Деккером, 2010
• Embarcadero/C++Builder Report 84279, Внутренне-бронджбемора (F1004), депонента Щедрого всплывающего окна «нового Т()»
  Сообщение никельс Деккера, 2010
• Sun CR 6947016, Sun 5.10-n-dwaciedil-slástificat-POD.
  ПОЧЕТОВАНИЕ СТАТЬЯ КЛАМАЗА, ЖЕНЕВЕНДУ Нильса Деккера, 2010–2010
• XL V10.1 и V11.1 от IBM, IBM, Imm, IBM, Imm, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb, Imb.
  Сообщение Майкло Вонгу Нильсом Деккером, 2010
• Смартфон Intel 589832 silka silánía desidae ] ] ] внутреннюю ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ] ]

Новые версии<value_initialized>(версия 1.35 или выше) предлагают обходные пути к этим проблемам:<value_initialized>теперь может очистить свои внутренние данные, прежде чем строить объект, который он содержит. Это будет сделано для тех компиляторов, которые должны иметь такой обходной путь, на основе макроса дефекта компилятораBOOST_NO_COMPLETE_VALUE_INITIALIZATION.

Types and objects

template class value_initialized<T>

namespace boost {

template<class T>
class value_initialized
{

  public :

    value_initialized() : x() {}

    operator T const &() const { return x ; }

    operator T&() { return x ; }

    T const &data() const { return x ; }

    T& data() { return x ; }

    void swap( value_initialized& );



  private :

    unspecified x ;

} ;



template<class T>

T const& get ( value_initialized<T> const& x )

{

  return x.data() ;

}



template<class T>

T& get ( value_initialized<T>& x )

{

  return x.data() ;

}



template<class T>

void swap ( value_initialized<T>& lhs, value_initialized<T>& rhs )

{

  lhs.swap(rhs) ;

}



} // namespace boost

Объектом этого класса шаблонов является<T>-обертка, конвертируемая в<'T&'>, чей обернутый объект (член данных типа<T>) являетсязначением-инициализациейпри инициализации по умолчанию этого класса обертки:

int zero = 0 ;
value_initialized<int> x ;
assert ( x == zero ) ;

std::string def ;
value_initialized< std::string > y ;
assert ( y == def ) ;

Целью этой обертки является обеспечение последовательного синтаксиса для инициализации значений скалярных, союзных и классовых типов (POD и неPOD), поскольку правильный синтаксис для инициализации значений варьируется (см.синтаксис инициализации значений).

К обернутому объекту можно получить доступ либо через оператор преобразования<T&>, функцию члена<data()>, либо функцию нечлена<get()>:

void watch(int);
value_initialized<int> x;


watch(x) ; // operator T& used.
watch(x.data());
watch( get(x) ) // function get() used

И<const>, и<const>объекты могут быть обернуты. Изменяемые объекты могут быть изменены непосредственно из обертки, но постоянные объекты не могут:

Когда<T>являетсяSwappableтипом,<value_initialized<T>>также является сменным, вызывая его<swap>функцию члена, а также вызывая<boost::swap>.

value_initialized<int> x ; 
static_cast<int&>(x) = 1 ; // OK
get(x) = 1 ; // OK


value_initialized<int const> y ; 
static_cast<int&>(y) = 1 ; // ERROR: cannot cast to int&
static_cast<int const&>(y) = 1 ; // ERROR: cannot modify a const value
get(y) = 1 ; // ERROR: cannot modify a const value

Warning:

<value_initialized>реализация Boost версии 1.40.0 и более старой разрешаланеконстдоступ к обернутому объекту из постоянной обертки как оператором преобразования, так и его<data()>функцией-членом. Например:

value_initialized<int> const x_c ;
int& xr = x_c ; // OK, conversion to int& available even though x_c is itself const.

xr = 2 ; 

Причиной этого неясного поведения было то, что некоторые компиляторы не приняли следующий действительный код:

struct X
{
  operator int&() ;
  operator int const&() const ;   
};
X x ;
(x == 1 ) ; // ERROR HERE!

Нынешняя версия<value_initialized>больше не имеет такого неясного поведения. Поскольку компиляторы в настоящее время широко поддерживают перегрузку оператора преобразования, имея версию<const>и<non-const>, мы решили исправить проблему соответствующим образом. Так что нынешняя версия поддерживает идею логической константы.

Recommended practice: The non-member get() idiom

Неясное поведение возможности модифицировать не<const>обернутый объект из постоянной обертки (как было поддержано предыдущими версиями<value_initialized>) можно избежать, если доступ к обернутому объекту всегда выполняется с идиомой<get()>:

value_initialized<int> x ;
get(x) = 1 ; // OK

value_initialized<int const> cx ;
get(x) = 1 ; // ERROR: Cannot modify a const object

value_initialized<int> const x_c ;
get(x_c) = 1 ; // ERROR: Cannot modify a const object

value_initialized<int const> const cx_c ;
get(cx_c) = 1 ; // ERROR: Cannot modify a const object

template class initialized<T>

namespace boost {

template<class T>
class initialized
{

  public :

    initialized() : x() {}

    explicit initialized(T const & arg) : x(arg) {}

    operator T const &() const;

    operator T&();

    T const &data() const;

    T& data();

    void swap( initialized& );



  private :

    unspecified x ;

} ;



template<class T>

T const& get ( initialized<T> const& x );



template<class T>

T& get ( initialized<T>& x );



template<class T>

void swap ( initialized<T>& lhs, initialized<T>& rhs );



} // namespace boost

<initialized<T>>особенно полезно, когда обернутый объект должен быть либо инициализирован, либо непосредственно инициализирован, в зависимости от условий выполнения. Например,<initialized<T>>может содержать значение элемента данных, которое может быть инициализировано некоторыми конструкторами и непосредственно инициализировано другими. С другой стороны, если заранее известно, что объектвсегдадолжен быть инициализирован,<value_initialized<T>>может быть предпочтительным. И если объект всегда должен быть непосредственно инициализирован, ни одна из двух оберток действительно не должна использоваться.

initialized_value

namespace boost {
class initialized_value_t
{
  public :
    template <class T> operator T() const ;
};
initialized_value_t const initialized_value = {} ;
} // namespace boost

  T var = T();

  T var = get( value_initialized<T>() );

  T var = initialized_value ;

References

Acknowledgements

Value_initialized была перезапущена Фернандо Каччиолой (Fernando Cacciola) и Нильсом Деккером (Niels Dekker) для релиза Boost версии 1.35 (2008), предлагая обходной путь к различным проблемам компилятора.

<boost::initialized>был очень вдохновлен отзывами Эдварда Динера и Джеффри Хеллрунга.

Начальное значение было написано Нильсом Деккером и добавлено к версии 1.36 (2008) Boost.

РазработанныйФернандо Каччиолой, последнюю версию этого файла можно найти наwww.boost.org.

Пересмотрено 30 мая 2010 года

© Авторское право Fernando Cacciola, 2002 - 2010.

Распространяется в соответствии с Лицензией на программное обеспечение Boost, версия 1.0. См.www.boost.org/LICENSE_1_0.txt

Статья value_initialized раздела может быть полезна для разработчиков на c++ и boost.

:: Главная :: ::