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

Esta observação 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 observação 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ê o faz

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

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

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

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

Esta observação é 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 recurso e arquivos de cabeçalho no mesmo projeto.

• A análise de .RC e .H Arquivos criados pelo AppWizard examina os múltiplos arquivos de recurso e cabeçalho que são usados por um aplicativo criado pelo AppWizard. Esses arquivos servem como um bom modelo para arquivos de recursos adicionais e arquivos de cabeçalho que talvez você queira adicionar ao seu 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.

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

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

• O controle de arquivos não editáveis do Visual C++ descreve como você pode assegurar que o Visual C++ não edite e reformate involuntariamente um recurso personalizado.

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

• Gerenciando dependências entre arquivos .RC, .CPP e .H, descreve como o Visual C++ evita a recompilação desnecessária de arquivos que dependem 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 .RC arquivo de recurso e um arquivo de cabeçalho correspondente .H como um par de arquivos firmemente acoplado. Ao editar e salvar recursos em um .RC arquivo, você edita e salva símbolos indiretamente no arquivo correspondente .H . Embora você possa abrir e editar vários .RC arquivos de cada vez (usando a interface do usuário MDI do Visual C++), para qualquer arquivo fornecido .RC , você edita indiretamente exatamente um arquivo de cabeçalho correspondente.

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

Para acessar Resource Includes, abra a Visualização de Recursos, 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 arquivo RESOURCE.Hde 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 que você altere o nome desse arquivo de cabeçalho. Insira um novo nome de arquivo na caixa de edição da seção.

Diretivas de símbolo somente leitura

Embora o Visual C++ edite apenas um arquivo de cabeçalho para qualquer arquivo específico .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 ao .RC arquivo, 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 .RC arquivo usando o Visual C++, todos os recursos nos arquivos incluídos não ficam visíveis. Mas quando você compila o .RC arquivo, 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 você traz para o Visual C++ um .RC arquivo que você estava mantendo manualmente com um editor de texto. Quando o Visual C++ lê o arquivo incluído .RC , ele mescla os recursos incluídos no arquivo pai .RC . Ao salvar o arquivo pai .RC, a instrução #include será efetivamente substituída pelos recursos incluídos. Se você não quiser que essa mesclagem aconteça, remova a #include instrução do arquivo pai .RCantes de importá-la para o Visual C++; então, usando o Visual C++, adicione novamente a mesma #include instrução como uma diretiva Compile-Time.

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 #includee em recursos TEXTINCLUDE. Os TEXTINCLUDE recursos, um detalhe de implementação com o qual você normalmente não precisa lidar, são explicados em Como o Visual C++ gerencia as informações incluídas no conjunto.

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

Examinar o código do aplicativo produzido pelo AppWizard fornece insights 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 MYAPP aplicativo 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 Arquivo/Conjunto de Inclusões do Visual C++.

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

RESOURCE.H é o arquivo de cabeçalho específico do aplicativo. Ele é sempre nomeado 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 compilado .EXE final. 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 RES\MYAPP.RC2 e editá-los usando o editor de texto do Visual C++.

AFXRES.RC e AFXPRINT.RC contêm recursos básicos necessários para certas funcionalidades do framework. Como RES\MYAPP.RC2, esses dois arquivos de recurso fornecidos pela estrutura são incluídos no final de MYAPP.RC e são especificados nas diretivas Compile-Time da caixa de diálogo Definir Inclusões. Portanto, você não exibe ou edita diretamente esses recursos da estrutura enquanto edita MYAPP.RC no Visual C++, mas eles são compilados no arquivo binário .RES e no arquivo final .EXE do aplicativo. Para obter mais informações sobre os recursos da estrutura padrão, incluindo procedimentos para modificá-los, consulte a Observação Técnica 23.

AFXRES.H define símbolos padrão, como ID_FILE_NEW, usados pela estrutura e usados especificamente em AFXRES.RC. AFXRES.H também usa #include para incluir WINRES.H, que contém um subconjunto do WINDOWS.H necessário para arquivos .RC gerados pelo Visual C++ e AFXRES.RC. Os símbolos definidos 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.

Incluindo 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. Pode ser necessário incluir arquivos de cabeçalho adicionais de somente leitura nos seguintes casos:

O arquivo de cabeçalho é fornecido por uma origem 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 #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 esta aparência:

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

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

Talvez você queira compartilhar um arquivo de cabeçalho entre dois .RC arquivos que estão em projetos diferentes ou possivelmente o mesmo projeto. Para fazer isso, aplique a técnica de diretivas de Read-Only descrita acima a ambos os .RC arquivos. No caso em que os dois .RC arquivos são para aplicativos diferentes (projetos diferentes), 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 em que o segundo arquivo de cabeçalho é compartilhado por dois .RC arquivos no mesmo aplicativo (projeto) é discutido abaixo.

Usando vários arquivos de recursos no mesmo projeto

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

• É mais fácil gerenciar um grande número de recursos entre vários membros da equipe de projeto se você dividir os recursos em vários .RC arquivos. 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, #endife #define, para partes de seus recursos, você deve isolá-las em recursos somente leitura que serão compilados pelo Compilador de Recursos.

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

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

• Se você precisar manter um recurso definido pelo usuário em um formulário binário ou de texto que seja interpretável por outro editor de dados especializado, mantenha-o em um arquivo separado .RC 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 de projeto .MAK do Visual Studio C++, deverá incluir o arquivo principal .RC no projeto para que todos os recursos incluídos sejam compilados com seu aplicativo.

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

