Extending the namespace `std`

From cppreference.net

Inhaltsverzeichnis

Hinzufügen von Deklarationen zu `std`

Es ist undefiniertes Verhalten, Deklarationen oder Definitionen zum Namensraum std oder zu einem beliebigen innerhalb von std geschachtelten Namensraum hinzuzufügen, mit wenigen unten aufgeführten Ausnahmen.

#include <utility>
namespace std
{
    // Eine Funktionsdefinition, die zum Namespace std hinzugefügt wurde: undefiniertes Verhalten
    pair<int, int> operator+(pair<int, int> a, pair<int, int> b)
    {
        return {a.first + b.first, a.second + b.second};
    }
}

Hinzufügen von Template-Spezialisierungen

Klassentemplates

Es ist erlaubt, Template-Spezialisierungen für jede Standardbibliothek-Klassentemplate zum Namensraum std hinzuzufügen, nur wenn die Deklaration von mindestens einem programmdefinierten Typ abhängt und die Spezialisierung alle Anforderungen des ursprünglichen Templates erfüllt, außer wo solche Spezialisierungen verboten sind.

// Deklaration der primären std::hash-Vorlage einbinden.
// Wir dürfen sie nicht selbst deklarieren.
// <typeindex> garantiert das Vorhandensein einer solchen Deklaration,
// und ist deutlich günstiger einzubinden als <functional>.
#include <typeindex>
// Spezialisiere std::hash, damit MyType als Schlüssel in
// std::unordered_set und std::unordered_map verwendet werden kann.
// Das Öffnen des std-Namensraums kann unbeabsichtigt undefiniertes Verhalten verursachen
// und ist für die Spezialisierung von Klassenvorlagen nicht erforderlich.
template<>
struct std::hash<MyType>
{
    std::size_t operator()(const MyType& t) const { return t.hash(); }
};

Das Spezialisieren der Vorlage std::complex für andere Typen als float , double und long double ist nicht spezifiziert.

Spezialisierungen von std::numeric_limits müssen alle in der primären Template deklarierten Member definieren, und zwar so, dass sie als integral constant expressions verwendbar sind.

Keines der in <type_traits> definierten Templates darf für einen programmdefinierten Typ spezialisiert werden, außer für std::common_type und std::basic_common_reference (seit C++20) . Dies schließt die Type Traits und die Klassen-Template std::integral_constant ein.

Spezialisierungen von std::hash für programmdefinierte Typen müssen die Hash -Anforderungen erfüllen.

Spezialisierungen von std::atomic müssen einen gelöschten Kopierkonstruktor, einen gelöschten Kopierzuweisungsoperator und einen constexpr-Wertkonstruktor besitzen.

Spezialisierungen von std::shared_ptr und std::weak_ptr müssen CopyConstructible und CopyAssignable sein. Zusätzlich müssen Spezialisierungen von std::shared_ptr LessThanComparable sein und in bool konvertierbar sein.

Spezialisierungen von std::istreambuf_iterator müssen einen trivialen Kopierkonstruktor, einen constexpr-Standardkonstruktor und einen trivialen Destruktor besitzen.

(seit C++11)

std::unary_function und std::binary_function dürfen nicht spezialisiert werden.

(bis C++17)

Es ist undefiniertes Verhalten, eine vollständige oder teilweise Spezialisierung eines beliebigen Member-Klassentemplates einer Standardbibliotheksklasse oder Klassentemplate zu deklarieren.