ATL Copy Policy Classes

Kelas kebijakan salin adalah kelas utilitas yang digunakan untuk menginisialisasi, menyalin, dan menghapus data. Kelas kebijakan salin memungkinkan Anda menentukan semantik salinan untuk semua jenis data, dan untuk menentukan konversi antara jenis data yang berbeda.

ATL menggunakan kelas kebijakan salin dalam implementasi templat berikut:

• CComEnumImpl

• IEnumOnSTLImpl

• ICollectionOnSTLImpl

Dengan merangkum informasi yang diperlukan untuk menyalin atau mengonversi data dalam kelas kebijakan salinan yang dapat diteruskan sebagai argumen templat, pengembang ATL telah menyediakan penggunaan kembali kelas-kelas ini secara ekstrem. Misalnya, jika Anda perlu menerapkan koleksi menggunakan jenis data arbitrer apa pun, yang perlu Anda berikan adalah kebijakan penyalinan yang sesuai; Anda tidak perlu menyentuh kode yang mengimplementasikan koleksi.

Definisi

Menurut definisi, kelas yang menyediakan fungsi statis berikut adalah kelas kebijakan salinan:

static void init( DestinationType * p);

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

static void destroy( DestinationType * p);

Anda dapat mengganti jenis DestinationType dan SourceType dengan jenis data arbitrer untuk setiap kebijakan penyalinan.

Gunakan init untuk menginisialisasi data, menyalin untuk menyalin data, dan menghancurkan untuk membebaskan data. Arti yang tepat dari inisialisasi, penyalinan, dan penghancuran adalah domain kelas kebijakan salin dan akan bervariasi tergantung pada jenis data yang terlibat.

Ada dua persyaratan tentang penggunaan dan implementasi kelas kebijakan salinan:

• Parameter pertama yang akan disalin hanya boleh menerima penunjuk ke data yang sebelumnya telah Anda inisialisasi menggunakan init.

• menghancurkan hanya boleh menerima pointer ke data yang sebelumnya telah Anda inisialisasi menggunakan init atau disalin melalui salinan.

Implementasi Standar

ATL menyediakan dua kelas kebijakan salinan dalam bentuk _Copy kelas templat dan _CopyInterface :

• Kelas ini _Copy hanya memungkinkan penyalinan homogen (bukan konversi antar jenis data) karena hanya menawarkan satu parameter templat untuk menentukan dan DestinationType SourceType. Implementasi generik templat ini tidak berisi inisialisasi memcpy atau kode penghancuran dan digunakan untuk menyalin data. ATL juga menyediakan spesialisasi _Copy untuk jenis data VARIAN, LPOLESTR, OLEVERB, dan CONNECTDATA.

• Kelas ini _CopyInterface menyediakan implementasi untuk menyalin penunjuk antarmuka mengikuti aturan COM standar. Sekali lagi kelas ini hanya memungkinkan penyalinan homogen, sehingga menggunakan penugasan sederhana dan panggilan untuk AddRef melakukan salinan.

Implementasi Kustom

Biasanya, Anda harus menentukan kelas kebijakan salinan Anda sendiri untuk penyalinan heterogen (yaitu, konversi antar jenis data). Untuk beberapa contoh kelas kebijakan salinan kustom, lihat file VCUE_Copy.h dan VCUE_CopyString.h dalam sampel ATLCollections . File-file ini berisi dua kelas kebijakan salinan templat, GenericCopy dan MapCopy, ditambah sejumlah spesialisasi GenericCopy untuk jenis data yang berbeda.

GenericCopy

GenericCopy memungkinkan Anda menentukan SourceType dan DestinationType sebagai argumen templat. Berikut adalah bentuk GenericCopy kelas yang paling umum dari 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 juga berisi spesialisasi berikut dari kelas ini: GenericCopy<BSTR>, , GenericCopy<VARIANT, BSTR>GenericCopy<BSTR, VARIANT>. VCUE_CopyString.h berisi spesialisasi untuk menyalin dari std::strings: GenericCopy<std::string>, GenericCopy<VARIANT, std::string>, dan GenericCopy<BSTR, std::string>. Anda dapat meningkatkan GenericCopy dengan memberikan spesialisasi lebih lanjut dari Anda sendiri.

MapCopy

MapCopy mengasumsikan bahwa data yang disalin disimpan ke dalam peta gaya Pustaka Standar C++, sehingga memungkinkan Anda menentukan jenis peta tempat data disimpan dan jenis tujuan. Implementasi kelas hanya menggunakan typedef yang disediakan oleh kelas MapType untuk menentukan jenis data sumber dan untuk memanggil kelas yang sesuai GenericCopy . Tidak ada spesialisasi kelas ini yang diperlukan.

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

Lihat juga

Menerapkan Koleksi Berbasis Pustaka Standar C++
Sampel ATLCollections