Partilhar via

Diretiva #import (C++)

específicos do C++

Usado para incorporar informações de uma biblioteca de tipos. O conteúdo da biblioteca de tipos é convertido em classes C++, principalmente descrevendo as interfaces COM.

Sintaxe

#import "nome do arquivo" [atributos]
<#import> [atributos]

Parâmetros

nome do ficheiro
Especifica a biblioteca de tipos a ser importada. O nome do arquivo pode ser um dos seguintes tipos:

  • O nome de um arquivo que contém uma biblioteca de tipos, como um arquivo .olb, .tlb ou .dll. A palavra-chave, file:, pode preceder cada nome de arquivo.

  • O progid de um controle na biblioteca de tipos. A palavra-chave, progid:, pode preceder cada progid. Por exemplo:

    #import "progid:my.prog.id.1.5"

    Para obter mais informações sobre progids, consulte Especificando o ID de localização e o número da versão.

    Quando você usa um compilador cruzado de 32 bits em um sistema operacional de 64 bits, o compilador só pode ler a seção do Registro de 32 bits. Talvez você queira usar o compilador nativo de 64 bits para criar e registrar uma biblioteca de tipos de 64 bits.

  • O ID da biblioteca da biblioteca de tipos. A palavra-chave, libid:, pode preceder cada ID de biblioteca. Por exemplo:

    #import "libid:12341234-1234-1234-1234-123412341234" version("4.0") lcid("9")

    Se você não especificar version ou lcid, as regras aplicadas também progid: serão aplicadas ao libid:.

  • Um ficheiro executável (.exe).

  • Um arquivo de biblioteca (.dll) contendo um recurso de biblioteca de tipos (como um .ocx).

  • Um documento composto que contém uma biblioteca de tipos.

  • Qualquer outro formato de arquivo que possa ser compreendido pela API LoadTypeLib .

atributos
Um ou mais atributos #import. Separe atributos com um espaço ou vírgula. Por exemplo:

#import "..\drawctl\drawctl.tlb" no_namespace, raw_interfaces_only

-ou-

#import "..\drawctl\drawctl.tlb" no_namespace raw_interfaces_only

Observações

Ordem de pesquisa para o nome do ficheiro

filename é opcionalmente precedido por uma especificação de diretório. O nome do arquivo deve nomear um arquivo existente. A diferença entre as duas formas de sintaxe é a ordem em que o pré-processador procura os arquivos da biblioteca de tipos quando o caminho é especificado incompletamente.

Forma de sintaxe Ação
Formulário cotado Instrui o pré-processador a procurar arquivos de biblioteca de tipos primeiro no diretório do arquivo que contém a instrução #import e, em seguida, nos diretórios de quaisquer arquivos que incluam (#include) esse arquivo. Em seguida, o pré-processador pesquisa ao longo dos caminhos mostrados abaixo.
Forma de colchete angular Instrui o pré-processador a procurar arquivos de biblioteca de tipos nos seguintes caminhos:

1. A lista de caminhos de PATH variáveis de ambiente
2. A lista de caminhos de LIB variáveis de ambiente
3. O caminho especificado pela opção de compilador /I , exceto que o compilador está procurando por uma biblioteca de tipos que foi referenciada de outra biblioteca de tipos com o atributo no_registry .

Especifique o ID de localização e o número da versão

Ao especificar um progid, você também pode especificar o ID de localização e o número da versão do progid. Por exemplo:

#import "progid:my.prog.id" lcid("0") version("4.0)

Se você não especificar um ID de localização, um progid será escolhido de acordo com as seguintes regras:

  • Se houver apenas um ID de localização, esse ID será usado.

  • Se houver mais de um ID de localização, o primeiro com o número de versão 0, 9 ou 409 será usado.

  • Se houver mais de um ID de localização e nenhum deles for 0, 9 ou 409, o último será usado.

  • Se você não especificar um número de versão, a versão mais recente será usada.

Arquivos de cabeçalho criados por importação

#import cria dois arquivos de cabeçalho que reconstroem o conteúdo da biblioteca de tipos no código-fonte C++. O arquivo de cabeçalho primário é semelhante ao produzido pelo compilador Microsoft Interface Definition Language (MIDL), mas com código e dados adicionais gerados pelo compilador. O arquivo de cabeçalho primário tem o mesmo nome base que a biblioteca de tipos, mais um arquivo . Extensão TLH. O arquivo de cabeçalho secundário tem o mesmo nome base que a biblioteca de tipos, com um arquivo . Extensão TLI. Ele contém as implementações para funções de membro geradas pelo compilador e está incluído (#include) no arquivo de cabeçalho primário.

Se importar uma propriedade dispinterface que usa byref parâmetros, #import não gerará uma instrução __declspec(property) para a função.

Ambos os arquivos de cabeçalho são colocados no diretório de saída especificado pela opção /Fo (name object file). Eles são então lidos e compilados pelo compilador como se o arquivo de cabeçalho primário fosse nomeado por uma #include diretiva.

