Compartilhar via

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

  • Artigo

Observação

A nota técnica a seguir não foi atualizada desde que foi incluída pela primeira vez na documentação online. Como resultado, alguns procedimentos e tópicos podem estar desatualizados ou incorretos. Para obter as informações mais recentes, é recomendável que você pesquise o tópico de interesse no índice de documentação online.

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

  • Quando você pode querer dividir um projeto em vários arquivos de recursos e/ou arquivos de cabeçalho e como você fazer isso

  • Como compartilhar um arquivo .H de cabeçalho comum entre dois arquivos .RC

  • Como dividir os recursos do projeto em vários arquivos .RC

  • Como você (e as ferramentas) gerenciam dependências de build entre arquivos .RC, .CPP e .H

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

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

  • A 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 comando Resource Set Includes no Visual C++ permite que você use vários arquivos de recursos e arquivos de cabeçalho no mesmo projeto.

  • A análise de arquivos .RC e .H criados pelo AppWizard analisa os vários arquivos de recurso e cabeçalho usados por um aplicativo criado pelo AppWizard. Esses arquivos servem como um bom modelo para arquivos de recurso e arquivos de cabeçalho adicionais que talvez você queira adicionar ao projeto.

  • A inclusão de arquivos de cabeçalho adicionais descreve onde você pode querer incluir vários arquivos de cabeçalho e fornece detalhes sobre como fazer isso.

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

  • O uso de vários arquivos de recurso no mesmo projeto descreve onde talvez você queira dividir seu projeto em vários arquivos .RC e fornece detalhes sobre como fazer isso.

  • A imposição de arquivos do Visual C++ não editáveis descreve como você pode garantir que o Visual C++ não edite e reformate involuntariamente um recurso personalizado.

  • O gerenciamento de símbolos compartilhados por vários arquivos .RC editados no Visual C++ descreve como compartilhar os mesmos símbolos em vários arquivos .RC e como evitar atribuir valores numéricos de ID duplicados.

  • O gerenciamento de dependências entre arquivos .RC, .CPP e .H descreve como o Visual C++ evita a recompilação desnecessária de arquivos .CPP dependentes de arquivos de símbolo de recurso.

  • Como o Visual C++ gerencia as informações sobre o Set Includes fornece detalhes técnicos sobre como o Visual C++ mantém o controle de vários arquivos .RC (aninhados) e vários arquivos de cabeçalho que foram incluídos (#include) por um arquivo .RC.

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

O Visual C++ gerencia um único arquivo de recurso .RC e um arquivo de cabeçalho .H correspondente como um par de arquivos bem acoplado. Quando você edita e salva recursos em um arquivo .RC, você edita e salva símbolos indiretamente no arquivo .H correspondente. Embora você possa abrir e editar vários arquivos .RC por vez, (usando a interface do usuário MDI do Visual C++) para qualquer arquivo .RC, você edita de modo indireto exatamente um arquivo de cabeçalho correspondente.

Caixa de diálogo Resource Includes do Modo de Exibição de Recursos

Para acessar o Resource Includes, abra o Modo de Exibição de Recursos e clique com o botão direito do mouse no arquivo .RC e selecione Resource Includes.

Arquivo de cabeçalho de símbolo

Por padrão, o Visual C++ sempre nomeia o RESOURCE.H do arquivo de cabeçalho correspondente, independentemente do nome do arquivo de recurso (por exemplo, MYAPP.RC). A seção Arquivo de Cabeçalho de Símbolo na caixa de diálogo Resource Includes no Visual C++ permite alterar o nome desse arquivo de cabeçalho. Insira um novo nome de arquivo na caixa de edição da seção.

Observação

Os arquivos de recurso não localizados no mesmo diretório que o arquivo .RC devem preparar um caminho relativo com '\' com escape para ser lido corretamente.

Diretivas de símbolo somente leitura

Embora o Visual C++ edite apenas um arquivo de cabeçalho para qualquer arquivo .RC, o Visual C++ dá suporte a referências a símbolos definidos em arquivos de cabeçalho somente leitura adicionais. A seção Diretivas de símbolo somente leitura na caixa de diálogo Resource Includes permite especificar qualquer número de arquivos de cabeçalho somente leitura adicionais como diretivas de símbolo somente leitura. A restrição "somente leitura" significa que, quando você adiciona um novo recurso no arquivo .RC, pode usar um símbolo definido no arquivo de cabeçalho somente leitura. No entanto, se você excluir o recurso, o símbolo ainda permanecerá definido no arquivo de cabeçalho somente leitura. Não é possível alterar o valor numérico atribuído a um símbolo somente leitura.

Diretivas de tempo de compilação

O Visual C++ também dá suporte ao aninhamento de arquivos de recurso, em que um arquivo .RC é incluído dentro de outro usando uma diretiva #include. Quando você edita um determinado arquivo .RC usando o Visual C++, todos os recursos nos arquivos incluídos não ficam visíveis. Mas, quando você compila o arquivo .RC, os arquivos incluídos também são compilados. A seção Diretivas de tempo de compilação: na caixa de diálogo Resource Includes permite que você especifique qualquer número de arquivos .RC para incluir como diretivas do tempo de compilação.

Observe o que acontece se você ler no Visual C++ um arquivo .RC que inclui outro arquivo .RC que não* é especificado como uma diretiva de tempo de compilação. Essa situação pode surgir quando coloca no Visual C++ um arquivo .RC que você estava mantendo manualmente com um editor de texto. Quando o Visual C++ lê o arquivo .RC incluído, ele mescla os recursos inclusos no arquivo .RC pai. Quando você salva o arquivo .RC pai, a instrução #include, na verdade, é substituída pelos recursos do que foram incluídos. Se você não quiser que essa mesclagem aconteça, remova a instrução #include do arquivo .RC pai antes de lê-lo no Visual C++. Em seguida, usando o Visual C++, adicione novamente a mesma instrução #include que uma diretiva de tempo de compilação.

O Visual C++ salva, em um arquivo .RC, os três tipos de informações Set Includes acima (arquivo de cabeçalho de símbolo, diretivas de símbolo somente leitura e diretivas de tempo de compilação) em diretivas #include e em recursos TEXTINCLUDE. Os recursos TEXTINCLUDE, um detalhe de implementação com o qual você normalmente não precisa lidar, são explicados em Como o Visual C++ gerencia informações do Set Includes.

Análise de arquivos .RC e .H criados pelo AppWizard

Examinar o código do aplicativo produzido pelo AppWizard fornece informações sobre como o Visual C++ gerencia vários arquivos de recurso 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 resumido no diagrama abaixo:

   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 Set Includes/File do Visual C++.

MYAPP.RC
O arquivo de recurso do aplicativo que você edita usando o Visual C++.

RESOURCE.H é o arquivo de cabeçalho específico do aplicativo. Ele é sempre chamado de RESOURCE.H pelo AppWizard, consistente com a nomenclatura padrão do Visual C++ do arquivo de cabeçalho. O #include desse arquivo de cabeçalho é a primeira instrução 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 final compilado. O AppWizard não cria esses recursos por padrão, já que o Visual C++ pode editar 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ê deseje adicionar seus próprios recursos formatados personalizados a esse arquivo.

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

AFXRES.RC e AFXPRINT.RC contêm recursos padrão exigidos por determinados recursos da estrutura. Como RES\MYAPP.RC2, esses dois arquivos de recurso fornecidos pela estrutura são inclusos MYAPP.RC no final do MYAPP.RC e eles são especificados nas diretivas de tempo de compilação da caixa de diálogo Set Includes. Portanto, você não visualiza ou edita diretamente esses recursos de estrutura enquanto edita MYAPP.RC no Visual C++, mas eles são compilados no arquivo .RES binário e no arquivo .EXE final do aplicativo. Para obter mais informações sobre os recursos da estrutura padrão, incluindo procedimentos para modificá-los, confira a Nota técnica 23.

O AFXRES.H define símbolos padrão, como ID_FILE_NEW, usados pela estrutura e usados especificamente usados no AFXRES.RC. AFXRES.H também usa #include para incluir WINRES.H, que contém um subconjunto de WINDOWS.H que é exigido pelos arquivos .RC gerados pelo Visual C++ e AFXRES.RC. Os símbolos definidos em AFXRES.H estão disponíveis à medida que você edita o arquivo de recurso do aplicativo (MYAPP.RC). Por exemplo, ID_FILE_NEW é usado para o item de menu FileNew no recurso de menu do MYAPP.RC. Não é possível alterar ou excluir esses símbolos definidos pela estrutura.

Incluir arquivos de cabeçalho adicionais

O aplicativo criado pelo AppWizard inclui apenas dois arquivos de cabeçalho: RESOURCE.H e AFXRES.H. Somente RESOURCE.H é específico do aplicativo. Talvez seja necessário incluir arquivos de cabeçalho somente leitura adicionais 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 mesmo projeto.

O arquivo de cabeçalho tem formatação e comentários que você não deseja que o Visual C++ altere ou filtre quando salvar o arquivo. Por exemplo, talvez você queira preservar as instruções #define que usam aritmética simbólica, como:

#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 somente leitura adicionais usando o comando Resource Includes para especificar a instrução #include como uma segunda diretiva de símbolo somente leitura, como em:

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

O novo diagrama de relação de arquivo agora tem a seguinte aparência:

                   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

Talvez você queira compartilhar um arquivo de cabeçalho entre dois arquivos .RC que estão em projetos diferentes ou possivelmente no mesmo projeto. Para fazer isso, aplique a técnica de diretivas somente leitura descrita acima a ambos os arquivos .RC. No caso em que os dois arquivos .RC são para aplicativos diferentes (projetos diferentes), o resultado é ilustrado no seguinte diagrama:

     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 em que o segundo arquivo de cabeçalho é compartilhado por dois arquivos .RC no mesmo aplicativo (projeto) é discutido abaixo.

Usar vários arquivos de recursos no mesmo projeto

O Visual C++ e o compilador de recursos dão suporte a vários arquivos .RC no mesmo projeto por meio de diretivas #include que incluem um arquivo .RC dentro de outro. Vários aninhamentos são permitidos. Há vários motivos para dividir os recursos do projeto em vários arquivos .RC:

  • É mais fácil gerenciar muitos recursos entre vários membros da equipe de projeto se você divide os recursos em vários arquivos .RC. Se você usar um pacote de gerenciamento de controle do código-fonte para fazer check-out de arquivos e check-in de alterações, dividir os recursos em vários arquivos .RC fornecerá um controle melhor sobre o gerenciamento de alterações nos recursos.

  • Se você quiser usar diretivas de pré-processador, como #ifdef, #endif e #define, para partes de seus recursos, você deverá isolá-las em recursos somente leitura que serão compilados pelo compilador de recursos.

  • Os arquivos .RC do componente serão carregados e salvos mais rapidamente no Visual C++ do que um arquivo .RC composto.

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

  • Se você precisar manter um recurso definido pelo usuário em um formato binário ou de texto que seja interpretável por outro editor de dados especializado, deverá mantê-lo em um arquivo .RC separado para que o Visual C++ não altere o formato para dados hexadecimal. Os recursos do arquivo .WAV (som) no SPEAKN de amostra dos Conceitos Avançados da MFC são um bom exemplo.

Você pode incluir SECOND.RC nas diretivas de tempo de compilação na caixa de diálogo Set Includes:

#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 seguinte diagrama:

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

Usando diretivas de tempo de compilação, você pode organizar seus recursos editáveis e não editáveis do Visual C++ em vários arquivos .RC, em que o MYAPP.RC principal não faz nada além de #include os outros arquivos .RC. Se você estiver usando um arquivo .MAK do projeto do Visual Studio C++, deverá incluir o arquivo .RC principal no projeto para que todos os recursos inclusos sejam compilados com seu aplicativo.

Imposição de arquivos não editáveis do Visual C++

O arquivo RES\MYAPP.RC2 criado pelo AppWizard é um exemplo de um arquivo que contém recursos que você não deseja ler acidentalmente no Visual C++ e depois gravá-lo novamente com perda de informações de formatação. Para se proteger contra esse problema, 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 e RC_INVOKED. Se a estrutura de arquivos criada pelo AppWizard estiver corrompida e o Visual C++ ler a linha de erro acima, ele relatará um erro fatal e anulará a leitura do arquivo .RC.

Gerenciar símbolos compartilhados por vários arquivos .RC editados pelo Visual C++

Dois problemas surgem quando você divide seus recursos em vários arquivos .RC que você deseja editar separadamente no Visual C++:

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

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

O seguinte diagrama ilustra uma organização de arquivos .RC e .H que lidam com o primeiro problema:

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

Neste exemplo, os recursos de cadeia de caracteres são mantidos em um arquivo de recurso, MYSTRS.RC, e os menus são mantidos em outro, MYMENUS.RC. Alguns símbolos, como para comandos, podem precisar ser compartilhados entre os dois arquivos. Por exemplo, um ID_TOOLS_SPELL pode ser a ID do comando de menu para o item Ortografia em um menu Ferramentas; e também pode ser a ID da cadeia de caracteres do prompt de comando exibido pela estrutura na barra de status da janela principal do aplicativo.

O símbolo ID_TOOLS_SPELL é mantido no arquivo de cabeçalho compartilhado, MYSHARED.H. Você mantém esse arquivo de cabeçalho compartilhado manualmente com um editor de texto. O Visual C++ não o edita diretamente. Nos dois arquivos de recurso MYSTRS.RC e MYMENUS.RC, você especifica #include "MYSHARED.H" nas diretivas somente leitura para MYAPP.RC, usando o comando Resource Includes, conforme descrito anteriormente.

É mais conveniente antecipar um símbolo que você compartilhará antes de tentar usá-lo para identificar qualquer recurso. Adicione o símbolo ao arquivo de cabeçalho compartilhado e, se ainda não tiver incluído o arquivo de cabeçalho compartilhado nas diretivas somente leitura para o arquivo .RC, faça isso antes de usar o símbolo. Se você não antecipou o compartilhamento do símbolo dessa forma, precisará mover manualmente (usando um editor de texto) a instrução #define para o símbolo de, por exemplo, MYMENUS.H para MYSHARED.H, antes de usá-la no MYSTRS.RC.

Quando você gerencia símbolos em vários arquivos .RC, você também deve ajudar o Visual C++ a evitar atribuir os mesmos valores numéricos de ID a recursos distintos (símbolos). Para qualquer arquivo .RC, o Visual C++ atribui incrementalmente IDs em cada um dos quatro domínios de ID. Entre as sessões de edição, o Visual C++ controla a última ID atribuída em cada um dos domínios no arquivo de cabeçalho de símbolo do arquivo .RC. Veja quais são os valores APS_NEXT 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 próximo valor de símbolo que será usado para um recurso de caixa de diálogo, recurso de menu e assim por diante. O intervalo válido para valores de símbolo de recurso é de 1 a 0x6FFF.

_APS_NEXT_COMMAND_VALUE é o próximo valor de símbolo que será usado para uma identificação de comando. O intervalo válido para valores de símbolo de recurso é de 0x8000 a 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 para valores de símbolo de controle de caixa de diálogo é 8 a 0xDFFF.

_APS_NEXT_SYMED_VALUE é o próximo valor de símbolo que será emitido quando você atribuir manualmente um valor de símbolo usando o comando New no Navegador de Símbolos.

O Visual C++ começa com valores ligeiramente mais altos que o menor valor legal ao criar um arquivo .RC. O AppWizard também inicializará esses valores para algo mais apropriado para aplicativos da MFC. Para mais informações sobre intervalos de valor de ID, confira a Nota técnica 20.

Agora, sempre que você cria um arquivo de recurso, mesmo no mesmo projeto, o Visual C++ define os mesmos valores _APS_NEXT_. Isso significa que, se você adiciona várias caixas de diálogos em dois arquivos .RC diferentes, é altamente provável que o mesmo valor de #define seja atribuído a caixas de diálogo diferentes. Por exemplo, IDD_MY_DLG1 no primeiro arquivo .RC pode receber o mesmo número, 101, como IDD_MY_DLG2 em um segundo arquivo .RC.

Para evitar esse problema, você deve reservar um intervalo numérico separado para cada um dos quatro domínios de IDs nos respectivos arquivos .RC. Defina os intervalos atualizando manualmente os valores _APS_NEXT em cada um dos arquivos .RC antes de começar a adicionar recursos. Por exemplo, se o primeiro arquivo .RC usa os valores _APS_NEXT padrão, talvez você queira atribuir os seguintes valores _APS_NEXT ao 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 que ainda é possível que o Visual C++ atribua tantas IDs ao primeiro arquivo .RC que os valores numéricos poderão começar a sobrepor os valores reservados para o segundo arquivo .RC. Você deve reservar intervalos suficientemente grandes para que essa colisão não aconteça.

Como gerenciar dependências entre arquivos .RC, .CPP e .H

Quando o Visual C++ salva um arquivo .RC, ele também salva alterações de símbolo no arquivo RESOURCE.H correspondente. Os arquivos .CPP que se referem a recursos no arquivo .RC precisam usar #include ara incluir o arquivo RESOURCE.H, geralmente de dentro do arquivo de cabeçalho principal do projeto. Essa inclusão leva a um efeito colateral indesejável por causa do gerenciamento de projeto interno do ambiente de desenvolvimento que verifica arquivos de origem em busca de dependências de cabeçalho. Toda vez que você adiciona um novo símbolo no Visual C++, todos os arquivos .CPP que incluem têm diretivas #include "RESOURCE.H" precisam ser recompilados.

O Visual C++ contorna a dependência do RESOURCE.H, incluindo o seguinte comentário como a primeira linha do arquivo RESOURCE.H:

//{{NO_DEPENDENCIES}}

O ambiente de desenvolvimento interpreta esse comentário ignorando as alterações no RESOURCE.H para que arquivos .CPP dependentes não precisem ser recompilados.

O Visual C++ sempre adiciona a linha de comentário //{{NO_DEPENDENCIES}} a um arquivo .RC quando salva o arquivo. Em alguns casos, burlar a dependência de build no RESOURCE.H pode levar a erros em tempo de execução não detectados no tempo de vinculação. Por exemplo, se você usar o navegador de símbolos para alterar o valor numérico atribuído a um símbolo para um recurso, o recurso não será encontrado e carregado corretamente no tempo de execução do aplicativo se o arquivo .CPP referente ao recurso não tiver sido recompilado. Nesses casos, você deve recompilar explicitamente os arquivos .CPP que você sabe que foram afetados pelas alterações de símbolo no RESOURCE.H ou selecionar Recompilar Tudo. Se você tiver a necessidade de alterar valores de símbolo com frequência para um determinado grupo de recursos, provavelmente achará mais conveniente e seguro dividir esses símbolos em um arquivo de cabeçalho somente leitura separado, conforme descrito na seção Incluir arquivos de cabeçalho adicionais acima.

Como o Visual C++ gerencia as informações de Set Includes

Conforme discutido acima, o comando Set Includes do menu Arquivo permite que você especifique três tipos de informações:

  • Arquivo de cabeçalho de símbolo

  • Diretivas de símbolo somente leitura

  • Diretivas de tempo de compilação

Veja abaixo uma tabela que descreve como o Visual C++ mantém essas informações em um arquivo .RC. Você não precisa dessas informações para usar o Visual C++, mas isso pode aprimorar sua compreensão para que você possa usar com mais confiança o recurso Set Includes.

Cada um dos três tipos acima de informações de Set Includes é armazenado no arquivo .RC em duas formas: (1) como #include ou outras diretivas interpretáveis pelo compilador de recursos e (2) como recursos TEXTINCLUDE especiais interpretáveis somente pelo Visual C++.

A finalidade do recurso TEXTINCLUDE é armazenar com segurança as informações de Set Include em um formato prontamente apresentável na caixa de diálogo Set Includes do Visual C++. TEXTINCLUDE é um tipo de recurso definido pelo Visual C++. O Visual C++ reconhece três recursos TEXTINCLUDE específicos que têm os números 1, 2 e 3 de identificação do recurso:

ID de recursos TEXTINCLUDE Tipo de informações Set Includes
1 Arquivo de cabeçalho de símbolo
2 Diretivas de símbolo somente leitura
3 Diretivas de tempo de compilação

Cada um dos três tipos de informações de Set Includes é ilustrado pelos arquivos MYAPP.RC e RESOURCE.H padrão criados por AppWizard, conforme descrito abaixo. Os tokens \0 e "" adicionais entre os blocos BEGIN e END são exigidos pela sintaxe RC para especificar zero cadeia de caracteres terminada e o caractere de aspas duplas, respectivamente.

Arquivo de cabeçalho de símbolo

O formato das informações do arquivo de cabeçalho de símbolo interpretadas pelo compilador de recursos é simplesmente uma instrução #include:

#include "resource.h"

O recurso TEXTINCLUDE correspondente é:

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

Diretivas de símbolo somente leitura

As diretivas de símbolo somente leitura estão incluídas na parte superior do MYAPP.RC no seguinte formato interpretável pelo compilador de recursos:

#include "afxres.h"

O recurso TEXTINCLUDE correspondente é:

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

Diretivas de tempo de compilação

As diretivas de tempo de compilação estão incluídas na parte final do MYAPP.RC no seguinte formato interpretável pelo compilador de recursos:

#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 #ifndef APSTUDIO_INVOKED instrui o Visual C++ a ignorar as diretivas de tempo de compilação.

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

Confira também

Observações técnicas por número
Observações técnicas por categoria