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

Esta observação descreve como o editor de recursos do Visual C++ oferece 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ê deseja dividir um projeto em vários arquivos de recursos e/ou arquivos de cabeçalho e como fazê-lo

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

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

• Como você (e as ferramentas) gerenciam as dependências de compilação entre .RC, .CPPe .H arquivos

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

Esta nota está estruturada para responder às questões acima da seguinte forma:

• 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 dos ficheiros criados pelo AppWizard .RC e .H examina os vários ficheiros de recursos e ficheiros de cabeçalho que são usados por uma aplicação criada pelo AppWizard. Esses arquivos servem como um bom modelo para arquivos de recursos adicionais e arquivos de cabeçalho que você pode querer adicionar ao seu projeto.

• Incluindo 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.

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

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

• Gerenciando 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 .RC, .CPPe .H arquivos descreve como o Visual C++ evita a recompilação .CPP desnecessária de arquivos que dependem de arquivos de símbolo de recurso.

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

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

Visual C++ gerencia um único .RC arquivo de recurso e um arquivo de cabeçalho correspondente .H como um par de arquivos fortemente 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 ao mesmo tempo (usando a interface de usuário MDI do Visual C++), para qualquer arquivo específico .RC , você edita indiretamente exatamente um arquivo de cabeçalho correspondente.

Caixa de diálogo de Inclusão de Recursos na Visualização de Recursos

Para aceder à Inclusão de Recursos, abra a Vista de Recursos e, em seguida, clique com o botão direito do rato no .RC ficheiro e selecione Inclusão de Recursos.

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 Inclui recurso 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.

Read-Only Diretivas de símbolos

Embora o Visual C++ edite apenas um arquivo de cabeçalho para qualquer .RC arquivo, o Visual C++ oferece suporte a referências a símbolos definidos em arquivos de cabeçalho somente leitura adicionais. A seção Read-Only Diretivas de Símbolo: na caixa de diálogo Recursos Incluídos permite especificar qualquer número de arquivos de cabeçalho somente leitura adicionais como Read-Only Diretivas de Símbolo. A restrição "somente leitura" significa que, quando você adiciona um novo recurso no .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.

Compile-Time Diretivas

Visual C++ também oferece suporte ao aninhamento de arquivos de recursos, onde um .RC arquivo é incluído dentro de outro usando uma #include diretiva . Quando você edita um determinado .RC arquivo usando o Visual C++, todos os recursos nos arquivos incluídos não são visíveis. Mas quando você compila o .RC arquivo, os arquivos incluídos também são compilados. A seção Compile-Time Diretivas: na caixa de diálogo de Recursos Inclui permite especificar qualquer número de .RC arquivos para serem incluídos como Compile-Time Directives.

Observa o que acontece se leres, no Visual C++, um arquivo .RC que inclui outro arquivo .RC que não está especificado como uma diretiva Compile-Time. Essa situação pode surgir quando você traz para o Visual C++ um .RC arquivo que você vinha mantendo manualmente anteriormente 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 . Quando se guarda o ficheiro pai .RC, a instrução #include será substituída pelos recursos incluídos. Se não quiseres que esta mesclagem aconteça, deves remover a instrução #include do ficheiro pai .RCantes de a ler no Visual C++; depois, usando o Visual C++, voltar a adicionar a mesma instrução #include como uma Diretiva Compile-Time.

Visual C++ salva num .RC arquivo as três categorias de informações Set Includes acima mencionadas (Symbol Header File, Diretivas de Símbolo Read-Only, e Diretivas Compile-Time) nas diretivas #include nos recursos . Em TEXTINCLUDE, são explicados os recursos, um detalhe de implementação com o qual o utilizador geralmente não requer a sua intervenção.

Análise de .RC e arquivos .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 recursos 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 recursos 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 Visual C++ File/set Includes.

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 nomeado RESOURCE.H pelo AppWizard, consistente com a nomenclatura padrão do Visual C++ do arquivo de cabeçalho. O #include para este 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 usar recursos formatados personalizados, pode adicioná-los em RES\MYAPP.RC2 e editá-los utilizando o editor de texto do Visual C++.

AFXRES.RC e AFXPRINT.RC contêm recursos padrão necessários para certas funcionalidades da estrutura. Como RES\MYAPP.RC2, estes dois ficheiros de recursos fornecidos pela framework 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. Assim, 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 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 Nota 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 em AFXRES.H estão disponíveis à medida que 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 arquivo 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. Apenas RESOURCE.H é específico do aplicativo. Talvez seja necessário incluir ficheiros de cabeçalho de apenas leitura adicionais nos casos a seguir:

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 ele salva 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 #include instrução como uma segunda Diretiva de Símbolo Read-Only, como mostrado no exemplo a seguir:

#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

Você pode querer compartilhar um arquivo de cabeçalho entre dois .RC arquivos que estão em projetos diferentes, ou possivelmente o mesmo projeto. Para tal, aplique a técnica das diretivas Read-Only acima descrita a ambos os .RC ficheiros. No caso em que os dois .RC arquivos são para aplicações 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

Visual C++ e o compilador de recursos suportam vários .RC arquivos no mesmo projeto por meio de #include diretivas que incluem um .RC arquivo dentro de outro. É permitido o encadeamento múltiplo. Há várias razões para dividir os recursos do seu 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 utilizar um pacote de gestão de controle de versão para requisitar arquivos e cometer alterações, dividir os recursos em vários .RC arquivos lhe proporcionará um controle mais preciso sobre o gerenciamento de alterações nos recursos.

