ID do artigo: 104248 - Última revisão: terça-feira, 5 de julho de 2005 - Revisão: 3.1

COMO: Utilizar init_seg # pragma para construção estáticas do controle

Vista lado a ladoClique aqui para exibir o artigo traduzido e o artigo original em inglês, lado a lado.
Tradução automáticaExibir Aviso de Isenção de Tradução Automática
Retired KB ArticleAviso de Isenção de Responsabilidade sobre Conteúdo do KB Aposentado
Exibir os produtos aos quais esse artigo se aplica.
Dica do SistemaEste artigo aplica-se a um sistema operativo diferente do que está a utilizar. Foi desactivado o conteúdo do artigo, que pode não ser relevante para si.

Nesta página

Expandir tudo | Recolher tudo

Sumário

No Microsoft C++ Compiler, é possível controle quando os objetos estáticos, declarados no escopo do arquivo, são construídos e destruídos usando a diretiva de pré-processamento init_seg #pragama.
Voltar para o início

OBTER MAIS INFORMAÇÕES

Há quatro opções para a diretiva de pré-processamento init_seg: compilador, lib, usuário e "user_defined_segment_name." Em código-fonte, essa diretiva teria que o formulário: 
   #pragma init_seg(compiler)
   #pragma init_seg(lib)
   #pragma init_seg(user)
   #pragma init_seg("user_defined_segment_name")
Observação: apenas uma diretiva init_seg pode aparecer em um único arquivo de origem. Caso contrário, o compilador gera "Erro C2356: segmento de inicialização não deve alterar durante a conversão de unidade."

O objetivo dessa diretiva é dar o desenvolvedor a capacidade de agrupar os construtores em um aplicativo. Isso seria útil se alguns objetos confiam a existência de outros objetos para funcionar corretamente. Objetos que são agrupados juntos usando init_seg(compiler) # pragma são construídos antes de todos os outros objetos e destruídos após todos os outros objetos no aplicativo. Isso é usado para objetos nas bibliotecas de tempo de execução. Por exemplo, porque cin e cout podem ou podem não ser construídos ainda, usando esses objetos em seu construtor ou destrutor que usa o init_seg(compiler) # pragma seria imprudente.

Objetos que são agrupados juntos usando init_seg(lib) # pragma são construídos após e destruídos antes de objetos que estão nos módulos compilados com # pragma init_seg(compiler), mas antes de todos os outros objetos no aplicativo. Objetos que são agrupados juntos usando init_seg(user) # pragma são construídos após e destruídos antes de objetos que estão nos módulos compilados com # pragma init_seg(compiler) e # pragma init_seg(lib). Em outras palavras, objetos que são agrupados juntos usando init_seg(user) # pragma são construídos e destruídos ao mesmo tempo em que todos os outros objetos estáticos que não foram agrupados usando # pragma init_seg.

A documentação não é totalmente criptografada neste ponto. Ele informa que objetos no grupo de usuários são construídos pela última vez. Isso significa que esses objetos são construídos após e destruídos antes dos grupos de compilador e lib. Uma maneira que você pode controlar a ordem de construção e destruição de dentro de cada grupo é alterar a ordem de vinculação. Módulos que aparecem na linha de vínculo serão construídos após e destruídos antes de módulos que aparecem na linha de vínculo que estão no mesmo grupo init_seg. Construtores são chamados em ordem inversa de sua aparência nos segmentos.

É importante observar que a linguagem C++ não garante que qualquer ordem de construção para objetos nonderived; a linguagem C++ garante que esses objetos serão ser construídos e que irão ser construídos classes base antes de classes que derivam-los.

A diretiva de pré-processamento # pragma init_seg("user_defined_segment_name") coloca os endereços dos construtores para o segmento lógico "user_defined_segment_name". Essa opção é útil apenas se você modificar o código de inicialização para chamar esses construtores.

O exemplo de código a seguir (quatro arquivos de origem) mostra as idéias acima. Após compilar todos os arquivos de origem, vinculá-las de duas maneiras mostrado a seguir e execute executáveis resultantes. A saída de cada um mostrará quais opções init_seg dependentes de ordem de vinculação e que não são.

Com versões do Visual C++ 32-bit Edition, usar: 
   link file1 file2 file3 file4 /out:demo1.exe
   link file4 file3 file2 file1 /out:demo2.exe
versões com Visual C++ 16 bits, usar: 
   link file1 file2 file3 file4, demo1;
   link file4 file3 file2 file1, demo2;
Voltar para o início

Código de exemplo

// file1.cpp
// command line: cl /c file1.cpp
#pragma init_seg(compiler)
#include<stdio.h>
class MyCompClass
{
public:
      MyCompClass(){ printf("In the ctor of MyCompClass\n");}
      ~MyCompClass(){ printf("In the dtor of MyCompClass\n");}
} MyComp;

// file2.cpp
// command line: cl /c file2.cpp
#pragma init_seg(lib)
#include<iostream.h>
class MyLibClass
{
public:
      MyLibClass(){cout<<"In the ctor of MyLibClass"<<endl;}
      ~MyLibClass(){cout<<"In the dtor of MyLibClass"<<endl;}
} MyLib;

// file3.cpp
// command line: cl /c file3.cpp
#pragma init_seg(user)
#include<iostream.h>
class MyUserClass
{
public:
      MyUserClass(){cout<<"In the ctor of MyUserClass"<<endl;}
      ~MyUserClass(){cout<<"In the dtor of MyUserClass"<<endl;}
} MyUser;

// file4.cpp
// command line: cl /c file4.cpp
#include<iostream.h>
class MyRegularClass
{
public:
      MyRegularClass(){cout<<"In the ctor of MyRegularClass"<<endl;}
      ~MyRegularClass(){cout<<"In the dtor of MyRegularClass"<<endl;}
} MyRegular;

void main(){}
Voltar para o início
A informação contida neste artigo aplica-se a:
  • Microsoft Visual C++ 1.0 Professional Edition
  • Microsoft Visual C++ 1.5 Professional Edition
  • Microsoft Visual C++ 1.0 Professional Edition
  • Microsoft Visual C++ 2.0 Professional Edition
  • Microsoft Visual C++ 2.1
  • Microsoft Visual C++ 4.0 Standard Edition
  • Microsoft Visual C++ 5.0 Standard Edition
  • Microsoft Visual C++ 6.0 Service Pack 5
Voltar para o início
Palavras-chave: 
kbmt kbcode kbhowto kbhowtomaster kblangcpp KB104248 KbMtpt
Voltar para o início
Tradução automáticaTradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 104248  (http://support.microsoft.com/kb/104248/en-us/ )
Voltar para o início
Retired KB ArticleAviso de Isenção de Responsabilidade sobre Conteúdo do KB Aposentado
Este artigo trata de produtos para os quais a Microsoft não mais oferece suporte. Por esta razão, este artigo é oferecido "como está" e não será mais atualizado.
Voltar para o início