Partilhar via

TN035: Usando vários recurso arquivos e arquivos de cabeçalho com o Visual C++

  • Artigo

 

Observação:

A seguinte nota técnica não foi atualizada desde que foi incluída pela primeira vez na documentação online.sistema autônomo resultado, alguns procedimentos e tópicos podem estar desatualizado ou incorreto.Para obter informações mais recentes, é recomendável que você procurar o tópico de interesse no índice de documentação online.

Esta nota descreve como o editor de recursos do Visual C++ oferece suporte a vários arquivos de cabeçalho compartilhado em um único projeto ou compartilhados em vários projetos e arquivos de recurso e como você pode usufruir esse suporte.Esta nota responde essas perguntas:

  • Quando podem desejar dividir um projeto em vários arquivos de recurso e/ou arquivos de cabeçalho e como fazê-lo?

  • Como você compartilha um arquivo .h de cabeçalho comum entre dois arquivos .RC?

  • Como você divide os recursos de projeto em vários arquivos .RC?

  • Como você (e as ferramentas) gerencia as dependências de compilação entre arquivos .RC, .CPP e .h?

Você deve estar ciente de que, se você adicionar um arquivo de recurso adicionais para seu projeto, ClassWizard não reconhecerá os recursos no arquivo adicionado.

Esta nota é estruturada para responder às perguntas acima da seguinte maneira:

  • Visão geral de como o Visual C++ gerencia arquivos de recursos e arquivos de cabeçalho fornece uma visão geral de como o recurso conjunto inclui comando no Visual C++ permite usar vários arquivos de recursos e arquivos de cabeçalho no projeto mesmo.

  • Análise de .RC AppWizard-criado e arquivos .h examina o múltiplo recurso e arquivos de cabeçalho que são usados por um aplicativo AppWizard-criado.Esses arquivos servem sistema autônomo um mercadoria modelo para arquivos de recurso adicionais e arquivos de cabeçalho que talvez queira adicionar ao seu projeto.

  • Incluindo arquivos de cabeçalho adicionais descreve onde você pode desejar incluir vários arquivos de cabeçalho e fornece detalhes sobre como fazer isso.

  • Compartilhar um arquivo de cabeçalho entre dois arquivos .RC mostra como você pode compartilhar um arquivo de cabeçalho entre vários arquivos .RC em diferentes projetos, ou talvez no mesmo projeto.

  • Usando vários arquivos de recurso no mesmo projeto descreve onde você pode querer dividir seu projeto em vários arquivos .RC e fornece detalhes sobre como fazer isso.

  • Aplicação de arquivos não-editáveis Visual C++ descreve como você pode certificar-se de que o Visual C++ não edição e, inadvertidamente, reformatar um recurso personalizado.

  • Gerenciando símbolos compartilhados por vários arquivos .RC de editado C++ Visual descreve como compartilhar os símbolos mesmos em vários arquivos .RC e como evitar a atribuição de valores numéricos de ID duplicados.

  • Gerenciar dependências entre .RC, .CPP e arquivos .h descreve como o Visual C++ evita desnecessários arquivos .CPP recompiling que são dependentes de arquivos de símbolos de recurso.

  • Como o Visual C++ gerencia conjunto inclui informações fornece detalhes técnicos sobre como Visual C++ mantém o controle de vários arquivos .RC (aninhados) e vários arquivos de cabeçalho que são # include'd por um arquivo .RC.

Visão geral de como o Visual C++ gerencia recurso arquivos e arquivos de cabeçalho

O Visual C++ gerencia um único arquivo de recurso .RC e um arquivo de cabeçalho correspondente .h sistema autônomo um emparelhar estreita de arquivos.Quando você edição e salvar recursos em um arquivo .RC, você indiretamente edite e salve símbolos no arquivo .h correspondente.Embora você possa em em aberto e edição vários .RC arquivos cada vez (usando a interface do usuário MDI do Visual C++) para qualquer determinado arquivo .RC você edição indiretamente exatamente um arquivo de cabeçalho correspondentes.

Arquivo de cabeçalho de símbolo

