Zum Exportieren einer Instanziierung einer Klasse Standardvorlagenbibliothek (Standard Template Library, STL) und eine Klasse, die einen Datenmember enthält, der ein STL-Objekt ist

SPRACHE AUSWÄHLEN SPRACHE AUSWÄHLEN
Artikel-ID: 168958 - Produkte anzeigen, auf die sich dieser Artikel bezieht
Alles erweitern | Alles schließen

Auf dieser Seite

Zusammenfassung

Dieser Artikel beschreibt die folgenden Aufgaben ausführen:
  • Exportieren eine Instanziierung einer Standardvorlagenbibliothek (STL)-Klasse.
  • Exportieren Sie eine Klasse, einen Datenmember enthält, die eine STL-Objekt.
Beachten Sie, dass Sie keine verallgemeinerte Vorlage exportieren. Die Vorlage muss instanziiert werden; das heißt, alle Vorlage-Parameter muss angegeben werden und muss vollständig definierte Typen zum Zeitpunkt der Instanziierung. Für Instanz "Stapel <int>;" instanziiert die STL Stack-Klasse. Die Instanziierung erzwingt alle Mitglieder der Klasse Stack <int> generiert werden.

Beachten Sie außerdem, dass einige STL-Containern (Map, Gruppe, Warteschlange, Liste, Deque) exportiert werden können. Sehen Sie hierfür im Abschnitt Weitere Informationen, eine ausführliche Erläuterung zu befolgen.

Weitere Informationen

Beginnend mit Visual C++ 5.0, ist es möglich zu erzwingen eine Instanziierung einer Vorlage-Klasse und die Instanziierung exportieren. Eine Vorlage-Klasse Instanziierung exportieren möchten, verwenden Sie die folgende Syntax:

Exportieren eine STL-Klasse

  1. In die DLL und EXE-Datei zu verknüpfen, mit der gleichen DLL-Version der Laufzeit C. Entweder beide mit MSVCRT.lib (Releasebuild) verknüpfen, oder beide mit msvcrtd.lib (Debugbuild) verknüpfen.
  2. Bereitstellen Sie in der DLL, den __declspec-Spezifizierer in der Vorlage Instanziierung Deklaration, die Instanziierung STL-Klasse aus der DLL zu exportieren.
  3. Bereitstellen Sie in der EXE-Datei, die Extern und __declspec-Bezeichner in der Vorlage Instanziierung Deklaration So importieren Sie die Klasse aus der DLL. Dies führt zu einer Warnung C4231 "nicht dem Standard entsprechende Erweiterung: 'Extern' vor der expliziten Instanziierung Vorlage." Sie können diese Warnung ignorieren.

So exportieren Sie eine Klasse mit einem Datenelement ist einer STL-Objekt

  1. In die DLL und EXE-Datei zu verknüpfen, mit der gleichen DLL-Version der Laufzeit C. Entweder beide mit MSVCRT.lib (Releasebuild) verknüpfen, oder beide mit msvcrtd.lib (Debugbuild) verknüpfen.
  2. Bereitstellen Sie in der DLL, den __declspec-Spezifizierer in der Vorlage Instanziierung Deklaration, die Instanziierung STL-Klasse aus der DLL zu exportieren.

    Hinweis: Sie können keine Schritt 2 überspringen. Sie müssen die Instanziierung der STL-Klasse exportieren, mit denen Sie das Datenelement erstellt.
  3. Bereitstellen Sie in der DLL, den __declspec-Spezifizierer in der Deklaration der Klasse, die Klasse aus der DLL zu exportieren.
  4. Bereitstellen Sie in der EXE-Datei, den __declspec-Spezifizierer in der Deklaration der Klasse die Klasse aus der DLL zu importieren.

    Wenn die Klasse, die Sie exportieren verfügt über eine oder mehrere base Klassen, dann müssen Sie die Basisklassen sowie exportieren. Wenn die Klasse, die Sie exportieren Datenelemente, die vom Klassentyp sind enthält, müssen Sie die Klassen der Datenmember exportieren.
Hinweis: Einige STL-Klassen verwenden anderer STL-Klassen. Diese anderen Klassen müssen ebenfalls exportiert werden. Klassen, die exportiert werden müssen sind in Compiler-Warnungen aufgelistet, wenn Sie eine Warnstufe niedriger als 1; dieser ist, /W2, /W3 oder/W4 kompilieren. Warnstufe 4 generiert zahlreiche Warnmeldungen für STL-Header und wird derzeit nicht aus diesem Grund empfohlen.

