Como lidar com alterações de design para reprovação de auto_ptr no C ++ 11?

Estamos testando uma biblioteca em C ++ 11 (ou seja, -std=c++11). A biblioteca usa auto_ptre esse padrão:

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

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

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

    return ptr.release();
}

O C ++ 11 foi descontinuado auto_ptr, então queremos nos afastar dele.

No entanto, o código suporta C ++ 03 e C ++ 11, portanto, não é tão simples quanto puxar auto_ptr. Também vale mencionar que a biblioteca não possui dependências externas. Ele usa C ++ 03; e não usa Autotools, Cmake, Boost, ...

Como devemos lidar com as alterações de design para se afastar do auto_ptrC ++ 11, mantendo a compatibilidade com o C ++ 03?

Em muitos aspectos, a std::unique_ptrsubstituição foi feita (mas é mais segura) std::auto_ptr, portanto, deve haver muito poucas (se houver) alterações de código necessárias além de (como você pede) direcionando o código para usar um unique_ptrou outro auto_ptr.

Existem algumas maneiras de fazer isso (e cada uma vem com suas próprias vantagens e desvantagens da lista) abaixo. Dado o exemplo de código fornecido, eu preferiria uma das duas primeiras opções .

Opção 1

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

Tradeoffs;

• Você introduz o auto_ptrnome no espaço para nome global; você pode atenuar isso definindo que é seu próprio espaço para nome "privado"
• Depois de migrar para o C ++ 17 (acredito auto_ptrque será completamente removido), você poderá pesquisar e substituir mais facilmente

opção 2

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

Tradeoffs;

• Provavelmente mais complicado de se trabalhar, toda a auto_ptrnecessidade atual mudou de código para algo comomy_ptr<T>::ptr
• Melhor segurança: os nomes não estão sendo introduzidos no espaço de nomes global

Opção 3

Um tanto controverso, mas se você estiver preparado para aguentar as advertências de ter uma stdclasse como base

#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

Tradeoffs;

• Não tente usar a classe herdada onde seria esperada uma base virtual (em particular, o destruidor não virtual). Não que isso deva ser um problema no caso - mas esteja ciente disso
• Novamente, o código muda
• Possíveis incompatibilidades de espaço para nome - tudo depende de como a classe do ponteiro é usada para começar

Opção 4

Coloque os ponteiros em uma nova classe e agregue as funções necessárias ao membro

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(); }
};

Tradeoffs;

• Um pouco extremo quando tudo o que você realmente deseja é "trocar" as implementações

Opção 5: Alias ​​direto.

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

Compensações:

1. Para versões mais recentes do idioma, AKA C ++ 11 e posterior, seu tipo de alias é mapeado para o ponteiro inteligente correto. Qualquer código de usuário que realmente dependa de APIs específicas para std :: auto_ptr será sinalizado pelo compilador, que é a garantia máxima de que realmente será corrigido.

2. No modo Legacy c ++ 03, o alias de tipo é uma macro. Isso é grosseiro, mas a sintaxe resultante MyPtr<T>será idêntica ao caso do C ++ 11 em todo o restante do código.

3. Você precisa encontrar e alterar todas as suas variáveis ​​auto_ptr MyPtrpara configurar isso.