TN035: Uso di più file di risorse e file di intestazione con Visual C++
Nota
La seguente nota tecnica non è stata aggiornata da quando è stata inclusa per la prima volta nella documentazione online. Di conseguenza, alcune procedure e argomenti potrebbero essere non aggiornati o errati. Per le informazioni più recenti, è consigliabile cercare l'argomento di interesse nell'indice della documentazione online.
In questa nota viene descritto in che modo l'editor risorse di Visual C++ supporta più file di risorse e file di intestazione condivisi in un singolo progetto o tra più progetti e come è possibile usufruire di tale supporto. Questa nota risponde alle domande seguenti:
Quando si vuole suddividere un progetto in più file di risorse e/o file di intestazione e come eseguire questa operazione
Come si condivide un file di intestazione
.Hcomune tra due.RCfileCome dividere le risorse del progetto in più
.RCfileCome gestire le dipendenze di compilazione tra
.RCi file ,.CPPe.H
Tenere presente che se si aggiunge un file di risorse aggiuntivo al progetto, ClassWizard non riconoscerà le risorse nel file aggiunto.
Questa nota è strutturata in modo da rispondere alle domande elencate in precedenza come segue:
Panoramica del modo in cui Visual C++ gestisce i file di risorse e i file di intestazione offre una panoramica del modo in cui il comando Include set di risorse in Visual C++ consente di usare più file di risorse e file di intestazione nello stesso progetto.
L'analisi di AppWizard creata
.RCe.HFile esamina i più file di risorsa e intestazione usati da un'applicazione creata da AppWizard. Questi file vengono utilizzati come modello per ulteriori file di risorse e di intestazione che potrebbero essere aggiunti al progetto.L'inclusione di file di intestazione aggiuntivi descrive dove includere più file di intestazione e fornisce informazioni dettagliate su come eseguire questa operazione.
La condivisione di un file di intestazione tra due
.RCfile mostra come condividere un file di intestazione tra più.RCfile in progetti diversi o forse nello stesso progetto.L'uso di più file di risorse nello stesso progetto descrive dove si potrebbe voler suddividere il progetto in più
.RCfile e fornisce informazioni dettagliate su come eseguire questa operazione.L'applicazione di file Visual C++ non modificabili descrive come è possibile assicurarsi che Visual C++ non modifichi e non modifichi involontariamente una risorsa personalizzata.
La gestione dei simboli condivisi da più file modificati
.RCda Visual C++descrive come condividere gli stessi simboli tra più.RCfile e come evitare di assegnare valori numerici ID duplicati.La gestione delle dipendenze tra
.RCi file ,.CPPe.Hdescrive in che modo Visual C++ evita la ricompilazione non necessaria dei.CPPfile dipendenti dai file di simboli delle risorse.Il modo in cui Visual C++ gestisce set include informazioni fornisce informazioni tecniche su come Visual C++ tiene traccia di più file (annidati)
.RCe di più file di intestazione inclusi in un.RCfile.
Panoramica del modo in cui Visual C++ gestisce i file di risorse e i file di intestazione
Visual C++ gestisce un singolo .RC file di risorse e un file di intestazione corrispondente .H come coppia di file strettamente accoppiati. Quando si modificano e si salvano le risorse in un .RC file, si modificano e si salvano indirettamente i simboli nel file corrispondente .H . Sebbene sia possibile aprire e modificare più .RC file alla volta (usando l'interfaccia utente MDI di Visual C++), per qualsiasi file specificato .RC si modifica indirettamente esattamente un file di intestazione corrispondente.
Finestra di dialogo Include risorse della visualizzazione risorse
Per accedere alle risorse include, aprire la visualizzazione risorse, quindi fare clic con il pulsante destro del mouse sul .RC file e selezionare Include risorse.
File di intestazione simboli
Per impostazione predefinita, Visual C++ assegna sempre un nome al file RESOURCE.Hdi intestazione corrispondente, indipendentemente dal nome del file di risorse , ad esempio MYAPP.RC. La sezione File intestazione simboli: nella finestra di dialogo Include risorse in Visual C++, consente di modificare il nome di questo file di intestazione. Immettere un nuovo nome di file nella casella di modifica della sezione.
Nota
i file di risorse che non si trovano nella stessa directory del .RC file devono anteporre un percorso relativo con escaped-'\' per essere letti correttamente.
Direttive per simboli in sola lettura
Sebbene Visual C++ modifichi solo un file di intestazione per un determinato .RC file, Visual C++ supporta riferimenti ai simboli definiti in file di intestazione di sola lettura aggiuntivi. La sezione Direttive simbolo di sola lettura: nella finestra di dialogo Include risorse consente di specificare un numero qualsiasi di file di intestazione di sola lettura aggiuntivi come direttive di simboli di sola lettura. La restrizione "sola lettura" indica che quando si aggiunge una nuova risorsa nel .RC file, è possibile usare un simbolo definito nel file di intestazione di sola lettura. Tuttavia, se si elimina la risorsa, il simbolo rimane ancora definito nel file di intestazione di sola lettura. Non è possibile modificare il valore numerico assegnato a un simbolo di sola lettura.
Direttive in fase di compilazione
Visual C++ supporta anche l'annidamento dei file di risorse, in cui un .RC file è incluso in un altro usando una #include direttiva . Quando si modifica un determinato .RC file usando Visual C++, tutte le risorse nei file inclusi non sono visibili. Tuttavia, quando si compila il .RC file, vengono compilati anche i file inclusi. La sezione Direttive in fase di compilazione: nella finestra di dialogo Include risorse consente di specificare un numero qualsiasi di file da includere come direttive in fase di .RC compilazione.
Si noti cosa accade se si legge in Visual C++ un .RC file che include un altro .RC file non* specificato come direttiva in fase di compilazione. Questa situazione può verificarsi quando si porta in Visual C++ un .RC file che in precedenza era stato gestito manualmente con un editor di testo. Quando Visual C++ legge il file incluso .RC , unisce le risorse incluse nel file padre .RC . Quando si salva il file padre .RC , l'istruzione #include , in effetti, verrà sostituita dalle risorse incluse. Se non si vuole che questa unione venga eseguita, è necessario rimuovere l'istruzione #include dal file padre .RC prima di leggerla in Visual C++, quindi usando Visual C++, aggiungere nuovamente la stessa #include istruzione di una direttiva Compile-Time.
Visual C++ salva in un .RC file i tre tipi di set include informazioni (file di intestazione di simboli, direttive di simboli di sola lettura e direttive di compilazione) nelle #include direttive e nelle TEXTINCLUDE risorse. Le TEXTINCLUDE risorse, un dettaglio di implementazione che normalmente non è necessario gestire, sono illustrate in Come Visual C++ gestisce il set include informazioni.
Analisi dei file e .H creati da .RC AppWizard
L'analisi del codice dell'applicazione generato dalla Creazione guidata applicazioni consente di comprendere in che modo Visual C++ gestisce i file di risorse e i file di intestazione. Gli estratti di codice esaminati di seguito provengono da un'applicazione MYAPP prodotta da AppWizard usando le opzioni predefinite.
Un'applicazione creata tramite la Creazione guidata applicazioni utilizza più file di risorse e più file di intestazione, come riepilogato nel diagramma riportato di seguito:
RESOURCE.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
AFXRES.RC
AFXPRINT.RC
È possibile visualizzare le relazioni tra più file utilizzando il comando File/Inclusioni impostazione di Visual C++.
MYAPP.RC
File di risorse dell'applicazione modificato con Visual C++.
RESOURCE.H è il file di intestazione specifico dell'applicazione. È sempre denominato RESOURCE.H da AppWizard, coerente con la denominazione predefinita di Visual C++del file di intestazione. #include Per questo file di intestazione è la prima istruzione nel file di risorse (MYAPP.RC):
//Microsoft Visual C++ generated resource script
//
#include "resource.h"
RES\MYAPP.RC2
Contiene risorse che non verranno modificate da Visual C++ ma che verranno incluse nel file compilato .EXE finale. La Creazione guidata applicazioni non crea tali risorse per impostazione predefinita, poiché Visual C++ può modificare tutte le risorse standard, inclusa la risorsa di versione (una nuova funzionalità di questa versione). Tramite la Creazione guidata applicazioni viene generato un file vuoto qualora si volessero aggiungere a questo file risorse in formato personalizzato.
Se si usano risorse formattate personalizzate, è possibile aggiungerle e RES\MYAPP.RC2 modificarle usando l'editor di testo di Visual C++.
AFXRES.RC e AFXPRINT.RC contengono risorse standard richieste da determinate funzionalità del framework. Come RES\MYAPP.RC2, questi due file di risorse forniti dal framework vengono inclusi alla fine di MYAPP.RCe vengono specificati nella finestra di dialogo Compilazione-Ora della finestra di dialogo Imposta include . Di conseguenza, non è possibile visualizzare o modificare direttamente queste risorse del framework durante la modifica MYAPP.RC in Visual C++, ma vengono compilate nel file binario .RES e nel file finale .EXE dell'applicazione. Per altre informazioni sulle risorse del framework standard, incluse le procedure per modificarle, vedere La nota tecnica 23.
AFXRES.H definisce i simboli standard, ad esempio ID_FILE_NEW, usati dal framework e usati in modo specifico in AFXRES.RC. AFXRES.H usa #include anche per includere WINRES.H, che contiene un subset di WINDOWS.H che è necessario per i file generati .RC da Visual C++ e AFXRES.RC. I simboli definiti in AFXRES.H sono disponibili durante la modifica del file di risorse dell'applicazione (MYAPP.RC). Ad esempio, ID_FILE_NEW viene usato per la FileNew voce di menu nella MYAPP.RC risorsa di menu del file. Non è possibile modificare o eliminare questi simboli definiti dal framework.
Inclusione di file di intestazione aggiuntivi
L'applicazione creata da AppWizard include solo due file di intestazione: RESOURCE.H e AFXRES.H. Solo RESOURCE.H è specifico dell'applicazione. Potrebbe essere necessario includere file di intestazione di sola lettura aggiuntivi nei seguenti casi:
Il file di intestazione viene fornito da un'origine esterna oppure se si desidera condividere il file di intestazione tra più progetti o più parti dello stesso progetto.
Il file di intestazione contiene formattazione e commenti che non si desidera che Visual C++ modifichi o filtra quando salva il file.The header file has formatting and comments that you don't want Visual C++ to change or filter out when it salva il file. Ad esempio, è possibile che si desideri conservare le istruzioni #define che utilizzano aritmetica simbolica come:
#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)
È possibile includere file di intestazione di sola lettura aggiuntivi usando il comando Inclusione risorse per specificare l'istruzione #include come seconda direttiva simbolo di sola lettura, come in:
#include "afxres.h"
#include "second.h"
Il nuovo diagramma delle relazioni tra file avrà il seguente aspetto:
AFXRES.H
RESOURCE.H SECOND.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
AFXRES.RC
AFXPRINT.RC
Condivisione di un file di intestazione tra due .RC file
È possibile condividere un file di intestazione tra due .RC file che si trovano in progetti diversi o eventualmente lo stesso progetto. A tale scopo, applicare la tecnica Direttive di sola lettura descritta in precedenza a entrambi i .RC file. Nel caso in cui i due .RC file si trovino per applicazioni diverse (progetti diversi), il risultato è illustrato nel diagramma seguente:
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
Il caso in cui il secondo file di intestazione viene condiviso da due .RC file nella stessa applicazione (progetto) viene illustrato di seguito.
Uso di più file di risorse nello stesso progetto
Visual C++ e il compilatore di risorse supportano più .RC file nello stesso progetto tramite #include direttive che includono un .RC file all'interno di un altro. È consentito l'annidamento multiplo. Esistono diversi motivi per suddividere le risorse del progetto in più .RC file:
È più facile gestire un numero elevato di risorse tra più membri del team di progetto se si suddivideno le risorse in più
.RCfile. Se si usa un pacchetto di gestione del controllo del codice sorgente per l'estrazione dei file e l'archiviazione delle modifiche, la suddivisione delle risorse in più.RCfile darà un controllo più corretto sulla gestione delle modifiche alle risorse.Se si desidera usare direttive del preprocessore, ad esempio
#ifdef,#endife#define, per parti delle risorse, è necessario isolarle in risorse di sola lettura che verranno compilate dal compilatore di risorse.I file di componente
.RCverranno caricati e salvati più velocemente in Visual C++ rispetto a un file composito.RC.Se si vuole mantenere una risorsa con un editor di testo in un formato leggibile, è consigliabile mantenerla
.RCseparata da quella modifica di Visual C++.Se è necessario mantenere una risorsa definita dall'utente in un formato binario o di testo interpretabile da un altro editor di dati specializzato, è necessario mantenerla in un file separato
.RCin modo che Visual C++ non modifichi il formato in dati esadecimali. Le.WAVrisorse file (audio) nell'esempio SPEAKN di MFC Advanced Concepts sono un buon esempio.
È possibile includere SECOND.RC nelle direttive in fase di compilazione nella finestra di dialogo Imposta inclusioni:
#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
Il risultato è illustrato nel diagramma seguente:
RESOURCE.H AFXRES.H
\ /
\ /
MYAPP.RC
|
|
RES\MYAPP.RC2
SECOND.RC
AFXRES.RC
AFXPRINT.RC
Usando le direttive in fase di compilazione, è possibile organizzare le risorse modificabili e modificabili di Visual C++ in più .RC file, in cui il principale MYAPP.RC non fa altro #include che gli altri .RC file. Se si usa un file di progetto .MAK C++ di Visual Studio, è necessario includere il file principale .RC nel progetto in modo che tutte le risorse incluse vengano compilate con l'applicazione.
Applicazione di file Visual C++ non modificabili
Il file creato RES\MYAPP.RC2 da AppWizard è un esempio di file che contiene risorse che non si desidera leggere accidentalmente in Visual C++ e quindi eseguire il writeback con perdita di informazioni di formattazione. Per proteggersi da questo problema, inserire le righe seguenti all'inizio del RES\MYAPP.RC2 file:
#ifdef APSTUDIO_INVOKED
#error this file is not editable by Visual C++
#endif //APSTUDIO_INVOKED
Quando Visual C++ compila il .RC file, definisce sia APSTUDIO_INVOKED che RC_INVOKED. Se la struttura di file creata da AppWizard è danneggiata e Visual C++ legge la riga #error precedente, segnala un errore irreversibile e interrompe la lettura del .RC file.
Gestione dei simboli condivisi da più file modificati .RC da Visual C++
Due problemi si verificano quando si suddivideno le risorse in più .RC file da modificare separatamente in Visual C++:
È possibile condividere gli stessi simboli tra più
.RCfile.È necessario evitare che Visual C++ assegni gli stessi valori numeri di ID a risorse distinte (simboli).
Il diagramma seguente illustra un'organizzazione di .RC file e .H che gestisce il primo problema:
MYAPP.RC
/ \
/ \
MYSTRS.H / MYSHARED.H \ MYMENUS.H
\ / / \ \ \
\ / / \ \ \
MYSTRS.RC MYMENUS.RC
In questo esempio le risorse stringa vengono mantenute in un file di risorse, MYSTRS.RCe i menu vengono mantenuti in un altro, MYMENUS.RC. Potrebbe essere necessario condividere alcuni simboli, quali i comandi, tra i due file. Ad esempio, un ID_TOOLS_SPELL può essere l'ID comando di menu per la voce Ortografia in un menu Strumenti e può anche essere l'ID stringa del prompt dei comandi visualizzato dal framework nella barra di stato della finestra principale dell'applicazione.
Il ID_TOOLS_SPELL simbolo viene mantenuto nel file di intestazione condiviso, MYSHARED.H. Il file di intestazione condiviso viene mantenuto manualmente con un editor di testo; Visual C++ non lo modifica direttamente. Nei due file MYSTRS.RC di risorse e MYMENUS.RCsi specificano #include "MYSHARED.H" nelle direttive di sola lettura per MYAPP.RC, usando il comando Include risorse, come descritto in precedenza.
È più comodo prevedere un simbolo che verrà condiviso prima di tentare di usarlo per identificare qualsiasi risorsa. Aggiungere il simbolo al file di intestazione condiviso e, se non è già stato incluso il file di intestazione condivisa nelle direttive di sola lettura per il .RC file, eseguire questa operazione prima di usare il simbolo . Se non si prevede di condividere il simbolo in questo modo, sarà necessario spostare manualmente (usando un editor di testo) l'istruzione #define per il simbolo da, ad esempio, MYMENUS.H prima di MYSHARED.H usarlo in MYSTRS.RC.
Quando si gestiscono i simboli in più .RC file, è anche necessario aiutare Visual C++ a evitare di assegnare gli stessi valori numerici ID a risorse distinte (simboli). Per qualsiasi file specificato .RC , Visual C++ assegna in modo incrementale gli ID in ognuno di quattro domini ID. Tra le sessioni di modifica, Visual C++ tiene traccia dell'ultimo ID assegnato in ognuno dei domini nel file di intestazione dei simboli per il .RC file. Ecco i APS_NEXT valori per un file vuoto (nuovo): .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 è il valore del simbolo successivo che verrà usato per una risorsa della finestra di dialogo, una risorsa di menu e così via. L'intervallo valido per i valori dei simboli risorsa è compreso tra 1 e 0x6FFF.
_APS_NEXT_COMMAND_VALUE è il valore del simbolo successivo che verrà usato per un'identificazione del comando. L'intervallo valido per i valori dei simboli di comando è compreso tra 0x8000 e 0xDFFF.
_APS_NEXT_CONTROL_VALUE è il valore del simbolo successivo che verrà utilizzato per un controllo finestra di dialogo. L'intervallo valido per i valori dei simboli di controllo finestra di dialogo è compreso tra 8 e 0xDFFF.
_APS_NEXT_SYMED_VALUE è il valore del simbolo successivo che verrà emesso quando si assegna manualmente un valore di simbolo usando il comando New nel Visualizzatore simboli.
Visual C++ inizia con valori leggermente più elevati che il valore legale più basso durante la creazione di un nuovo .RC file. Questi valori verranno inizializzati anche dalla Creazione guidata applicazioni in valori più appropriati per le applicazioni MFC. Per altre informazioni sugli intervalli di valori ID, vedere La nota tecnica 20.
Ora ogni volta che si crea un nuovo file di risorse, anche nello stesso progetto, Visual C++ definisce gli stessi _APS_NEXT_ valori. Ciò significa che se si aggiungono più dialoghi in due file diversi .RC , è molto probabile che lo stesso valore #define venga assegnato a dialoghi diversi. Ad esempio, IDD_MY_DLG1 nel primo .RC file potrebbe essere assegnato lo stesso numero, 101, come IDD_MY_DLG2 in un secondo .RC file.
Per evitare questo problema, è necessario riservare un intervallo numerico separato per ognuno dei quattro domini di ID nei rispettivi .RC file. Impostare gli intervalli aggiornando manualmente i _APS_NEXT valori in ognuno dei .RC file prima di iniziare ad aggiungere risorse. Ad esempio, se il primo .RC file usa i valori predefiniti _APS_NEXT , è possibile assegnare i valori seguenti _APS_NEXT al secondo .RC file:
#define _APS_NEXT_RESOURCE_VALUE 2000
#define _APS_NEXT_COMMAND_VALUE 42000
#define _APS_NEXT_CONTROL_VALUE 2000
#define _APS_NEXT_SYMED_VALUE 2000
Naturalmente, è comunque possibile che Visual C++ assegnerà così tanti ID nel primo .RC file che i valori numerici iniziano a sovrapporsi a quelli riservati per il secondo .RC file. È consigliabile riservare intervalli sufficientemente grandi in modo che questa collisione non si verifichi.
Gestione delle dipendenze tra .RCfile , .CPPe .H
Quando Visual C++ salva un .RC file, salva anche le modifiche dei simboli nel file corrispondente RESOURCE.H . Uno dei .CPP file che fanno riferimento alle risorse nel .RC file deve usare #include per includere il RESOURCE.H file, in genere dall'interno del file di intestazione principale del progetto. Questa inclusione comporta un effetto collaterale indesiderato a causa della gestione interna del progetto dell'ambiente di sviluppo, che analizza i file di origine per individuare le dipendenze delle intestazioni. Ogni volta che si aggiunge un nuovo simbolo in Visual C++, tutti i .CPP file con #include "RESOURCE.H" direttive devono essere ricompilati.
Visual C++, aggirare la dipendenza RESOURCE.H da includendo il commento seguente come prima riga del RESOURCE.H file:
//{{NO_DEPENDENCIES}}
L'ambiente di sviluppo interpreta questo commento ignorando le modifiche apportate in RESOURCE.H modo che i file dipendenti .CPP non debbano essere ricompilati.
Visual C++ aggiunge sempre la //{{NO_DEPENDENCIES}} riga del commento a un .RC file quando salva il file. In alcuni casi, aggirare la dipendenza di compilazione da RESOURCE.H può causare errori di runtime non rilevati in fase di collegamento. Ad esempio, se si usa il Visualizzatore simboli per modificare il valore numerico assegnato a un simbolo per una risorsa, la risorsa non verrà trovata e caricata correttamente in fase di esecuzione dell'applicazione se il .CPP file che fa riferimento alla risorsa non viene ricompilato. In questi casi, è consigliabile ricompilare in modo esplicito tutti i .CPP file noti che sono interessati dalle modifiche del simbolo in RESOURCE.H o selezionare Ricompila tutto. Se hai la necessità di modificare frequentemente i valori dei simboli per un determinato gruppo di risorse, probabilmente troverai più comodo e sicuro suddividere questi simboli in un file di intestazione di sola lettura separato, come descritto nella sezione precedente Inclusione di file di intestazione aggiuntivi.
Come Visual C++ gestisce set include informazioni
Come descritto in precedenza, il menu comando Inclusioni impostazione del menu File consente di specificare tre tipi di informazioni:
File di intestazione simboli
Direttive per simboli in sola lettura
Direttive in fase di compilazione
Nella tabella seguente viene descritto come Visual C++ gestisce queste informazioni in un .RC file. Queste informazioni non sono necessarie per l'uso di Visual C++, ma possono migliorare la comprensione in modo da poter usare in modo più sicuro la funzionalità Imposta include.
Ognuno dei tre tipi precedenti di set include le informazioni viene archiviato nel .RC file in due forme: (1) come #include o altre direttive interpretabili dal compilatore di risorse e (2) come risorse speciali TEXTINCLUDE interpretabili solo da Visual C++.
Lo scopo della risorsa consiste nell'archiviare TEXTINCLUDE in modo sicuro le informazioni di inclusione impostate in un modulo facilmente presente nella finestra di dialogo Imposta inclusioni di Visual C++. TEXTINCLUDE è un tipo di risorsa definito da Visual C++. Visual C++ riconosce tre risorse specifiche TEXTINCLUDE con i numeri di identificazione delle risorse 1, 2 e 3:
TEXTINCLUDE ID risorsa |
Tipo informazioni di Inclusioni impostazione |
|---|---|
| 1 | File di intestazione simboli |
| 2 | Direttive per simboli in sola lettura |
| 3 | Direttive in fase di compilazione |
Ognuno dei tre tipi di set include informazioni è illustrato dai file predefiniti MYAPP.RC e RESOURCE.H creati da AppWizard, come descritto di seguito. I token aggiuntivi \0 e "" compresi tra BEGIN i blocchi e END sono richiesti dalla sintassi RC per specificare rispettivamente stringhe con terminazione zero e il carattere virgolette doppie.
File di intestazione simboli
Il formato delle informazioni del file di intestazione dei simboli interpretato dal compilatore di risorse è semplicemente un'istruzione #include :
#include "resource.h"
La risorsa corrispondente TEXTINCLUDE è:
1 TEXTINCLUDE DISCARDABLE
BEGIN
"resource.h\0"
END
Direttive per simboli in sola lettura
Le direttive dei simboli di sola lettura sono incluse nella parte superiore di nel formato seguente interpretabili dal compilatore di MYAPP.RC risorse:
#include "afxres.h"
La risorsa corrispondente TEXTINCLUDE è:
2 TEXTINCLUDE DISCARDABLE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
Direttive in fase di compilazione
Le direttive in fase di compilazione sono incluse alla fine di nel formato seguente interpretabili dal compilatore di MYAPP.RC risorse:
#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 #ifndef APSTUDIO_INVOKED direttiva indica a Visual C++ di ignorare le direttive in fase di compilazione.
La risorsa corrispondente 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