Classes de stratégie de copie ATL
Les classes de stratégie de copie sont classes de service utilisé pour initialiser, copier, et supprimer des données.Les classes de stratégie de copie vous permettent de définir la sémantique de copie pour un type de données, et pour définir des conversions entre des types de données.
ATL utilise des classes de stratégie de copie dans ses implémentations des modèles suivants :
En encapsulant les informations nécessaires pour copier ou convertir des données dans une classe de stratégie de copie qui peut être passée comme argument template, les développeurs ATL est attendu la réutilisabilité extrême de ces classes.Par exemple, si vous devez implémenter une collection à l'aide de n'importe quel type de données arbitraire, tout ce que vous devez fournir est la stratégie de copie appropriée ; vous devez jamais toucher le code qui implémente la collection.
Définition
Par définition, une classe qui fournit les fonctions statiques suivantes est une classe de stratégie de copie :
static void init(DestinationType* p);
static HRESULT copy(DestinationType* pTo, const SourceType* pFrom);
static void destroy(DestinationType* p);
Vous pouvez remplacer les types DestinationType et SourceType par les types de données arbitraires pour chaque stratégie de copie.
[!REMARQUE]
Bien que vous puissiez définir des classes de stratégie de copie pour tous les types de données arbitraires, l'utilisation des classes dans le code ATL doit limiter les types qui ont un sens.Par exemple, lorsque vous utilisez une classe de stratégie de copie avec les implémentations de la collection ou de l'énumérateur ATL, DestinationType doit être un type qui peut être utilisé comme paramètre dans une méthode d'interface COM.
Utilisez INIT pour initialiser des données, copy pour copier des données, et destroy pour libérer les données.La signification exacte de l'initialisation, la copie, et la destruction sont le champ de la classe de stratégie de copie et varient en fonction de les types de données impliqués.
Il existe deux spécifications sur l'implémentation d'utilisation d'une classe de stratégie de copie :
Le premier paramètre à copy doit accepter uniquement un pointeur vers les données que vous avez précédemment initialisées à l'aide de INIT.
destroy doit uniquement jamais recevoir un pointeur vers les données que vous avez précédemment initialisées à l'aide de INIT ou avez copiées via copy.
Implémentations standard
ATL fournit deux classes de stratégie de copie sous la forme de classes de modèle de _Copy et de _CopyInterface :
La classe de _Copy permet de copier homogène uniquement (pas conversion entre types de données) parce qu'elle offre uniquement un seul paramètre de modèle pour spécifier DestinationType et SourceType.L'implémentation générique de ce modèle ne contient aucune initialisation ou code de destruction et utilise memcpy pour copier des données.ATL fournit également des spécialisations de _Copy pour variant, LPOLESTR, des types de données d' OLEVERB, et de CONNECTDATA .
La classe de _CopyInterface fournit une implémentation pour copier des pointeurs d'interface qui suivent les règles standard COM.De nouveau cette classe permet uniquement la copie homogène, elle utilise l'assignation simple et un appel à AddRef pour effectuer la copie.
Implémentations personnalisées
En général, vous devrez définir vos propres classes de stratégie de copie de la copie hétérogène (autrement dit, conversion entre types de données).Pour quelques exemples des classes personnalisées de stratégie de copie, examinez les fichiers VCUE_Copy.h et VCUE_CopyString.h dans l'exemple de ATLCollections .Ces fichiers contiennent deux classes de stratégie de copie de modèle, GenericCopy et MapCopy, ainsi que plusieurs spécialisations d' GenericCopy pour différents types de données.
.gif "td6kz9x0.collapse_all(fr-fr,VS.110).gif")
GenericCopy
GenericCopy vous permet de spécifier le SourceType et DestinationType comme arguments template.Voici la forme la plus générale de la classe d' GenericCopy de 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 contient également les spécialisations suivantes de cette classe : GenericCopy<BSTR>, GenericCopy<VARIANT, BSTR>, GenericCopy<BSTR, VARIANT>.VCUE_CopyString.h contient les spécialisations de copie de std::strings : GenericCopy<std::string>, GenericCopy<VARIANT, std::string>, et GenericCopy<BSTR, std::string>.Vous pouvez améliorer GenericCopy en fournissant d'autres spécialisations de votre choix.
MapCopy
MapCopy suppose que les données qui sont copiées sont stockées dans un mappage de style STL, elles vous permettent de spécifier le type de mappage dans lequel les données sont stockées et le type de destination.L'implémentation de la classe utilise uniquement les typedefs fournis par la classe de MapType pour déterminer le type des données sources et appeler la classe appropriée d' GenericCopy .Une spécialisation de cette classe n'est requise.
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