技术在于交流、沟通,本文为博主原创文章转载请注明出处并保持作品的完整性

C++11新增move()语法(我暂时交错右值引用),在前面我有一篇文章叫 C++11_右值引用 简单的介绍了右值引用类的实现,这节我主要介绍一下为什么move()会更高效.

这次主要以一个带右值引用的Person类,和vector做测试

首先我们先实现一个带右值引用的Person类

class Person
{ public:
static size_t DCtor; //记录默认构造函数调用次数
static size_t Ctor; //记录构造函数调用次数
static size_t CCtor;//记录拷贝函数调用次数
static size_t CAsgn;//记录赋值拷贝调用次数
static size_t MCtor;//记录move 构造调用次数
static size_t MAsgn;//记录move 赋值调用次数
static size_t Dtor;//记录析构函数调用次数 private:
int _age;
char* _name;
size_t _len;
void _test_name(const char *s)
{
_name = new char[_len+];
memcpy(_name, s, _len);
_name[_len] = '\0';
} public:
//default ctor
Person(): _age() , _name(NULL), _len(){ DCtor++;} Person(const int age, const char * p) : _age(age), _len(strlen(p)) {
_test_name(p);
Ctor++;
} //dctor
~Person(){
if(_name){
delete _name;
}
Dtor++;
} // copy ctor
Person (const Person& p):_age(p._age),_len(p._len){
_test_name(p._name);
CCtor++;
} //copy assignment
Person & operator=(const Person& p)
{
if (this != &p){
if(_name) delete _name;
_len = p._len;
_age = p._age;
_test_name(p._name);
}
else{
cout<< "self Assignment. Nothing to do." <<endl;
}
CAsgn++;
return *this;
} // move cotr , wihth "noexcept"
Person(Person&& p) noexcept :_age(p._age) , _name(p._name), _len(p._len){
MCtor++;
p._age = ;
p._name = NULL;//必须为NULL 如果你把这里设为空 那么这个函数走完之后将调用析够函数 因为当前的Person类 和你将要析够的Person的_name指向同一部分 析构部分见析构函数
}
// move assignment
Person& operator=(Person&& p) noexcept { if (this != &p)
{
if(_name) delete _name;
_age = p._age;
_len = p._len;
_name = p._name;
p._age = ;
p._len = ;
p._name = NULL;
}
MAsgn++;
return *this;
}
}; size_t Person::DCtor = ;
size_t Person::Ctor = ;
size_t Person::CCtor = ;
size_t Person::CAsgn = ;
size_t Person::MCtor = ;
size_t Person::MAsgn = ;
size_t Person::Dtor = ;

我们先看正常的拷贝构造函数

    Person (const Person& p):_age(p._age),_len(p._len){
_test_name(p._name);
CCtor++;
}

它是先申请一段新的内存,然后将传进参数咋赋值给新的内存,型似下图

我们在看move 构造函数

    // move cotr , wihth "noexcept"
Person(Person&& p) noexcept :_age(p._age) , _name(p._name), _len(p._len){
MCtor++;
p._age = ;
p._name = NULL;//必须为NULL 如果你把这里设为空 那么这个函数走完之后将调用析够函数 因为当前的Person类 和你将要析够的Person的_name指向同一部分 析构部分见析构函数
}

它值复制了指针,没有在去申请内存,就是我们常说的浅拷贝,它只是将原来指向数据的指针打断,然后将复制的指针指向数据,型似下图

只拷贝指针,当然比拷贝数据要快上很多


现在来验证一下上面的结论

template<typename M, typename NM>
void test_moveable(M c1, NM c2, long& value)
{
char buf[]; typedef typename iterator_traits<typename M::iterator>::value_type MyPerson;//萃取出type clock_t timeStart = clock();//记录起始时间
for(long i=; i<value; i++)
{
snprintf(buf,,"%d",rand());
auto ite = c1.end();
c1.insert(ite,MyPerson(,buf));
}
cout << "Move Person" << endl;
cout << "construction, milli-seconds: "<<(clock()-timeStart) << endl;//验证构造耗时
cout << "size()= " << c1.size() << endl;//验证测试基数 我这里用三百万做基数 output_Static_data(*c1.begin());
cout << "copy, milli-seconds: "<<(clock()-timeStart) << endl;//验证copy耗时 timeStart = clock();//
M c11(c1);
cout << "move copy, milli-seconds: "<<(clock()-timeStart) << endl;//验证move copy函数耗时 timeStart = clock();
M c12(std::move(c1));
cout << "move construction, milli-seconds: "<<(clock()-timeStart) << endl;//验证Move 构造耗时 timeStart = clock();
c11.swap(c12);//验证seap耗时
cout << "swap, milli-seconds: "<<(clock()-timeStart) << endl;
}

