m0_51955470的博客

代码如下:#include <iostream>#include <string>using namespace std;int main(){ string str1 = R"(D:\hello\world\test.txt)"; cout << str1 << endl; string str2 = R"(dsdas asdas asda asda gd fh ada gd)"; cout <..

static_cast 用于内置的数据类型还有具有继承关系的指针或者引用代码如下:#include <iostream>using namespace std;class Building {};class Animal{};class Cat:public Animal{};int main(){ int a = 97; char c = static_cast<char>(a); cout << c << endl; int

adesfg

弱引用智能指针 std::weak_ptr 可以看做是 shared_ptr 的助手，它不管理 shared_ptr 内部的指针。std::weak_ptr 没有重载操作符 * 和 ->，因为它不共享指针，不能操作资源，所以它的构造不会增加引用计数，析构也不会减少引用计数，它的主要作用就是作为一个旁观者监视 shared_ptr 中管理的资源是否存在。1.初始化// 默认构造函数constexpr weak_ptr() noexcept;// 拷贝构造weak_ptr (const weak

unique_ptr 指定删除器和 shared_ptr 指定删除器是有区别的，unique_ptr 指定删除器的时候需要确定删除器的类型，所以不能像 shared_ptr 那样直接指定删除器，举例说明：代码如下:#include <iostream>#include <memory>#include <string>using namespace std;class Test{public: Test() { cout << "co

std::unique_ptr是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针，可以通过它的构造函数初始化一个独占智能指针对象，但是不允许通过赋值将一个unique_ptr 赋值给另一个 unique_ptr。std::unique_ptr 不允许复制，但是可以通过函数返回给其他的 std::unique_ptr，还可以通过 std::move来转译给其他的 std::unique_ptr，这样原始指针的所有权就被转移了，这个原始指针还是被独占的。使用 reset 方法可以让 un.

当智能指针管理的内存对应的引用计数变为 0 的时候，这块内存就会被智能指针析构掉了。另外，我们在初始化智能指针的时候也可以自己指定删除动作，这个删除操作对应的函数被称之为删除器，这个删除器函数本质是一个回调函数，我们只需要进行实现，其调用是由智能指针完成的。代码如下:#include <iostream>#include <memory>#include <string>using namespace std;class Test{public: Te

使用智能指针需要添加头文件:代码如下:#include <memory>初始化:1.通过构造函数初始化代码如下:std::shared_ptr<T> 智能指针名字(创建堆内存)2.通过拷贝和移动构造函数初始化代码如下:#include <iostream>#include <memory>using namespace std;int main(){ // 使用智能指针管理一块 int 型的堆内存, 内部引用计数为 1

// 函数原型template <class T> T&& forward (typename remove_reference<T>::type& t) noexcept;template <class T> T&& forward (typename remove_reference<T>::type&& t) noexcept;// 精简之后的样子std::forward<T&gt.

dasf

代码如下:#include <iostream>using namespace std;int main(){ //左值 int num = 9; //左值引用 int &a = num; //右值 const int N = 5; //右值引用 int && b = 8; //常量左值引用 const int &c = num; //常量右值引用 const int &&d = 6; //const in.

代码如下:

