vector 释放内存 swap

本文详细阐述了 C++ STL 中的泛型算法 swap 和容器成员函数 swap 的使用及内存管理策略。通过示例展示了如何利用这些算法实现内存的有效释放,特别是通过容器成员函数 swap 来减少容器占用的内存空间,实现“收缩到合适”的内存管理。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

http://blog.csdn.net/jerryjbiao/article/details/7389233


 相信大家看到swap这个词都一定不会感到陌生,甚至会有这样想法:这不就是简单的元素交换嘛。的确,swap交换函数是仅次于Hello word这样老得不能老的词,然而,泛型算法东风,这个小小的玩意儿却在C++ STL中散发着无穷的魅力。本文不仅详细地阐述STL泛型算法swap,并借助泛型算法这股东风,展现STL容器中swap成员函数的神奇魅力。注意哦,泛型算法swap和容器中的swap成员函数,这是两个不同角度和概念哦!

     一、泛型算法swap

      老规矩,我们先来看看swap的函数原型:

[cpp]  view plain copy
  1. template <class T> void swap ( T& a, T& b )  
  2. {  
  3.   T c(a); a=b; b=c;  
  4. }  
  5.    
      函数原型超级简单吧,这里我们就不做过多的解释啦,下面我们还是通过一个简单的示例来熟悉熟悉它的使用吧。

但是vector的swap成员函数是怎么实现的?

[cpp]  view plain copy
  1. void swap(vector<_Tp, _Alloc>& __x) {  
  2.     __STD::swap(_M_start, __x._M_start);  
  3.     __STD::swap(_M_finish, __x._M_finish);  
  4.     __STD::swap(_M_end_of_storage, __x._M_end_of_storage);  
  5.   }  

仅仅是交换了指向的首尾指针和容量指针

      程序示例:

[cpp]  view plain copy
  1. /******************************************************************* 
  2.  * Copyright (C) Jerry Jiang 
  3.  *                
  4.  * File Name   : swap.cpp 
  5.  * Author      : Jerry Jiang 
  6.  * Create Time : 2012-3-24 4:19:31 
  7.  * Mail        : jbiaojerry@gmail.com 
  8.  * Blog        : http://blog.csdn.net/jerryjbiao  
  9.  *                
  10.  * Description : 简单的程序诠释C++ STL算法系列之十五                   
  11.  *               变易算法 : 元素交换swap    
  12.  *                
  13.  ******************************************************************/  
  14.   
  15. #include <iostream>  
  16. #include <algorithm>  
  17. #include <vector>  
  18. #include <iterator>  
  19.   
  20. using namespace std;  
  21.   
  22. int main ()   
  23. {  
  24.       
  25.     int x = 10, y = 20;                         // x:10 y:20  
  26.     swap(x, y);                              // x:20 y:10  
  27.       
  28.     vector<int> first (4, x), second (6, y);  // first:4x20 second:6x10  
  29.     swap(first, second);                     // first:6x10 second:4x20  
  30.       
  31.     cout << "first contains:";  
  32.     //使用一般的iterator方式输出first  
  33.     for (vector<int>::iterator it=first.begin();  it != first.end(); ++it)  
  34.     {  
  35.         cout << " " << *it;  
  36.     }  
  37.     cout << endl;  
  38.   
  39.     cout << "second contains: ";  
  40.     //使用copy()来实现second的输出  
  41.     copy(second.begin(), second.end(), ostream_iterator<int>(cout, " "));  
  42.     cout << endl;  
  43.       
  44.     return 0;  
  45. }  
          上面示例程序十分简单,只是为了巩固前文中copy算法的使用,我在程序中采用了两种方式进行输出,好了,泛型算法swap我们就不再废话了,现在我们来看看本文中的重头戏吧。

        二、容器中的成员函数swap

        在容器vector中,其内存占用的空间是只增不减的,比如说首先分配了10,000个字节,然后erase掉后面9,999个,则虽然有效元素只有一个,但是内存占用仍为10,000个。所有内存空间在vector析构时回收。

     一般,我们都会通过vector中成员函数clear进行一些清除操作,但它清除的是所有的元素,使vector的大小减少至0,却不能减小vector占用的内存。要避免vector持有它不再需要的内存,这就需要一种方法来使得它从曾经的容量减少至它现在需要的容量,这样减少容量的方法被称为“收缩到合适(shrink to fit)”。(节选自《Effective STL》)如果做到“收缩到合适”呢,嘿嘿,这就要全仰仗“Swap大侠”啦,即通过如下代码进行释放过剩的容量:

[cpp]  view plain copy
  1. vector< T >().swap(X)  
        下面我们通过一个简单的示例来show一下:

[cpp]  view plain copy
  1. /******************************************************************* 
  2.  * Copyright (C) Jerry Jiang 
  3.  *                
  4.  * File Name   : swap.cpp 
  5.  * Author      : Jerry Jiang 
  6.  * Create Time : 2012-3-24 4:19:31 
  7.  * Mail        : jbiaojerry@gmail.com 
  8.  * Blog        : http://blog.csdn.net/jerryjbiao  
  9.  *                
  10.  * Description : 简单的程序诠释C++ STL算法系列之十五                   
  11.  *               成员函数swap实现容器的内存释放    
  12.  *                
  13.  ******************************************************************/  
  14.   
  15. #include <iostream>  
  16. #include <algorithm>  
  17. #include <vector>  
  18. #include <iterator>  
  19.   
  20. using namespace std;  
  21.   
  22. int main ()   
  23. {  
  24.     int x = 10;  
  25.     vector<int> myvector(10000, x);    
  26.   
  27.     //这里打印仅仅是元素的个数不是内存大小  
  28.     cout << "myvector size:"  
  29.          << myvector.size()  
  30.          << endl;  
  31.   
  32.     //swap交换函数释放内存:vector<T>().swap(X);  
  33.     //T:int ; myvertor代表X  
  34.     vector<int>().swap(myvector);  
  35.   
  36.     //两个输出仅用来表示swap前后的变化  
  37.     cout << "after swap :"  
  38.          << myvector.size()  
  39.          << endl;  
  40.   
  41.     return 0;  
  42. }  
swap交换技巧实现内存释放思想:vector()使用vector的默认构造函数建立临时vector对象,再在该临时对象上调用swap成员,swap调用之后对象myvector占用的空间就等于一个默认构造的对象的大小,临时对象就具有原来对象v的大小,而该临时对象随即就会被析构,从而其占用的空间也被释放。

std::vector<T>().swap(X)

作用相当于:

{

std::vector<T>  temp(X);

temp.swap(X);

}


可以用类似的方法实现vector和string的适当收缩

[cpp]  view plain copy
  1. vector<int> vec(100000, 0);  
  2. for (int i = 0; i < 100000-2; ++i) vec.pop_back();  
  3. cout << vec.capacity() <<endl;  
  4. vector<int>(vec).swap(vec);  
  5. cout << vec.capacity() << endl;  


    注意:并不是所有的STL容器的clear成员函数的行为都和vector一样。事实上,其他容器的clear成员函数都会释放其内存。比如另一个和vector类似的顺序容器deque。