As seguintes otimizações do compilador vêm com a diretiva #import :

  • O arquivo de cabeçalho, quando criado, recebe o mesmo carimbo de data/hora que a biblioteca de tipos.

  • Quando #import é processado, o compilador primeiro verifica se o cabeçalho existe e está up-to-date. Se sim, então ele não precisa ser recriado.

A diretiva #import também participa da reconstrução mínima e pode ser colocada em um arquivo de cabeçalho pré-compilado. Para obter mais informações, consulte Criando arquivos de cabeçalho pré-compilados.

Arquivo de cabeçalho da biblioteca de tipos primários

O arquivo de cabeçalho da biblioteca de tipos primários consiste em sete seções:

  • Título clichê: Consiste em comentários, #include declaração para COMDEF. H (que define algumas macros padrão usadas no cabeçalho) e outras informações diversas de configuração.

  • Forward references e typedefs: Consiste em declarações de estrutura como struct IMyInterface e typedefs.

  • Declarações de ponteiro inteligente: A classe _com_ptr_t de modelo é um ponteiro inteligente. Ele encapsula ponteiros de interface e elimina a necessidade de chamar AddRef, Releasee QueryInterface funções. Ele também oculta a CoCreateInstance chamada ao criar um novo objeto COM. Esta seção usa a instrução _COM_SMARTPTR_TYPEDEF macro para estabelecer typedefs de interfaces COM como especializações de modelo da classe de modelo _com_ptr_t . Por exemplo, para a interface IMyInterface, o . O arquivo TLH conterá:

    _COM_SMARTPTR_TYPEDEF(IMyInterface, __uuidof(IMyInterface));

    que o compilador expandirá para:

    typedef _com_ptr_t<_com_IIID<IMyInterface, __uuidof(IMyInterface)> > IMyInterfacePtr;

    O tipo IMyInterfacePtr pode então ser usado no lugar do ponteiro IMyInterface*de interface bruto. Consequentemente, não há necessidade de chamar as várias IUnknown funções de membro

  • Declarações Typeinfo: Consiste principalmente em definições de classe e outros itens que expõem os itens typeinfo individuais retornados pelo ITypeLib::GetTypeInfo. Nesta seção, cada typeinfo da biblioteca de tipos é refletida no cabeçalho em um formulário dependente das TYPEKIND informações.

  • Definição de GUID de estilo antigo opcional: contém inicializações das constantes GUID nomeadas. Estes nomes têm a forma CLSID_CoClass e IID_Interface, semelhantes aos gerados pelo compilador MIDL.

  • #include para o cabeçalho secundário da biblioteca de tipos.

  • Rodapé clichê: Atualmente inclui #pragma pack(pop).

Todas as seções, exceto a seção clichê de cabeçalho e a seção clichê de rodapé, são incluídas em um namespace com seu nome especificado pela library instrução no arquivo IDL original. Você pode usar os nomes do cabeçalho da biblioteca de tipos por uma qualificação explícita usando o nome do namespace. Ou, você pode incluir a seguinte instrução:

using namespace MyLib;

imediatamente após a instrução #import no código-fonte.

O namespace pode ser suprimido usando o atributo no_namespace) da diretiva #import . No entanto, suprimir o namespace pode levar a colisões de nome. O namespace também pode ser renomeado pelo atributo rename_namespace .

O compilador fornece o caminho completo para qualquer dependência de biblioteca de tipos exigida pela biblioteca de tipos que está processando no momento. O caminho é gravado, na forma de comentários, no cabeçalho da biblioteca de tipos (. TLH) que o compilador gera para cada biblioteca de tipos processada.

Se uma biblioteca de tipos incluir referências a tipos definidos em outras bibliotecas de tipos, o . O arquivo TLH incluirá comentários do seguinte tipo:

//
// Cross-referenced type libraries:
//
//  #import "c:\path\typelib0.tlb"
//

O nome do arquivo real no comentário #import é o caminho completo da biblioteca de tipos de referência cruzada, conforme armazenado no registro. Se você encontrar erros causados por definições de tipo ausentes, verifique os comentários no cabeçalho do . TLH para ver quais bibliotecas de tipos dependentes podem precisar ser importadas primeiro. Os erros prováveis são erros de sintaxe (por exemplo, C2143, C2146, C2321), C2501 (especificadores decl ausentes) ou C2433 ('inline' não permitido na declaração de dados) durante a compilação do arquivo . Arquivo TLI.

Para resolver erros de dependência, determine quais dos comentários de dependência não são fornecidos pelos cabeçalhos do sistema e, em seguida, forneça uma diretiva #import em algum momento antes da diretiva #import da biblioteca de tipos dependentes.

#import atributos

#import pode opcionalmente incluir um ou mais atributos. Esses atributos dizem ao compilador para modificar o conteúdo dos cabeçalhos da biblioteca de tipos. Um símbolo de barra invertida (\) pode ser usado para incluir linhas adicionais em uma única instrução #import . Por exemplo:

#import "test.lib" no_namespace \
   rename("OldName", "NewName")

Para obter mais informações, consulte #import atributos.

específicos do END C++

Ver também

Diretivas de pré-processador
Suporte COM do compilador

  • Last updated on