O arquivo criado pelo RES\MYAPP.RC2 AppWizard é um exemplo de um arquivo que contém recursos que você não deseja ler acidentalmente no Visual C++ e, em seguida, gravar novamente com perda de informações de formatação. Para proteger contra esse problema, coloque as seguintes linhas no início do RES\MYAPP.RC2 arquivo:

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

Quando o Visual C++ compila o .RC arquivo, ele define ambos APSTUDIO_INVOKED e RC_INVOKED. Se a estrutura de arquivos criada pelo AppWizard estiver corrompida e o Visual C++ ler o #error linha acima, ele relatará um erro fatal e anulará a leitura do .RC arquivo.

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

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

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

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

O diagrama a seguir ilustra uma organização de arquivos .RC e .H que abordam 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 MYSTRS.RCde recurso 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, uma ID_TOOLS_SPELL pode ser a ID do comando de menu para o item Ortografia em um menu de ferramentas; e também pode ser a ID da cadeia de caracteres da linha de comando exibida pela estrutura na barra de status da janela principal do aplicativo.

O ID_TOOLS_SPELL símbolo é 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 Read-Only para MYAPP.RC, usando o comando Resource Includes, conforme descrito anteriormente.

É mais conveniente prever 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 você ainda não tiver incluído o arquivo de cabeçalho compartilhado nas Diretivas de Read-Only do .RC arquivo, faça isso antes de usar o símbolo. Se você não antecipou o compartilhamento do símbolo dessa maneira, precisará mover manualmente (usando um editor de texto) a instrução #define 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 .RC arquivos, 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 específico .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. Aqui está o que os APS_NEXT valores são para um arquivo vazio (novo): .RC

#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 comando é 0x8000 a 0xDFFF.

_APS_NEXT_CONTROL_VALUE é o próximo valor de símbolo que será usado para um controle de diálogo. O intervalo válido para valores de símbolo de controle de caixa de diálogo é de 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 novo comando no Navegador de Símbolos.

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

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

Para evitar esse problema, você deve reservar um intervalo numérico separado para cada um dos quatro domínios de IDs nos respectivos .RC arquivos. Defina os intervalos atualizando manualmente os _APS_NEXT valores em cada um dos arquivos .RC de começar a adicionar recursos. Por exemplo, se o primeiro .RC arquivo usar os valores padrão _APS_NEXT , talvez você queira atribuir os seguintes _APS_NEXT valores ao segundo .RC arquivo:

#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 o Visual C++ atribua tantas IDs no primeiro .RC arquivo que os valores numéricos começam a se sobrepor aos reservados para o segundo .RC arquivo. Você deve reservar intervalos suficientemente grandes para que essa colisão não aconteça.

Gerenciando dependências entre .RC, .CPPe .H arquivos

Quando o Visual C++ salva um .RC arquivo, ele também salva alterações de símbolo no arquivo correspondente RESOURCE.H . Qualquer arquivo .CPP que se refira aos recursos no arquivo .RC deve usar #include para incluir o arquivo RESOURCE.H, geralmente a partir do arquivo de cabeçalho principal do projeto. Essa inclusão causa um efeito colateral indesejável devido ao gerenciamento interno de projetos no ambiente de desenvolvimento, que examina os arquivos-fonte em busca de dependências dos cabeçalhos. Sempre que você adicionar um novo símbolo no Visual C++, todos os .CPP arquivos que têm #include "RESOURCE.H" diretivas precisarão ser recompilados.

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

//{{NO_DEPENDENCIES}}

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

O Visual C++ sempre adiciona a //{{NO_DEPENDENCIES}} linha de comentário a um .RC arquivo 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 .CPP arquivo que se refere ao recurso não for recompilado. Nesses casos, você deve recompilar explicitamente todos os arquivos .CPP que você sabe que são afetados pelas alterações nos símbolos em RESOURCE.H ou selecionar Recompilar Tudo. Se você tiver a necessidade de alterar frequentemente os valores de símbolo 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 acima, incluindo arquivos de cabeçalho adicionais.

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

A tabela a seguir descreve como o Visual C++ mantém essas informações em um .RC arquivo. 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 do Set Includes em um formulário que seja 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 específicos TEXTINCLUDE que têm os números de identificação do recurso 1, 2 e 3:

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 extras \0 e "" entre os blocos BEGIN e END são necessários pela sintaxe RC para especificar cadeias de caracteres terminadas em zero e o caractere de aspa dupla, respectivamente.

Arquivo de cabeçalho de símbolo

A forma das informações do Arquivo de Cabeçalho de Símbolo interpretadas pelo Compilador de Recursos é simplesmente uma #include instrução:

#include "resource.h"

O recurso correspondente TEXTINCLUDE é:

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

Diretivas de símbolo somente leitura

Diretivas de Símbolo Read-Only são incluídas no topo do MYAPP.RC de forma interpretável pelo Compilador de Recursos.

#include "afxres.h"

O recurso correspondente TEXTINCLUDE é:

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

Diretivas de tempo de compilação

Compile-Time Diretivas são incluídas no final de MYAPP.RC na forma seguinte, compreensí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 #ifndef APSTUDIO_INVOKED diretiva instrui o Visual C++ a ignorar as diretivas de Compile-Time.

O recurso correspondente TEXTINCLUDE é:

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

Notas técnicas por número
Notas técnicas por categoria