TN035: Uso di più file di risorse e file di intestazione con Visual C++

Annotazioni

La nota tecnica seguente non è stata aggiornata perché è stata inclusa per la prima volta nella documentazione online. Di conseguenza, alcune procedure e argomenti potrebbero non essere aggiornati o non corretti. Per le informazioni più recenti, è consigliabile cercare l'argomento di interesse nell'indice della documentazione online.

Questa nota descrive in che modo l'editor di risorse di Visual C++ supporta più file di risorse e file di intestazione condivisi in un singolo progetto o condivisi tra più progetti e come sfruttare 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 .H comune tra due .RC file

• Come dividere le risorse del progetto in più .RC file

• Come gestisci (e gli strumenti) le dipendenze di compilazione tra i file .RC, .CPP e .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 per rispondere alle domande precedenti come indicato di seguito:

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

• Analisi dei file .RC e .H creati con AppWizard esamina i vari file di risorsa e intestazione utilizzati da un'applicazione creata da AppWizard. Questi file fungono da modello valido per file di risorse aggiuntivi e file di intestazione che è possibile aggiungere 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 .RC file mostra come condividere un file di intestazione tra più .RC file 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ù .RC file 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 riformatti involontariamente una risorsa personalizzata.

• La gestione dei simboli condivisi da più file modificati .RC da Visual C++ descrive come condividere gli stessi simboli tra più .RC file e come evitare di assegnare valori numerici ID duplicati.

• Gestire le dipendenze tra .RC, .CPP e .H descrive in che modo Visual C++ evita di ricompilare inutilmente i file che dipendono dai simboli delle risorse.

• Come Visual C++ gestisce le informazioni sui set include fornisce dettagli tecnici su come Visual C++ tiene traccia di più file (annidati) e di più file di intestazione che sono inclusi in un file .RC.

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 "Includi Risorse" della vista risorse

Per accedere alle Resource Includes, aprire la Resource View , quindi fare clic con il pulsante destro del mouse sul .RC file e selezionare Resource Includes.

File di intestazione dei 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 delle Inclusioni risorse di Visual C++, consente di modificare il nome di questo file di intestazione. Immettere un nuovo nome di file nella casella di modifica della sezione.

Annotazioni

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 del simbolo Read-Only

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. Nella sezione Direttive simboloRead-Only: della finestra di dialogo Include risorse puoi specificare qualsiasi numero di file di intestazione aggiuntivi di sola lettura come Direttive simbolo Read-Only. 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 definito nel file di intestazione di sola lettura. Non è possibile modificare il valore numerico assegnato a un simbolo di sola lettura.

Direttive Compile-Time

Visual C++ supporta anche l'annidamento dei file di risorse, in cui un file di risorse è incluso all'interno di un altro tramite un'istruzione .RC. 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 direttiveCompile-Time: nella finestra di dialogo Risorse include consente di specificare un numero qualsiasi di .RC file da includere come direttive Compile-Time.

Si noti cosa accade se si legge in Visual C++ un .RC file che include un altro .RC file non specificato come direttiva Compile-Time. 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 eseguire l'unione, è necessario rimuovere l'istruzione #include dal file padre .RCprima 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 file .RC tre tipi di informazioni sui set include (file di intestazione dei simboli, direttive simbolo Read-Only e Compile-Time) nelle direttive #include, nelle e nelle risorse TEXTINCLUDE. 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 .RC e .H creati da AppWizard

L'analisi del codice dell'applicazione prodotto da AppWizard fornisce informazioni dettagliate sul modo in cui Visual C++ gestisce più file di risorse e 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 da AppWizard usa più file di risorse e più file di intestazione, come riepilogato nel diagramma seguente:

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

È possibile visualizzare queste relazioni tra più file usando il comando File/Set Includes di Visual C++.

MYAPP.RC
File di risorse dell'applicazione modificato con Visual C++.

RESOURCE.H è il file header specifico dell'applicazione. È sempre denominato RESOURCE.H da AppWizard, coerente con la denominazione predefinita di Visual C++del file di intestazione. Il #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. AppWizard non crea tali risorse per impostazione predefinita, poiché Visual C++ può modificare tutte le risorse standard, inclusa la risorsa versione (una nuova funzionalità in questa versione). Un file vuoto viene generato da AppWizard nel caso in cui si desideri aggiungere risorse formattate personalizzate a questo file.

Se si utilizzano risorse formattate personalizzate, è possibile aggiungerle a RES\MYAPP.RC2 e 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.RC, e vengono specificati nella direttiva Compile-Time della finestra di dialogo Imposta inclusioni. 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 altri file di intestazione di sola lettura nei casi seguenti:

Il file di intestazione viene fornito da un'origine esterna oppure si vuole 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 filtri quando salva il file. Ad esempio, potresti voler conservare i #define che impiegano l'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 Read-Only, come in:

#include "afxres.h"
#include "second.h"

Il nuovo diagramma delle relazioni tra file è ora simile al seguente:

                   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 delle direttive Read-Only descritte 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ù .RC file. 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ù .RC file 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 .RC verranno caricati e salvati più velocemente in Visual C++ rispetto a un file composito .RC .

• Se si vuole mantenere una risorsa utilizzando un editor di testo in un formato leggibile dall'uomo, è consigliabile conservarla in un file .RC separato da quello modificato da 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 .RC in modo che Visual C++ non modifichi il formato in dati esadecimali. Le .WAV risorse file (audio) nell'esempio SPEAKN di MFC Advanced Concepts sono un buon esempio.

È possibile includere SECOND.RC nelle Direttive Compile-Time nella finestra di dialogo per l'impostazione delle 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 Compile-Time, è possibile organizzare le risorse modificabili e non modificabili di Visual C++ in più .RC file, in cui il file principale MYAPP.RC non esegue altro che #include 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.

Attuazione dei 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ù .RC file.

• È necessario aiutare Visual C++ a evitare di assegnare gli stessi valori numerici 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. Alcuni simboli, ad esempio per i comandi, potrebbero dover essere condivisi 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.RC, si specificano #include "MYSHARED.H" nelle direttive Read-Only per MYAPP.RC, usando il comando Resource Includes, 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 condiviso nelle direttive Read-Only 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 di 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 è 0x8000 a 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 della 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. AppWizard inizializzerà anche questi valori in un valore più appropriato 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 . Qualsiasi 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 dei progetti nell'ambiente di sviluppo, che esamina i file sorgenti per rilevare 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++ aggira la dipendenza RESOURCE.H includendo il commento seguente come prima riga del file RESOURCE.H.

//{{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 le informazioni sui set di inclusione

Come illustrato in precedenza, il comando Set Includes del menu File consente di specificare tre tipi di informazioni:

• File di intestazione dei simboli

• Direttive del simbolo Read-Only

• Direttive Compile-Time

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 di Set Include informazioni
1	File di intestazione dei simboli
2	Direttive del simbolo Read-Only
3	Direttive Compile-Time

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 dei 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 del simbolo Read-Only

"Read-Only Direttive di simboli sono incluse nella parte superiore di MYAPP.RC nel formato seguente interpretabile dal compilatore di risorse:"

#include "afxres.h"

La risorsa corrispondente TEXTINCLUDE è:

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

Direttive Compile-Time

Compile-Time Le direttive sono incluse alla fine di MYAPP.RC nel seguente formato interpretabile dal compilatore di 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 Compile-Time.

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

Vedere anche

Note tecniche per numero
Note tecniche per categoria