Por padrão, Visual C++ sempre nomeia o arquivo de cabeçalho correspondentes RESOURCE.H, independentemente do nome do arquivo de recurso (por exemplo, MYAPP.RC).Usando o recurso Inclui comando a Modo de exibição menu no Visual C++, você pode alterar o nome desse arquivo de cabeçalho por atualizar o arquivo do arquivo de cabeçalho de símbolo no Conjunto inclui caixa de diálogo.

Diretivas de símbolo somente leitura

Embora o Visual C++ somente edita um arquivo de cabeçalho para qualquer determinado arquivo .RC, Visual C++ oferece suporte a referências aos símbolos definidos nos arquivos de cabeçalho adicionais de somente leitura.Usando o Inclui recursos comando a Modo de exibição menu no Visual C++, você pode especificar qualquer número de arquivos de cabeçalho adicional de somente leitura sistema autônomo diretivas de símbolo somente leitura.A restrição "somente leitura" significa que, quando você adiciona um novo recurso no arquivo .RC, você pode usar um símbolo definido no arquivo de cabeçalho de somente leitura; mas se você excluir o recurso, o símbolo ainda permanece definido no arquivo de cabeçalho de somente leitura.Não é possível alterar o valor numérico atribuído a um símbolo de somente leitura.

Diretivas de time de compilar

O Visual C++ também suporta aninhamento de arquivos de recurso, onde um arquivo .RC é # include'd dentro de outro.Quando você edição um determinado arquivo .RC usando o Visual C++, os arquivos # include'd quaisquer recursos não estão visíveis.Mas quando você compila o arquivo .RC, os arquivos # include'd também são compilados.Usando o recurso Inclui comando a Modo de exibição menu no Visual C++, você pode especificar que qualquer número de # include'd .RC arquivos sistema autônomo diretivas de time de compilar.

Observe o que acontece se você ler em Visual C++ um arquivo .RC # include do outro arquivo de .RC não especificado sistema autônomo uma diretiva de time de compilar.Essa situação pode surgir quando você trazer para o Visual C++ um arquivo .RC que você tinha sido previamente mantendo manualmente com um editor de texto.Quando o Visual C++ lê que o # include'd .RC arquivo, ele mescla recursos # include'd arquivo .RC pai.Quando salvar o arquivo .RC pai, o # inclui demonstrativo, na verdade, serão substituídas por recursos # include'd.Se não desejar que esta mesclagem para ocorrer, remova o # incluir demonstrativo do pai .RC arquivo anterior para lê-lo em Visual C++; e, em seguida, usando o Visual C++, adicionar novamente a mesma # include demonstrativo sistema autônomo uma diretiva de time de compilar.

O Visual C++ salva em um arquivo .RC três tipos de acima conjunto inclui informações (arquivo de cabeçalho de símbolo, diretivas de símbolo somente leitura e diretivas de time de compilar) # incluir diretivas e TEXTINCLUDE recursos.Os recursos TEXTINCLUDE, um detalhe de implementação que você normalmente não precisa lidar com, são explicados na Como o Visual C++ gerencia conjunto inclui informações.

Análise de criação AppWizard .RC e arquivos .h

Examinar o código do aplicativo produzido pelo AppWizard fornece idéias sobre como o Visual C++ gerencia vários arquivos de recursos e arquivos de cabeçalho.Os trechos de código examinados abaixo são de um aplicativo MYAPP produzido pelo AppWizard usando as opções padrão.

Um aplicativo criado pelo AppWizard usa vários arquivos de recurso e vários arquivos de cabeçalho, conforme resumo no diagrama a seguir:

   RESOURCE.H     AFXRES.H                    
          \       /                              
           \     /                                
          MYAPP.RC                               
              |                                
              |                              
        RES\MYAPP.RC2  
        AFXRES.RC                   
        AFXPRINT.RC

Você pode exibir essas várias relações de arquivo usando o comando inclui o arquivo de Visual C++/conjunto.

  • MYAPP.RC
    Arquivo de recurso do aplicativo que você edição usando o Visual C++.

