Copy diretiva classes ATL
Cópia diretiva classes são classes de utilitário usado para inicializar, copiar e excluir dados.Copiar diretiva classes permitem que você para definir a semântica de cópia para qualquer tipo de dados e para definir as conversões entre diferentes tipos de dados.
ATL usa cópia diretiva classes em suas implementações dos seguintes modelos:
Encapsulando sistema autônomo informações necessárias para copiar ou converter dados em uma classe de diretiva de cópia que pode ser passada sistema autônomo argumento de modelo, sistema autônomo desenvolvedores ATL foi fornecido para reutilização extrema dessas classes.Por exemplo, se você precisar implementar uma coleção usando qualquer tipo de dados arbitrários, tudo o que você precisa fornecer é a diretiva apropriada de cópia; você nunca precisará tocar o código que implementa a coleção.
Definição
Por definição, uma classe que fornece as seguintes funções estáticas é uma cópia diretiva classe:
static void init(DestinationType* p);
static HRESULT copy(DestinationType* pTo, const SourceType* pFrom);
static void destroy(DestinationType* p);
Você pode substituir a tipos de DestinationType e SourceType com tipos de dados arbitrários para cada diretiva de cópia.
.gif "Observação") Observação: |
|---|
Apesar de poder definir cópia diretiva classes de qualquer tipo de dados arbitrários, usar as classes de I n código ATL deve limitar os tipos que fazem sentido.Para exemplo , ao usar uma classe de diretiva de cópia com Do ATL implementações de coleção ou enumerador, DestinationType deve ser um tipo que pode ser usado sistema autônomo um parâmetro em um método de interface COM. |
Use init inicializar dados, cópia para copiar dados e destruir para liberar os dados.O significado preciso de inicialização, a cópia e a destruição são o domínio da classe da diretiva de cópia e apresentará variação dependendo dos tipos de dados envolvidos.
Há dois requisitos na implementação de uma cópia e uso diretiva classe:
O primeiro parâmetro para cópia deve receber apenas um ponteiro para dados que você tenha anteriormente inicializado usando init.
destruir deve receber apenas um ponteiro para dados que você tenha anteriormente inicializado usando init ou copiados por meio de cópia.
Implementações padrão
ATL fornece dois cópia diretiva classes na forma do _Copy and _CopyInterface classes de modelo:
The _Copy classe permite homogêneo copiando somente (não a conversão entre tipos de dados), pois ela oferece apenas um parâmetro de modelo único para especificar os dois DestinationType e SourceType.A implementação genérica deste modelo não contém nenhum código de inicialização ou destruição e usa memcpy Para copiar os dados. ATL também fornece especializações em de _Copy for VARIANTE, LPOLESTR, OLEVERB, and CONNECTDATA tipos de dados.
The _CopyInterface classe fornece uma implementação para copiar os ponteiros de interface seguindo as regras COM padrão.Mais uma vez essa classe permite apenas homogêneos copiar, para que ele usa atribuição simples e uma telefonar para AddRef para executar a cópia.
Implementações personalizadas
Normalmente, você precisará definir sua própria cópia diretiva classes para heterogêneos copiar (ou seja, a conversão entre tipos de dados).Para obter alguns exemplos de classes de política de cópia personalizada, examine os arquivos VCUE_Copy.h e VCUE_CopyString.h no ATLCollections amostra.Esses arquivos contêm classes de diretiva de cópia do modelo de duas, GenericCopy e MapCopy, além de um número de especializações em de GenericCopy diferentes tipos de dados.
GenericCopy
GenericCopy permite que você especifique a SourceType and DestinationType sistema autônomo argumentos de modelo. Aqui é a forma mais geral do GenericCopy classe do VCUE_Copy.h:
template <class DestinationType, class SourceType = DestinationType>
class GenericCopy
{
public :
typedef DestinationType destination_type;
typedef SourceType source_type;
static void init(destination_type* p)
{
_Copy<destination_type>::init(p);
}
static void destroy(destination_type* p)
{
_Copy<destination_type>::destroy(p);
}
static HRESULT copy(destination_type* pTo, const source_type* pFrom)
{
return _Copy<destination_type>::copy(pTo, const_cast<source_type*>(pFrom));
}
}; // class GenericCopy
VCUE_Copy.h também contém as seguintes especializações em desta classe: GenericCopy<BSTR>, GenericCopy<VARIANT, BSTR>, GenericCopy<BSTR, VARIANT>.VCUE_CopyString.h contém especializações em para copiar de STD::Strings: GenericCopy<std::string>, GenericCopy<VARIANT, std::string>, e GenericCopy<BSTR, std::string>. Você pode aprimorar GenericCopy fornecendo mais especializações em seus próprios.
MapCopy
MapCopy pressupõe-se de que os dados que estão sendo copiados serão armazenados em um MAP de estilo STL, para que ele permite que você especifique o tipo de MAP na qual os dados são armazenados e digite o destino. A implementação da classe usa apenas typedefs fornecida pelo MapType classe para determinar o tipo de dados de fonte e para chamar o apropriado GenericCopy classe. Nenhum especializações em dessa classe são necessários.
template <class MapType, class DestinationType = MapType::referent_type>
class MapCopy
{
public :
typedef DestinationType destination_type;
typedef typename MapType::value_type source_type;
typedef MapType map_type;
typedef typename MapType::referent_type pseudosource_type;
static void init(destination_type* p)
{
GenericCopy<destination_type, pseudosource_type>::init(p);
}
static void destroy(destination_type* p)
{
GenericCopy<destination_type, pseudosource_type>::destroy(p);
}
static HRESULT copy(destination_type* pTo, const source_type* pFrom)
{
return GenericCopy<destination_type, pseudosource_type>::copy(pTo, &(pFrom->second));
}
}; // class MapCopy