<think>好的,我现在需要回答用户关于如何释放`std::vector`内存的问题。首先,用户可能已经知道`std::vector`会自动管理内存,但他们可能遇到需要手动释放的情况,比如在内存紧张时减少容量。 首先,我得回忆一下`std::vector`的内存管理机制。`vector`有三个相关的概念:size、capacity和存储空间。size是当前元素数量,capacity是分配的内存可以容纳的元素数量。当元素被删除时,size减少,但capacity通常不变,这意味着内存没有被释放。用户可能希望减少capacity以释放未使用的内存。 接下来,我应该考虑标准的释放内存的方法。最常用的是`shrink_to_fit()`,这是C++11引入的成员函数,请求容器减少capacity到匹配size。不过需要注意,这个请求是非强制的,具体实现可能不会完全释放,但大多数现代编译器会处理。 然后是swap技巧,这在C++11之前常用。通过创建一个临时空vector,并与原vector交换,这样原vector的capacity会被临时vector的(即0)替代,从而释放内存。不过这种方法在C++11之后可能不如`shrink_to_fit()`直观,但仍然有效。 用户可能想知道哪种方法更推荐。需要指出在C++11及以上,优先使用`shrink_to_fit()`,因为它更简洁明了。而swap技巧则适用于旧标准或需要确保释放的情况。 另外,用户可能误以为`clear()`会释放内存。需要澄清`clear()`只销毁元素,将size设为0,但capacity不变,内存未被释放。这时候需要结合`shrink_to_fit()`或swap来真正减少内存占用。 还应该提到,`vector`的析构函数会自动释放所有内存,所以在vector生命周期结束时无需手动释放。问题主要出现在需要中途释放未使用的预留内存时。 可能需要举例说明两种方法的代码,比如使用`shrink_to_fit()`和使用swap的技巧。同时,提醒用户在某些情况下手动释放内存可能影响性能,因为重新分配内存需要时间,所以应在必要时才这样做。 最后,总结不同方法的适用场景,帮助用户根据具体情况选择最合适的方式。可能还需要提到C++17或20是否有新的方法,但据我所知目前主要还是这两种方式。</think>在C++中,`std::vector`的**内存释放逻辑**需要结合其设计特点来理解。以下是逐步分析和解决方案: --- ### **1. `std::vector`的内存管理机制** - **自动扩容**:当元素数量超过当前容量(`capacity()`)时,`vector`会自动分配更大的内存块(通常是原容量的1.5或2倍),并将旧数据拷贝到新内存中。 - **不自动缩容**:删除元素(如`pop_back()`或`erase()`)时,`size()`会减小,但`capacity()`通常**保持不变**,保留内存以便后续重用。 --- ### **2. 释放内存的两种核心方法** #### **(1) 方法1:`shrink_to_fit()`(C++11起)** - **作用**:请求容器将容量(`capacity()`)缩减至与当前大小(`size()`)匹配。 - **代码示例**: ```cpp std::vector<int> vec = {1, 2, 3, 4, 5}; vec.erase(vec.begin() + 2); // 删除第3个元素(size=4,capacity仍可能为5) vec.shrink_to_fit(); // capacity可能变为4 ``` - **注意**: - 这是一个“非强制请求”,具体实现可能忽略(但现代编译器普遍遵守)。 - 触发**内存重分配**,原有迭代器、指针、引用会失效。 #### **(2) 方法2:`swap`技巧(兼容所有C++标准)** - **原理**:通过交换临时空`vector`,强制释放未使用的内存。 - **代码示例**: ```cpp std::vector<int> vec = {1, 2, 3, 4, 5}; vec.erase(vec.begin() + 2); // size=4,capacity可能仍为5 std::vector<int>().swap(vec); // vec的capacity变为0(若需保留数据需调整) // 或保留现有元素但释放多余容量: std::vector<int>(vec).swap(vec); // 新vector用vec的数据构造,再交换 ``` - **注意**: - 完全释放内存时,`swap`会清空所有元素。 - 若需保留数据,需先通过拷贝构造新`vector`再交换。 --- ### **3. 常见误区** #### **`clear()`不会释放内存** ```cpp vec.clear(); // 仅将size设为0,capacity不变 vec.capacity(); // 仍为原值(如5) ``` - **结论**:`clear()`仅清空元素,**不释放内存**,需配合`shrink_to_fit()`或`swap`释放。 --- ### **4. 释放内存的完整操作流程** | 目标 | 操作步骤 | |-----------------------|--------------------------------------------------------------------------| | 清空并释放所有内存 | `vec.clear(); vec.shrink_to_fit();` 或 `std::vector<int>().swap(vec);` | | 保留数据但释放多余内存| `vec.shrink_to_fit();` 或 `std::vector<int>(vec).swap(vec);` | | 彻底销毁对象并释放内存| `vec.~vector<int>();` (通常无需手动调用,超出作用域时自动析构) | --- ### **5. 性能与使用场景建议** - **何时需要主动释放内存**: - 内存敏感环境(如嵌入式系统) - `vector`曾扩容到极大容量,后续只需少量内存时 - **注意事项**: - 频繁调用`shrink_to_fit()`或`swap`可能因内存重分配降低性能。 - 推荐在长期闲置的`vector`上使用,避免在关键性能路径中调用。 --- ### **6. 验证内存释放** 可通过以下代码观察内存变化: ```cpp std::vector<int> vec(1000); // capacity >= 1000 std::cout << "初始容量: " << vec.capacity() << std::endl; vec.resize(10); // size=10,capacity仍可能为1000 vec.shrink_to_fit(); // capacity可能变为10 std::cout << "释放后容量: " << vec.capacity() << std::endl; ``` --- ### **7. 扩展:C++17的`data()`与内存预分配** 若需直接操作底层数组,可通过`data()`获取指针,但内存释放仍需依赖`vector`的机制: ```cpp std::vector<int> vec(100); int* ptr = vec.data(); // 获取指向数组的指针 // 操作ptr[...]后,仍需通过vector自身释放内存 ``` --- 通过上述方法,可精准控制`std::vector`的内存占用。建议优先使用现代C++的`shrink_to_fit()`,兼容旧代码时使用`swap`技巧。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值