从测试结果中我们可以看出 拷贝构造与move构造的耗时差距是巨大的


我们来看一下C++11 vector中的move()的使用,下面是vector<>中的拷贝构造函数的源码

      /**
* @brief %Vector copy constructor.
* @param __x A %vector of identical element and allocator types.
*
* The newly-created %vector uses a copy of the allocation
* object used by @a __x. All the elements of @a __x are copied,
* but any extra memory in
* @a __x (for fast expansion) will not be copied.
*/
vector(const vector& __x)
: _Base(__x.size(),
_Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_finish =
std::__uninitialized_copy_a(__x.begin(), __x.end(),
this->_M_impl._M_start,
_M_get_Tp_allocator());
}

这里其实就是一个move的使用,这个拷只拷贝指针的函数(将__x.end()赋值给_M_finish,将__x.begin()赋值给_M_impl._M_start),只复制指针,当然效率会更高


vector中还有一处用到了move(),那就是vector的move 构造函数

      /**
* @brief %Vector move constructor.
* @param __x A %vector of identical element and allocator types.
*
* The newly-created %vector contains the exact contents of @a __x.
* The contents of @a __x are a valid, but unspecified %vector.
*/
vector(vector&& __x) noexcept
: _Base(std::move(__x)) { }

调用

      _Vector_base(_Vector_base&& __x) noexcept
: _M_impl(std::move(__x._M_get_Tp_allocator()))
{ this->_M_impl._M_swap_data(__x._M_impl); }

调用

    void _M_swap_data(_Vector_impl& __x) _GLIBCXX_NOEXCEPT
{
std::swap(_M_start, __x._M_start);
std::swap(_M_finish, __x._M_finish);
std::swap(_M_end_of_storage, __x._M_end_of_storage);
}

vector的move 构造函数 只是将上面的三个指针做了交换,也同样告诉了我们swap()耗时为什么也是这么短.

总结

move 给我们带来了更高效的语法,但是不要忘了,move的实质是浅拷贝,编程中尤其要注意浅拷贝的使用,因为浅拷贝一旦操作不当,可能造成不可预估的错误(如一个变量被删除两次)

上面介绍move虽然做了特殊处理,但是被move处理后的变量,依然不能再使用.(例:如果你使用了这段代码M c12(std::move(c1)); 那么在这之后一定不要在出现 c1 这个变量)

测试代码如下

