Come esportare un'istanza di una classe di libreria di modelli standard (STL) e una classe che contiene un membro dati che Ŕ un oggetto STL

Traduzione articoli Traduzione articoli
Identificativo articolo: 168958 - Visualizza i prodotti a cui si riferisce l?articolo.
Espandi tutto | Chiudi tutto

In questa pagina

Sommario

In questo articolo viene descritto come eseguire le seguenti operazioni:
  • Esportare un'istanza di una raccolta di modelli standard (STL) classe.
  • Esportazione di una classe che contiene un membro di dati che Ŕ un STL oggetto.
Si noti che non Ŕ possibile esportare un modello generalizzato. Il modello deve essere creata un'istanza e che tutti i parametri di modello deve essere fornita deve essere tipi completamente definiti al momento della creazione di un'istanza. Per l'istanza "stack <int>;" crea un'istanza della classe di stack STL. La creazione di istanze impone a generare tutti i membri della classe stack <int>.

Si noti inoltre che non possono essere esportati alcuni contenitori STL (mappa, set, coda, elenco, deque). Consultare la sezione informazioni per una spiegazione dettagliata.

Informazioni

A partire da Visual c ++ 5.0, Ŕ possibile forzare un'istanza di una classe modello e la creazione di istanze di esportazione. Per esportare un'istanza della classe modello, utilizzare la sintassi seguente:

Per esportare una classe STL

  1. Nella DLL e il file con estensione exe, il collegamento con la stessa DLL versione di runtime C. ╚ possibile collegare entrambi con MSVCRT.lib (build di rilascio) oppure collegare entrambi con msvcrtd.lib (build di debug).
  2. In DLL, Ŕ necessario fornire l'identificatore di __declspec nella dichiarazione di creazione di un'istanza del modello da cui esportare l'istanza di classe STL la DLL.
  3. Il file exe, forniscono gli identificatori di tipo extern e __declspec nella dichiarazione di creazione di un'istanza del modello per importare la classe dalla DLL. In questo modo un messaggio di avviso C4231 "estensione non standard utilizzata: 'extern' prima di creare un'istanza esplicita modello." ╚ possibile ignorare questo avviso.

Per esportare una classe contenente un membro di dati che rappresenta un oggetto STL

  1. Nella DLL e il file con estensione exe, il collegamento con la stessa DLL versione di runtime C. ╚ possibile collegare entrambi con MSVCRT.lib (build di rilascio) oppure collegare entrambi con msvcrtd.lib (build di debug).
  2. In DLL, Ŕ necessario fornire l'identificatore di __declspec nella dichiarazione di creazione di un'istanza del modello da cui esportare l'istanza di classe STL la DLL.

    Nota: Non Ŕ possibile ignorare il passaggio 2. ╚ necessario esportare l'istanza della classe STL che consente di creare il membro dati.
  3. In DLL, Ŕ necessario fornire l'identificatore di __declspec nella dichiarazione della classe da cui esportare la classe della DLL.
  4. In file exe, Ŕ necessario fornire l'identificatore di __declspec nella dichiarazione della classe per importare la classe dalla DLL.

    Se la classe che si desidera esportare include uno o pi¨ classi base, quindi Ŕ necessario esportare anche le classi base. Se la classe che si sta esportando contiene membri dati che sono di tipo classe, Ŕ necessario esportare le classi dei membri dati.
Nota: Alcune classi STL utilizzano altre classi STL. Necessario esportare anche le altre classi. Se si compila con un livello di avviso inferiore rispetto a 1; tale, /W2, /W3 o/W4, le classi che devono essere esportate sono elencate negli avvisi del compilatore. Livello avvisi 4 genera numerosi messaggi di avviso per le intestazioni STL e non Ŕ attualmente consigliata per questo motivo.

Alcune classi STL contengono classi nidificate. Queste classi possono non essere esportate. Ad esempio, deque contiene deque::iterator una classe nidificata. Se si esporta deque, verrÓ visualizzato un avviso che Ŕ necessario esportare deque::iterator. Se si esporta deque::iterator, viene visualizzato un avviso che Ŕ necessario esportare deque. Questo Ŕ causato da una limitazione progettati in modo che una volta che viene creata un'istanza di una classe modello, pu˛ non essere re-instantiated ed esportato. L'unico contenitore STL che attualmente pu˛ essere esportato Ŕ vettore. Altri contenitori (vale a dire, mappa, set, coda, elenco, deque) tutte contengono le classi nidificate e non possono essere esportati.

