TN035: Usando vários arquivos de recurso e arquivos de cabeçalho com o Visual C++
.gif "Observação") Observação |
|---|
A seguinte nota técnica 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 desatualizado ou incorreto.As informações mais recentes, é recomendável que você procure o tópico de interesse no índice de documentação on-line. |
Esta nota descreve como o editor de recursos do Visual C++ oferece suporte a vários arquivos de recurso e arquivos de cabeçalho compartilhados em um único projeto ou compartilhados entre vários projetos e como você pode aproveitar esse suporte.Esta observação responde essas perguntas:
Quando você pode desejar dividir um projeto em vários arquivos de recurso e/ou arquivos de cabeçalho e como fazer?
Como compartilhar um cabeçalho comuns.Arquivo h entre os dois.Arquivos RC?
Como você dividir recursos projeto em vários.Arquivos RC?
Como você (e as ferramentas) gerenciar dependências de compilação entre.RC.CPP, e.Arquivos H?
Você deve estar ciente de que, se você adicionar um arquivo de recursos adicionais ao seu projeto, ClassWizard não reconhecerá os recursos no arquivo adicionado.
Esta nota é estruturada para responder as perguntas acima da seguinte maneira:
Overview of How Visual C++ Manages Resource Files and Header FilesFornece uma visão geral de como o comando Set inclui recursos no Visual C++ permite usar vários arquivos de recurso e arquivos de cabeçalho no mesmo projeto.
Analysis of AppWizard-created .RC and .H Filesanalisa os vários arquivos de cabeçalho e os recursos usados por um aplicativo criado 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.
Including Additional Header FilesDescreve onde você pode desejar incluir vários arquivos de cabeçalho e fornece detalhes sobre como fazer isso.
Sharing a Header File Between Two .RC Filesmostra como você pode compartilhar um arquivo de cabeçalho entre múltiplo.Arquivos RC em diferentes projetos, ou talvez no mesmo projeto.
Using Multiple Resource Files in the Same ProjectDescreve onde deseja dividir o projeto em vários.RC arquivos e fornece detalhes sobre como fazer isso.
Enforcement of Non-Editable Visual C++ FilesDescreve como você pode certificar-se de Visual C++ não editar e reformatar acidentalmente um recurso personalizado.
Managing Symbols Shared by Multiple Visual C++-Edited .RC FilesDescreve como compartilhar os mesmos símbolos em vários.Arquivos RC e como evitar a atribuição de valores numéricos de ID duplicados.
Managing Dependencies Between .RC, .CPP, and .H FilesDescreve como o Visual C++ evita desnecessários recompilar.Arquivos CPP que são dependentes de arquivos de símbolo de recurso.
How Visual C++ Manages Set Includes InformationFornece detalhes técnicos sobre como o Visual C++ mantém o controle de vários (aninhados).Arquivos RC e vários arquivos de cabeçalho são # include'd por um.Arquivo RC.
Visão geral de como o Visual C++ gerencia arquivos de recurso e arquivos de cabeçalho
Visual C++ gerencia um único.Arquivo de recurso RC e um correspondente.Arquivo de cabeçalho h como um par estreita de arquivos.Quando você editar e salvar os recursos em um.Arquivo RC, você indiretamente editar e salva símbolos correspondentes.Arquivo de H.Embora você possa abrir e editar várias.Arquivos RC no momento (usando a interface do usuário MDI do Visual C++) para qualquer dado.Arquivo RC você indiretamente Editar exatamente um arquivo de cabeçalho correspondentes.
Arquivo de cabeçalho de símbolo
Por padrão, 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 Inclui recursos comando o modo menu no Visual C++, você pode alterar o nome desse arquivo de cabeçalho, atualizando o arquivo do arquivo de cabeçalho de símbolo na Definir inclui caixa de diálogo.
Diretivas de símbolo somente leitura
Embora o Visual C++ somente edita um arquivo de cabeçalho para qualquer dado.Arquivo RC, Visual C++ oferece suporte a referências a símbolos definidos em arquivos de cabeçalho de somente leitura adicional.Usando o Inclui o recurso comando do modo menu no Visual C++, você pode especificar qualquer número de arquivos de cabeçalho de somente leitura adicional como diretivas de símbolo somente leitura.A restrição "somente leitura" significa que quando você adiciona um novo recurso do.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.Você não pode alterar o valor numérico atribuído a um símbolo somente leitura.
Diretivas de tempo de compilação
Visual C++ também suporta aninhamento de arquivos de recurso, onde um.Arquivo RC é # include'd dentro de outro.Quando você edita um determinado.Arquivo RC usando o Visual C++, quaisquer recursos em arquivos # include'd não são visíveis.Mas quando você compilar o.Arquivo RC, os arquivos # include'd também são compilados.Usando o Inclui o recurso comando do modo menu no Visual C++, você pode especificar qualquer número de # include'd.Arquivos RC como diretivas de tempo de compilação.
Observe o que acontece se você ler em Visual C++ um.Do arquivo RC que # include outra.Arquivo RC está não especificado como uma diretiva de tempo de compilação.Essa situação pode surgir quando trazer para o Visual C++ um.Arquivo RC que você tinha sido anteriormente mantendo manualmente com um editor de texto.Quando o Visual C++ lê o # include'd.Arquivo RC, ele mescla recursos # include'd do pai.Arquivo RC.Quando você salvar o pai.Arquivo RC, # include instrução, na verdade, serão substituídos por recursos # include'd.Se não desejar esta mesclagem aconteça, você deve remover o # incluir instrução do pai.Arquivo RC anterior para leitura em Visual C++; usando o Visual C++, adicionar novamente o mesmo # include instrução como uma diretiva de tempo de compilação.
Visual C++ é salva em um.Três tipos de arquivo RC de acima definir inclui informações (arquivo de cabeçalho de símbolo, diretivas de símbolo somente leitura e diretivas de tempo de compilação) # diretivas include e em recursos TEXTINCLUDE.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 definir inclui informações.
Análise de AppWizard-criado.RC e.Arquivos H
Examinar o código de aplicativo produzido pelo AppWizard fornece idéias 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 AppWizard usa vários arquivos de recurso e vários arquivos de cabeçalho, como resumido no diagrama abaixo:
RESOURCE.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
AFXRES.RC
AFXPRINT.RC
Você pode exibir esses vários relacionamentos de arquivo usando o comando inclui o arquivo do Visual C++/Set.
- MYAPP.RC
O arquivo de recurso de aplicativo Editar usando o Visual C++.
RECURSO.H é o arquivo de cabeçalho específico do aplicativo.Ele sempre é denominado recurso.H por AppWizard, consistente com o padrão do Visual C++ de nomeação de arquivo de cabeçalho.# Include para o 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 final compilado.Arquivo EXE.AppWizard cria recursos sem por padrão, como 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ê deseja adicionar seus próprios recursos personalizados formatados para esse arquivo.
Se você usar recursos formatados personalizados, você pode adicioná-los para RES\MYAPP.RC2 e editá-los usando o editor de texto do Visual C++.
AFXRES.RC e AFXPRINT.RC contêm recursos padrão necessários para determinados recursos do framework.Como RES\MYAPP.RC2, esses dois arquivos de recurso fornecido pelo framework são # include'd no final do MYAPP.RC e elas são especificadas as diretivas de tempo de compilação da caixa de diálogo Definir inclui.Assim, não diretamente exibir ou editar esses recursos de framework enquanto edita MYAPP.RC no Visual C++, mas eles são compilados no binário do aplicativo.Arquivo RES e final.Arquivo EXE.Para obter mais informações sobre os recursos de estrutura padrão, incluindo procedimentos para modificá-los, consulte técnico Observação 23.
AFXRES.H define símbolos padrão, como ID_FILE_NEW, usado pela estrutura e especificamente usado 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++ gerados.Arquivos RC, bem como AFXRES.RC.Os símbolos definidos no AFXRES.H estão disponíveis como editar o arquivo de recurso do aplicativo (MYAPP.RC).Por exemplo, ID_FILE_NEW é usado para o item de menu arquivo novo em MYAPP.Recurso de menu do RC.Você não pode alterar ou excluir esses símbolos definidos pelo framework.
Incluindo arquivos de cabeçalho adicionais
O aplicativo criado AppWizard inclui apenas dois arquivos de cabeçalho: recurso.H e AFXRES.H.Somente o recurso.H é específico do aplicativo.Talvez você precise incluir arquivos de cabeçalho de somente leitura adicional 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 de 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++ para alterar ou filtrar quando salva o arquivo.Por exemplo, talvez você queira preservar # do definir que usar 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 de somente leitura adicional usando o Inclui o recurso comando para especificar o # include instrução como uma segunda diretiva de símbolo somente leitura, como em:
#include "afxres.h"
#include "second.h"
O novo diagrama de relacionamento de arquivo agora esta aparência:
AFXRES.H
RESOURCE.H SECOND.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
AFXRES.RC
AFXPRINT.RC
Compartilhamento de um arquivo de cabeçalho entre os dois.Arquivos RC
Você poderá compartilhar um arquivo de cabeçalho entre os dois.Arquivos RC em diferentes projetos ou possivelmente o mesmo projeto.Para isso, basta aplica a técnica de diretivas de somente leitura descrita acima para ambos.Arquivos RC.No caso em que os dois.São arquivos RC para diferentes aplicativos (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.Arquivos RC no mesmo aplicativo (projeto) é discutida abaixo.
Usando vários arquivos de recurso no mesmo projeto
Visual C++ e o compilador de recurso suportam vários.Arquivos RC no mesmo projeto através de # do incluir um.Arquivo RC dentro de outro.O aninhamento múltiplo é permitido.Há várias razões para dividir os recursos do projeto em vários.Arquivos RC:
É 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.Arquivos RC.Se você usar um pacote de gerenciamento de controle de origem para fazer check-out de arquivos e verificar as alterações, dividir os recursos em vários.Arquivos RC lhe dará controle sobre o gerenciamento de alterações em recursos.
Se você quiser usar diretivas de pré-processamento, como # ifdef, # endif e # definem, partes de seus recursos, deve isolá-los em recursos de somente leitura serão ser compilados pelo compilador de recurso.
Componente.RC arquivos carregará e salvar mais rápido no Visual C++ de uma composição.Arquivo RC.
Se você quiser manter um recurso com um editor de texto em um formulário legível, deve mantê-lo um.Edita o arquivo RC separado de um Visual C++.
Se você precisar manter um recurso definido pelo usuário em um formulário de texto ou binário é interpretable por outro editor de dados especializados, você deve mantê-lo em um separado.Arquivo RC para que Visual C++ não altera o formato de dados hexadecimais.O.Recursos de arquivo WAV (som) no exemplo MFC avançado conceitos SPEAKN são um bom exemplo.
# Você pode incluir um segundo.RC as diretivas de tempo de compilação na caixa de diálogo Definir 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 tempo de compilação, você pode organizar seus recursos Visual C++ editáveis e não editáveis em vários.Arquivos RC, onde MYAPP "mestre".RC não faz nada, mas # include do outro.Arquivos RC.Se você estiver usando um projeto Visual C++.Arquivo MAK, você deve incluir o "mestre".Arquivo RC no projeto para que todos os recursos do # include'd são compilados com o seu aplicativo.
Imposição de arquivos não seja editável Visual C++
RES\MYAPP criado AppWizard.Arquivo RC2 é um exemplo de um arquivo que contém recursos que você fazer não deseja ler acidentalmente em Visual C++ e gravá-lo de volta com perda de informações de formatação.Para proteger contra isso, coloque as seguintes linhas no início do RES\MYAPP.Arquivo 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 como RC_INVOKED.Se a estrutura do arquivo criado AppWizard está corrompida e Visual C++ lê a linha # erro acima, ele reporta um erro fatal e anular a leitura da.Arquivo RC.
Gerenciar símbolos compartilhados por vários Visual C++-editada.Arquivos RC
Dois problemas surgem quando você dividir os recursos em várias.Arquivos RC que você deseja editar separadamente no Visual C++:
Talvez queira compartilhar os mesmos símbolos em vários.Arquivos RC.
Você precisa de Ajuda do Visual C++ evite atribuir os mesmos valores numéricos de identificação para recursos distintos (símbolos).
O diagrama a seguir ilustra uma organização.RC e.Arquivos h que lida com o primeiro problema:
MYAPP.RC
/ \
/ \
MYSTRS.H / MYSHARED.H \ MYMENUS.H
\ / / \ \ \
\ / / \ \ \
MYSTRS.RC MYMENUS.RC
Neste exemplo, os recursos de seqüência de caracteres são mantidos no arquivo de um recurso, MYSTRS.RC e menus são mantidas em outro, MYMENUS.RC.Alguns símbolos, como comandos, talvez precise ser compartilhados entre os dois arquivos.Por exemplo, um ID_TOOLS_SPELL pode ser o comando de menu ID do item de ortografia em um menu de ferramentas; e também pode ser a identificação da seqüência de caracteres do prompt de comando exibida pelo framework na barra de status da janela principal do aplicativo.
O símbolo ID_TOOLS_SPELL é mantido no arquivo de cabeçalho compartilhada, MYSHARED.H.Manter esse arquivo de cabeçalho compartilhada manualmente com um editor de texto; Visual C++ não diretamente editá-lo.No recurso de dois arquivos MYSTRS.RC e MYMENUS.RC, você especificar # incluem MYSHARED.H as diretivas de somente leitura para MYAPP.RC, usando o Inclui o recurso de comando, conforme descrito anteriormente.
É 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 compartilhada as diretivas de somente leitura para o.RC de arquivo, antes de usar o símbolo.Se você não antecipou a compartilhar o símbolo dessa maneira, você terá que manualmente (usando um editor de texto) mover o # define instrução para o símbolo de, digamos, MYMENUS.H para MYSHARED.H antes de usá-lo em MYSTRS.RC.
Quando você gerencia vários símbolos.Arquivos RC, você também deve ajudar Visual C++ evite atribuir os mesmos valores numéricos de identificação para recursos distintos (símbolos).Para qualquer dado.Arquivo RC, Visual C++ incrementalmente atribui identificações em cada um dos quatro domínios de identificação.Entre as sessões de edição Visual C++ mantém controle sobre o último ID ele atribuídos em cada um dos domínios no arquivo de cabeçalho de símbolo para o.Arquivo RC.Aqui está o que os valores APS_NEXT são um vazio (novo).Arquivo 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, o recurso de menu e assim por diante.O intervalo válido para valores de símbolo de recurso é 1 a 0x6FFF.
_APS_NEXT_COMMAND_VALUE é o próximo valor de símbolo que será usado para a identificação de comando.O intervalo válido para valores de símbolo de comando é 0x8000 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 para valores de símbolo de controle de caixa de diálogo é 8 para 0xDFFF.
_APS_NEXT_SYMED_VALUE é o próximo valor de símbolo será emitido quando você atribuir manualmente um valor de símbolo usando o comando novo no navegador do símbolo.
Início do Visual C++ com valores ligeiramente maiores 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 técnico anotação 20.
Agora, sempre que criar um novo arquivo de recursos, até mesmo no mesmo projeto, Visual C++ define o mesmo _APS_NEXT_ valores.Isso significa que, se você adicionar, digamos, vários diálogos em dois diferentes.Arquivos RC, é bastante provável que o mesmo # definir valor será atribuído a diferentes caixas de diálogo.Por exemplo, IDD_MY_DLG1 no primeiro.Arquivo RC pode ser atribuído o mesmo número, 101, como 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 no respectivo.Arquivos RC.Para fazer isso, atualizar manualmente o _APS_NEXT valores em cada um a.Arquivos RC before você começar a adicionar recursos.Por exemplo, se o primeiro.Arquivo RC usa o padrão _APS_NEXT valores, então talvez você queira atribuir o 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 o Visual C++ irá atribuir muitas identificações no primeiro.Arquivo RC que iniciam os valores numéricos para sobrepor os reservada para o segundo.Arquivo RC.Você deve reservar intervalos suficientemente grandes para que isso não acontece.
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 recurso correspondente.Arquivo de H.Qualquer um dos seus.Arquivos CPP que se referem a recursos do.Arquivo RC deve # incluir o recurso.Arquivo H, geralmente a partir do arquivo de cabeçalho principal do projeto.Isso leva a um efeito colateral indesejável por causa do gerenciamento de projeto interno do ambiente de desenvolvimento que examina os arquivos de origem para dependências de cabeçalho.Sempre que você adicionar um novo símbolo no Visual C++, todos os.Arquivo CPP que # incluir recurso.H precisa ser recompilado.
Visual C++, contorna a dependência de recursos.H, incluindo o seguinte comentário como a primeira linha do recurso.Arquivo H:
//{{NO_DEPENDENCIES}}
O ambiente de desenvolvimento interpreta esse comentário ignorando as alterações para o recurso.H assim que dependentes.Arquivos CPP não precise ser recompilado.
Visual C++ sempre adiciona o //{{NO_DEPENDENCIES}} comentário linha para um.Arquivo RC quando salva o arquivo.Em alguns casos, contornando da dependência compilação em recurso.H pode levar a erros de tempo de execução sem serem detectados em tempo de link.Por exemplo, se você usar o navegador do símbolo para alterar o valor numérico atribuído a um símbolo de um recurso, o recurso será não corretamente localizado e carregado ao se do tempo de execução de aplicativos do.Arquivo CPP se referindo ao recurso não é recompilado.Em tais casos, você deve explicitamente recompilar qualquer.Arquivos CPP que você sabe que são afetados pelas alterações símbolo no recurso.H ou selecione Reconstruir todos os.Se você precisar alterar os valores de símbolo para um determinado grupo de recursos com freqüência, você provavelmente achará mais conveniente e segura quebrar esses símbolos em um arquivo de cabeçalho separado de somente leitura, conforme descrito na seção acima Incluindo arquivos de cabeçalho adicionais.
Como o Visual C++ gerencia conjunto inclui informações
Conforme discutido acima, o menu Arquivo conjunto inclui comando permite que você especificar 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 seguir 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 ele pode aprimorar a compreensão para que mais segura, você pode usar o recurso Definir inclui.
Cada um dos três tipos de informações inclui o conjunto acima é armazenada na.Arquivo RC de duas formas: (1) como # incluir ou outras diretivas interpretable pelo compilador de recurso e (2) como recursos especiais TEXTINCLUDE interpretable somente pelo Visual C++.
A finalidade do recurso TEXTINCLUDE é armazenar com segurança definir incluem informações em um formulário é prontamente apresentável no Visual C++ Definir inclui caixa de diálogo.TEXTINCLUDE é um tipo de recurso definidos pelo Visual C++.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:
Identificação 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 tempo de compilação |
Cada um dos três tipos de informações inclui o conjunto é ilustrada por padrão MYAPP.RC e recurso.H arquivos criados por AppWizard, conforme descrito abaixo.\0 Extra e "" tokens entre blocos BEGIN e END são necessárias pela sintaxe RC para especificar zero seqüências de caracteres terminadas e o caractere de aspas duplas, respectivamente.
Arquivo de cabeçalho de símbolo
Informações do arquivo de cabeçalho de símbolo interpretado pelo compilador de recurso é 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
Diretivas de símbolo somente leitura são incluídas na parte superior da MYAPP.RC no seguinte formato 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 tempo de compilação
As diretivas de tempo de compilação são incluídas no final 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
Diretiva APSTUDIO_INVOKED # ifndef instrui o Visual C++ para 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