std::bind用来将可调用对象与其参数一起进行绑定。绑定后的结果可以使用std::function进行保存，并延迟调用到任何我们需要的时候。通俗来说，它主要有两个作用:1.将可调用对象与其参数一起绑定成一个仿函数。2.将多元(参数个数为n，n > 1）可调用对象转换为一元或者(n -1)元可调用对象，即只绑定部分参数。绑定器函数使用语法格式如下://绑定非类成员函数/变量auto f = std::bind(可调用对象地址,绑定的参数 / 占位符);//绑定类成员函数/变量auto

可调用对象包装器std::function是可调用对象的包装器。它是一个类模板，可以容纳除了类成员(函数)指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数，函数对象，函数指针，并允许保存和延迟执行它们。基本用法:std::function必须要包含一个叫做functional的头文件，可调用对象包装器使用语法如下:#include <functional>std::function<返回值类型(参数类型列表)> diy_name = 可调用对象;

在C++中存在"可调用对象"这么一个概念，准确来说，可调用对象有如下几种定义:1.是一个函数指针代码如下:int print(int a, double b){ cout << a << b << endl; return 0;}int(*func)(int, double) = &print;2.是一个具有operator()成员函数的类对象(仿函数)代码如下:#include <vector>#include <i

C++11提供了一种新型的for循环形式 - 基于范围的for循环语法:for (declaration : expression){ //循环体}在上面的语法格式中，declaration表示遍历声明，在遍历过程中，当前被遍历到的元素会被存储到声明的变量中，expression是要遍历的对象，它可以是表达式，容器，数组，初始化列表等。代码如下:#include <vector>#include <iostream>using namespace std;

代码如下:#include <iostream>using namespace std;void func(initializer_list<int> ls){ auto it = ls.begin(); for (; it != ls.end(); it++) { cout << *it << " "; } cout << endl;}int main(){ func({ 1,2,5,12,23 }); re.

关于C++中的变量，数组，对象等都有不同的初始化方法，在这些繁琐的初始化方法中没有任何一种方式适用于所有的情况。为了统一初始化方式，并且让初始化行为具有确定的效果，在C++11中提出了列表初始化的概念。...

C++11中提供的继承构造函数可以让派生类直接使用基类的构造函数，而无需自己再写构造函数，尤其是在基类有很多构造函数的情况下，可以极大地简化派生类构造函数的编写。先来看没有继承构造函数之前的处理方式:代码如下:#include <iostream>#include <string>using namespace std;class Base{public: Base(int i):m_i(i){} Base(int i,double j):m_i(i),m_j(

委托构造函数允许使用同一个类中的一个构造函数调用其他的构造函数，从而简化相关变量的初始化。注意点:1.这种链式的构造函数调用不能形成一个闭环(死循环)，否则会在运行期抛异常。2.如果要进行多层构造函数的链式调用，建议将构造函数的调用写在初始化列表中而不是函数体内部，否则编译器会提示形参的重复定义。3.在初始化列表中调用了代理构造函数初始化某个类成员变量之后，就不能在初始化列表中再次初始化这个变量了。代码如下:#include <iostream>using namespace st

adfsdgh

1.定义别名语法:typedef 旧的类型名 新的类型名;typedef unsigned int uint_t;using 新的类型 = 旧的类型;using uint_t = int ;通过using和typedef的语法格式可以看到二者的使用没有太大的区别，假如我们定义一个函数指针，using的优势就凸显出来了，可读性更好。代码如下:#include <iostream>#include <string>using namespace std;in

在C++11中添加了对函数模板默认参数的支持。代码如下:#include<iostream>using namespace std;template<typename T = long ,typename U = int >void myTest(T t = 'A',U u = 'B'){ cout << "t = " << t << " u = " << u << endl;}int main()

在泛型编程中，模板实例化有一个非常繁琐的地方，那就是连续的两个右尖括号(>>)会被编译器解析成右移操作符，而不是模板参数表的结束。

override关键字确保在派生类中声明的重写函数与基类的虚函数有相同的签名，同时也明确表明将会重写基类的虚函数，这样就可以保证重写的虚函数的正确性，也提高了代码的可读性，和final一样，这个关键字要写到方法的后面。1.有继承关系2.子类重写父类虚函数3.父类指针或引用指向子类对象代码如下:#include <iostream>using namespace std;class Base{public: virtual void test() { cout <

C++中增加了final关键字来限制某个类不能被继承，或者或个虚函数不能被重写，和java的final关键字的功能是类似的。如果使用final修饰函数，只能修饰虚函数，并且要把final关键字放到类或者函数的后面。1.如果使用final修饰函数，只能修饰虚函数，这样就能阻止子类重写父类的这个函数了。代码如下:#include <iostream>using namespace std;class Base{public: virtual void test() { cou

在泛型编程中，可能需要通过参数的运算来得到返回值类型。代码如下:

关于decltype的应用多出现在泛型编程中，比如我们编写一个类模板，在里面添加遍历容器的函数，操作如下:代码如下:#include <iostream>#include <list>using namespace std;template<typename T>class Container{public: void printElem(T & t) { for (m_it = t.begin(); m_it != t.end();

在某些情况下，不需要或者不能定义变量，但是希望得到某种类型，这时候就可以用C++11提供的decltype关键字了，它的作用是在编译器编译的时候推导出一个表达式的类型。语法:decltype (表达式)decltype是"declare type “的缩写，意思是"声明类型”，decltype的推导是在编译期完成的，它只是用于表达式类型的推导，并不会计算表达式的值。代码如下:int a = 10;decltype(a) b = 99;// b -> intdecltype(a + 3.

推荐使用auto的场景：1.用于STL的容器遍历。代码如下:#include <string>#include <iostream>#include <map>using namespace std;int main(){ map<int, string>mp; mp.insert(make_pair(1, "Tom")); mp.insert(make_pair(2, "Mike")); mp.insert(make_pair(3

不允许使用auto的四个场景：1.不能作为函数参数使用，因为只有在函数调用的时候才会给函数参数传递实参，auto要求必须要给修饰的变量赋值，因此二者矛盾。代码如下://errorint func(auto a, auto b){ cout << a << " " << b << endl;}2.不能用于类的非静态成员变量的初始化。代码如下:class Test{ auto a = 0;//error static auto b =

1.autoC++11中，auto并不代表一种实际的数据类型，只是一个类型声明的"占位符"，auto并不是万能的在任意场景下都能够推导出变量的实际类型，使用auto声明的变量必须要进行初始化，以让编译器推导出它的实际类型，在编译时将auto占位符替换成真正的类型。语法:auto 变量名 = 变量值；代码如下:#include <iostream>using namespace std;int main(){ auto x = 3.14;// double auto y =

constexpr修饰函数。普通函数/类成员函数。1.函数必须要有返回值，并且return返回的表达式必须是常量表达式。错误代码如下:#include <iostream>using namespace std;//error 不是常量表达式函数constexpr void func1(){ int a = 200; cout << a << endl;}//error 不是常量表达式函数 因为a是变量，不是常量constexpr int

constexpr定义一个常量。代码如下:#include <iostream>using namespace std;int main(){ constexpr int a = 10;//a的值不可以修改! return 0;}constexpr修饰class或struct。代码如下:#include <iostream>using namespace std;//不能这样写!!!/*constexpr struct T{ int a;};*

代码如下:#include <iostream>using namespace std;void func(char *p){ cout << "void func(char *p)" << endl;}void func(int p){ cout << "void func(int p)" << endl;}int main(){ func(10); func(NULL); return 0;}测试结果