Wie gehe ich mit Designänderungen für auto_ptr in C ++ 11 um?

Wir testen eine Bibliothek unter C ++ 11 (dh -std=c++11). Die Bibliothek verwendet auto_ptrund dieses Muster:

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

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

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

    return ptr.release();
}

C ++ 11 ist veraltet auto_ptr, daher möchten wir uns davon entfernen.

Der Code unterstützt jedoch sowohl C ++ 03 als auch C ++ 11 auto_ptr. Erwähnenswert ist auch, dass die Bibliothek keine externen Abhängigkeiten aufweist. Es verwendet C ++ 03; und verwendet keine Autotools, Cmake, Boost, ...

Wie sollen wir mit den Designänderungen umgehen, um uns von auto_ptrC ++ 11 zu entfernen, während die Kompatibilität mit C ++ 03 erhalten bleibt?

In den meisten Hinsichten wurde das std::unique_ptrals Ersatz (aber sicherer) gemacht std::auto_ptr, so dass nur sehr wenige (wenn überhaupt) Codeänderungen erforderlich sein sollten, außer (wie Sie verlangen), den Code entweder unique_ptroder zu verwenden auto_ptr.

Es gibt einige Möglichkeiten, dies zu tun (und jede hat ihre eigenen Listenkompromisse). Angesichts des bereitgestellten Codebeispiels würde ich eine der beiden ersten Optionen bevorzugen .

Option 1

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

Kompromisse;

• Sie fügen den auto_ptrNamen in den globalen Namespace ein. Sie können dies abschwächen, indem Sie festlegen, dass es sich um Ihren eigenen "privaten" Namespace handelt
• Sobald Sie auf C ++ 17 migriert haben (ich glaube, das auto_ptrwird komplett entfernt), können Sie einfacher suchen und ersetzen

Option 2

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

Kompromisse;

• Wahrscheinlich umständlicher in der Arbeit, der gesamte aktuelle auto_ptrCode muss auf so etwas wie geändert werdenmy_ptr<T>::ptr
• Aus Sicherheitsgründen werden die Namen nicht in den globalen Namespace übernommen

Option 3

Etwas umstritten, aber wenn Sie bereit sind, die Einschränkungen einer stdKlasse als Basis in Kauf zu nehmen

#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

Kompromisse;

• Versuchen Sie nicht, die geerbte Klasse zu verwenden, bei der eine virtuelle Basis (insbesondere für den nicht virtuellen Destruktor) erwartet wird. Nicht, dass dies ein Problem sein sollte - aber seien Sie sich dessen bewusst
• Auch hier ändert sich der Code
• Mögliche Namespace-Konflikte - alles hängt davon ab, wie die Zeigerklasse verwendet wird

Option 4

Schließen Sie die Zeiger in eine neue Klasse ein und aggregieren Sie die erforderlichen Funktionen für das Mitglied

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

Kompromisse;

• Ein wenig extrem, wenn Sie nur die Implementierungen "austauschen" möchten

Option 5: Direkter Alias.

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

Kompromisse:

1. Bei neueren Sprachversionen, AKA C ++ 11 und höher, wird Ihr Alias-Typ dem richtigen Smart Pointer zugeordnet. Jeder Benutzercode, der tatsächlich von APIs abhängt, die für std :: auto_ptr spezifisch sind, wird vom Compiler markiert. Dies ist die ultimative Garantie dafür, dass er wirklich repariert wird.

2. Im Legacy-C ++ 03-Modus ist der Typ-Alias ​​ein Makro. Dies ist grob, aber die resultierende Syntax MyPtr<T>ist im Rest des Codes identisch mit der von C ++ 11.

3. Sie müssen alle auto_ptr-Variablen MyPtrin suchen und ändern , um dies einzurichten.