recurso.H é o arquivo de cabeçalho específicas do aplicativo.Ele é denominado sempre recurso.H por AppWizard, consistente com o padrão do Visual C++ de nomeação de arquivo de cabeçalho.# Include para este arquivo de cabeçalho é a primeira demonstrativo no arquivo de recurso (MYAPP.RC):

//Microsoft Visual C++ generated resource script
//
#include "resource.h"
  • RES\MYAPP.RC2
    Contém recursos que não serão editados pelo Visual C++, mas serão incluídos no arquivo EXE compilado final.AppWizard cria sem esses recursos por padrão, como o Visual C++ pode edição todos os recursos padrão, incluindo o recurso de versão (um novo recurso nesta versão).Um arquivo vazio é gerado pelo AppWizard caso você deseja adicionar seus próprios recursos personalizados formatados para este arquivo.

Se você usar recursos personalizados formatados, você pode adicioná-los para RES\MYAPP.RC2 e editá-los usando o editor de texto Visual C++.

AFXRES.RC e AFXPRINT.RC contêm recursos padrão necessários para determinados recursos da estrutura.Como RES\MYAPP.RC2, esses dois arquivos de recurso fornecido pelo estrutura são # include'd no participante do MYAPP.RC e elas são especificadas em diretivas de time de compilar da caixa de diálogo conjunto inclui.Assim, você não diretamente exibir ou edição esses recursos de estrutura enquanto você edição MYAPP.RC no Visual C++, mas eles são compilados no arquivo .RES binário do aplicativo e o final do arquivo .exe.Para obter mais informações sobre os recursos de estrutura padrão, incluindo procedimentos para modificá-los, consulte Observação técnica 23.

AFXRES.H define símbolos padrão, sistema autônomo ID_FILE_NEW, usado pela estrutura e usado especificamente em AFXRES.RC. AFXRES.H também # include do WINRES.H, que contém um subconjunto do Windows.H que são necessárias pelo Visual C++ gerado .RC arquivos, bem sistema autônomo AFXRES.RC.sistema autônomo símbolos definidos no AFXRES.H estão disponível ao edição o arquivo de recurso do aplicativo (MYAPP.RC).Por exemplo, ID_FILE_NEW é usado para o novo item de menu no recurso de menu do MYAPP.RC. Não é possível alterar ou excluir esses símbolos definidos pelo estrutura.

Incluindo arquivos de cabeçalho adicionais

O aplicativo criado pelo AppWizard inclui apenas dois arquivos de cabeçalho: recurso.H e AFXRES.H.Somente recurso.H é específico do aplicativo.Talvez você precise incluir arquivos de cabeçalho adicional de somente leitura nos seguintes casos:

O arquivo de cabeçalho é fornecido por uma fonte externa, ou você deseja compartilhar o arquivo de cabeçalho entre vários projetos ou várias partes do projeto mesmo.

O arquivo de cabeçalho tem formatação e comentários que não deseja que o Visual C++ para alterar ou filtrar quando salva o arquivo.Por exemplo, talvez você queira preservar # define que usar aritmética simbólica, sistema autônomo:

#define RED 0
#define BLUE 1
#define GREEN 2
#define ID_COLOR_BUTTON 1001
#define ID_RED_BUTTON (ID_COLOR_BUTTON + RED)
#define ID_BLUE_BUTTON (ID_COLOR_BUTTON + BLUE)
#define ID_GREEN_BUTTON (ID_COLOR_BUTTON + GREEN)

Você pode incluir arquivos de cabeçalho adicional de somente leitura, usando o recurso Incluicomando para especificar o # incluem demonstrativo sistema autônomo uma segunda diretiva de símbolo somente leitura, sistema autônomo em:

#include "afxres.h"
#include "second.h"

O novo diagrama de relação do arquivo agora é semelhante a:

                   AFXRES.H       
    RESOURCE.H     SECOND.H                    
          \       /                              
           \     /                                
          MYAPP.RC   
              |                                
              |                              
        RES\MYAPP.RC2  
        AFXRES.RC                   
        AFXPRINT.RC