#include <iostream>
#include <vector>
#include <string.h>//strlen()
#include <typeinfo>//typeid().name()
#include <iterator>
#include <ctime> using namespace std; class CNoMovePerson
{
public:
static size_t DCtor;
static size_t Ctor;
static size_t CCtor;
static size_t CAsgn;
static size_t MCtor;
static size_t MAsgn;
static size_t Dtor;
private:
int _age;
char* _name;
size_t _len;
void _test_name(const char *s)
{
_name = new char[_len+];
memcpy(_name, s, _len);
_name[_len] = '\0';
} public:
//default ctor
CNoMovePerson(): _age() , _name(NULL), _len(){DCtor++;} CNoMovePerson(const int age, const char * p) : _age(age), _len(strlen(p)) {
_test_name(p);
Ctor++;
} //dctor
~CNoMovePerson(){
if(_name){
delete _name;
}
Dtor++;
} // copy ctor
CNoMovePerson (const CNoMovePerson& p):_age(p._age),_len(p._len){
_test_name(p._name);
CCtor++;} //copy assignment
CNoMovePerson & operator=(const CNoMovePerson& p)
{
if (this != &p){
if(_name) delete _name;
_len = p._len;
_age = p._age;
_test_name(p._name);
}
else{
cout<< "self Assignment. Nothing to do." <<endl;
}
CAsgn++;
return *this;
}
}; size_t CNoMovePerson::DCtor = ;
size_t CNoMovePerson::Ctor = ;
size_t CNoMovePerson::CCtor = ;
size_t CNoMovePerson::CAsgn = ;
size_t CNoMovePerson::MCtor = ;
size_t CNoMovePerson::MAsgn = ;
size_t CNoMovePerson::Dtor = ; class Person
{ public:
static size_t DCtor;
static size_t Ctor;
static size_t CCtor;
static size_t CAsgn;
static size_t MCtor;
static size_t MAsgn;
static size_t Dtor; private:
int _age;
char* _name;
size_t _len;
void _test_name(const char *s)
{
_name = new char[_len+];
memcpy(_name, s, _len);
_name[_len] = '\0';
} public:
//default ctor
Person(): _age() , _name(NULL), _len(){ DCtor++;} Person(const int age, const char * p) : _age(age), _len(strlen(p)) {
_test_name(p);
Ctor++;
} //dctor
~Person(){
if(_name){
delete _name;
}
Dtor++;
} // copy ctor
Person (const Person& p):_age(p._age),_len(p._len){
_test_name(p._name);
CCtor++;
} //copy assignment
Person & operator=(const Person& p)
{
if (this != &p){
if(_name) delete _name;
_len = p._len;
_age = p._age;
_test_name(p._name);
}
else{
cout<< "self Assignment. Nothing to do." <<endl;
}
CAsgn++;
return *this;
} // move cotr , wihth "noexcept"
Person(Person&& p) noexcept :_age(p._age) , _name(p._name), _len(p._len){
MCtor++;
p._age = ;
p._name = NULL;//必须为NULL 如果你把这里设为空 那么这个函数走完之后将调用析够函数 因为当前的Person类 和你将要析够的Person的_name指向同一部分 析构部分见析构函数
}
// move assignment
Person& operator=(Person&& p) noexcept { if (this != &p)
{
if(_name) delete _name;
_age = p._age;
_len = p._len;
_name = p._name;
p._age = ;
p._len = ;
p._name = NULL;
}
MAsgn++;
return *this;
}
}; size_t Person::DCtor = ;
size_t Person::Ctor = ;
size_t Person::CCtor = ;
size_t Person::CAsgn = ;
size_t Person::MCtor = ;
size_t Person::MAsgn = ;
size_t Person::Dtor = ; template<typename T>
void output_Static_data(const T& myPerson)
{
cout << typeid(myPerson).name() << "--" << endl;
cout << "CCtor=" << T::CCtor <<endl
<< "MCtor=" << T::MCtor <<endl
<< "CAsgn=" << T::CAsgn <<endl
<< "MAsgn=" << T::MAsgn <<endl
<< "Dtor=" << T::Dtor <<endl
<< "Ctor=" << T::Ctor <<endl
<< "DCtor=" << T::DCtor <<endl
<< endl;
} template<typename M, typename NM>
void test_moveable(M c1, NM c2, long& value)
{
char buf[]; typedef typename iterator_traits<typename M::iterator>::value_type MyPerson; clock_t timeStart = clock();
for(long i=; i<value; i++)
{
snprintf(buf,,"%d",rand());
auto ite = c1.end();
c1.insert(ite,MyPerson(,buf));
}
cout << "Move Person" << endl;
cout << "construction, milli-seconds: "<<(clock()-timeStart) << endl;
cout << "size()= " << c1.size() << endl; output_Static_data(*c1.begin()); timeStart = clock();
M c11(c1);
cout << "copy, milli-seconds: "<<(clock()-timeStart) << endl; timeStart = clock();
M c12(std::move(c1));
cout << "move construction, milli-seconds: "<<(clock()-timeStart) << endl; timeStart = clock();
c11.swap(c12);
cout << "swap, milli-seconds: "<<(clock()-timeStart) << endl; cout << "------------------------------" << endl;
cout << "No Move Person" << endl; typedef typename iterator_traits<typename NM::iterator>::value_type MyPersonNoMove; timeStart = clock();
for(long i=; i<value; i++)
{
snprintf(buf,,"%d",rand());
auto ite = c2.end();
c2.insert(ite,MyPersonNoMove(,buf));
} cout << "construction, milli-seconds: "<<(clock()-timeStart) << endl;
cout << "size()= " << c2.size() << endl; output_Static_data(*c1.begin()); timeStart = clock();
NM c22(c2);
cout << "move copy, milli-seconds: "<<(clock()-timeStart) << endl; timeStart = clock();
NM c222(std::move(c2));
cout << "move construction, milli-seconds: "<<(clock()-timeStart) << endl; timeStart = clock();
c22.swap(c222);
cout << "swap, milli-seconds: "<<(clock()-timeStart) << endl;
} long value = ;
int main()
{
test_moveable(vector<Person>(),vector<CNoMovePerson>(),value);
return ;
}

参考侯捷<<STL源码剖析>>

