🎇C++学习历程:入门
- 博客主页:一起去看日落吗
- 持续分享博主的C++学习历程
博主的能力有限,出现错误希望大家不吝赐教
- 分享给大家一句我很喜欢的话: 也许你现在做的事情,暂时看不到成果,但不要忘记,树🌿成长之前也要扎根,也要在漫长的时光🌞中沉淀养分。静下来想一想,哪有这么多的天赋异禀,那些让你羡慕的优秀的人也都曾默默地翻山越岭🐾。
♠️ ♥️ ♣️ ♦️
目录
- ♠️ 1. C++11简介
- ♠️ 2. 列表初始化
- ♥️ 2.1 {} 初始化
- ♥️ 2.2 std::initializer_list
- ♠️ 3. 声明
- ♥️ 3.1 auto
- ♥️ 3.2 decltype
- ♥️ 3.3 nullptr
- ♠️ 4. STL中一些变化
- ♠️ 5. final 和 override
- ♠️ 6. 右值引用和移动语义
- ♥️ 6.1 左值引用和右值引用
- ♥️ 6.2 左值引用和右值引用比较
- ♥️ 6.3 右值引用使用场景和意义
- ♥️ 6.4 左值引用使用场景
- ♥️ 6.4 左值引用短板
- ♥️ 6.5 右值引用和移动语义解决上述问题
- ♥️ 6.6 STL容器插入接口函数也增加了右值引用版本
♠️ 1. C++11简介
相比C++98/03,C++11则带来了数量可观的变化,其中包含了约140个新特性,以及对C++03标准中约600个缺陷的修正,这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言,C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全,不仅功能更强大,而且能提升程序员的开发效率。
♠️ 2. 列表初始化
♥️ 2.1 {} 初始化
- 在C++98中,标准允许使用花括号{}对数组元素进行统一的列表初始值设定。
struct Point
{int _x;int _y;
};
int main()
{int array1[] = { 1, 2, 3, 4, 5 };int array2[5] = { 0 }; //0 0 0 0 0 Point p = { 1, 2 }; //运用了struct结构体的语法 初始化return 0; }
- C++11扩大了用大括号括起的列表(初始化列表)的使用范围,使其可用于所有的内置类型和用户自定义的类型,使用初始化列表时,可添加等号(=),也可不添加。
struct Point
{int _x;int _y;Point(int x, int y):_x(x), _y(y){}
};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()
{Point p = { 1, 2 };//Point p{ 1, 2 };Point* p3 = new Point[3]{ {1, 1}, { 2, 2 }, { 3, 3 } };int* p1 = new int(0);int* p2 = new int[5]{1,2,3,4,5}; //C++11中 new可以初始化数组//自定义类型的列表初始化Date d1(2022, 3, 13);Date d2 = { 2022, 3, 15 };Date d3{ 2022, 3, 15 };Date{2022,3,15};int i = 1;int j = { 2 };int k{ 3 };return 0;
}
♥️ 2.2 std::initializer_list
std::initializer_list介绍文档
- std::initializer_list是什么类型
int main()
{// the type of il is an initializer_listauto il = { 10, 20, 30 };cout << typeid(il).name() << endl;return 0;
}
- 模拟实现的vector支持{}初始化和赋值
template<class T>
class vector
{
public:typedef T* iterator;vector(initializer_list<T> l){_start = new T[l.size()];_finish = _start + l.size();_endofstorage = _start + l.size();iterator vit = _start;typename initializer_list<T>::iterator lit = l.begin();while (lit != l.end()){*vit++ = *lit++;}//for (auto e : l)// *vit++ = e;}vector<T>& operator=(initializer_list<T> l) {vector<T> tmp(l);std::swap(_start, tmp._start);std::swap(_finish, tmp._finish);std::swap(_endofstorage, tmp._endofstorage);return *this;}
private:iterator _start;iterator _finish;iterator _endofstorage;
};
- std::initializer_list使用场景
std::initializer_list一般是作为构造函数的参数,C++11对STL中的不少容器(像map、vector、list)就增加std::initializer_list作为参数的构造函数,这样初始化容器对象就更方便了。也可以作为operator=的参数,这样就可以用大括号赋值
class A
{
public:A(int a, double d, int b):_a(a), _d(d), _b(b){}
private:int _a;double _d;int _b;
};
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()
{//内置类型的列表初始化vector<int> v1 = { 1, 2, 3, 4, 5 };vector<int> v2{ 1, 2, 3, 4, 5 };//vector (initializer_list<value_type> il,const allocator_type& alloc = allocator_type());auto lt1 = {1, 2, 3, 4};initializer_list<int> lt2 = { 1, 2, 3, 4 };//auto=initializer_list<int>map<string, int> dict1 = { pair<string, int>("sort", 1), pair<string, int>("insert", 2) };map<string, int> dict2 = { { "sort", 1 }, { "insert", 2 } };//首先{ "sort", 1 }, { "insert", 2 }创建成initializer_list<map<string,int>>类型的对象//最后map (initializer_list<value_type> il,const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type());//这个构造函数初始化dict2//自定义类型的列表初始化Date d1(2022, 3, 13);Date d2 = { 2022, 3, 15 };Date d3{ 2022, 3, 15 };Date{ 2022, 3, 15 };A aa1 = { 1, 1.11, 1};list<A> lt = { { 1, 1.11, 1}, { 2, 2.22, 1} };//首先{ { 1, 1.11, 1}, { 2, 2.22, 1} }创建成initializer_list<list<A>>类型的对象(首先是A类得有相应的构造函数才行)//最后list的构造函数初始化itreturn 0;
}
♠️ 3. 声明
c++11提供了多种简化声明的方式,尤其是在使用模板时。
♥️ 3.1 auto
在C++98中auto是一个存储类型的说明符,表明变量是局部自动存储类型,但是局部域中定义局部的变量默认就是自动存储类型,所以auto就没什么价值了。C++11中废弃auto原来的用法,将其用于实现自动类型腿断。这样要求必须进行显示初始化,让编译器将定义对象的类型设置为初始化值的类型。
int main()
{int i = 10;auto p = &i;auto pf = strcpy;//输出p、pf的类型cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };//map<string, string>::iterator it = dict.begin();auto it = dict.begin();return 0;
}
♥️ 3.2 decltype
关键字decltype将变量的类型声明为表达式指定的类型
// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2)
{decltype(t1 * t2) ret = t1 * t2;vector<decltype(t1* t2)> v;v.push_back(ret);cout << typeid(ret).name() << endl;
}int main()
{int i = 10;auto p = &i;auto pf = strcpy;decltype(pf) pf1; //char * (__cdecl*)(char *,char const *)vector<decltype(pf)> v;cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;return 0;
}
注意:decltype与auto的差别:auto必须要求显式初始化,而decltype没要求
♥️ 3.3 nullptr
由于C++中NULL被定义成字面量0,这样就可能回带来一些问题,因为0既能指针常量,又能表示整形常量。所以出于清晰和安全的角度考虑,C++11中新增了nullptr,用于表示空指针。
#ifndef NULL
#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
♠️ 4. STL中一些变化
新容器
用橘色圈起来是C++11中的一些几个新容器,但是实际最有用的是unordered_map和
unordered_set。其他的大家了解一下即可。
容器中的一些新方法
如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法,但是其实很多都是用得比较少的。
比如提供了cbegin和cend方法返回const迭代器等等,但是实际意义不大,因为begin和end也是可以返回const迭代器的,这些都是属于锦上添花的操作。
♠️ 5. final 和 override
final
- final修饰类的时候,表示该类不能被继承
class A final //表示该类是最后一个类
{
private:int _year;
};
class B : public A //无法继承
{};
- final修饰虚函数时,这个虚函数不能被重写
class A
{
public:virtual void fun() final//修饰虚函数{cout << "this is A" << endl;}
private:int _year;
};
class B : public A
{
public:virtual void fun()//父类虚函数用final修饰,表示最后一个虚函数,无法重写{cout << "this is B" << endl;}
};
override
- 检查派生类虚函数是否重写了基类某个虚函数,如果没有重写编译报错
class A
{
public:virtual void fun(){cout << "this is A" << endl;}
private:int _year;
};
class B : public A
{
public:virtual void fun() override{cout << "this is B" << endl;}
};
♠️ 6. 右值引用和移动语义
♥️ 6.1 左值引用和右值引用
传统的C++语法中就有引用的语法,而C++11中新增了的右值引用语法特性,无论左值引用还是右值引用,都是给对象取别名。
- 左值引用
左值是一个表示数据的表达式(如变量名或解引用的指针),我们可以获取它的地址+可以对它赋值,左值可以出现赋值符号的左边,右值不能出现在赋值符号左边。定义时const修饰符后的左值,不能给他赋值,但是可以取它的地址。左值引用就是给左值的引用,给左值取别名。
int main()
{// 以下的p、b、c、*p都是左值int* p = new int(0);int b = 1;const int c = 2;// 可以取地址cout << &p << endl;cout << &b << endl;cout << &c << endl;cout << &(*p) << endl;b = c;// 以下几个是对上面左值的左值引用int*& rp = p;int& rb = b;const int& rc = c;int& pvalue = *p;return 0;
}
- 右值引用
右值也是一个表示数据的表达式,如:字面常量、表达式返回值,函数返回值(这个不能是左值引用返回)等等,右值可以出现在赋值符号的右边,但是不能出现出现在赋值符号的左边,右值不能取地址。右值引用就是对右值的引用,给右值取别名。
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);// // 不能取地址// cout << &10 << endl;// cout << &(x+y) << endl;// cout << &fmin(x, y) << endl;// 这里编译会报错:error C2106: “=”: 左操作数必须为左值//10 = 1; //x + y = 1;//fmin(x, y) = 1;return 0;
}
需要注意的是右值是不能取地址的,但是给右值取别名后,会导致右值被存储到特定位置,且可以取到该位置的地址,也就是说例如:不能取字面量10的地址,但是rr1引用后,可以对rr1取地址,也可以修改rr1。如果不想rr1被修改,可以用const int&& rr1 去引用
int main()
{double x = 1.1, y = 2.2;int&& rr1 = 10;const double&& rr2 = x + y;rr1 = 20;int& rr = rr1;//rr2 = 5.5; // 报错return 0;
}
注意:左值引用可以连续左值引用,而右值引用是不可以连续右值引用的(右值引用后该变量为左值,不能使用右值引用了)
♥️ 6.2 左值引用和右值引用比较
左值引用总结:
- 左值引用只能引用左值,不能引用右值。
- 但是const左值引用既可引用左值,也可引用右值
int main()
{// 左值引用只能引用左值,不能引用右值。int a = 10;int& ra1 = a;// ra为a的别名//int& ra2 = 10;// 编译失败,因为10是右值// const左值引用既可引用左值,也可引用右值。const int& ra3 = 10;const int& ra4 = a;return 0;
}
右值引用总结:
- 右值引用只能右值,不能引用左值。
- 但是右值引用可以move以后的左值。
int main()
{// 右值引用只能右值,不能引用左值int&& r1 = 10;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用int a = 10;//int&& r2 = a; //报错 右值引用只能右值,不能引用左值// 右值引用可以引用move以后的左值int&& r3 = move(a);return 0;
}
♥️ 6.3 右值引用使用场景和意义
右值引用可以补齐左值引用的短板
namespace lc
{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){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 移动拷贝" << endl;//this->swap(s);swap(s);}// 赋值重载string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷贝" << endl;string tmp(s);swap(tmp);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;size_t _size;size_t _capacity; // 不包含最后做标识的\0};
}
♥️ 6.4 左值引用使用场景
void func1(bit::string s)
{}void func2(const bit::string& s)
{}int main()
{bit::string s1("hello world");// func1和func2的调用我们可以看到左值引用做参数减少了拷贝,提高效率的使用场景和价值func1(s1);func2(s1);// string operator+=(char ch) 传值返回存在深拷贝// string& operator+=(char ch) 传左值引用没有拷贝提高了效率s1 += '!';return 0;
}
♥️ 6.4 左值引用短板
但是当函数返回对象是一个局部变量,出了函数作用域就不存在了,就不能使用左值引用返回,只能传值返回。例如:bit::string to_string(int value)函数中可以看到,这里只能使用传值返回,传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。
♥️ 6.5 右值引用和移动语义解决上述问题
移动构造本质是将参数右值的资源窃取过来,占位已有,那么就不用做深拷贝了,所以它叫做移动构造,就是窃取别人(将亡值)的资源来构造自己。
注意:出了作用域,如果返回对象不在了,不能使用引用返回(左值引用和右值引用都不可以)
namespace byih
{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){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr), _size(0), _capacity(0){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 移动拷贝" << endl;//this->swap(s);swap(s);}// 拷贝赋值string& operator=(const string& s){cout << "string& operator=(const string& s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}// 移动赋值string& operator=(string&& s){cout << "string& operator=(string&& s) -- 移动赋值" << endl;swap(s);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;}void clear(){_str[0] = '\0';_size = 0;}private:char* _str;size_t _size;size_t _capacity; // 不包含最后做标识的\0};string to_string(int val){string str;while (val){int i = val % 10;str += ('0' + i);val /= 10;}reverse(str.begin(), str.end());return str;}
}
右值是将亡值而将亡值不一定是右值
注意:
按照语法,右值引用只能引用右值,但右值引用也能引用左值。因为:有些场景下,可能 真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时,可以通过move 函数将左值转化为右值。C++11中,std::move()函数位于 头文件中,该函数名字具有迷惑性, 它并不搬移任何东西,唯一的功能就是将一个左值强制转化为右值引用,然后实现移动语义。
使用move函数时,要注意该对象的资源(所开空间),该对象的资源会根据移动赋值、移动拷贝来决定,建议使用完move函数之后不要再使用该对象了
♥️ 6.6 STL容器插入接口函数也增加了右值引用版本
void push_back (value_type&& val);
int main()
{list<bit::string> lt;bit::string s1("1111");// 这里调用的是拷贝构造lt.push_back(s1);// 下面调用都是移动构造lt.push_back("2222");lt.push_back(std::move(s1));return 0;
}运行结果:
// string(const string& s) -- 深拷贝
// string(string&& s) -- 移动语义
// string(string&& s) -- 移动语义