是否有必要“嵌套”释放 std::vector<pair<vector<int>,int>> 中的保留内存以手动释放它？答案

【问题标题】：Is it necessary a "nested" freeing of reserved memory in a std::vector<pair<vector<int>,int>> for manually free it?是否有必要“嵌套”释放 std::vector<pair<vector<int>,int>> 中的保留内存以手动释放它？
【发布时间】：2017-05-24 12:46:46
【问题描述】：

我有：

vector< pair<vector<int> , int> > mapped_samples;

这是非常大的。我会手动释放内存。我知道一个简单向量的技巧是：

vector<int> simple_vector;
vector<int>().swap(simple_vector);

在我的情况下没关系：

vector<pair<vector<int> , int>>().swap(mapped_samples);

还是需要做一些嵌套操作？

（我使用的是 C++11）

【问题讨论】：

是什么让您认为需要进行嵌套交换？（包含向量在销毁时销毁它的子向量）
“释放”向量内存的正确方法是什么都不做
您能否扩展“我将手动释放内存。”，因为我觉得这是您的实际问题所在
@Umbert：嵌套的vectors 在你clear 时被破坏。从技术上讲，顶级vector 可能会在clear 之后保留空间来保存项目，但其内容必须被标准破坏。再往前走，您最多只能恢复为顶级vector 保留的空间（保留以防新东西被推到它上面）。
你看std::vector::shrink_to_fit./

标签： c++ c++11 memory-management

【解决方案1】：

如果您绝对必须保证在函数作用域退出之前清除vector，只需添加额外的作用域即可。

对于原始代码：

... myfunc(...) {

    ... stuff without vector ...

    vector< pair<vector<int> , int> > mapped_samples;

    ... stuff using vector ...

    ... more stuff without vector ...

}

为了确保vector 在东西停止使用后完全消失，只需添加大括号：

... myfunc(...) {

    ... stuff without vector ...

    {  // Start of vector's block scope
        vector< pair<vector<int> , int> > mapped_samples;

        ... stuff using vector ...

    }  // End of vector's block scope, guaranteed to be cleaned here

    ... more stuff without vector ...

}

这比swap 技巧（必须创建和销毁垃圾vector）更干净，更通用；它适用于所有 RAII 资源，实际上是使用std::lock_guard 的常用方式。

【讨论】：

【解决方案2】：

我怀疑您要问的是如何减少外部向量和所有嵌套向量的capacity。

如果是这种情况，那么您必须分别处理每个内部向量。

作为记录，swap 可能不会这样做，因为它的实现很可能只是交换 2 个向量的内部实现。

如果我想减少向量的容量，我可能会这样做：

#include <vector>
#include <iterator>


// general case
template<class Vector>
auto reduce_capacity_impl(Vector& target) -> Vector&
{
    auto temp = Vector();
    temp.reserve(target.size());
    auto first = std::make_move_iterator(target.begin());
    auto last = std::make_move_iterator(target.end());
    std::copy(first, last, std::back_inserter(temp));
    std::swap(temp, target);
    return target;
}

// vector of non-vector
template<class T, class A>
auto reduce_capacity(std::vector<T, A>& target) -> std::vector<T, A>&
{
    return reduce_capacity_impl(target);
};

// vector of vector
template<class T, class AOuter, class AInner>
auto reduce_capacity(std::vector<std::vector<T, AInner>, AOuter>& target) -> std::vector<std::vector<T, AInner>, AOuter>&
{
    for (auto& i : target)
    {
        reduce_capacity(i);
    }

    return reduce_capacity_impl(target);
};


int main()
{
    std::vector<std::vector<std::vector<int>>> iii;

    reduce_capacity(iii);
}

我可能弄错了，您要做的是清除向量并释放与其关联的所有内存。

在这种情况下，与空向量交换将满足您的需求。

【讨论】：