Třídy zásady kopírování ATL

Článek
10/12/2023

Třídy zásad kopírování jsou třídy nástrojů používané k inicializaci, kopírování a odstraňování dat. Třídy zásad kopírování umožňují definovat sémantiku kopírování pro libovolný typ dat a definovat převody mezi různými datovými typy.

ATL ve svých implementacích následujících šablon používá třídy zásad kopírování:

Zapouzdřením informací potřebných ke zkopírování nebo převodu dat do třídy zásad kopírování, kterou lze předat jako argument šablony, vývojáři KNIHOVNY ATL poskytli extrémní opětovnou použitelnost těchto tříd. Pokud například potřebujete implementovat kolekci pomocí libovolného datového typu, stačí zadat příslušnou zásadu kopírování; Nikdy se nemusíte dotýkat kódu, který implementuje kolekci.

Definice

Podle definice je třída, která poskytuje následující statické funkce, třída zásad kopírování:

static void init( DestinationType * p);

static HRESULT copy( DestinationType * pTo, const SourceType * pFrom);

static void destroy( DestinationType * p);

Typy DestinationType a Typ zdroje můžete nahradit libovolnými datovými typy pro každou zásadu kopírování.

Poznámka:

I když můžete definovat třídy zásad kopírování pro libovolné datové typy, použití tříd v kódu ATL by mělo omezit typy, které mají smysl. Pokud například používáte třídu zásad kopírování s implementací knihovny ATL nebo enumerátoru, musí být typem, DestinationType který lze použít jako parametr v metodě rozhraní MODELU COM.

Inicializace dat, kopírování a kopírování dat a zničení, aby se data uvolnila, použijte inicializaci. Přesný význam inicializace, kopírování a zničení jsou doména třídy zásad kopírování a bude se lišit v závislosti na příslušných datových typech.

Existují dva požadavky na použití a implementaci třídy zásad kopírování:

První parametr pro kopírování musí přijímat pouze ukazatel na data, která jste dříve inicializovali pomocí inicializace.
destroy musí vždy přijímat ukazatel na data, která jste dříve inicializovali pomocí inicializace nebo zkopírování prostřednictvím kopírování.

Standardní implementace

ATL poskytuje dvě třídy zásad kopírování ve formě _Copy tříd šablony:_CopyInterface

Třída _Copy umožňuje homogenní kopírování (nikoli převod mezi datovými typy), protože nabízí pouze jeden parametr šablony pro zadání obou DestinationType typů i SourceType. Obecná implementace této šablony neobsahuje kód inicializace ani zničení a používá memcpy se ke kopírování dat. ATL také poskytuje specializace _Copy pro datové typy VARIANT, LPOLESTR, OLEVERB a CONNECTDATA.
Třída _CopyInterface poskytuje implementaci pro kopírování ukazatelů rozhraní následující standardní pravidla modelu COM. Opět tato třída umožňuje pouze homogenní kopírování, takže používá jednoduché přiřazení a volání k AddRef provedení kopie.

Vlastní implementace

Obvykle budete muset definovat vlastní třídy zásad kopírování pro heterogenní kopírování (to znamená převod mezi datovými typy). V některých příkladech vlastních tříd zásad kopírování se podívejte na soubory VCUE_Copy.h a VCUE_CopyString.h v ukázce ATLCollections . Tyto soubory obsahují dvě třídy GenericCopy zásad kopírování šablon a MapCopyplus řadu specializace GenericCopy pro různé datové typy.

GenericCopy

GenericCopy umožňuje zadat Typ zdroje a DestinationType jako argumenty šablony. Tady je nejobecnější forma GenericCopy třídy z 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 obsahuje také následující specializace této třídy: GenericCopy<BSTR>, GenericCopy<VARIANT, BSTR>, GenericCopy<BSTR, VARIANT>. VCUE_CopyString.h obsahuje specializace pro kopírování z std::strings: GenericCopy<std::string>, GenericCopy<VARIANT, std::string>a GenericCopy<BSTR, std::string>. Můžete ho vylepšit GenericCopy tím, že poskytnete další specializace.

MapCopy

MapCopy Předpokládá, že data, která se kopírují, jsou uložena do mapy standardní knihovny jazyka C++, takže umožňuje určit typ mapy, ve kterém jsou data uložena, a cílový typ. Implementace třídy pouze používá typedefs dodané MapType třídy k určení typu zdrojových dat a volání příslušné GenericCopy třídy. Nejsou potřeba žádné specializace této třídy.

template <class MapType, class DestinationType = MapType::mapped_type>
class MapCopy
{
public :
   typedef DestinationType               destination_type;
   typedef typename MapType::value_type  source_type;
   
   typedef MapType                       map_type;
   typedef typename MapType::mapped_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

Viz také

Implementace kolekce založené na standardní knihovně C++
Ukázka ATLCollections

Sdílet prostřednictvím