Bagaimana menangani perubahan desain untuk penghentian auto_ptr di C ++ 11?

Kami sedang menguji perpustakaan di bawah C ++ 11 (yaitu, -std=c++11). Perpustakaan menggunakan auto_ptrdan pola ini:

Foo* GetFoo()
{
    autoptr<Foo> ptr(new Foo);

    // Initialize Foo
    ptr->Initialize(...);

    // Now configure remaining attributes
    ptr->SomeSetting(...);

    return ptr.release();
}

C ++ 11 sudah usang auto_ptr, jadi kami ingin menjauh darinya.

Namun, kode ini mendukung C ++ 03 dan C ++ 11, jadi tidak sesederhana menarik auto_ptr. Perlu juga disebutkan bahwa perpustakaan tidak memiliki dependensi eksternal. Ini menggunakan C ++ 03; dan tidak menggunakan Autotools, Cmake, Boost, ...

Bagaimana seharusnya kita menangani perubahan desain untuk menjauh dari auto_ptrC ++ 11 sambil mempertahankan kompatibilitas dengan C ++ 03?

Dalam sebagian besar hal std::unique_ptrpenggantian dilakukan untuk menjadi pengganti (tetapi lebih aman) std::auto_ptr, sehingga harus ada sangat sedikit (jika ada) perubahan kode yang diperlukan selain (seperti yang Anda minta) mengarahkan kode untuk menggunakan salah satu unique_ptratau auto_ptr.

Ada beberapa cara untuk melakukan ini (dan masing-masing dilengkapi dengan daftar pengorbanan sendiri) di bawah ini. Mengingat contoh kode yang diberikan, saya akan memilih salah satu dari dua opsi pertama .

Pilihan 1

#if __cplusplus >= 201103L
template <typename T>
using auto_ptr = std::unique_ptr<T>;
#else
using std::auto_ptr;
#endif

Pengorbanan;

• Anda memperkenalkan auto_ptrnama ke ruang nama global; Anda dapat mengurangi ini dengan mendefinisikannya sebagai namespace "pribadi" Anda sendiri
• Setelah bermigrasi ke C ++ 17 (saya percaya auto_ptrakan sepenuhnya dihapus), Anda dapat lebih mudah mencari dan mengganti

pilihan 2

template <typename T>
struct my_ptr {
    #if __cplusplus >= 201103L
    typedef std::unique_ptr<T> ptr;
    #else
    typedef std::auto_ptr<T> ptr;
    #endif
};

Pengorbanan;

• Mungkin lebih rumit untuk dikerjakan, semua auto_ptrkebutuhan saat ini diubah dalam kode menjadi sepertimy_ptr<T>::ptr
• Keamanan yang lebih baik tidak diperkenalkan ke namespace global

Opsi 3

Agak kontroversial, tetapi jika Anda siap untuk menerima peringatan memiliki stdkelas sebagai basis

#if __cplusplus >= 201103L
template <typename T>
using my_ptr = std::unique_ptr<T>;
#else
template <typename T>
class my_ptr : public std::auto_ptr<T> {
  // implement the constructors for easier use
  // in particular
  explicit my_ptr( X* p = 0 ) : std::auto_ptr(p) {}
};
#endif

Pengorbanan;

• Jangan mencoba menggunakan kelas yang diwariskan di mana basis virtual (khususnya wrt yang bukan-virtual destruktor) akan diharapkan. Bukan berarti ini harus menjadi masalah dalam kasus ini - tetapi sadari
• Sekali lagi, perubahan kode
• Ketidakcocokan namespace potensial - semuanya tergantung pada bagaimana kelas pointer digunakan untuk memulai

Opsi 4

Bungkus pointer dalam kelas baru dan agregasikan fungsi yang diperlukan untuk anggota

template <typename T>
class my_ptr { // could even use auto_ptr name?
  #if __cplusplus >= 201103L
  std::unique_ptr<T> ptr_;
  #else
  std::auto_ptr<T> ptr_;
  #endif

  // implement functions required...
  T* release() { return ptr_.release(); }
};

Pengorbanan;

• Sedikit ekstrem ketika semua yang Anda inginkan adalah "menukar" implementasi keluar

Opsi 5: Alias ​​langsung.

#if __cplusplus >= 201103L
template<typename T> 
using MyPtr = std::unique_ptr<T>;
#else 
#define MyPtr std::auto_ptr
#endif 

Pengorbanan:

1. Untuk versi bahasa yang lebih baru, AKA C ++ 11 dan yang lebih baru, alias Anda ketik memetakan ke smart pointer yang benar. Kode pengguna apa pun yang sebenarnya bergantung pada API khusus untuk std :: auto_ptr akan ditandai oleh kompiler, yang merupakan jaminan utama bahwa itu akan benar-benar diperbaiki.

2. Dalam mode Legacy c ++ 03 jenis alias adalah makro. Ini kasar, tetapi sintaks yang dihasilkan MyPtr<T>akan identik dengan kasus C ++ 11 sepanjang sisa kode.

3. Anda harus menemukan dan mengubah semua variabel auto_ptr Anda MyPtruntuk mengaturnya.