STL标准库-Move对容器效率的影响的更多相关文章

  1. STL标准库中的容器

    容器:顾名思义,我的理解就是把同一种数据类型括起来,作为一捆.如vector<int> ,vector就是个容器,里面全是一个个的int型数据. 容器包括三大块: 顺序型容器: (1)ve ...

  2. STL标准库-容器-set与multiset

    技术在于交流.沟通,转载请注明出处并保持作品的完整性. set与multiset关联容器 结构如下 set是一种关联容器,key即value,value即key.它是自动排序,排序特点依据key se ...

  3. STL标准库-容器-deque

    技术在于交流.沟通,本文为博主原创文章转载请注明出处并保持作品的完整性. deque双向开口可进可出的容器 我们知道连续内存的容器不能随意扩充,因为这样容易扩充别人那去 deque却可以,它创造了内存 ...

  4. STL标准库-容器-vector

    技术在于交流.沟通,本文为博主原创文章转载请注明出处并保持作品的完整性. 向量容器vector是一个动态数组,内存连续,它是动态分配内存,且每次扩张的原来的二倍. 他的结构如下 一 定义 vector ...

  5. STL标准库-容器-set与map

    STL标准库-容器-set与multiset C++的set https://www.cnblogs.com/LearningTheLoad/p/7456024.html STL标准库-容器-map和 ...

  6. STL标准库-算法-常用算法

    技术在于交流.沟通,本文为博主原创文章转载请注明出处并保持作品的完整性 介绍11种STL标准库的算法,从这11种算法中总结一下算法的基本使用 1.accumulate() 累加 2.for_each( ...

  7. C++STL标准库学习笔记(五)set

    前言: 在这个笔记中,我把大多数代码都加了注释,我的一些想法和注解用蓝色字体标记了出来,重点和需要关注的地方用红色字体标记了出来,这一篇后面主要都是我的记录了,为了防止大片蓝色字体出现,后面就不改蓝色 ...

  8. C++STL标准库学习笔记(三)multiset

    C++STL标准库学习笔记(三)multiset STL中的平衡二叉树数据结构 前言: 在这个笔记中,我把大多数代码都加了注释,我的一些想法和注解用蓝色字体标记了出来,重点和需要关注的地方用红色字体标 ...

  9. C++STL标准库学习笔记(一)sort

    前言: 近来在学习STL标准库,做一份笔记并整理好,方便自己梳理知识.以后查找,也方便他人学习,两全其美,快哉快哉! 这里我会以中国大学慕课上北京大学郭炜老师的<程序设计与算法(一)C语言程序设 ...

随机推荐

  1. [BZOJ5139][Usaco2017 Dec]Greedy Gift Takers 权值线段树

    Description Farmer John's nemesis, Farmer Nhoj, has NN cows (1≤N≤10^5), conveniently numbered 1…N. T ...

  2. UVa 12563 劲歌金曲(0-1背包)

    https://vjudge.net/problem/UVA-12563 题意: 在一定的时间内连续唱歌,最后一首唱11分钟18秒的劲歌金曲,问最多能长多长时间. 思路: 0-1背包问题,背包容量为t ...

  3. vue-cli 组件运用

    // components ----- helloworld.vue <script> export default { name: 'Hellowworld', props: { //接 ...

  4. awk 提取数字

    echo b1c2d3d1e8f9 | awk ' { string=$0 len=length(string) for(i=0; i<=len; i++) { tmp=substr(strin ...

  5. 转载:oracle 11g ADG实施手册(亲测,已成功部署多次)

    https://www.cnblogs.com/yhfssp/p/7815078.html 一:实验环境介绍 虚拟机系统: RHEL Linux 6.4(64位) 数据库版本: Oracle 11gR ...

  6. 怎么彻底删除2345的各种顽固Process

    清晨打开电脑,都是2345的不良新闻,心情不美美哒 2345如何卸载? “C:\Windows\System32\drivers”目录删除Mslmedia.sys 开始-运行-cmd输入“sc del ...

  7. servlet生命周期深入理解

    什么是Servlet Java Servlet 是运行在 Web 服务器或应用服务器上的程序,它是作为来自 Web 浏览器或其他 HTTP 客户端的请求和 HTTP 服务器上的数据库或应用程序之间的中 ...

  8. NPOI操作

    1.操作Excel 准备生成的公共方法(将数据源DataTable转换成MemoryStream) /// <summary> /// 生成Excel /// </summary&g ...

  9. ADO.NET 批量插入

    在.Net1.1中无论是对于批量插入整个DataTable中的所有数据到数据库中,还是进行不同数据源之间的迁移,都不是很方便.而 在.Net2.0中,SQLClient命名空间下增加了几个新类帮助我们 ...

  10. Map<K, V> 中k,v如果为null就转换

    Set<String> set = map.keySet(); if(set != null && !set.isEmpty()) { for(String key : s ...