Inicialização variável em C ++

Meu entendimento é que uma variável int será inicializada para 0 automaticamente; no entanto, não é. O código abaixo imprime um valor random.

 int main () { int a[10]; int i; cout << i << endl; for(int i = 0; i < 10; i++) cout << a[i] << " "; return 0; } 
  • Quais regras, se houver, se aplicam à boot?
  • Especificamente, sob quais condições as variables ​​são inicializadas automaticamente?

Será inicializado automaticamente se

  • é uma instância de class / estrutura na qual o construtor padrão inicializa todos os tipos primitivos; como a MyClass instance;
  • você usa a syntax do inicializador de array, por exemplo, int a[10] = {} (todo zerado) ou int a[10] = {1,2}; (todos zerados, exceto os dois primeiros itens: a[0] == 1 e a[1] == 2 )
  • o mesmo se aplica a classs / estruturas não agregadas, por exemplo, instância MyClass = {}; (mais informações sobre isso podem ser encontradas aqui )
  • é uma variável global / externa
  • a variável é definida static (não importa se dentro de uma function ou no escopo global / namespace) – obrigado Jerry

Nunca confie em uma variável de tipo simples (int, long, …) sendo inicializada automaticamente! Isso pode acontecer em linguagens como C #, mas não em C & C ++.

int não inicializa para zero. Quando você diz int i; , tudo o que você está fazendo é reservar espaço para um inteiro. O valor nesse local não é inicializado. Isso só é feito com você dizer int i = 0; (ou int i = 5; nesse caso, o valor é inicializado em 5). De qualquer forma, é uma boa prática inicializar uma variável com algum valor conhecido. Caso contrário, i detém qualquer valor random naquele local de memory quando o espaço foi reservado para ele. É por isso que o cout imprime um valor random.

Valores padrão dependem da implementação do idioma. Algumas linguagens irão inicializá-lo com algum valor “sensato” (como 0 talvez). Como regra geral, eu sempre inicializo uma variável com algum valor sensível (a menos que eu saiba que vou inicializá-la para outra coisa com certeza antes de usá-la). Como mencionei antes, é imprudente supor que o valor seja algo sensato. Pode ou não ser (dependendo do idioma ou da implementação do interpretador / compilador para esse idioma).

See section 4.9.5 Inicializando a Linguagem de Programação C ++.

Dependendo de sua variável ser local, a boot estática, definida pelo usuário ou padrão const pode acontecer.

Como você está usando POD (Plain Old Datatypes), a variável automática não é inicializada para nenhum valor padrão.

Este post diz melhor: http://www.velocityreviews.com/forums/showpost.php?p=1528247&postcount=10

Não há nenhum construtor “padrão” para tipos que não são de class, mas há uma boot padrão (zero). Infelizmente, para compatibilidade com C, a boot padrão NÃO é feita para os tipos POD nas seguintes circunstâncias:

Variáveis ​​nuas (isto é, declaradas sem inicializadores) locais para uma class ou function.

instâncias dinamicamente alocadas.

No entanto, em outros lugares (notavelmente variables ​​estáticas) e no caso de qualquer coisa que receba os parâmetros do inicializador vazio (quando isso é válido), obtém a boot padrão (zero).

Para forçar a boot de um POD (que int é), você pode usar a syntax do inicializador de cópia:

 #include  int main() { int i = int(); int j; std::cout << "i: " << i << std::endl; // warning: undefined behavior std::cout << "j: " << j << std::endl; } 

Isso se enquadra em "pagar apenas pelo que você usa". Se você for subseqüentemente atribuir um valor à variável, ou possivelmente não usá-la, não há razão para fazer o trabalho de inicializá-la. Para conseguir isso, você tem que pedir explicitamente que esse trabalho seja feito.

Em C ++, as variables ​​automáticas são indefinidas até receberem explicitamente um valor. Talvez você esteja pensando em C # ou outras linguagens .Net ou Java.

Sistemas operacionais diferentes (ou seja, OS X versus Ubuntu Linux) reagirão de maneira diferente a variables ​​não inicializadas versus inicializadas em C ++. Na minha experiência, a versão OS X do gcc irá compilar e imprimir 2 para ambas as versões do código abaixo. Onde, como se eu estivesse trabalhando em uma máquina Ubuntu Linux, o primeiro bloco de código imprimirá o que aconteceu no local da memory que a variável faz referência (+ 2 após o loop).

  int c; for( int i = 0; i < 3; i++ ) { c++; } cout << c << endl; 

Onde, todos eles darão os mesmos resultados para:

  int c = 0; for( int i = 0; i < 3; i++ ) { c++; } cout << c << endl; 

As variables ​​locais não são inicializadas, a menos que você faça isso sozinho. O que você está vendo é o lixo que estava na pilha antes de seu método ser chamado.

Se nenhum inicializador for especificado para um object, o object será inicializado por padrão; se nenhuma boot for executada, um object com duração de armazenamento automática ou dinâmica terá valor indeterminado.

Par. 8.5, seção 11 de um recente rascunho C ++ 0x N3092.pdf,

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/

Embora sua descoberta recente possa não ser bem-vinda (porque talvez seja necessário inicializar algumas variables ​​que outras linguagens teriam resolvido), isso pode significar menos ciclos de CPU e, portanto, código mais rápido.

Aqui int i; é uma variável automática que deve ser inicializada manualmente. A variável automática não inicializa automaticamente em c e c ++.

Se você quer que o compilador inicialize, então você precisa usar as seguintes coisas,

declare i como variável estática.

static int i; // zero atribui ao i pelo compilador.

declare i como variável global [fora do main ()].