TN035 : Utilisation de plusieurs fichiers de ressources et les fichiers d'en-tête avec Visual C++
[!REMARQUE]
La note technique suivante n'a pas été modifiée depuis si c'était première inclus dans la documentation en ligne.Par conséquent, certaines procédures et rubriques peuvent être obsolètes ou incorrects.Pour obtenir les informations les plus récentes, il est recommandé que vous trouviez la rubrique d'intérêt dans l'index de la documentation en ligne.
Cette remarque décrit comment fichiers de ressources et fichiers d'en-tête provenant de l'éditeur de ressources Visual C++ plusieurs partagés dans un projet unique ou partagés entre plusieurs projets et comment vous pouvez tirer parti de cette prise en charge.Cette remarque répond à ces questions :
Lorsque pourriez-vous souhaiter couper un projet en plusieurs fichiers de ressources et/ou fichiers d'en-tête, et comment allez-vous il ?
Comment vous partagez un en-tête communs. Fichier de H entre deux fichiers .RC ?
Comment divisez-vous les ressources du projet en plusieurs fichiers .RC ?
Comment vous faites (et les outils) gérez des dépendances de génération entre .RC, .CPP, et. fichiers de H ?
Vous devez savoir que si vous ajoutez un fichier de ressources supplémentaires à votre projet, l'assistant classe ne reconnaît pas les ressources dans le fichier ajouté.
Cette remarque est structurée pour répondre aux questions ci-dessus comme suit :
Overview of How Visual C++ Manages Resource Files and Header Files explique comment l'ensemble de ressources inclut la commande dans Visual C++ vous permet d'utiliser plusieurs fichiers de ressources et les fichiers d'en-tête dans le même projet.
Analysis of AppWizard-created .RC and .H Files recherche plusieurs ressources et les fichiers d'en-tête utilisés par une application AppWizard-créée.Ces fichiers servent de bon modèle aux fichiers de ressources supplémentaires et les fichiers d'en-tête que vous êtes susceptible d'ajouter à votre projet.
Including Additional Header Files décrit dans lesquelles vous pouvez inclure plusieurs fichiers d'en-tête, et fournit des détails comment faire.
Sharing a Header File Between Two .RC Files montre comment vous pouvez partager un fichier d'en-tête entre plusieurs fichiers .RC dans des projets différents, voire dans le même projet.
Using Multiple Resource Files in the Same Project décrit dans lesquelles vous pouvez diviser votre projet en plusieurs fichiers .RC, et fournit des détails comment faire.
Enforcement of Non-Editable Visual C++ Files décrit comment vous pouvez faire en sorte que Visual C++ ne modifie pas et ne se reformate pas involontairement une ressource personnalisée.
Managing Symbols Shared by Multiple Visual C++-Edited .RC Files décrit comment partager les mêmes symboles dans plusieurs fichiers .RC et comment éviter d'assigner un ID en double des valeurs numériques.
Managing Dependencies Between .RC, .CPP, and .H Files décrit comment Visual C++ évite les fichiers recompilants inutiles de .CPP qui dépendent des fichiers de symboles des ressources.
How Visual C++ Manages Set Includes Information fournit des détails techniques à propos de la façon dont Visual C++ contient plusieurs fichiers (imbriqués) .RC et plusieurs fichiers d'en-tête qui sont #include'd par un fichier .RC.
Vue d'ensemble de la façon dont Visual C++ gère les fichiers de ressources et les fichiers d'en-tête
Visual C++ gère un fichier de ressources unique .RC et correspondant. Fichier d'en-tête de H tant que paire fortement couplée de fichiers.Lorsque vous modifiez et enregistrez des ressources dans un fichier .RC, vous indirectement modifiez et enregistrez les symboles dans correspondre. fichier de H.Bien que vous puissiez ouvrir et modifier plusieurs fichiers .RC à la fois (via l'interface utilisateur MDI Visual C++) pour tout fichier donné .RC vous modifiez indirectement exactement un fichier d'en-tête correspondant.
Fichier d'en-tête de symbole
Par défaut, Visual C++ nomme toujours le fichier d'en-tête correspondant RESOURCE.H, quel que soit le nom du fichier de ressources (par exemple, MYAPP.RC).À l'aide de la commande de Include des ressources dans le menu Afficher dans Visual C++, vous pouvez modifier le nom de ce fichier d'en-tête en mettant à jour le fichier de fichier d'en-tête de symbole dans la boîte de dialogue de Set Includes .
Directives en lecture seule de symbole
Bien que Visual C++ modifie uniquement un fichier d'en-tête pour tout fichier donné .RC, Visual C++ prend en charge les références aux symboles définis dans des fichiers d'en-tête en lecture seule supplémentaires.À l'aide de la commande de Include des ressources dans le menu Afficher dans Visual C++, vous pouvez spécifier plusieurs fichiers d'en-tête en lecture seule supplémentaires comme directives en lecture seule de symbole.La restriction « readonly » signifie que lorsque vous ajoutez une nouvelle ressource dans le fichier .RC, vous pouvez utiliser un symbole défini dans le fichier d'en-tête en lecture seule ; mais si vous supprimez la ressource, le symbole reste toujours défini dans le fichier d'en-tête en lecture seule.Vous ne pouvez pas modifier la valeur numérique assignée à un symbole en lecture seule.
Directives de compilation
Visual C++ prend en charge également l'imbrication des fichiers de ressources, où un fichier .RC est #include'd dans une autre.Lorsque vous modifiez un fichier donné .RC à l'aide de Visual C++, aucune ressource dans les fichiers de #include'd n'est visible.Mais lorsque vous compilez le fichier .RC, les fichiers de #include'd est également compilé.À l'aide de la commande de Include des ressources dans le menu Afficher dans Visual C++, vous pouvez spécifier plusieurs fichiers du #include'd .RC comme directives de compilation.
Notez ce qui se produit si vous lisez dans Visual C++ ce un autre fichier du .RC des #include .RC un fichier qui n'est pas spécifié comme directive de compilation.Cette situation peut se produire lorsque vous apportez à Visual C++ un fichier .RC que vous avez préalablement maintenu manuellement avec un éditeur de texte.Lorsque Visual C++ lit le fichier du #include'd .RC, il fusionne les ressources de #include'd dans le fichier du parent .RC.Lorsque vous enregistrez le fichier du parent .RC, l'instruction #include, en effet, sera remplacé par les ressources de #include'd.Si vous ne souhaitez pas cette fusion à générer, vous devez supprimer l'instruction #include du fichier du parent .RC avant de lire dans Visual C++ ; ensuite à l'aide de Visual C++, ajoutez en arrière la même instruction #include qu'une directive de compilation.
Visual C++ archive dans un fichier .RC que les trois genres d'en haut définis inclut des informations (fichier d'en-tête de symbole, directives en lecture seule de symbole, et directives de compilation) dans les directives de #include et dans les ressources TEXTINCLUDE.Les ressources TEXTINCLUDE, un détail d'implémentation lequel vous n'avez pas normalement besoin de traitement, sont expliquées dans Comment Visual C++ gère l'ensemble contient des informations.
Analyse .RC AppWizard-Créé et. fichiers de H
La révision du code d'application produit par AppWizard fournit l'analyse dans la manière dont Visual C++ gère plusieurs fichiers de ressources et fichiers d'en-tête.Les extraits de code ci-dessous sont examinés d'une application de MYAPP produite par AppWizard à l'aide de les options par défaut.
Fichiers de ressources AppWizard-créés de qu'une application utilise plusieurs et plusieurs fichiers d'en-tête, comme résumés dans le diagramme ci-dessous :
RESOURCE.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
AFXRES.RC
AFXPRINT.RC
Vous pouvez afficher ces relations de fichier en utilisant le fichier/set de Visual C++ inclut la commande.
- MYAPP.RC
Le fichier de ressources de l'application que vous modifiez l'aide de Visual C++.
RESOURCE.H est le fichier d'en-tête spécifique à l'application.Il est toujours nommé RESOURCE.H par AppWizard, compatible avec nommer par défaut de Visual C++ du fichier d'en-tête.Le #include pour ce fichier d'en-tête est la première instruction dans le fichier de ressources (MYAPP.RC) :
//Microsoft Visual C++ generated resource script
//
#include "resource.h"
- Recherche \MYAPP.RC 2
Contient les ressources qui ne sont pas modifiées par Visual C++ mais sera inclus dans le fichier .exe compilé final.AppWizard ne crée pas de cette ressource par défaut, étant donné que Visual C++ peut modifier toutes les ressources standard, notamment la ressource de version (une nouvelle fonctionnalité dans cette version finale).Un fichier vide est généré par AppWizard au cas où vous souhaitez ajouter vos propres ressources mises en forme personnalisées à ce fichier.
Si vous utilisez des ressources mises en forme personnalisés, vous pouvez les ajouter à l'éditeur de texte de recherche \MYAPP.RC2 and edit them using the Visual C C/C++.
AFXRES.RC et AFXPRINT.RC contiennent les ressources standard requises pour certaines fonctionnalités de l'infrastructure.Comme la boîte de dialogue de \MYAPP.RC2, these two framework-provided resource files are #include'd at the end of MYAPP.RC, and they are specified in the Compile-Time Directives of the Set Includes de recherche.Ainsi, vous directement n'affichez pas ou ne modifiez pas ces ressources d'infrastructure pendant que vous modifiez MYAPP.RC dans Visual C++, mais ils sont compilés dans le fichier binaire du .RES de l'application et le fichier .exe de finale.Pour plus d'informations sur les ressources standard en infrastructure, notamment les procédures pour les modifier, consultez note technique 23.
AFXRES.H définit les symboles standard, par exemple ID_FILE_NEW, utilisé par l'infrastructure et spécifiquement utilisé dans AFXRES.RC.D'AFXRES.H LE WINRES.H des #include également, qui contient un sous-ensemble de WINDOWS.H qui sont requis par Visual C++ a généré des fichiers .RC ainsi qu'AFXRES.RC.Les symboles définis dans AFXRES.H sont disponibles lorsque vous modifiez le fichier de ressources de l'application (MYAPP.RC).Par exemple, ID_FILE_NEW est utilisé pour le nouvel élément de menu de fichier de la ressource menu en MYAPP.RC.Vous ne pouvez pas modifier ou supprimer ces symboles définis.
Notamment les fichiers d'en-tête supplémentaires
L'application AppWizard-créée inclut uniquement deux fichiers d'en-tête : RESOURCE.H et AFXRES.H.Uniquement RESOURCE.H est spécifique à l'application.Vous devrez peut-être inclure les fichiers d'en-tête en lecture seule supplémentaires dans les cas suivants :
Le fichier d'en-tête est fourni par une source externe, ou vous souhaitez partager le fichier d'en-tête entre plusieurs projets ou plusieurs parties du même projet.
Le fichier d'en-tête a la mise en forme et les commentaires que vous ne souhaitez pas Visual C++ pour changer ou filtrer lorsqu'il enregistre le fichier.Par exemple, vous souhaitez conserver les #define telles que les qui utilisent l'arithmétique de jeton :
#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)
Vous pouvez inclure les fichiers d'en-tête en lecture seule supplémentaires à l'aide de la commande de Include des ressources de spécifier des instructions #include comme deuxième directive en lecture seule de symbole, comme suit :
#include "afxres.h"
#include "second.h"
Le diagramme des relations de nouveau fichier se présente maintenant comme suit :
AFXRES.H
RESOURCE.H SECOND.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
AFXRES.RC
AFXPRINT.RC
Partager un fichier d'en-tête entre deux fichiers .RC
Vous pouvez partager un fichier d'en-tête entre deux fichiers .RC qui sont dans des projets différents, voire le même projet.Pour ce faire, appliquez simplement la technique en lecture seule de directives décrite ci-dessus aux deux fichiers .RC.Dans le cas où les deux fichiers .RC sont pour différentes applications (différents projets), le résultat est illustré dans le diagramme suivant :
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
Le cas où le deuxième fichier d'en-tête est partagé par deux fichiers .RC dans la même application (projet) est décrite ci-dessous.
Utilisation de plusieurs fichiers de ressources dans le même projet
Visual C++ et le compilateur de ressources prennent en charge plusieurs fichiers .RC dans le même projet via les #include d'un fichier .RC dans une autre.Autorisée à plusieurs imbrication.Il existe différentes raisons de fractionner les ressources de votre projet en plusieurs fichiers .RC :
Il est plus facile à gérer de nombreuses ressources parmi plusieurs membres de l'équipe du projet si vous fractionné les ressources en plusieurs fichiers .RC.Si vous utilisez un package de gestion de contrôle de code source pour activer des fichiers et archivage des modifications, fractionnant les ressources en plusieurs fichiers .RC vous offre un contrôle plus fin de gérer les modifications apportées aux ressources.
Si vous souhaitez utiliser des directives de préprocesseur, telles que le #ifdef, #endif, et #define, pour les parties de vos ressources, vous devez les isoler dans les ressources en lecture seule qui seront compilation par le compilateur de ressources.
Les fichiers composants .RC seront chargés et sauvegarderont plus rapidement en Visual C++ qu'un fichier composé .RC.
Si vous souhaitez maintenir une ressource avec un éditeur de texte sous forme explicite, vous devez le conserver dans un fichier .RC séparées des modifications d'une Visual C++.
Si vous devez conserver une ressource définie par l'utilisateur dans un fichier binaire ou le formulaire de texte qui représente interprétable par un autre éditeur spécialisée de données, vous devez alors le conserver dans un fichier séparé .RC donc Visual C++ ne modifie pas le format aux données hexadécimales.Les ressources (correctes) en fichier de .WAV dans l'exemple SPEAKN de concepts avancés par MFC sont un bon exemple.
Vous pouvez #include qu'un SECOND.RC dans les directives de compilation dans l'ensemble inclut la boîte de dialogue :
#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
Le résultat est illustré dans le diagramme suivant :
RESOURCE.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
SECOND.RC
AFXRES.RC
AFXPRINT.RC
Utilisation de directives de compilation, vous pouvez organiser votre Visual C++-editable et ressources non-modifiables en plusieurs fichiers .RC, où « MASTER » MYAPP.RC ne fait rien d'autre que le #include les autres fichiers .RC.Si vous utilisez un fichier projet Visual C++ .MAK, vous devez inclure le « MASTER » fichier .RC dans le projet afin que toutes les ressources #include'd soient compilées avec votre application.
Contrainte de mise en conformité des fichiers de Noneditable Visual C++
Le fichier AppWizard-créé de recherche \MYAPP.RC 2 est un exemple de fichier qui contient les ressources que vous ne souhaitez pas lire par erreur dans Visual C++ et l'écrire ensuite revenez à la perte d'information de mise en forme.Pour éviter que cela, placez les lignes suivantes au début du fichier de recherche \MYAPP.RC 2 :
#ifdef APSTUDIO_INVOKED
#error this file is not editable by Visual C++
#endif //APSTUDIO_INVOKED
Lorsque Visual C++ compile le fichier .RC, il définit APSTUDIO_INVOKED ainsi que RC_INVOKED.Si la structure de fichiers AppWizard-créée est endommagé et Visual C++ lit la ligne de #error ci-dessus, il signale une erreur irrécupérable et interrompt la lecture du fichier .RC.
Gestion des symboles partagés par plusieurs fichiers de Visual C++-Edited .RC
Deux problèmes surviennent lorsque vous fractionnez vos ressources dans plusieurs fichiers .RC que vous souhaitez modifier séparément dans Visual C++ :
Vous pouvez partager les mêmes symboles dans plusieurs fichiers .RC.
Vous devez aider Visual C++ pour éviter d'assigner au même ID des valeurs numériques aux ressources distinctes (symboles).
Le diagramme suivant illustre une organisation .RC et. Fichiers de H qui traite le premier problème :
MYAPP.RC
/ \
/ \
MYSTRS.H / MYSHARED.H \ MYMENUS.H
\ / / \ \ \
\ / / \ \ \
MYSTRS.RC MYMENUS.RC
Dans cet exemple, des ressources de type chaîne sont conservées dans un fichier de ressources, MYSTRS.RC, et des menus sont conservés dans les autres, MYMENUS.RC.Certains symboles, par exemple pour les commandes, peuvent devoir être partagés entre les deux fichiers.Par exemple, un ID_TOOLS_SPELL peut être l'ID de commande de menu pour l'élément de vérifier l'orthographe dans un menu Outils ; et il peut également être l'ID de chaîne de l'invite de commandes affichée par l'infrastructure dans la barre d'état de la fenêtre principale de l'application.
Le symbole d'ID_TOOLS_SPELL est conservé dans le fichier d'en-tête partagé, MYSHARED.H.Vous conservez ce fichier d'en-tête partagé manuellement avec un éditeur de texte ; Visual C++ ne le modifie pas directement.Dans les deux fichiers de ressources MYSTRS.RC et MYMENUS.RC, vous spécifiez le #include MYSHARED.H dans les directives en lecture seule pour MYAPP.RC, à l'aide de la commande de Include des ressources , comme décrit précédemment.
Il est plus pratique de prendre un symbole que vous partagerez avant de tenter l'utilisation il d'identifier toutes les ressources.Ajoutez le symbole dans le fichier d'en-tête partagé et, si vous n'avez pas encore le #include'd le fichier d'en-tête partagé dans les directives en lecture seule pour le fichier .RC, faites -le avant d'utiliser le symbole.Si vous n'anticipiez pas partager le symbole de cette façon, vous devrez manuellement (à l'aide d'un éditeur de texte) déplacer l'instruction #define pour le symbole par exemple de MYMENUS.H à MYSHARED.H avant de l'utiliser dans MYSTRS.RC.
Lorsque vous gérez des symboles dans plusieurs fichiers .RC, vous devez aussi aider Visual C++ pour éviter d'assigner au même ID des valeurs numériques aux ressources distinctes (symboles).Pour tout fichier donné .RC, Visual C++ assigne de façon incrémentielle des identificateurs dans chacun des quatre domaines d'ID.Entre des sessions d'édition, Visual C++ contient le dernier ID qu'il a assigné dans ces domaines dans le fichier d'en-tête de symbole pour le fichier .RC.Voici ce qui sont des valeurs d'APS_NEXT pour (nouveau) fichier vide .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 est la valeur suivante de symboles qui sera utilisée pour une ressource de boîte de dialogue, ressource menu, et ainsi de suite.La plage valide des valeurs de symboles de ressource est 1 à 0x6FFF.
_APS_NEXT_COMMAND_VALUE est la valeur suivante de symboles qui sera utilisée pour un ID de commande.La plage valide des valeurs de symboles de commande est 0x8000 à 0xDFFF.
_APS_NEXT_CONTROL_VALUE est la valeur suivante de symboles qui sera utilisée pour un contrôle de boîte de dialogue.La plage valide des valeurs de symboles de contrôle de boîte de dialogue est 8 à 0xDFFF.
_APS_NEXT_SYMED_VALUE est la valeur suivante de symboles qui sera publiée lorsque vous assignez manuellement une valeur de symbole en utilisant la nouvelle commande dans le navigateur de symbole.
Démarrage de Visual C++ avec légèrement des valeurs supérieures ces la valeur autorisé la plus basse en créant un fichier .RC.AppWizard initialisera également ces valeurs par un nom plus approprié pour les applications MFC.Pour plus d'informations sur les chaînes de valeur d'ID, consultez note technique 20.
Maintenant chaque fois que vous créez un fichier de ressources, même dans le même projet, Visual C++ définit les mêmes valeurs de _APS_NEXT_ .Cela signifie que si vous ajoutez des boîtes de dialogue par exemple plusieurs dans deux fichiers différents .RC, il est fort probable que la même valeur #define soit assignée à des boîtes de dialogue.Par exemple, IDD_MY_DLG1 dans le premier fichier .RC peut être assigné le même nombre, 101, comme IDD_MY_DLG2 dans un deuxième fichier .RC.
Pour éviter ceci, vous devez réserver une plage numérique distincte pour les quatre domaines des identificateurs dans les fichiers respectifs .RC.Procédez ainsi lors de la mise à jour manuellement les valeurs de _APS_NEXT dans chaque fichier before .RC que vous démarrez l'ajout de ressources.Par exemple, si le premier fichier .RC utilise les valeurs par défaut de _APS_NEXT , puis vous pouvez assigner les valeurs suivantes de _APS_NEXT au deuxième fichier .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
Naturellement, il est néanmoins possible que Visual C++ assigne forme d'identificateurs dans le premier fichier .RC que les valeurs numériques commencent à superposer ceux réservés pour le deuxième fichier .RC.Vous devez réserver des plages suffisamment étendues afin que cela ne se produisent pas.
Gérer les dépendances entre .RC, .CPP, et. fichiers de H
Lorsque Visual C++ enregistre un fichier .RC, il enregistre également des modifications de symboles au fichier correspondant de RESOURCE.H.L'un de vos fichiers de .CPP qui font référence à des ressources dans un fichier .RC doit #include le fichier de RESOURCE.H, généralement du fichier d'en-tête de votre projet.Cela signifie qu'un effet secondaire indésirable en raison de la gestion de projet interne de l'environnement de développement qui analyse les fichiers sources des dépendances d'en-tête.Chaque fois que vous ajoutez un nouveau symbole dans Visual C++, tout le fichier .cpp que le #include RESOURCE.H doit être recompilé.
Visual C++, évite la dépendance sur RESOURCE.H en incluant le commentaire suivant comme la première ligne du fichier de RESOURCE.H :
//{{NO_DEPENDENCIES}}
L'environnement de développement interprète cette opération en ignorant les modifications apportées à RESOURCE.H afin que les fichiers dépendants de .CPP ne doivent pas être recompilés.
Visual C++ ajoute toujours la ligne de commentaire de //{{NO_DEPENDENCIES}} dans un fichier .RC lorsqu'il enregistre le fichier.Dans certains cas, la mise en échec de la dépendance de génération sur RESOURCE.H peut provoquer des erreurs d'exécution non détectées au moment de la liaison.Par exemple, si vous utilisez le navigateur de symbole pour modifier la valeur numérique assignée à un symbole pour une ressource, la ressource ne sera pas correctement trouvée et ne sera pas chargée au moment de l'exécution de l'application si le fichier .cpp faisant référence à la ressource n'est pas recompilé.Dans ce cas, vous devez explicitement recompiler tous les fichiers de .CPP que vous savez affecté par les modifications de symbole de RESOURCE.H ou sélectionner Régénérer tout.Si vous avez le besoin de modifier fréquemment des valeurs de symbole d'un groupe de ressources, vous trouverez peut-être plus facile et plus sûr de quitter ces symboles dans un fichier d'en-tête en lecture seule séparé, comme décrit dans la section ci-dessus Notamment les fichiers d'en-tête supplémentaires.
Comment Visual C++ gère l'ensemble contient des informations
Comme décrit ci-dessus, l'ensemble de menu Fichier comprend la commande vous permet de spécifier trois types d'informations :
Fichier d'en-tête de symbole
Directives en lecture seule de symbole
Directives de compilation
Les éléments suivants décrivent comment Visual C++ contient ces informations dans un fichier .RC.Vous n'avez pas besoin de ces informations utiliser Visual C++, mais il peut mieux comprendre le fonctionnement afin que vous puissiez avec plus de confiance utiliser l'ensemble inclue la fonctionnalité.
Les trois types ci-dessus d'ensemble présente les informations est stocké dans le fichier .RC sous deux formes : (1) comme #include ou d'autres directives interprétables par le compilateur de ressources, et (2) en tant que ressources particulières en TEXTINCLUDE interprétables uniquement par Visual C++.
L'objectif de la ressource TEXTINCLUDE est à sans risque signalent l'ensemble incluent des informations dans un format qui est facilement présentable dans la boîte de dialogue de Set Includes Visual C++.TEXTINCLUDE est un type de ressource défini par Visual C++.Visual C++ reconnaît trois ressources spécifiques en TEXTINCLUDE dont les numéros d'ID de ressource 1, 2 et 3 :
ID de ressource de TEXTINCLUDE |
Le type de jeu inclut les informations |
|---|---|
1 |
Fichier d'en-tête de symbole |
2 |
Directives en lecture seule de symbole |
3 |
Directives de compilation |
Les trois types d'ensemble présente les informations est indiqué par la valeur par défaut MYAPP.RC et les fichiers de RESOURCE.H créés par AppWizard, comme décrit ci-dessous.La syntaxe supplémentaire de \0 and "" tokens between BEGIN and END blocks are required by the RC pour spécifier zéro a terminé les chaînes et le guillemet respectivement.
Fichier d'en-tête de symbole
Le formulaire des informations du fichier d'en-tête de symbole interprétées par le compilateur de ressources est simplement une instruction #include :
#include "resource.h"
La ressource correspondante en TEXTINCLUDE est :
1 TEXTINCLUDE DISCARDABLE
BEGIN
#resource.h\0"
END
Directives en lecture seule de symbole
Les directives en lecture seule de symboles sont incluses en haut de MYAPP.RC dans le formulaire suivant interprétable par le compilateur de ressources :
#include "afxres.h"
La ressource correspondante en TEXTINCLUDE est :
2 TEXTINCLUDE DISCARDABLE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
Directives de compilation
Les directives de compilation sont incluses à la fin de MYAPP.RC dans le formulaire suivant interprétable par le compilateur de ressources :
#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
La directive du #ifndef APSTUDIO_INVOKED demande à Visual C++ d'ignorer les directives de compilation.
La ressource correspondante en TEXTINCLUDE est :
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