ATL Copy Policy Classes
Le classi criteri di copia sono classi di utilità utilizzato per inizializzare, copia ed eliminazione dei dati. Le classi criteri di copia consentono di definire la semantica di copia per qualsiasi tipo di dati e definire le conversioni tra tipi di dati diversi.
ATL utilizza le classi criteri di copia nelle implementazioni dei seguenti modelli:
Incapsulamento delle informazioni necessarie per copiare o convertire i dati in una classe criteri di copia che può essere passata come argomento di modello, gli sviluppatori ATL forniti all'estremità riutilizzo delle classi. Ad esempio, se è necessario implementare una raccolta utilizzando qualsiasi tipo di dati arbitrario, è sufficiente fornire ai criteri di copia appropriati; è necessario non alterare mai il codice per implementare la raccolta.
Definizione
Per definizione, la classe che fornisce le seguenti funzioni statiche è una classe di criteri di copia:
static void init(DestinationType* p);
static HRESULT copy(DestinationType* pTo, const SourceType* pFrom);
static void destroy(DestinationType* p);
È possibile sostituire i tipi DestinationType e SourceType con tipi di dati arbitrari per ogni criteri di copia.
Nota
Sebbene sia possibile definire classi criteri di copia per qualsiasi tipo di dati arbitrari, l'utilizzo delle classi nel codice ATL deve limitare i tipi che hanno significato.Ad esempio quando si utilizza la classe criteri di copia con le implementazioni della raccolta o enumeratore ATL, DestinationType deve essere un tipo che può essere utilizzato come parametro in un metodo di un'interfaccia COM.
Utilizzare init per inizializzare i dati, copy per copiare i dati e destroy per liberare i dati. Il significato esatto di inizializzazione, copiare e la distruzione del dominio della classe criteri di copia e variano a seconda dei tipi di dati utilizzati.
Esistono due requisiti sull'utilizzo e sull'implementazione di una classe di criteri di copia:
Il primo parametro a copy deve ricevere solo un puntatore ai dati precedentemente inizializzato utilizzando init.
destroy deve ricevere solo mai un puntatore ai dati precedentemente inizializzato utilizzando init o copiato tramite copy.
Implementazioni standard
ATL fornisce due classi criteri di copia sotto forma di classi modello _CopyInterface e _Copy :
La classe _Copy consente di copiare solo omogenea (non conversione tra tipi di dati) poiché offre un solo parametro di modello per specificare sia DestinationType che SourceType. L'implementazione generica di questo modello non contiene inizializzazione o codice di distruzione e utilizza memcpy per copiare i dati. ATL fornisce inoltre le specializzazioni _Copy per VARIANT, LPOLESTR, CONNECTDATA e OLEVERB.
La classe _CopyInterface fornisce un'implementazione per i puntatori a interfaccia di copia che seguono le regole COM standard. Nuovamente questa classe consente solo la copia omogenea, pertanto utilizza una semplice assegnazione e una chiamata a AddRef per eseguire la copia.
Implementazioni personalizzate
In genere, è necessario definire classi criteri di copia per copiare eterogenea ovvero conversione tra tipi di dati). Per alcuni esempi di classi criteri di copia personalizzate, l'aspetto dei file VCUE_Copy.h e VCUE_CopyString.h nell'esempio ATLCollections. Questi file sono contenute due classi criteri di copia del modello, GenericCopy e MapCopy, nonché una serie di specializzazioni GenericCopy per i tipi di dati diversi.
GenericCopy
GenericCopy consente di specificare il SourceType e DestinationType come argomenti. Di seguito viene riportata la forma più generale della classe GenericCopy in 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 contiene anche le specializzazioni di questa classe: GenericCopy<BSTR>, GenericCopy<VARIANT, BSTR>, GenericCopy<BSTR, VARIANT>. VCUE_CopyString.h contiene le specializzazioni per la copia da std::stringoggetti: GenericCopy<std::string>, GenericCopy<VARIANT, std::string>e GenericCopy<BSTR, std::string>. È possibile migliorare GenericCopy fornendo ulteriori specializzazioni personalizzati.
MapCopy
MapCopy presuppone che i dati che vengono copiati siano archiviati in un mapping stile STL, che consentono di specificare il tipo di mapping in cui vengono archiviati i dati e il tipo di destinazione. L'implementazione della classe utilizza solo i typedef forniti dalla classe di MapType per determinare il tipo di dati di origine e chiamare la classe appropriata GenericCopy. Nessuna di specializzazione di questa classe è necessario.
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