Compartilhar um arquivo de cabeçalho entre dois arquivos .RC

Você talvez deseje compartilhar um arquivo de cabeçalho entre dois arquivos .RC que estão em diferentes projetos ou possivelmente o mesmo projeto.Para fazer isso, basta aplicar a técnica de diretivas de somente leitura descrita acima para os dois arquivos .RC.No caso em que os dois arquivos .RC são para aplicativos distintos (diferentes projetos), o resultado é ilustrado no diagrama a seguir:

     RESOURCE.H   AFXRES.H   RESOURCE.H  
    (for MYAPP1)  SECOND.H   (for MYAPP2)             
          \       /     \       /           
           \     /       \     /             
          MYAPP1.RC      MYAPP2.RC                 
           /    \        /     \                   
          /      \      /       \            
RES\MYAPP1.RC2  AFXRES.RC     RES\MYAPP2.RC2              
                AFXPRINT.RC

O caso onde o segundo arquivo de cabeçalho é compartilhado por dois arquivos .RC no mesmo aplicativo (projeto) é discutido abaixo.

Usando vários arquivos de recurso no mesmo projeto

O Visual C++ e o suporte a compilador de recurso incluem vários arquivos .RC no mesmo projeto através de # 's de um arquivo .RC dentro de outro.O aninhamento de vários é permitido.Há várias razões para dividir os recursos do seu projeto em vários arquivos .RC:

  • É mais fácil de gerenciar um grande número de recursos entre vários membros da equipe de projeto se você dividir os recursos em vários arquivos .RC.Se você usar um pacote de gerenciamento de controle de fonte para que o check-out de arquivos e verificar as alterações, dividindo os recursos em vários arquivos .RC fornecerá exercer um melhor controle sobre o gerenciamento de alterações em recursos.

  • Se você desejar usar sistema autônomo diretivas de pré-processador, sistema autônomo # ifdef, definem # endif e #, para partes de seus recursos, deve isolá-los em recursos de somente leitura serão ser compilados pelo compilador de recurso.

  • .RC arquivos irão carregar e salvar mais rapidamente no Visual C++ que um arquivo .RC composto.

  • Se você desejar manter um recurso com um editor de texto de forma legível, você deve mantê-lo em um arquivo .RC separado das edições do Visual C++ um.

  • Se você precisar manter um recurso definido pelo usuário em um formulário de texto ou binário que está interpretable por outro editor de dados especializados, em seguida, você deve mantê-lo em um arquivo separado .RC para que Visual C++ não altera o formato para dados hexadecimais.Recursos do arquivo .wav (som) o MFC Advanced conceitos de exemplo SPEAKN são um mercadoria exemplo.

Você pode # incluir um SECOND.RC em diretivas de time de compilar na caixa de diálogo conjunto inclui:

#include "res\myapp.rc2"  // non-Visual C++ edited resources
#include "second.rc"  // THE SECOND .RC FILE

#include "afxres.rc"  // Standard components
#include "afxprint.rc"  // printing/print preview resources

O resultado é ilustrado no diagrama a seguir:

   RESOURCE.H     AFXRES.H                    
          \       /                              
           \     /                                
          MYAPP.RC
              |                                
              |                              
        RES\MYAPP.RC2
        SECOND.RC  
        AFXRES.RC                   
        AFXPRINT.RC

Usando diretivas de time de compilar, você pode organizar seus recursos Visual C++ editáveis e não-editáveis em vários arquivos .RC, onde MYAPP.RC "mestre" não faz nada, mas # include os outros arquivos .RC.Se você estiver usando um arquivo .MAK de projeto do Visual C++, em seguida, você deve incluir o arquivo .RC "mestre" no projeto para que todos os recursos do # include'd são compilados com o seu aplicativo.

Aplicação de arquivos não seja editável Visual C++

O arquivo RES\MYAPP.RC2 AppWizard-criado é um exemplo de um arquivo que contém recursos que você faça não deseja ler acidentalmente em Visual C++ e gravá-lo de volta com perda de informações de formatação.Para se proteger contra isso, coloque as seguintes linhas no início do arquivo RES\MYAPP.RC2:

