Разбиение динамически размещенного массива без линейного копирования по времени

Я не думаю, что вы можете иметь только часть динамического массива, освобожденную путем отслеживания указателей и длины. Однако вы можете подделать это, создав новый класс для управления стартовым массивом, выделив его, как вы хотите, и сохраните его с помощью std :: shared_ptr.

Вы просто возвращаете класс, содержащий shared_ptr в память, простой указатель на первый элемент и размер массива. Когда текущий класс Array выходит за пределы области действия, shared_ptr уменьшается, и когда больше не используются фрагменты памяти, память освобождается.

Вы должны быть осторожны с этим, так как могут быть несколько объектов, ссылающихся на одну и ту же память, но есть способы вокруг этого (например, маркировка оригинала недействительна после разделения с помощью bool).

[Изменить] Ниже представлена очень простая реализация этой идеи. Оператор split() может быть легко реализован с помощью операций 2 slice(). Я не уверен, как вы хотите реализовать это с точки зрения вашего примера выше, так как я не уверен, как вы управляете своим vector<bool> **, но если вы хотите разделить vector<bool>, вы может создать экземпляр ShareVector<bool>, или если у вас есть массив vector<bool>, вместо этого сделайте SharedVector<vector<bool>>.

#ifndef __SharedVector__
#define __SharedVector__

#include <memory>
#include <assert.h>

template <typename T>
class SharedVector {

    std::shared_ptr<T> _data;
    T *_begin;
    size_t _size;
    // perhaps add size_t capacity if need for limited resizing arises.

public:
    SharedVector<T>(size_t const size)
    : _data(std::shared_ptr<T>(new T[size], []( T *p ) { delete[] p; })), _begin(_data.get()), _size(size)
    {}

    // standard copy and move constructors work fine

    // pass shared_ptr by reference to avoid unnecessary refcount changes
    SharedVector<T>(std::shared_ptr<T> &data, T *begin, size_t size)
    : _data(data), _begin(begin), _size(size)
    {}

    T& operator[] (const size_t nIndex) {
        assert(nIndex < _size);

        return _begin[nIndex];
    }  

    T const & operator[] (const size_t nIndex) const {
        assert(nIndex < _size);

        return _begin.get()[nIndex];
    }

    size_t size(){
        return _size;
    }

    SharedVector<T> slice(size_t const begin, size_t const end) {
        assert(begin + end < _size);

        return SharedVector<T>(_data, _begin + begin, end - begin);
    }

    T *begin() {
        return _begin;
    }

    T *end() {
        return _begin + _size;
    }
};

#endif