Puis-je détacher un std :: vecteur à partir des données qu'il contient?

Je donne une réponse à la question initiale ci-dessous. Cependant, gardez à l'esprit que dans la plupart des cas à l'aide de vecteur :: data () code> et réorganisant le code de sorte que le vecteur mentionné ne sort pas de la portée, à l'aide d'un vecteur différent initialisé avec vecteur ( STD :: Move (StreverVector)) CODE> ou Swapping Contenu avec un autre vecteur ( Vector :: Swap (StreverVector) code>) est la meilleure option comme indiqué dans d'autres réponses.

Néanmoins Il existe un moyen de détacher les données d'un vecteur à l'aide d'un allocator personnalisé. Les éléments suivants implémentent l'allocator noalloc code> qui ne fait absolument rien. Il n'allocie pas / ne construit ni ne gêne ni négocie les choses. De plus, il ne contient aucune variables non statiques ou virtuelles. Donc, cela ne devrait pas changer le contenu d'une instance de vecteur code>. Intérieur Détachdata ​​Code> Nous jetons un vecteur ordinaire à un vecteur utilisant le type d'allocator susmentionné en réinterprétant son type et déplacez son contenu sur un nouveau vecteur avec le même allocateur. Lorsque le nouveau vecteur fonctionne hors de portée, il essaiera de détruire et de brancher son contenu. Cependant, comme nous avons annulé cette fonctionnalité dans notre allocator personnalisé cela ne fait absolument rien. La fonction renvoie un pointeur sur les données nouvellement détachées du vecteur d'origine (qui contient maintenant une nullptr sous forme de données et d'éléments zéro). N'oubliez pas de détruire et de négocier les éléments de la matrice manuellement après! P>

#include <iostream>
#include <vector>
#include <new>

// Our custom allocator
template <class T>
struct Noalloc {
    typedef T value_type;
    Noalloc() = default;
    template <class U> constexpr Noalloc(const Noalloc<U>&) noexcept {}
    T* allocate(std::size_t n)
    {
        return nullptr;
    }
    void deallocate(T* p, std::size_t) noexcept {}
    template<class... Args> void construct(T* p, Args&&... args) {}
    void destroy(T* p) {}
};
template <class T, class U>
bool operator==(const Noalloc<T>&, const Noalloc<U>&) { return true; }
template <class T, class U>
bool operator!=(const Noalloc<T>&, const Noalloc<U>&) { return false; }

// detach the data from a vector and return its pointer
template<typename T>
    T* detachData(std::vector<T>& vec)
{
    T* dataPtr = vec.data();
    // swap contents with a new vector
    // that uses "Noalloc" as allocator but is otherwise identical
    std::vector<T, Noalloc<T>> detachHelper
        (std::move(*reinterpret_cast<std::vector<T, Noalloc<T>>*>(&vec)));
    return dataPtr;
    // "detachHelper" runs out of scope here
    // But it will neither destruct nor deallocate
    // given data due to our custom allocator
}

// destroy and deallocate the data manually
template<typename T>
    void destroyData(T* data, size_t n, size_t capacity)
{
    // should be pretty self explanatory...
    std::allocator<T> alloc;
    for(size_t i = 0; i < n; i++)
    {
        std::allocator_traits<std::allocator<T>>::destroy(alloc, data+i);
    }
    std::allocator_traits<std::allocator<T>>::deallocate(alloc, data, capacity);
}

int main()
{
    int* testData = nullptr;
    size_t size = 0;
    // For vectors data size and actually allocated size
    // may differ. So we need to keep track of both.
    // If you want to avoid this you may call "vector::shrink_to_fit()"
    // This should resize the vector to fit its data.
    // However the implementation is not required to fulfill this request.
    // So beware!
    size_t capacity = 0;
    {
        std::vector<int> test{1,2,3,4};
        // copy size and data pointer
        size = test.size();
        capacity = test.capacity();
        testData = detachData(test);
        // "test" runs out of scope here.
        // However after calling "detachData(test)"
        // it doesn't contain any data
    }
    // Print the contents of the array
    for(size_t i = 0; i < size; i++)
    {
        std::cout << testData[i] << std::endl;
    }
    // Don't forget to destroy the data yourself!
    // The original vector doesn't exist anymore
    destroyData(testData, size, capacity);
    std::cout << "data destroyed successfully" << std::endl;
}