#ifdef APSTUDIO_INVOKED
    #error this file is not editable by Visual C++
#endif //APSTUDIO_INVOKED

Quando o Visual C++ compila o arquivo .RC, ele define APSTUDIO_INVOKED sistema autônomo RC_INVOKED.Se a estrutura de arquivos criados pelo AppWizard está corrompida e Visual C++ lê a linha # Error acima, ele reporta um erro fatal e anular a leitura do arquivo .RC.

Gerenciando símbolos compartilhados por vários arquivos .RC de editado C++ Visual

Dois problemas surgem quando você divide os recursos em vários arquivos .RC que você deseja edição separadamente no Visual C++:

  • Talvez você deseja compartilhar os símbolos mesmos em vários arquivos .RC.

  • Você precisa evitar Visual C++ atribuir os mesmos valores numéricos ID a recursos distintos (símbolos).

O diagrama a seguir ilustra uma organização de arquivos .RC e .h que lida com o primeiro problema:

              MYAPP.RC
             /         \
            /           \
MYSTRS.H   / MYSHARED.H  \  MYMENUS.H
     \    /    /      \   \    \
      \  /    /        \   \    \
   MYSTRS.RC           MYMENUS.RC

Neste exemplo, recursos de seqüência de caracteres são mantidos em um recurso de arquivo, MYSTRS.RC, e menus são mantidas em outra, MYMENUS.RC.Alguns símbolos, sistema autônomo para comandos, talvez precise ser compartilhados entre sistema autônomo dois arquivos.Por exemplo, um ID_TOOLS_SPELL pode ser a ID de comando de menu para o item ortográfico em um menu de ferramentas; e também pode ser a ID de seqüência de caracteres do aviso de comando exibido pela estrutura na BAR de status da janela principal do aplicativo.

O símbolo ID_TOOLS_SPELL é mantido no arquivo de cabeçalho compartilhada, MYSHARED.H.Manter este arquivo de cabeçalho compartilhada manualmente com um editor de texto; Visual C++ não diretamente edição para ele.sistema autônomo arquivos de dois recursos MYSTRS.RC e MYMENUS.RC, você especificar # incluem MYSHARED.H em diretivas de somente leitura para MYAPP.RC, usando o Inclui recursos comando, conforme descrito anteriormente.

Seja mais conveniente prever um símbolo que irá compartilhar antes de tentar usar para identificar qualquer recurso.Adicionar o símbolo para o arquivo de cabeçalho compartilhada e, se você já não # include'd o arquivo de cabeçalho compartilhado em diretivas de somente leitura para o arquivo .RC, fazê-lo antes de usar o símbolo.Se você não antecipou compartilhando o símbolo dessa forma e, em seguida, você precisará manualmente (usando um editor de texto) mover o # define demonstrativo para o símbolo de, digamos, MYMENUS.H para MYSHARED.H antes de usá-lo em MYSTRS.RC.

Ao gerenciar símbolos em vários arquivos .RC, você também deve ajudar Visual C++ Evite atribuir os mesmos valores numéricos de ID para recursos distintos (símbolos).Para qualquer determinado arquivo .RC, Visual C++ incrementalmente atribui identificações em cada um dos quatro domínios ID.Entre as sessões de edição, Visual C++ mantém controle da ID de última-atribuída em cada domínio no arquivo de cabeçalho de símbolo para o arquivo .RC.Eis o que os valores APS_NEXT são para um arquivo .RC vazio (novo):

#define _APS_NEXT_RESOURCE_VALUE  101
#define _APS_NEXT_COMMAND_VALUE   40001
#define _APS_NEXT_CONTROL_VALUE   1000
#define _APS_NEXT_SYMED_VALUE     101

_APS_NEXT_RESOURCE_VALUE é o valor próximo do símbolo que será usado para um recurso de caixa de diálogo, o recurso de menu e assim por diante.O intervalo válido de valores de símbolo de recurso é 1 para 0x6FFF.

