Como exportar uma instanciação de uma classe de STL (Standard Template Library) e uma classe que contém um membro de dados que é um objeto STL

Traduções deste artigo Traduções deste artigo
ID do artigo: 168958 - Exibir os produtos aos quais esse artigo se aplica.
Expandir tudo | Recolher tudo

Neste artigo

Sumário

Este artigo discute como executar as seguintes tarefas:
  • Exportar uma instanciação de uma biblioteca padrão do modelo de classe (STL).
  • Exportar uma classe que contém um membro de dados que é um STL objeto.
Observe que você não pode exportar um modelo generalizado. O modelo deve ser instanciado; ou seja, todos os parâmetros de modelo devem ser fornecidos e devem ser de tipos totalmente definidos no ponto da instanciação. Para a instância "pilha <int>;" instancia a classe de pilha STL. A instanciação força todos os membros da classe pilha <int> a ser gerado.

Observe também que alguns contêineres STL (mapa, conjunto, fila, lista, deque) não podem ser exportados. Consulte a seção mais informações a seguir para obter uma explicação detalhada.

Mais Informações

Começando com Visual C++ 5.0, é possível forçar uma instanciação de uma classe de modelo e exportar a instanciação. Para exportar uma instanciação de classe de modelo, use a seguinte sintaxe:

Para exportar uma classe STL

  1. A DLL e o arquivo .exe, vincular com a mesma DLL versão do C tempo de execução. O link com Msvcrt.lib (versão de compilação) ou vincular com Msvcrtd.lib (compilação de depuração).
  2. A DLL, forneça o especificador __declspec na declaração de instanciação do modelo para exportar a instanciação de classe STL a DLL.
  3. O arquivo .exe, forneça os especificadores extern e __declspec na declaração de instanciação do modelo para importar a classe de DLL. Isso resulta em um aviso C4231 "extensão fora do padrão usada: 'extern' antes de instanciação de modelo explícita." Você pode ignorar este aviso.

Para exportar uma classe que contém um membro de dados que é um objeto STL

  1. A DLL e o arquivo .exe, vincular com a mesma DLL versão do C tempo de execução. O link com Msvcrt.lib (versão de compilação) ou vincular com Msvcrtd.lib (compilação de depuração).
  2. A DLL, forneça o especificador __declspec na declaração de instanciação do modelo para exportar a instanciação de classe STL a DLL.

    Observação: Você não pode ignorar a etapa 2. Você deve exportar a instanciação da classe STL que você usar para criar o membro de dados.
  3. A DLL, forneça o especificador __declspec na declaração da classe para exportar a classe de DLL.
  4. O arquivo .exe, forneça o especificador __declspec na declaração da classe para importar a classe da DLL.

    Se a classe que você estiver exportando tem um ou mais classes base, você deve exportar as classes base. Se a classe que você está exportando contém membros de dados que são do tipo de classe, você deve exportar as classes dos membros de dados.
Observação: Algumas classes STL usam outras classes STL. Essas outras classes também devem ser exportados. As classes que devem ser exportadas são listadas em avisos do compilador se você compilar com um nível de aviso menor que 1; que é, /W2, /W3 ou/W4. Nível de aviso 4 produz uma grande quantidade de mensagens de aviso para cabeçalhos de STL e não é recomendado no momento por esse motivo.

Algumas classes STL contém classes aninhadas. Essas classes não podem ser exportadas. Por exemplo, o deque contém uma classe aninhada deque::iterator. Se você exportar deque, você receberá um aviso de que você deve exportar deque::iterator. Se você exportar deque::iterator, você receber um aviso que você deve exportar deque. Isso é causado por uma limitação projetada que depois de uma classe de modelo é instanciada, ele pode não ser re-instantiated e exportado. O recipiente STL apenas que no momento pode ser exportado é vetor. Outros recipientes (isto é, mapa, conjunto, fila, lista, deque) todos contêm classes aninhadas e não podem ser exportados.

Quando você exporta um recipiente de STL parametrizado com um tipo definido pelo usuário (UDT), você deve definir os operadores < e == para seu UDT. <myclass>Por exemplo, se você exportar vetor < MyClass >, você deve definir MyClass::operator < and MyClass operador ==. Isso ocorre porque todas as classes de contêiner STL ter membro operadores de comparação que requerem a existência dos operadores < e == para o tipo contido. Normalmente, esses não são instanciados, porque eles não são usados. Quando você criar uma instância de uma classe de modelo, todas as funções de membro são geradas. Porque as classes de contêiner STL tem funções de membro que usam os operadores < e == para o tipo contido, você deve implementá-los. Se a comparação de objetos do seu UDT não faz sentido, você pode definir os operadores de comparação para simplesmente retornar "true".

Quando _DLL símbolo é definido durante a compilação (esse símbolo implicitamente é definido durante a compilação com /MD ou /MDd para vincular com a versão DLL do tempo de execução C), as seguintes classes STL e vários globais operadores e funções que operam dessas classes, já são exportados pela DLL de tempo de execução C. Portanto, você não pode exportá-los de sua DLL. Isso não deve causar um problema para o programa executável que importa sua classe, desde que ele usa também a versão DLL do C Runtime:
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)
				
para detalhes específicos sobre quais parâmetros de modelo são usados e quais funções globais e os operadores são declarados, por favor consulte o arquivo de cabeçalho relevantes.

Código de exemplo

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

Referências

Para obter informações adicionais, procure sobre os seguintes tópicos na Ajuda do Visual C++:
Instanciação explícita
__declspec
pilha
/ MD, ML, /MT /LD (usar Run-Time Library)

Propriedades

ID do artigo: 168958 - Última revisão: terça-feira, 6 de setembro de 2005 - Revisão: 3.0
A informação contida neste artigo aplica-se 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
Palavras-chave: 
kbmt kbstl kbinfo kbcode kbhowto KB168958 KbMtpt
Tradução automática
IMPORTANTE: Este artigo foi traduzido por um sistema de tradução automática (também designado por Machine Translation ou MT), não tendo sido portanto traduzido ou revisto por pessoas. A Microsoft possui artigos traduzidos por aplicações (MT) e artigos traduzidos por tradutores profissionais, com o objetivo de oferecer em português a totalidade dos artigos existentes na base de dados de suporte. No entanto, a tradução automática não é sempre perfeita, podendo conter erros de vocabulário, sintaxe ou gramática. A Microsoft não é responsável por incoerências, erros ou prejuízos ocorridos em decorrência da utilização dos artigos MT por parte dos nossos clientes. A Microsoft realiza atualizações freqüentes ao software de tradução automática (MT). Obrigado.
Clique aqui para ver a versão em Inglês deste artigo: 168958

Submeter comentários

 

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