医院网站设计怎么做,一米设计公司,徐州建设工程交易网开标大厅,多城市地方门户网站系统目录
一、列表初始化
1.1 { } 初始化
1.2 std::initializer_list
二、声明
2.1 auto
2.2 decltype
2.3 nullptr
三、新容器
四、右值引用和移动语义
4.1 左值和左值引用
4.2 右值和右值引用
4.3 左值引用与右值引用比较
4.4 右值引用使用场景和意义#xff1a;移…目录
一、列表初始化
1.1 { } 初始化
1.2 std::initializer_list
二、声明
2.1 auto
2.2 decltype
2.3 nullptr
三、新容器
四、右值引用和移动语义
4.1 左值和左值引用
4.2 右值和右值引用
4.3 左值引用与右值引用比较
4.4 右值引用使用场景和意义移动构造、移动赋值
4.5右值引用引用左值及其一些更深入的使用场景分析
五、万能引用和完美转发
5.1 万能引用
5.2 完美转发 一、列表初始化
1.1 { } 初始化
在C98中标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如
struct Point
{int _x;int _y;
};int main()
{int array1[] { 1, 2, 3, 4, 5 };int array2[5] { 0 };Point p { 1, 2 };return 0;
}
C11扩大了用大括号括起的列表(初始化列表)的使用范围使其可用于所有的内置类型和用户自 定义的类型使用初始化列表时可以省略赋值符号即可以添加等号()也可以不添加。
class Date
{
public:Date(int year, int month, int day):_year(year), _month(month), _day(day){cout Date(int year, int month, int day) endl;}private:int _year;int _month;int _day;
};//一切都可以用列表初始化//并且可以省略掉
int main()
{int i 0;int j { 0 };int k{ 0 };int array1[]{ 1, 2, 3, 4, 5 };int array2[5]{ 0 };Point p{ 1, 2 };//创建对象时也可以使用列表初始化方式调用构造函数初始化Date d1(1949, 10, 1);//构造函数// 类型转换: 构造拷贝构造-编译器优化为直接构造Date d2 { 1949, 10, 2 };Date d3{ 1949, 10, 3 };//单参数的构造函数支持隐式类型转换string s1 xxxx;const Date d4 { 1949, 10, 1 };Date* p1 new Date[3]{ d1, d2, d3 };Date* p2 new Date[3]{ {1949, 10, 1}, {1949, 10, 2}, {1949, 10, 3} };return 0;
}
1.2 std::initializer_list
在 C11 中initializer_list 是一个新的模板类型它是 std::initializer_listT 的缩写用于表示一组值的集合。std::initializer_list的介绍文档 查看std::initializer_list是什么类型 int main() { // the type of il is an initializer_list auto il { 10, 20, 30 }; cout typeid(il).name() endl; return 0; } 使用场景std::initializer_list一般是作为构造函数的参数C11对STL中的不少容器就增加std::initializer_list作为参数的构造函数例如vector、list和map这样初始化容器对象就更方便了。也可以作为operator的参数这样就可以用大括号赋值。
在下面的示例中。
Date d2 { 1949, 10, 1 };的列表不转换成initializer_list而是通过构造函数构造临时对象再通过拷贝构造赋给d2。initializer_list支持迭代器和范围for。在mapstring, string dict {{insert, 插入}, {get,获取} };使用 initializer_list 直接在初始化表达式中指定键值对不需要显式地创建一个临时对象
int main()
{//默认识别成initializer_listvectorint v1 { 1,2,3,4 };vectorint v2 { 1,2,3,4,5,6};v1 { 10,20,30 };listint lt { 10,20,30 };// 多参数构造类型转换 构造拷贝构造-优化直接构造// 跟对应构造函数参数个数匹配Date d2 { 1949, 10, 2 };initializer_listint il2 { 10, 20, 30};initializer_listint::iterator it2 il2.begin();while (it2 ! il2.end()){cout *it2 ;it2;}cout endl;//for (int e : il2)for (auto e : il2){cout e ;}cout endl;pairstring, string kv1(sort, 排序);mapstring, string dict {{insert, 插入}, {get,获取} };for (auto kv : dict){cout kv.first : kv.second endl;}Date dd2 { 1949, 10, 1 };//Date dd3 { 1949, 10, 1, 20};return 0;
} 二、声明
2.1 auto
在C98中auto是一个存储类型的说明符表明变量是局部自动存储类型但是局部域中定义局 部的变量默认就是自动存储类型所以auto就没什么价值了。C11中废弃auto原来的用法将 其用于实现自动类型推断它允许编译器自动推导变量的类型。使用auto必须进行显示初始化让编译器将定义对象的类型设置为初始化值的类型。
2.2 decltype
在 C11 中decltype 是一个关键字用于返回表达式的类型。decltype 通常与 auto 一起使用以提供更加灵活和强大的类型推断能力。
decltype推导出来的类型可以用来当作模板实参或者定义对象。typeid获取的类型不能用来定义对象
int main()
{int i 1;double d 2.2;// 类型以字符串形式获取到cout typeid(i).name() endl;cout typeid(d).name() endl;// typeid(i).name() j; //typeid获取的类型不能用来定义对象auto j i;auto ret i * d;decltype(ret) x;// 用ret的类型去实例化vector// decltype可以推导对象的类型。这个类型是可以用// 用来模板实参或者再定义对象vectordecltype(ret) v;v.push_back(1);v.push_back(1.1);for (auto e : v){cout e ;}cout endl;return 0;
} 2.3 nullptr
由于C中NULL被定义成字面量0这样就可能回带来一些问题因为0既能指针常量又能表示 整形常量。所以出于清晰和安全的角度考虑C11中新增了nullptr用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
三、新容器
用橘色圈起来是C11中的一些几个新容器但是实际最有用的是unordered_map和 unordered_set。这两个我前面已经进行了非常详细的讲解其他的大家了解一下即可。 C语言没有办法进行很好的越界检查(C语言是抽查)[ ]就可以检查出来读/写是否越界。 array很少用因为已经有了vector。forward_list只有头插头删。
如果我们再细细去看会发现基本每个容器中都增加了一些C11的方法但是其实很多都是用得 比较少的。 比如提供了cbegin和cend方法返回const迭代器等等但是实际意义不大因为begin和end也是 可以返回const迭代器的这些都是属于锦上添花的操作
四、右值引用和移动语义
4.1 左值和左值引用
传统的C语法中就有引用的语法而C11中新增了的右值引用语法特性所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用都是给对象取别名。 什么是左值什么是左值引用 左值是一个表示数据的表达式(如变量名或解引用的指针)我们可以获取它的地址并且可以对它赋值。左值可以出现赋值符号的左边也可以出现在右边右值不能出现在赋值符号左边。定义时const修饰符后的左值不能给他赋值但是可以取它的地址。左值引用就是给左值的引用给左值取别名。区分左值和右值要看能不能取它的地址能取地址的是左值不能取地址的是右值。 int main()
{// 以下的p、b、c、*p都是左值int* p new int(0);int b 1;const int c 2;// 以下几个是对上面左值的左值引用int* rp p;int rb b;const int rc c;int pvalue *p;return 0;
}
4.2 右值和右值引用 什么是右值什么是右值引用 右值也是一个表示数据的表达式如字面常量、表达式返回值函数返回值(这个不能是左值引用返回)等等。右值可以出现在赋值符号的右边但是不能出现出现在赋值符号的左边。右值不能取地址。右值引用就是对右值的引用给右值取别名。 int main()
{double x 1.1, y 2.2;// 以下几个都是常见的右值10;x y;fmin(x, y);// 以下几个都是对右值的右值引用int rr1 10;double rr2 x y;double rr3 fmin(x, y);// 这里编译会报错error C2106: “”: 左操作数必须为左值10 1;x y 1;fmin(x, y) 1;return 0;
}
4.3 左值引用与右值引用比较
右值引用总结
左值引用只能引用左值不能引用右值。但是const左值引用既可引用左值也可引用右值。
右值引用总结
左值引用不能给右值取别名但是const左值引用可以。右值引用不能给左值取别名但是右值引用可以给move(左值)取别名
int main()
{int i 0;int j i;// 左值引用能否给右值取别名不能但是const左值引用可以//int r1 10;//出错const int r2 i j;int rr1 10;int rr2 ij;// 右值引用能否给左值取别名不能但是右值引用可以给move(左值)取别名//int rr3 i;//出错int rr4 move(i);return 0;
}
4.4 右值引用使用场景和意义移动构造、移动赋值
右值引用的主要目的是为了优化性能特别是在实现移动语义时可以避免不必要的拷贝操作提高性能。 移动语义 在 C 中当一个对象被另一个对象所需要时通常会发生拷贝操作。例如当函数需要一个对象作为参数时通常会创建该对象的一个副本。使用右值引用可以避免这种不必要的拷贝操作而是直接移动move对象。这被称为移动语义它通常比拷贝操作更快因为它不涉及创建副本而是直接移动对象的数据。 注右值引用的移动语义对于深拷贝的类有意义对于自定义类型浅持贝的类无意义例如Date 例如swap函数在C11中进行改变 自定义类型使用右值引用的场景
namespace mystring
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str _size;}string(const char* str ):_size(strlen(str)), _capacity(_size){cout string(char* str) -- 构造 endl;_str new char[_capacity 1];strcpy(_str, str);}// s1.swap(s2)void swap(string s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}// 拷贝构造string(const string s){cout string(const string s) -- 深拷贝 endl;_str new char[s._capacity 1];strcpy(_str, s._str);_size strlen(_str);_capacity s._capacity 1;}// 赋值重载string operator(const string s){cout string operator(const string s) -- 深拷贝 endl;/*string tmp(s);swap(tmp);*/if (this ! s){char* tmp new char[s._capacity 1];strcpy(tmp, s._str);delete[] _str;_str tmp;_size s._size;_capacity s._capacity;}return *this;}~string(){delete[] _str;_str nullptr;}char operator[](size_t pos){assert(pos _size);return _str[pos];}void reserve(size_t n){if (n _capacity){char* tmp new char[n 1];strcpy(tmp, _str);delete[] _str;_str tmp;_capacity n;}}void push_back(char ch){if (_size _capacity){size_t newcapacity _capacity 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size] ch;_size;_str[_size] \0;}//string operator(char ch)string operator(char ch){push_back(ch);return *this;}const char* c_str() const{return _str;}private:char* _str nullptr;size_t _size 0;size_t _capacity 0; // 不包含最后做标识的\0};mystring::string to_string(int x){mystring::string ret;while (x){int val x % 10;x / 10;ret (0 val);}reverse(ret.begin(), ret.end());return ret;}
}int main()
{mystring::string s ;s mystring::to_string(1234);return 0;
}
Debug版本下 release版本下连续的构造加拷贝构造优化为一次直接构造 发生许多次构造的原因 mystring::string to_string(int x) { mystring::string ret; while (x) { int val x % 10; x / 10; ret (0 val); } reverse(ret.begin(), ret.end()); return ret; } to_string会创建、构造一个retret在栈上有自己空间在返回时传给返回值临时对象使用拷贝构造并且该临时对象也在栈上有自己的空间返回时使用赋值重载并将ret和临时对象使用的空间释放。这种拷贝操作就是不必要的拷贝操作。即使release版本优化后也会浪费时间和空间。 这时就要使用移动构造和移动赋值。 // 移动构造string(string s){cout string(string s) -- 移动拷贝 endl;swap(s);}// 移动赋值string operator(string s){cout string operator(string s)-- 移动赋值 endl;swap(s);return *this;}
Debug版本 release版本 可以看到return ret 给临时对象不再是深拷贝而是直接交换临时对象给s赋值时也是移动赋值直接交换数据这时ret和临时对象出作用域销毁时直接把s原本的不用的数据顺便销毁了。
4.5右值引用引用左值及其一些更深入的使用场景分析
按照语法右值引用只能引用右值但右值引用一定不能引用左值吗
因为有些场景下可能真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时可以通过move函数将左值转化为右值。C11中std::move()函数位于头文件中该函数名字具有迷惑性它并不搬移任何东西唯一的功能就是将一个左值强制转化为右值引用然后实现移动语义。
//move的定义
//templateclass _Ty
//inline typename remove_reference_Ty::type move(_Ty _Arg) _NOEXCEPT
//{
// // forward _Arg as movable
// return ((typename remove_reference_Ty::type)_Arg);
//}int main()
{mystring::string s1(hello world);// 这里s1是左值调用的是拷贝构造mystring::string s2(s1);// 这里我们把s1 move处理以后, 会被当成右值调用移动构造// 但是这里要注意一般是不要这样用的因为我们会发现s1的// 资源被转移给了s3s1被置空了。mystring::string s3(std::move(s1));return 0;
}
STL容器插入接口函数也增加了右值引用版本 五、万能引用和完美转发
5.1 万能引用
在 C11 之前模板参数默认情况下是左值引用。这意味着模板函数或模板模板参数默认只能接收左值引用类型的参数。为了接收右值引用类型的参数需要显式地指定模板参数为右值引用。
C11 引入了万能引用的概念使得模板参数可以同时接受左值引用和右值引用类型的参数。万能引用通常是通过模板参数上的 类型参数来实现的例如
void Fun(int x) { cout 左值引用 endl; }
void Fun(const int x) { cout const 左值引用 endl; }void Fun(int x) { cout 右值引用 endl; }
void Fun(const int x) { cout const 右值引用 endl; }// 函数模板万能引用
templatetypename T
void PerfectForward(T t)
{Fun(t);
}
特点
模板中的不代表右值引用而是万能引用其既能接收左值又能接收右值。模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力但是引用类型的唯一副作用就是限制了接收的类型参数在后续使用中都退化成了左值我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
右值不能直接修改但是右值被右值引用后需要被修改否则无法实现移动构造和移动赋值(也就无法转移资源)。这就需要右值引用的属性是左值才能修改。 为什么万能引用的参数在后续使用中都退化成了左值如何确定实参的属性 具体来说当一个函数模板接受一个右值引用类型的参数时这个参数在函数内部被视为右值。但是一旦该参数被传递给函数它的引用特性就会退化因为它在函数内部被绑定到一个具体的对象上而这个对象在函数内部是可修改的。这种绑定会改变参数的语义使其在后续的使用中被视为左值。 这样可以确保函数内部对参数的修改不会影响到外部环境中的原始对象。但是这也意味着函数内部不能直接使用右值引用的语义来执行某些操作例如移动语义。 为了解决这个问题C11 引入了 std::forward 模板它可以用来转发参数保持参数的引用特性不变。这种方法也叫做完美转发。 上面说到STL容器插入接口函数也增加了右值引用版本其实也是增加了万能引用版本在内部实现时可以使用完美转发确定实参的属性(左值/右值)进而进行相应的操作。 例如右值被万能引用后这个引用是左值必要时需要move()转换为右值。 5.2 完美转发
完美转发是指在函数模板或类模板中转发参数时保持参数类型的引用特性不变。这意味着如果原始参数是左值引用转发后的参数也是左值引用如果原始参数是右值引用转发后的参数也是右值引用。
C11 提供了两种方法来实现完美转发 1. 通过万能引用 templatetypename T void PerfectForward(T t) { // 这里 t 保持原始参数的引用特性 Fun(std::forwardT(t));// 使用 std::forward 进行转发 } 注如果 T 被推断为右值引用类型例如 T 被推断为 int那么 std::forwardT(t) 将返回一个右值引用这意味着它返回的是一个临时的右值而不是 t 本身变成右值。 2. 针对Fun传入的参数调用特定的函数模板 template typename T void Func(const T t) {} template typename T void Func(T t) {} 完美转发中实际的使用场景 templateclass Tstruct list_node{T _data;list_nodeT* _next;list_nodeT* _prev;list_node(const T x T()):_data(x),_next(nullptr),_prev(nullptr){}list_node(T x):_data(move(x)), _next(nullptr), _prev(nullptr){}template class... Argslist_node(Args... args):_data(args...),_next(nullptr),_prev(nullptr){}};// T T T*// T cosnt T const T*templateclass T, class Ref, class Ptrstruct __list_iterator{typedef list_nodeT Node;typedef __list_iteratorT, Ref, Ptr self;Node* _node;__list_iterator(Node* node):_node(node){}self operator(){_node _node-_next;return *this;}self operator--(){_node _node-_prev;return *this;}self operator(int){self tmp(*this);_node _node-_next;return tmp;}self operator--(int){self tmp(*this);_node _node-_prev;return tmp;}Ref operator*(){return _node-_data;}Ptr operator-(){return _node-_data;}bool operator!(const self s){return _node ! s._node;}bool operator(const self s){return _node s._node;}};templateclass Tclass list{typedef list_nodeT Node;public:typedef __list_iteratorT, T, T* iterator;typedef __list_iteratorT, const T, const T* const_iterator;//typedef __list_const_iteratorT const_iterator;const_iterator begin() const{return const_iterator(_head-_next);}const_iterator end() const{return const_iterator(_head);}iterator begin(){//return iterator(_head-_next);return _head-_next;}iterator end(){//return iterator(_head-_next);return _head;}void empty_init(){_head new Node;_head-_next _head;_head-_prev _head;_size 0;}list(){empty_init();}// lt2(lt1)list(const listT lt){empty_init();for (auto e : lt){push_back(e);}}void swap(listT lt){std::swap(_head, lt._head);std::swap(_size, lt._size);}// lt3 lt1listint operator(listint lt){swap(lt);return *this;}~list(){clear();delete _head;_head nullptr;}void clear(){iterator it begin();while (it ! end()){it erase(it);}}void push_back(const T x){insert(end(), x);}void push_back(T x){insert(end(), forwardT(x));}template class... Argsvoid emplace_back(Args... args){Node* newnode new Node(args...);// 链接节点}void push_front(const T x){insert(begin(), x);}void pop_front(){erase(begin());}void pop_back(){erase(--end());}iterator insert(iterator pos, const T x){Node* cur pos._node;Node* newnode new Node(x);Node* prev cur-_prev;// prev newnode curprev-_next newnode;newnode-_prev prev;newnode-_next cur;cur-_prev newnode;_size;return iterator(newnode);}iterator insert(iterator pos, T x){Node* cur pos._node;Node* newnode new Node(forwardT(x));Node* prev cur-_prev;// prev newnode curprev-_next newnode;newnode-_prev prev;newnode-_next cur;cur-_prev newnode;_size;return iterator(newnode);}iterator erase(iterator pos){Node* cur pos._node;Node* prev cur-_prev;Node* next cur-_next;delete cur;prev-_next next;next-_prev prev;--_size;return iterator(next);}size_t size(){return _size;}private:Node* _head;size_t _size;};
为了实现万能引用模拟实现的list中分别实现左值和右值的insert和push_back。如下 iterator insert(iterator pos, const T x) iterator insert(iterator pos, T x) void push_back(const T x) void push_back(T x)