_APS_NEXT_COMMAND_VALUE é o valor próximo do símbolo que será usado para a identificação de comando.O intervalo válido de valores de símbolo de comando é 0 x 8000 para 0xDFFF.

_APS_NEXT_CONTROL_VALUE é o próximo valor de símbolo que será usado para um controle de caixa de diálogo.O intervalo válido de valores da caixa de diálogo controle de símbolo é 8 para 0xDFFF.

_APS_NEXT_SYMED_VALUE é o valor do símbolo próximo será emitido quando você atribuir manualmente um valor de símbolo usando o comando novo no símbolo navegador.

C++ Visual começa com valores levemente mais altos que legal menor valor quando criar um novo arquivo .RC.AppWizard também irá inicializar esses valores para algo mais apropriado para aplicativos MFC.Para obter mais informações sobre intervalos de valores de ID, consulte Observação técnica 20.

Agora cada time criar um novo arquivo de recurso, mesmo no mesmo projeto, Visual C++ define o mesmo _APS_NEXT_ valores.Isso significa que, se você adicionar, digamos, várias caixas de diálogo em dois arquivos .RC diferentes, é altamente provável # mesmo definir valor será atribuída a diferentes caixas de diálogo.Por exemplo, IDD_MY_DLG1 no primeiro arquivo .RC pode ser atribuído o mesmo número, 101, sistema autônomo IDD_MY_DLG2 em um segundo arquivo .RC.

Para evitar isso, você deve reservar um intervalo numérico separado para cada um dos quatro domínios de IDs nos respectivos arquivos .RC.Para fazer isso, atualizar manualmente o _APS_NEXT valores em cada uma a .RC os arquivosbefore começar a adicionar recursos. Por exemplo, se o primeiro arquivo .RC usa o padrão de _APS_NEXT valores e, em seguida, você pode querer atribuir a seguinte _APS_NEXT valores para o segundo arquivo .RC:

#define _APS_NEXT_RESOURCE_VALUE  2000
#define _APS_NEXT_COMMAND_VALUE   42000
#define _APS_NEXT_CONTROL_VALUE   2000
#define _APS_NEXT_SYMED_VALUE     2000

Claro, ainda é possível que Visual C++ irá atribuir identificações tantas no primeiro arquivo .RC que iniciam os valores numéricos para sobrepor reservado para o segundo arquivo .RC.Você deve reservar intervalos suficientemente grandes para que isso não acontecer.

Gerenciar dependências entre .RC, .CPP e arquivos .h

Quando o Visual C++ salva um arquivo .RC, ele também salva as alterações de símbolo para o arquivo recurso.H correspondente.Qualquer um dos seus arquivos .CPP que se referem a recursos em .RC o arquivo deve ser # include arquivo recurso.H, geralmente de dentro do arquivo de cabeçalho principal do seu projeto.Isso leva a um efeito colateral indesejado por causa de gerenciamento de projeto interno do ambiente de desenvolvimento que verifica os arquivos de fonte para as dependências de cabeçalho.Cada vez que você adiciona um novo símbolo no Visual C++, todo o arquivo .CPP # include recurso.H precisa ser recompilado.

O Visual C++, contorna a dependência em recurso.H, incluindo o seguinte comentário sistema autônomo a primeira linha do arquivo recurso.H:

//{{NO_DEPENDENCIES}}

O ambiente de desenvolvimento interpreta esse comentário ignorando as alterações recurso.H para que arquivos .CPP dependentes não precise ser recompilado.

O Visual C++ sempre adiciona o //{{NO_DEPENDENCIES}} comente a linha para um arquivo .RC quando salva o arquivo.Em alguns casos, contornar da dependência de compilação no recurso.H pode levar a em time de execução erros sem serem detectados no momento do link.Por exemplo, se você usar o Pesquisador de símbolo para alterar o valor numérico atribuído a um símbolo de um recurso, o recurso será não ser corretamente localizado e carregado no time de execução do aplicativo se o arquivo .CPP referir-se ao recurso não é recompilado.Em tais casos, você deve explicitamente recompilar todos os arquivos .CPP que você sabe que são afetados pelas alterações de símbolo em recurso.H ou selecionar Reconstruir tudo.Se você tem a necessidade de alterar valores de símbolo para um determinado agrupar de recursos com freqüência, você provavelmente achará mais conveniente e segura separar esses símbolos em um arquivo cabeçalho separado somente para leitura, sistema autônomo descrito o acima da seção Incluindo arquivos de cabeçalho adicionais.

