Как по умолчанию инициализировать локальные переменные встроенных типов в C++?

Question

Как инициализировать по умолчанию локальную переменную примитивного типа в C++? Например, если у ЬурейеЕ:

typedef unsigned char boolean;//that's Microsoft RPC runtime typedef 

Я хотел бы изменить следующую строку:

boolean variable = 0; //initialize to some value to ensure reproduceable behavior 
retrieveValue(&variable); // do actual job 

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

struct Struct { 
    int Value; 
    Struct() : Value() {} 
}; 

, а Struct::Value будет инициализирован по умолчанию для одного и того же значения каждый раз, когда экземпляр cinstructed, но я никогда не записываю фактическое значение в коде.

Как я могу получить то же поведение для локальных переменных?

Answer 1

Вы можете эмулировать что поведение следующим образом:

boolean x = boolean(); 

или, более общее,

T x = T(); 

Это будет по умолчанию инициализировать x, если такая инициализация по умолчанию существует. Однако просто писать T x никогда не будет делать трюк для локальных переменных, независимо от того, что вы делаете.

Вы также можете использовать размещение нового для вызова «конструктора», даже для POD:

T x; 
new (&x) T(); 

Обратите внимание, что этот код вызывает неопределенное поведение для неконтактного типа POD (в частности, для типов, которые имеют непустой тривиальный деструктор). Для того, чтобы сделать этот код работать с определенными пользователем типами, сначала нужно вызвать деструктор объекта:

T x; 
x.~T(); 
new (&x) T(); 

Этот синтаксис может также использоваться для стручков (гарантируемых §§5.2.4/12.4.15) поэтому вышеуказанный код можно использовать без разбора для любого типа.

Answer 2

int var = int(); 
    string str = string(); 
    ... 

... или любой другой тип, который вы хотите.

Answer 3

Обертка в struct (Boolean), как в вашем примере, и доступ через открытый элемент (Boolean :: value). Это может быть не самое изящное решение (немного крутое для небольшой выгоды), но оно похоже на то, что вы уже показали.

Answer 4

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

#include <cassert> 

template <class T> 
class Type 
{ 
    T t; 
public: 
    Type(const T& t = T()): t(t) {} 
    operator T&() { return t; } 
    operator const T&() const { return t; } 
}; 

int main() 
{ 
    Type<unsigned char> some_value; 
    assert(some_value == '\0'); 
} 

Это должно быть довольно хорошо использовать для операторов преобразования.

Answer 5

Если я понимаю исходный вопрос, плакат говорит, что хочет, чтобы переменные данного типа всегда имели одинаковое начальное значение, но ему все равно, что это за значение, потому что он никогда не будет смотреть на него. Я прав?

Если да, то мой вопрос для плаката таков: если вы не инициализировали переменные, у них были бы случайные начальные значения ... но вы сказали, что никогда не смотрите на начальные значения - так почему это имеет значение, re random?

Я думаю, что ключевым вопросом является то, что вы пытаетесь достичь здесь?