Kopieren von Objekten mit verschiedenen Zuweisern in C++

Question

So habe ich eine schöne hartnäckige Allokator-Klasse , die ermöglicht mir C++ Container-Objekte und Zeichenfolgen im persistenten Speicher, die von einer Mmap-Datei unterstützt wird, die von einem Lauf von meinem Programm auf die beibehalten werden kann Nächster.

Mein Problem kommt, wenn ich etwas tun möchte, das persistente und nicht persistente Objekte mischt. Zum Beispiel habe ich

typedef std::basic_string<char, std::char_traits<char>, persistent_alloc<char>> pstring; 

pstring a, b, c; 
std::string x, y, z; 

Ich will die Dinge zu tun, wie in der Lage sein:

if (a == x) 
    a = y; 
c = z + b; 

und so weiter, aber standardmäßig ist es nicht funktioniert, wie pstring und std::string nicht verwandten Arten sind. Nun, was den Vergleich betrifft, kann ich definieren:

template<typename Alloc1, typename Alloc2> inline bool 
operator==(const std::basic_string<char, std::char_traits<char>, Alloc1> &a, 
      const std::basic_string<char, std::char_traits<char>, Alloc2> &b) 
{ 
    return strcmp(a.c_str(), b.c_str()) == 0; 
} 

... und jetzt kann ich Zeichenfolgen für die Gleichheit vergleichen. Aber diese für jede Operation hinzuzufügen scheint wie ein Schmerz - es scheint, als ob sie von der Standardbibliothek bereitgestellt werden sollten. Schlimmer noch, Zuweisungsoperatoren und Kopierkonstruktoren müssen Mitglieder sein und können nicht als globale Inline-Funktionen wie diese definiert werden.

Gibt es einen vernünftigen Weg, dies zu tun? Oder muss ich die gesamte Standardbibliothek neu schreiben, um Zuweiser sinnvoll zu unterstützen?

Answer 1

Es gibt einen Weg, damit umzugehen, aber Sie müssen etwas außerhalb der Box denken. Was Sie brauchen, ist ein Zwischentyp, der implizit sowohl von std::string als auch von Ihrem Allokator-String konstruiert werden kann.

Es gibt eine proposal for such a thing before the C++ committee currently. Es basiert auf einem Google-built Apache-licensed implementation that already exists. Es heißt basic_string_ref; Es ist eine Vorlagenklasse, die im Grunde genommen ein Zeiger auf das erste Zeichen in einer Zeichenfolge und eine Größe ist, die die Länge der Zeichenfolge darstellt. Es ist kein echter Container in dem Sinne, dass es nicht die Speicherverwaltung übernimmt.

Welches ist genau das, was Sie brauchen.

basic_string_ref für einen bestimmten Zeichentyp und Eigenschaften Typ ist implizit konstruierbar aus einem std::basic_stringunabhängig von Allocator.

Alle Vergleichsoperatoren können in basic_string_ref definiert werden. Da es implizit von std::basic_string (und praktisch frei zu konstruieren) konstruiert werden kann, würde es transparent für Vergleiche zwischen unterschiedlich zugewiesenen Strings funktionieren.

Doing Zuordnung ist eher knifflig, aber machbar. Es erfordert eine Reihe von Konvertierungen:

a = pstring{basic_string_ref{y}}; 

Nicht der hübscheste Code, natürlich. Wir würden es vorziehen, einfach den Kopierkonstruktor und den Zuweisungsoperator std::basic_string als Zuweisungsagenten zu ändern. Aber da das nicht machbar ist, ist das wirklich das nächstbeste.Man könnte sogar in einer Template-Funktion wickeln:

template<typename DestAllocator, typename SourceAllocator, typename charT, typename traits> 
std::basic_string<charT, traits, DestAllocator> conv_str(const std::basic_string<charT, traits, SourceAllocator> &input) 
{ 
    return std::basic_string<charT, traits, DestAllocator>{basic_string_ref<charT, traits>{y}}; 
} 

Natürlich, wenn Sie das tun können, können Sie einfach tun:

template<typename DestAllocator, typename SourceAllocator, typename charT, typename traits> 
std::basic_string<charT, traits, DestAllocator> conv_str(const std::basic_string<charT, traits, SourceAllocator> &input) 
{ 
    return std::basic_string<charT, traits, DestAllocator>{y.begin(), y.end()}; 
} 

Es wäre toll, wenn dies nur war Teil std::basic_string, damit Sie die Problemumgehungen nicht benötigen. Aber es ist nicht.