• Se desejar usar diretivas de pré-processador, como #ifdef, #endife #define, para partes de seus recursos, isole-as 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 formato legível por humanos, você deve mantê-lo em um .RC arquivo separado do que o Visual C++ edita.

• 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, você deve mantê-lo em um arquivo separado .RC para que o Visual C++ não altere o formato para dados hexadecimais. Os .WAV recursos de arquivo (som) no exemplo MFC Advanced Concepts SPEAKN são um bom exemplo.

Você pode incluir SECOND.RC nas Diretivas Compile-Time na caixa de diálogo Incluir Configurações.

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

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

Usando diretivas Compile-Time, você pode organizar seus recursos editáveis e não editáveis do Visual C++ em vários .RC arquivos, onde o principal MYAPP.RC não faz nada além #include dos outros .RC arquivos. Se você estiver usando um arquivo de projeto .MAK do Visual Studio C++, inclua o arquivo principal .RC no projeto para que todos os recursos incluídos sejam compilados com seu aplicativo.

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

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 se 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 ficheiro .RC, ele define ambos APSTUDIO_INVOKED e RC_INVOKED. Se a estrutura de arquivo criada pelo AppWizard estiver corrompida e o Visual C++ ler a linha #error acima, ele relatará um erro fatal e abortará a .RC leitura do 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 você 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 seguinte ilustra uma organização de .RC e .H arquivos que aborda a primeira questão.

              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, a ID_TOOLS_SPELL pode ser o ID do comando de menu para o item Spell em um menu Ferramentas e também pode ser o ID de string do prompt de comando exibido 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 este ficheiro de cabeçalho partilhado manualmente com um editor de texto; o Visual C++ não o edita diretamente. Nos dois ficheiros MYSTRS.RC de recursos e MYMENUS.RC, especifica-se #include "MYSHARED.H" nas Diretivas Read-Only para MYAPP.RC, utilizando o comando Resource Includes como 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 você ainda não tiver incluído o arquivo de cabeçalho compartilhado nas diretivas de Read-Only para o .RC arquivo, faça isso antes de usar o símbolo. Se você não previu compartilhar o símbolo dessa maneira, então você terá que 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.

Quando você gerencia símbolos em vários .RC arquivos, você também deve ajudar o Visual C++ evitar atribuir os mesmos valores numéricos de ID para 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++ mantém registo do último identificador atribuído em cada um dos domínios no cabeçalho de símbolos para o ficheiro .RC. Veja quais são os APS_NEXT valores 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 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ímbolos 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 comando Novo no Navegador de Símbolos.

Visual C++ começa com valores ligeiramente mais altos do que o menor valor legal ao criar um novo .RC arquivo. O 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, toda vez 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 de #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 respetivos .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 usa os valores padrão _APS_NEXT , convém 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 que ainda é possível que o Visual C++ atribua tantas IDs no primeiro .RC arquivo que os valores numéricos comecem 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 um dos seus .CPP arquivos que se referem a recursos no .RC arquivo deve usar #include para incluir o RESOURCE.H arquivo, geralmente de dentro do arquivo de cabeçalho principal do seu projeto. Esta inclusão leva a um efeito secundário indesejável devido à gestão interna de projetos dentro do ambiente de desenvolvimento, que examina os ficheiros de código-fonte para identificar dependências de cabeçalhos. Toda vez que você adiciona um novo símbolo no Visual C++, todos os .CPP arquivos que têm #include "RESOURCE.H" diretivas precisariam ser recompilados.

Visual C++, contorna a dependência de RESOURCE.H incluindo 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 ficheiros dependentes .CPP não precisem de ser recompilados.

Visual C++ sempre adiciona a //{{NO_DEPENDENCIES}} linha de comentário a um .RC arquivo quando ele salva o arquivo. Em alguns casos, contornar a dependência de compilação em RESOURCE.H pode resultar em erros de tempo de execução que não são detetados no momento da ligação. Por exemplo, se você usar o Navegador de Símbolos para alterar o valor numérico atribuído a um símbolo de um recurso, o recurso não será encontrado e carregado corretamente em tempo de execução do aplicativo se o .CPP arquivo referente ao recurso não for recompilado. Nesses casos, deve-se recompilar explicitamente todos os .CPP arquivos que se sabe serem afetados pelas alterações de símbolo em RESOURCE.H ou selecionar Reconstruir Tudo. Se você tiver a necessidade de alterar frequentemente os valores dos símbolos 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 o conjunto inclui informações

Como discutido acima, o comando Conjunto de itens do menu Arquivo permite especificar três tipos de informações:

• Arquivo de cabeçalho de símbolo

• Read-Only Diretivas de símbolos

• Compile-Time Diretivas

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 melhorar sua compreensão para que você possa usar com mais confiança o recurso Definir incluis.

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

O objetivo do TEXTINCLUDE recurso é armazenar com segurança informações Set Include num formato que seja facilmente apresentável na caixa de diálogo de 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 de recursos 1, 2 e 3:

Cada um dos três tipos de informações "Set Includes" é ilustrado pelos arquivos padrão, MYAPP.RC e RESOURCE.H, criados pelo AppWizard, conforme descrito abaixo. Os tokens extra \0 e "" entre os blocos BEGIN e END são exigidos pela sintaxe RC para especificar cadeias de caracteres terminadas por zero e o caráter de aspas duplas, 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

Read-Only Diretivas de símbolos

Read-Only Diretivas de símbolos são incluídas na parte superior de MYAPP.RC na seguinte 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

Compile-Time Diretivas

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

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

Ver também

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