Quando as variáveis ​​estáticas de nível de função são alocadas / inicializadas?

Estou bastante confiante de que as variáveis ​​declaradas globalmente são alocadas (e inicializadas, se aplicável) na hora de início do programa.

int globalgarbage;
unsigned int anumber = 42;

Mas e quanto aos estáticos definidos em uma função?

void doSomething()
{
  static bool globalish = true;
  // ...
}

Quando é o espaço globalishalocado? Estou adivinhando quando o programa começa. Mas ele também é inicializado? Ou é inicializado quando doSomething()é chamado pela primeira vez?

Eu estava curioso sobre isso, então escrevi o seguinte programa de teste e o compilei com o g ++ versão 4.1.2.

include <iostream>
#include <string>

using namespace std;

class test
{
public:
        test(const char *name)
                : _name(name)
        {
                cout << _name << " created" << endl;
        }

        ~test()
        {
                cout << _name << " destroyed" << endl;
        }

        string _name;
};

test t("global variable");

void f()
{
        static test t("static variable");

        test t2("Local variable");

        cout << "Function executed" << endl;
}


int main()
{
        test t("local to main");

        cout << "Program start" << endl;

        f();

        cout << "Program end" << endl;
        return 0;
}

Os resultados não foram os que eu esperava. O construtor do objeto estático não foi chamado até a primeira vez que a função foi chamada. Aqui está o resultado:

global variable created
local to main created
Program start
static variable created
Local variable created
Function executed
Local variable destroyed
Program end
local to main destroyed
static variable destroyed
global variable destroyed

Alguns verbos relevantes do padrão C ++:

3.6.2 Inicialização de objetos não locais [basic.start.init]

1

O armazenamento para objetos com duração de armazenamento estático ( basic.stc.static ) deve ser inicializado em zero ( dcl.init ) antes que qualquer outra inicialização ocorra. Objetos do tipo POD ( basic.types ) com duração de armazenamento estático inicializados com expressões constantes ( expr.const ) devem obrigatoriamente ser inicializados antes que qualquer inicialização dinâmica ocorra. Objetos de escopo de namespace com duração de armazenamento estático definido na mesma unidade de tradução e inicializados dinamicamente devem ser inicializados na ordem em que sua definição aparece na unidade de tradução. [Nota: dcl.init.aggr descreve a ordem em que os membros agregados são inicializados. A inicialização de objetos estáticos locais é descrita em stmt.dcl . ]

[mais texto abaixo adicionando mais liberdades para escritores de compiladores]

6.7 Declaração de declaração [stmt.dcl]

...

4

A inicialização zero ( dcl.init ) de todos os objetos locais com duração de armazenamento estático ( basic.stc.static ) é realizada antes que qualquer outra inicialização ocorra. Um objeto local do tipo POD ( basic.types ) com duração de armazenamento estático inicializado com expressões constantes é inicializado antes de seu bloco ser inserido pela primeira vez. Uma implementação tem permissão para realizar a inicialização antecipada de outros objetos locais com duração de armazenamento estático sob as mesmas condições em que uma implementação tem permissão para inicializar estaticamente um objeto com duração de armazenamento estático no escopo do namespace ( basic.start.init) Caso contrário, esse objeto é inicializado na primeira vez que o controle passa por sua declaração; tal objeto é considerado inicializado após a conclusão de sua inicialização. Se a inicialização for encerrada lançando uma exceção, a inicialização não será concluída, portanto, ela será tentada novamente na próxima vez que o controle entrar na declaração. Se o controle entrar novamente na declaração (recursivamente) enquanto o objeto está sendo inicializado, o comportamento é indefinido. [ Exemplo:

      int foo(int i)
      {
          static int s = foo(2*i);  // recursive call - undefined
          return i+1;
      }

- exemplo final ]

5

O destruidor de um objeto local com duração de armazenamento estático será executado se e somente se a variável foi construída. [Observação: basic.start.term descreve a ordem em que os objetos locais com duração de armazenamento estático são destruídos. ]