Como o Visual C++ gerencia conjunto inclui informações

Conforme mencionado acima, no menu arquivo comando conjunto inclui permite especificar três tipos de informações:

  • Arquivo de cabeçalho de símbolo

  • Diretivas de símbolo somente leitura

  • Diretivas de time de compilar

A seguir descrevem como o Visual C++ mantém essas informações em um arquivo .RC.Você não é necessário essas informações para usar o Visual C++, mas ela pode aperfeiçoar sua compreensão para que você com mais confiança pode usar o recurso de conjunto inclui.

Cada um dos tipos de três acima de conjunto inclui informações é armazenada no arquivo .RC duas formas: (1) (2) sistema autônomo # incluem ou outras diretivas interpretable pelo compilador de recurso e sistema autônomo recursos especiais TEXTINCLUDE interpretable somente pelo Visual C++.

A finalidade do recurso TEXTINCLUDE é armazenar com segurança definir inclusão informações em um formulário que seja prontamente apresentável do Visual C++ Conjunto inclui caixa de diálogo.TEXTINCLUDE é um tipo de recurso definido pelo Visual C++.O Visual C++ reconhece três recursos TEXTINCLUDE específicos que têm o recurso de números de identificação de 1, 2 e 3:

ID do recurso TEXTINCLUDE

Tipo de conjunto inclui informações

1

Arquivo de cabeçalho de símbolo

2

Diretivas de símbolo somente leitura

3

Diretivas de time de compilar

Cada um dos três tipos de conjunto inclui informações é ilustrada sistema autônomo arquivos MYAPP.RC e recurso.H padrão criados pelo AppWizard, conforme descrito abaixo.\0 Extra e "" tokens entre blocos BEGIN e participante são necessárias pela sintaxe RC para especificar zero seqüências de caracteres encerradas e o caractere de aspas duplas, respectivamente.

Arquivo de cabeçalho de símbolo

O formulário informulárioation o arquivo de cabeçalho de símbolo interpretado pelo compilador de recurso é simplesmente um # include demonstrativo:

#include "resource.h"

O recurso TEXTINCLUDE correspondente é:

1 TEXTINCLUDE DISCARDABLE
BEGIN
   #resource.h\0"
END

Diretivas de símbolo somente leitura

Diretivas de símbolo somente leitura serão incluídas na parte superior da MYAPP.RC no exemplo a seguir formulário interpretable pelo compilador de recurso:

#include "afxres.h"

O recurso TEXTINCLUDE correspondente é:

2 TEXTINCLUDE DISCARDABLE
BEGIN
   "#include ""afxres.h""\r\n"
   "\0"
END

Diretivas de time de compilar

time de compilar diretivas estão incluídas no participante do MYAPP.RC no seguinte formato interpretable pelo compilador de recurso:

#ifndef APSTUDIO_INVOKED
///////////////////////
//
// From TEXTINCLUDE 3
//
#include "res\myapp.rc2"  // non-Visual C++ edited resources

#include "afxres.rc"  // Standard components
#include "afxprint.rc"  // printing/print preview resources
#endif  // not APSTUDIO_INVOKED

A diretiva APSTUDIO_INVOKED # ifndef instrui o Visual C++ para ignorar diretivas de time de compilar.

O recurso TEXTINCLUDE correspondente é:

3 TEXTINCLUDE DISCARDABLE
BEGIN
"#include ""res\myapp.rc2""  // non-Visual C++ edited resources\r\n"
"\r\n"
"#include ""afxres.rc""  // Standard components\r\n"
"#include ""afxprint.rc""  // printing/print preview resources\r\n"
"\0"
END

Consulte também

Outros recursos

Notas técnicas por número

Notas técnicas por categoria