Einige STL-Klassen, geschachtelte Klassen enthalten. Diese Klassen können nicht exportiert werden. Deque enthält beispielsweise eine geschachtelte Klasse deque::iterator. Wenn Sie Deque exportieren, erhalten Sie eine Warnung, die, dass Sie deque::iterator exportieren müssen. Wenn Sie deque::iterator exportieren, erhalten Sie eine Warnung, dass Sie Deque exportieren müssen. Ursache hierfür ist eine entworfene Einschränkung, dass nach eine Vorlage-Klasse instanziiert wird, nicht re-instantiated und exportiert werden können. Der einzige STL-Container, der zurzeit exportiert werden können ist Vektor. Andere Container (d. h., Zuordnung, Satz, Warteschlange, Liste, Deque) alle geschachtelte Klassen enthalten und können nicht exportiert werden.

Wenn Sie einen mit einem benutzerdefinierten Typ (UDT) parametrisierten STL-Container exportieren, müssen Sie die Operatoren definieren < und == für Ihr UDT. <myclass>Beispielsweise wenn Sie Vektor < MyClass > Exportieren, Sie müssen definieren MyClass::operator < und "MyClass" Operator ==. Dies ist da alle Klassen der STL-Container Member Vergleichsoperatoren haben, die erfordern das Vorhandensein der Operatoren < und == für den enthaltenen Typ. Normalerweise werden diese nicht instanziiert, da Sie nicht verwendet werden. Wenn Sie eine Instanz der Vorlage-Klasse instanziieren, werden alle Memberfunktionen generiert. Da STL-Container-Klassen Memberfunktionen, die die Operatoren < und == für den Typ enthalten, müssen Sie implementiert. Wenn Objekte Ihr UDT vergleichen nicht sinnvoll ist, können Sie die Vergleichsoperatoren einfach "true" zurückgeben definieren.

Wenn Symbol _DLL, während der kompilieren definiert ist (dieses Symbol wird implizit definiert, beim Kompilieren mit/MD oder/MDd mit der DLL-Version der C Runtime verknüpfen), die folgenden STL-Klassen und verschiedene globale Operatoren und Funktionen, die auf diese Klassen angewendet werden, werden bereits von der C-Laufzeit-DLL exportiert. Daher können nicht Sie Sie aus einer DLL exportieren. Sollte nicht dadurch ein Problem für das ausführbare Programm, das die Klasse, importiert solange es auch die DLL-Version der Laufzeit C verwendet:
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)
				
für spezifische Details zu der Vorlage-Parameter verwendet werden und welche globale Funktionen und Operatoren deklariert werden, bitte die entsprechenden Headerdatei anzuzeigen.

Beispielcode

   // -------------------------------------------
   // 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;
    }
				

Informationsquellen

Weitere Informationen finden Sie auf den folgenden Themen in Visual C++ Hilfemenü:
Explizite Instanziierung
__declspec
Stapel
/ MD, / ML, / MT, / ld (Laufzeitbibliothek verwenden)

Eigenschaften

Artikel-ID: 168958 - Geändert am: Dienstag, 6. September 2005 - Version: 3.0
Die Informationen in diesem Artikel beziehen sich auf:
  • 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
Keywords: 
kbmt kbstl kbinfo kbcode kbhowto KB168958 KbMtde
Maschinell übersetzter Artikel
Wichtig: Dieser Artikel wurde maschinell und nicht von einem Menschen übersetzt. Die Microsoft Knowledge Base ist sehr umfangreich und ihre Inhalte werden ständig ergänzt beziehungsweise überarbeitet. Um Ihnen dennoch alle Inhalte auf Deutsch anbieten zu können, werden viele Artikel nicht von Menschen, sondern von Übersetzungsprogrammen übersetzt, die kontinuierlich optimiert werden. Doch noch sind maschinell übersetzte Texte in der Regel nicht perfekt, insbesondere hinsichtlich Grammatik und des Einsatzes von Fremdwörtern sowie Fachbegriffen. Microsoft übernimmt keine Gewähr für die sprachliche Qualität oder die technische Richtigkeit der Übersetzungen und ist nicht für Probleme haftbar, die direkt oder indirekt durch Übersetzungsfehler oder die Verwendung der übersetzten Inhalte durch Kunden entstehen könnten.
Den englischen Originalartikel können Sie über folgenden Link abrufen: 168958
Microsoft stellt Ihnen die in der Knowledge Base angebotenen Artikel und Informationen als Service-Leistung zur Verfügung. Microsoft übernimmt keinerlei Gewährleistung dafür, dass die angebotenen Artikel und Informationen auch in Ihrer Einsatzumgebung die erwünschten Ergebnisse erzielen. Die Entscheidung darüber, ob und in welcher Form Sie die angebotenen Artikel und Informationen nutzen, liegt daher allein bei Ihnen. Mit Ausnahme der gesetzlichen Haftung für Vorsatz ist jede Haftung von Microsoft im Zusammenhang mit Ihrer Nutzung dieser Artikel oder Informationen ausgeschlossen.

Ihr Feedback an uns

 

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