std:: aligned_storage

Stellt den geschachtelten Typ type bereit, der TrivialType und StandardLayoutType erfüllt und geeignet ist als nicht initialisierter Speicher für jedes Objekt, dessen Größe höchstens Len beträgt und dessen Ausrichtungsanforderung ein Teiler von Align ist.

Der Standardwert von Align ist die strengste (größte) Ausrichtungsanforderung für jedes Objekt, dessen Größe höchstens Len beträgt. Wenn der Standardwert nicht verwendet wird, muss Align dem Wert von alignof ( T ) für einen Typ T entsprechen, andernfalls ist das Verhalten undefiniert.

Das Verhalten ist undefiniert, wenn Len == 0 .

Es ist implementierungsdefiniert, ob eine erweiterte Ausrichtung unterstützt wird.

Wenn das Programm Spezialisierungen für std::aligned_storage hinzufügt, ist das Verhalten undefiniert.

Mitgliedertypen

Hilfstypen

Hinweise

Der von std::aligned_storage<>::type definierte Typ kann verwendet werden, um nicht initialisierte Speicherblöcke zu erstellen, die geeignet sind, Objekte eines gegebenen Typs aufzunehmen, optional mit einer strengeren Ausrichtung als ihre natürliche Ausrichtungsanforderung, beispielsweise an einer Cache- oder Seitenbegrenzung.

Wie bei jedem anderen nicht initialisierten Speicher werden die Objekte mit placement new erstellt und mit expliziten Destruktoraufrufen zerstört.

Mögliche Implementierung

Mit Ausnahme von Standardargumenten ist aligned_storage durch alignas ausdrückbar:

template<std::size_t Len, std::size_t Align = /* default alignment not implemented */>
struct aligned_storage
{
    struct type
    {
        alignas(Align) unsigned char data[Len];
    };
};

Beispiel

#include <cstddef>
#include <iostream>
#include <new>
#include <string>
#include <type_traits>
template<class T, std::size_t N>
class static_vector
{
    // Properly aligned uninitialized storage for N T's
    std::aligned_storage_t<sizeof(T), alignof(T)> data[N];
    std::size_t m_size = 0;
public:
    // Create an object in aligned storage
    template<typename ...Args> void emplace_back(Args&&... args)
    {
        if (m_size >= N) // Possible error handling
            throw std::bad_alloc{};
        // Construct value in memory of aligned storage using inplace operator new
        ::new(&data[m_size]) T(std::forward<Args>(args)...);
        ++m_size;
    }
    // Access an object in aligned storage
    const T& operator[](std::size_t pos) const
    {
        // Note: std::launder is needed after the change of object model in P0137R1
        return *std::launder(reinterpret_cast<const T*>(&data[pos]));
    }
    // Destroy objects from aligned storage
    ~static_vector()
    {
        for (std::size_t pos = 0; pos < m_size; ++pos)
            // Note: std::launder is needed after the change of object model in P0137R1
            std::destroy_at(std::launder(reinterpret_cast<T*>(&data[pos])));
    }
};
int main()
{
    static_vector<std::string, 10> v1;
    v1.emplace_back(5, '*');
    v1.emplace_back(10, '*');
    std::cout << v1[0] << '\n' << v1[1] << '\n';
}

*****
**********

Siehe auch