A memória para todas as variáveis ​​estáticas é alocada no carregamento do programa. Mas as variáveis ​​estáticas locais são criadas e inicializadas na primeira vez em que são usadas, não na inicialização do programa. Há algumas boas leituras sobre isso e estática em geral aqui . Em geral, acho que alguns desses problemas dependem da implementação, especialmente se você quiser saber onde essas coisas serão localizadas na memória.

O compilador irá alocar variável (s) estática (s) definida (s) em uma função foono carregamento do programa, no entanto, o compilador também adicionará algumas instruções adicionais (código de máquina) à sua função foopara que na primeira vez que for invocado, este código adicional inicialize a variável estática ( por exemplo, invocando o construtor, se aplicável).

@Adam: Esta injeção de código nos bastidores pelo compilador é a razão para o resultado que você viu.

Tento testar novamente o código de Adam Pierce e adicionei mais dois casos: variável estática na classe e tipo POD. Meu compilador é g ++ 4.8.1, no sistema operacional Windows (MinGW-32). O resultado é a variável estática na classe é tratada da mesma forma que a variável global. Seu construtor será chamado antes de entrar na função principal.

• Conclusão (para g ++, ambiente Windows):

  1. Variável global e membro estático na classe : o construtor é chamado antes de entrar na função principal (1) .
  2. Variável estática local : o construtor só é chamado quando a execução atinge sua declaração pela primeira vez.
  3. Se a variável estática local for do tipo POD , ela também será inicializada antes de entrar na função principal (1) . Exemplo para o tipo de POD: static int number = 10;

(1) : O estado correto deve ser: "antes que qualquer função da mesma unidade de tradução seja chamada". Porém, por simples, como no exemplo abaixo, então é a função principal .

inclui <iostream>

#include < string>

using namespace std;

class test
{
public:
   test(const char *name)
            : _name(name)
    {
            cout << _name << " created" << endl;
    }

    ~test()
    {
            cout << _name << " destroyed" << endl;
    }

    string _name;
    static test t; // static member
 };
test test::t("static in class");

test t("global variable");

void f()
{
    static  test t("static variable");
    static int num = 10 ; // POD type, init before enter main function

    test t2("Local variable");
    cout << "Function executed" << endl;
}

int main()
{
    test t("local to main");
    cout << "Program start" << endl;
    f();
    cout << "Program end" << endl;
    return 0;
 }

resultado:

static in class created
global variable created
local to main created
Program start
static variable created
Local variable created
Function executed
Local variable destroyed
Program end
local to main destroyed
static variable destroyed
global variable destroyed
static in class destroyed

Alguém testou em env Linux?

Variáveis ​​estáticas são alocadas dentro de um segmento de código - elas fazem parte da imagem executável e, portanto, são mapeadas já inicializadas.

Variáveis ​​estáticas dentro do escopo da função são tratadas da mesma forma, o escopo é puramente uma construção de nível de linguagem.

Por esse motivo, você tem a garantia de que uma variável estática será inicializada com 0 (a menos que você especifique outra coisa) em vez de um valor indefinido.

Existem algumas outras facetas da inicialização que você pode tirar vantagem - por exemplo, segmentos compartilhados permitem que diferentes instâncias do seu executável em execução ao mesmo tempo acessem as mesmas variáveis ​​estáticas.

Em C ++ (com escopo global), objetos estáticos têm seus construtores chamados como parte da inicialização do programa, sob o controle da biblioteca C runtime. No Visual C ++, pelo menos a ordem em que os objetos são inicializados pode ser controlada pelo pragma init_seg .

Ou é inicializado quando doSomething () é chamado pela primeira vez?

Sim, ele é. Isso, entre outras coisas, permite inicializar estruturas de dados acessadas globalmente quando for apropriado, por exemplo, dentro de blocos try / catch. Por exemplo, em vez de

int foo = init(); // bad if init() throws something

int main() {
  try {
    ...
  }
  catch(...){
    ...
  }
}

você pode escrever

int& foo() {
  static int myfoo = init();
  return myfoo;
}

e use-o dentro do bloco try / catch. Na primeira chamada, a variável será inicializada. Então, na primeira e nas próximas chamadas, seu valor será retornado (por referência).