Quando si esporta un contenitore STL con parametrizzato con un tipo definito dall'utente (UDT), Ŕ necessario definire gli operatori < e == per l'UDT. <myclass>Ad esempio, se si esporta un vettore < MyClass >, Ŕ necessario definire MyClass::operator < e MyClass operatore ==. Non dispongono di tutte le classi contenitore STL operatori di confronto membro che richiedono l'esistenza degli operatori < e == per il tipo di contenuto. In genere, questi non sono istanziati poichÚ non vengono utilizzati. Quando si crea un'istanza un'istanza di una classe modello, vengono generate tutte le funzioni membro. PoichÚ le classi contenitore STL dispongono di funzioni membro che utilizzare gli operatori < e == per il tipo di contenuto, Ŕ necessario implementarli. Confronto di oggetti dell'UDT non ha senso, Ŕ possibile definire gli operatori di confronto semplicemente per restituire "true".

Quando il _DLL simbolo Ŕ definito durante la compilazione (questo simbolo Ŕ definito in modo implicito durante la compilazione con /MD o /MDd collegamento con la versione DLL di Runtime C), le seguenti classi STL e diversi gli operatori globali e le funzioni che operano su queste classi, giÓ vengono esportati dalla DLL di Runtime C. Di conseguenza, non Ŕ possibile esportarli dalla DLL. Questo non dovrebbe causare un problema per il programma eseguibile che importa la classe purchÚ utilizzi anche la versione DLL di runtime C:
Header      STL template class
------------------------------
<IOSFWD>    basic_ios
<IOSFWD>    <IOSFWD>
<IOSFWD>    basic_istream
<IOSFWD>    basic_string (also typedef'd as string and wstring)
<IOSFWD>    complex
<LOCALE>    messages
<XLOCALE>   codecvt
<XLOCALE>   ctype
<XLOCMON>   moneypunct
<XLOCMON>   money_get
<XLOCMON>   money_put
<XLOCNUM>   numpunct
<XLOCTIME>  time_get
<XLOCTIME>  time_put
<XSTRING>   basic_string (also typedef'd as string and wstring)
				
per dettagli specifici sulle vengono utilizzati i parametri di modello e le funzioni globali e gli operatori vengono dichiarati, vedere il file di intestazione rilevanti.

Codice di esempio

   // -------------------------------------------
   // MYHEADER.H
   //disable warnings on 255 char debug symbols
    #pragma warning (disable : 4786)
   //disable warnings on extern before template instantiation
    #pragma warning (disable : 4231)

    #include <vector>

    // Provide the storage class specifier (extern for an .exe file, null
    // for DLL) and the __declspec specifier (dllimport for .an .exe file,
    // dllexport for DLL).
    // You must define EXP_STL when compiling the DLL.
    // You can now use this header file in both the .exe file and DLL - a
    // much safer means of using common declarations than two different
    // header files.
    #ifdef EXP_STL
    #    define DECLSPECIFIER __declspec(dllexport)
    #    define EXPIMP_TEMPLATE
    #else
    #    define DECLSPECIFIER __declspec(dllimport)
    #    define EXPIMP_TEMPLATE extern
    #endif

    // Instantiate classes vector<int> and vector<char>
    // This does not create an object. It only forces the generation of all
    // of the members of classes vector<int> and vector<char>. It exports
    // them from the DLL and imports them into the .exe file.
    EXPIMP_TEMPLATE template class DECLSPECIFIER std::vector<int>;
    EXPIMP_TEMPLATE template class DECLSPECIFIER std::vector<char>;

    // Declare/Define a class that contains both a static and non-static
    // data member of an STL object.
    // Note that the two template instantiations above are required for
    // the data members to be accessible. If the instantiations above are
    // omitted, you may experience an access violation.
    // Note that since you are exporting a vector of MyClass, you must
    // provide implementations for the operator < and the operator ==.
    class DECLSPECIFIER MyClass
    {
    public:
        std::vector<int> VectorOfInts;
        static std::vector<char> StaticVectorOfChars;

    public:
        bool operator < (const MyClass > c) const
        {
            return VectorOfInts < c. VectorOfInts;
        }
        bool operator == (const MyClass > c) const
        {
            return VectorOfInts == c. VectorOfInts;
        }
    };

    // Instantiate the class vector<MyClass>
    // This does not create an object. It only forces the generation of
    // all of the members of the class vector<MyClass>. It exports them
    // from the DLL and imports them into the .exe file.
    EXPIMP_TEMPLATE template class DECLSPECIFIER std::vector<MyClass>;

    // -------------------------------------------
    // Compile options needed: /GX /LDd /MDd /D"EXP_STL"
    //                     or: /GX /LD  /MD  /D"EXP_STL"
    // DLL.CPP

    #include "MyHeader.h"
    std::vector<char> MyClass::StaticVectorOfChars;

    // -------------------------------------------
    // Compile options needed: /GX /MDd
    //                     or: /GX /MD
    // EXE.CPP

    #include <iostream>
    #include "MyHeader.h"

    int main ()
    {
        MyClass x;

        for (int i=0; i<5; i++) x.VectorOfInts.push_back(i);
        for (char j=0; j<5; j++) x.StaticVectorOfChars.push_back('a' + j);

        std::vector<int>::iterator vii = x.VectorOfInts.begin();
        while (vii != x.VectorOfInts.end())
        {
            std::cout << *vii;
            std::cout << " displayed from x.VectorOfInts" << std::endl;
            vii++;
        }
        std::vector<char>::iterator vci = x.StaticVectorOfChars.begin();
        while (vci != x.StaticVectorOfChars.end())
        {
            std::cout << *vci;
            std::cout << " displayed from MyClass::StaticVectorOfChars";
            std::cout << std::endl;
            vci++;
        }

        std::vector<MyClass> vy;
        for (i=0; i=5; i++) vy.push_back(MyClass());

        return 1;
    }
				

Riferimenti

Per ulteriori informazioni, cercare i seguenti argomenti nella Guida in linea di Visual c ++:
Creazione di istanze esplicite
__declspec
stack
/ MD, / ML, / MT, /ld (utilizza la libreria di runtime)

ProprietÓ

Identificativo articolo: 168958 - Ultima modifica: martedý 6 settembre 2005 - Revisione: 3.0
Le informazioni in questo articolo si applicano a:
  • Microsoft Visual C++ 5.0 Enterprise Edition
  • Microsoft Visual C++ 6.0 Enterprise Edition
  • Microsoft Visual C++ 5.0 Professional Edition
  • Microsoft Visual C++ 6.0 Professional Edition
  • Microsoft Visual C++, 32-bit Learning Edition 6.0
Chiavi:á
kbmt kbstl kbinfo kbcode kbhowto KB168958 KbMtit
Traduzione automatica articoli
Il presente articolo Ŕ stato tradotto tramite il software di traduzione automatica di Microsoft e non da una persona. Microsoft offre sia articoli tradotti da persone fisiche sia articoli tradotti automaticamente da un software, in modo da rendere disponibili tutti gli articoli presenti nella nostra Knowledge Base nella lingua madre dell?utente. Tuttavia, un articolo tradotto in modo automatico non Ŕ sempre perfetto. Potrebbe contenere errori di sintassi, di grammatica o di utilizzo dei vocaboli, pi¨ o meno allo stesso modo di come una persona straniera potrebbe commettere degli errori parlando una lingua che non Ŕ la sua. Microsoft non Ŕ responsabile di alcuna imprecisione, errore o danno cagionato da qualsiasi traduzione non corretta dei contenuti o dell?utilizzo degli stessi fatto dai propri clienti. Microsoft, inoltre, aggiorna frequentemente il software di traduzione automatica.
Clicca qui per visualizzare la versione originale in inglese dell?articolo: 168958
LE INFORMAZIONI CONTENUTE NELLA MICROSOFT KNOWLEDGE BASE SONO FORNITE SENZA GARANZIA DI ALCUN TIPO, IMPLICITA OD ESPLICITA, COMPRESA QUELLA RIGUARDO ALLA COMMERCIALIZZAZIONE E/O COMPATIBILITA' IN IMPIEGHI PARTICOLARI. L'UTENTE SI ASSUME L'INTERA RESPONSABILITA' PER L'UTILIZZO DI QUESTE INFORMAZIONI. IN NESSUN CASO MICROSOFT CORPORATION E I SUOI FORNITORI SI RENDONO RESPONSABILI PER DANNI DIRETTI, INDIRETTI O ACCIDENTALI CHE POSSANO PROVOCARE PERDITA DI DENARO O DI DATI, ANCHE SE MICROSOFT O I SUOI FORNITORI FOSSERO STATI AVVISATI. IL DOCUMENTO PUO' ESSERE COPIATO E DISTRIBUITO ALLE SEGUENTI CONDIZIONI: 1) IL TESTO DEVE ESSERE COPIATO INTEGRALMENTE E TUTTE LE PAGINE DEVONO ESSERE INCLUSE. 2) I PROGRAMMI SE PRESENTI, DEVONO ESSERE COPIATI SENZA MODIFICHE, 3) IL DOCUMENTO DEVE ESSERE DISTRIBUITO INTERAMENTE IN OGNI SUA PARTE. 4) IL DOCUMENTO NON PUO' ESSERE DISTRIBUITO A SCOPO DI LUCRO.

Invia suggerimenti

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com