工作总结 工作总结个人

{
    "version": "2.0.0",
    "tasks": [
        {//这个大括号里是‘构建（build）’任务
            "label": "build", //任务名称，可以更改，不过不建议改
            "type": "shell", //任务类型，process是vsc把预定义变量和转义解析后直接全部传给command；shell相当于先打开shell再输入命令，所以args还会经过shell再解析一遍
            "command": "gcc", //编译命令，这里是gcc，编译c++的话换成g++
            "args": [    //方括号里是传给gcc命令的一系列参数，用于实现一些功能
                "${file}", //指定要编译的是当前文件
                "-o", //指定输出文件的路径和名称
                "${fileDirname}\\bin\\${fileBasenameNoExtension}.exe", //承接上一步的-o，让可执行文件输出到源码文件所在的文件夹下的bin文件夹内，并且让它的名字和源码文件相同
                "-g", //生成和调试有关的信息
                "-Wall", // 开启额外警告
                "-static-libgcc",  // 静态链接libgcc
                "-fexec-charset=GBK", // 生成的程序使用GBK编码，不加这一条会导致Win下输出中文乱码
                "-std=c11", // 语言标准，可根据自己的需要进行修改，写c++要换成c++的语言标准，比如c++11
            ],
            "group": {  //group表示‘组’，我们可以有很多的task，然后把他们放在一个‘组’里
                "kind": "build",//表示这一组任务类型是构建
                "isDefault": true//表示这个任务是当前这组任务中的默认任务
            },
            "presentation": { //执行这个任务时的一些其他设定
                "echo": true,//表示在执行任务时在终端要有输出
                "reveal": "always", //执行任务时是否跳转到终端面板，可以为always，silent，never
                "focus": false, //设为true后可以使执行task时焦点聚集在终端，但对编译来说，设为true没有意义，因为运行的时候才涉及到输入
                "panel": "new" //每次执行这个task时都新建一个终端面板，也可以设置为shared，共用一个面板，不过那样会出现‘任务将被终端重用’的提示，比较烦人
            },
            "problemMatcher": "$gcc" //捕捉编译时编译器在终端里显示的报错信息，将其显示在vscode的‘问题’面板里
        },
        {//这个大括号里是‘运行(run)’任务，一些设置与上面的构建任务性质相同
            "label": "run", 
            "type": "shell", 
            "dependsOn": "build", //任务依赖，因为要运行必须先构建，所以执行这个任务前必须先执行build任务，
            "command": "${fileDirname}\\bin\\${fileBasenameNoExtension}.exe", //执行exe文件，只需要指定这个exe文件在哪里就好
            "group": {
                "kind": "test", //这一组是‘测试’组，将run任务放在test组里方便我们用快捷键执行
                "isDefault": true
            },
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": true, //这个就设置为true了，运行任务后将焦点聚集到终端，方便进行输入
                "panel": "new"
            }
        }

    ]
}
launch.json

{
    "version": "0.2.0",
    "configurations": [
        {//这个大括号里是我们的‘调试(Debug)’配置
            "name": "Debug", // 配置名称
            "type": "cppdbg", // 配置类型，cppdbg对应cpptools提供的调试功能；可以认为此处只能是cppdbg
            "request": "launch", // 请求配置类型，可以为launch（启动）或attach（附加）
            "program": "${fileDirname}\\bin\\${fileBasenameNoExtension}.exe", // 将要进行调试的程序的路径
            "args": [], // 程序调试时传递给程序的命令行参数，这里设为空即可
            "stopAtEntry": false, // 设为true时程序将暂停在程序入口处，相当于在main上打断点
            "cwd": "${fileDirname}", // 调试程序时的工作目录，此处为源码文件所在目录
            "environment": [], // 环境变量，这里设为空即可
            "externalConsole": false, // 为true时使用单独的cmd窗口，跳出小黑框；设为false则是用vscode的内置终端，建议用内置终端
            "internalConsoleOptions": "neverOpen", // 如果不设为neverOpen，调试时会跳到“调试控制台”选项卡，新手调试用不到
            "MIMode": "gdb", // 指定连接的调试器，gdb是minGW中的调试程序
            "miDebuggerPath": "C:\\Program Files\\mingw64\\bin\\gdb.exe", // 指定调试器所在路径，如果你的minGW装在别的地方，则要改成你自己的路径，注意间隔是\\
            "preLaunchTask": "build" // 调试开始前执行的任务，我们在调试前要编译构建。与tasks.json的label相对应，名字要一样
    }]
}

{
    "version": "2.0.0",
    "tasks": [
        {//这个大括号里是‘构建（build）’任务
            "label": "build", //任务名称，可以更改，不过不建议改
            "type": "shell", //任务类型，process是vsc把预定义变量和转义解析后直接全部传给command；shell相当于先打开shell再输入命令，所以args还会经过shell再解析一遍
            "command": "g++", //编译命令，这里是gcc，编译c++的话换成g++
            "args": [    //方括号里是传给gcc命令的一系列参数，用于实现一些功能
                "${file}", //指定要编译的是当前文件
                "-o", //指定输出文件的路径和名称
                "${fileDirname}\\bin\\${fileBasenameNoExtension}.exe", //承接上一步的-o，让可执行文件输出到源码文件所在的文件夹下的bin文件夹内，并且让它的名字和源码文件相同
                "-g", //生成和调试有关的信息
                "-Wall", // 开启额外警告
                "-static-libgcc",  // 静态链接libgcc
                "-fexec-charset=GBK", // 生成的程序使用GBK编码，不加这一条会导致Win下输出中文乱码
                "-std=c++17", // 语言标准，可根据自己的需要进行修改，写c++要换成c++的语言标准，比如c++11
            ],
            "group": {  //group表示‘组’，我们可以有很多的task，然后把他们放在一个‘组’里
                "kind": "build",//表示这一组任务类型是构建
                "isDefault": true//表示这个任务是当前这组任务中的默认任务
            },
            "presentation": { //执行这个任务时的一些其他设定
                "echo": true,//表示在执行任务时在终端要有输出
                "reveal": "always", //执行任务时是否跳转到终端面板，可以为always，silent，never
                "focus": false, //设为true后可以使执行task时焦点聚集在终端，但对编译来说，设为true没有意义，因为运行的时候才涉及到输入
                "panel": "new" //每次执行这个task时都新建一个终端面板，也可以设置为shared，共用一个面板，不过那样会出现‘任务将被终端重用’的提示，比较烦人
            },
            "problemMatcher": "$gcc" //捕捉编译时编译器在终端里显示的报错信息，将其显示在vscode的‘问题’面板里
        },
        {//这个大括号里是‘运行(run)’任务，一些设置与上面的构建任务性质相同
            "label": "run", 
            "type": "shell", 
            "dependsOn": "build", //任务依赖，因为要运行必须先构建，所以执行这个任务前必须先执行build任务，
            "command": "${fileDirname}\\bin\\${fileBasenameNoExtension}.exe", //执行exe文件，只需要指定这个exe文件在哪里就好
            "group": {
                "kind": "test", //这一组是‘测试’组，将run任务放在test组里方便我们用快捷键执行
                "isDefault": true
            },
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": true, //这个就设置为true了，运行任务后将焦点聚集到终端，方便进行输入
                "panel": "new"
            }
        }

    ]
}

 1 #include<iostream>
 2 #include<tuple>
 3 using namespace std;
 4 
 5 tuple<int,double,string> f()
 6 {
 7     return make_tuple(1, 2.0, "hello");
 8 }
 9 int main()
10 {
11     auto [x,y,z] = f();             
12 
13     cout<< x <<","<< y <<"," <<"z" <<endl;
14 
15     return 0;
16 }

 1 #include<iostream>
 2 #include<tuple>
 3 using namespace std;
 4 
 5 int main()
 6 {
 7     auto t = tuple<int,double,string>(1,2.0,"hello");   //创建一个tuple元组t  
 8 
 9     cout << get<string>(t) << endl;  
10     cout << get<double>(t) << endl;    //get方法在名称空间std中
11     cout << get<int>(t) << endl;  
12 
13     return 0;
14 }

 1 #include<iostream>
 2 #include<tuple>
 3 using namespace std;
 4 
 5 int main()
 6 {
 7     int t1 = 0;
 8     double d1 = 0.0;
 9     string s1 = "";       //必须先定义tie中使用的变量 
10 
11     tie(t1, d1 ,s1) = tuple<int,double,string>(1,2.0,"hello");   //创建一个tuple元组t  
12 
13     cout << t1 << endl;  
14     cout << d1 << endl;    //get方法在名称空间std中
15     cout << s1 << endl;  
16 
17     return 0;
18 }

 1 #include<iostream>
 2 #include<tuple>
 3 using namespace std;
 4 
 5 int main()
 6 {
 7     /* 1、使用make_tuple创建元组,tie拆包方法获取元组内的值 */
 8     int t1 = 0;
 9     double d1 = 0.0;
10     string s1 = "";                                //必须先定义tie中使用的变量 
11 
12     tie(t1, d1 ,s1) = make_tuple(1,2.0,"hello");   //使用make_tuple就可以不用写元组内元素的类型
13 
14     cout << t1 << endl;  
15     cout << d1 << endl;    //get方法在名称空间std中
16     cout << s1 << endl;  
17 
18     /* 2、使用tuple创建元组,get方法获取元组内元素的值 */
19     auto t = tuple<string,int,double>("I'm tiple", 111, 1.0);
20     cout << get<string>(t) << endl;        //获取元组t内类型为string元素的值,C++14支持,必须使用tuple创建元组
21     cout << get<int>(t) << endl;           //获取元组t内类型为double元素的值,C++14支持
22     cout << get<double>(t) << endl;         //获取元组t内类型为int元素的值,C++14支持
23 
24     /* 3、使用make_tuple创建元组,get<index>(元组名字)方法获取元组内元素的值 */
25     auto t2 = make_tuple("world", 12, "hello");
26     cout << get<0>(t2) <<"," << get<1>(t2) << "," << get<2>(t2) << endl;   //使用get<index>(元组名字)方法获取元组元素的值
27 
28     return 0;
29 }

 1 #include <iostream>
 2 
 3 template<int n = 0, typename T0, typename... Ts>
 4 void my_print(T0 value, Ts... args)
 5 {
 6     std::cout << n << ",";              //从模板参数中传递而来
 7     std::cout << value << std::endl;
 8     if constexpr (sizeof...(args) > 0)
 9     {
10         my_print(args...);             //由于这里没有指定模板参数n的值,故下一次调用的时候就会使用n的默认值0
11     }
12 }
13 
14 int main()
15 {
16     my_print<1228>("hello","12.2");
17 
18     return 0;
19 }

 1 #include <iostream>
 2 #include <string>
 3 #include <variant>
 4 
 5 using std::string;
 6 using std::cout;
 7 using std::endl;
 8 using std::variant;
 9 
10 int main()
11 {
12     //创建varialt对象和使用
13     variant<string, double, float,int> var1(3.1f);  //使用float初始化var1
14     cout << var1.index() <<endl;                    //打印float对应的下表2
15 
16     variant<string, double, float,int> var2(3.0);  //使用double初始化var2
17     cout << var2.index() <<endl;                   //打印double对应的下表1
18 
19 
20     return 0;
21 }

 1 #include <iostream>
 2 #include <string>
 3 #include <variant>
 4 
 5 using std::string;
 6 using std::cout;
 7 using std::endl;
 8 using std::variant;
 9 using std::in_place_index;
10 
11 int main()
12 {
13     //为了避免出现歧义,使用std::in_palace_index进行标记是要为那个类型指定值
14     variant<string, double, float, int> var{in_place_index<1>, 3.3}; //in_place_index<1>表示要对double进行赋多个值
15     cout << std::get<1>(var) << endl;
16 
17     cout << "hello" << endl;
18 
19 
20     return 0;
21 }

 1 #include <iostream>
 2 #include <string>
 3 #include <variant>
 4 
 5 using std::string;
 6 using std::cout;
 7 using std::endl;
 8 using std::variant;
 9 using std::in_place_index;
10 
11 struct myVisit
12 {
13     void operator()(int & i) const  //对操作符()进行重载,参数为引用表明可以修改传入的值,也可以不使用引用
14     {
15         i *= 2;
16         cout << i << endl;
17     }
18     void operator()(double & d) const // 
19     {
20         d *= 2;
21         cout << d << endl;
22     }
23     void operator()(string & s) const
24     {
25         s = s + s;
26         cout << s << endl;
27     }
28     void operator()(float & f) const    //必须有这个重载,因为variant对象中有float成员,否则会报错！
29     {
30         f *= 2;
31         cout << f << endl;
32     }
33 };
34 
35 int main()
36 {
37     variant<string, double, float, int> var1("hello"), var2(3.14), var3(12);  //3.14默认为double类型
38     std::visit(myVisit(), var1);   //执行myVisit中的void operator()(string & s)
39     std::visit(myVisit(), var2);   //执行myVisit中的void operator()(double & d) 
40     std::visit(myVisit(), var3);   //执行myVisit中的void operator()(int & i) 
41 
42     cout << std::get<int>(var3) << " " << std::get<double>(var2) << " " << std::get<string>(var1) << endl; 
43 
44 
45     return 0;
46 }

 1 #include <iostream>
 2 #include <string>
 3 #include <variant>
 4 
 5 using std::string;
 6 using std::cout;
 7 using std::endl;
 8 using std::variant;
 9 using std::in_place_index;
10 
11 auto myVisit = [](auto & a)
12 {
13     a = a + a;
14     cout << a << endl;
15 };
16 
17 int main()
18 {
19     variant<string, double, float, int> var1("hello"), var2(3.14), var3(12);  //3.14默认为double类型
20     std::visit(myVisit, var1);   //执行myVisit中的void operator()(string & s)
21     std::visit(myVisit, var2);   //执行myVisit中的void operator()(double & d) 
22     std::visit(myVisit, var3);   //执行myVisit中的void operator()(int & i) 
23 
24     cout << std::get<int>(var3) << " " << std::get<double>(var2) << " " << std::get<string>(var1) << endl; 
25 
26     return 0;
27 }

 1 #include<iostream>
 2 using namespace std;
 3 
 4 //变长参数函数
 5 template<typename... Ts>
 6 void magic(Ts... args)
 7 {
 8     cout << sizeof...(args) << endl;    //使用sizeof...来计算变长参数的个数
 9 }
10 
11 int main()
12 {
13     magic(21);                      //打印1
14     magic(11,22);                   //打印2
15     magic(11,2.0,"hello world");    //打印3
16 
17     return 0;
18 }

 1 #include<iostream>
 2 using namespace std;
 3 
 4 //普通模板函数
 5 template<typename T0>
 6 void magic(T0 arg)
 7 {
 8     cout << arg << endl;
 9 }
10 
11 //变长参数函数
12 template<typename T0, typename... Ts>
13 void magic(T0 t, Ts... args)
14 {
15     cout << t << ",";
16     magic(args...);               //需要特别注意的时这里要写agrs...只写agrs会报错
17 }                                 //等到args只包含一个元素时,执行普通模板函数
18 
19 int main()
20 {
21     magic(11,2.1,"hello world");    //打印3
22 
23     return 0;
24 }
25 
26 /*
27 第一次运行magic(11,2.1,"hello world");会执行变长参数magic,将11赋值给t，将2.1,"hello world"赋值给args...
28 后打印t
29 后执行magic(2.1,"hello world");，执行变长参数magic,将2.1赋值给t，将"hello world"赋值给args...
30 后打印t
31 后执行magic("hello world");此时会执行普通模板函数magic(T0 arg)，将"hello world"赋值给arg并打印
32 
33 */

 1 #include<iostream>
 2 using namespace std;
 3 
 4 //普通模板函数
 5 template<typename T0>
 6 void magic(T0 arg)
 7 {
 8     cout << arg << endl;
 9 }
10 
11 //变长参数函数
12 template<typename T0, typename... Ts>
13 void magic(T0 t, Ts... args)
14 {
15     cout << t << ",";
16     magic(args...);               //需要特别注意的时这里要写agrs...只写agrs会报错
17 }                                 //等到args只包含一个元素时,执行普通模板函数
18 
19 int main()
20 {
21     magic(22);                      //直接执行普通模板函数magic(T0 arg)
22     magic(11,2.1,"hello world");    //打印3
23 
24     return 0;
25 }

 1 #include<iostream>
 2 using namespace std;
 3 
 4 template<typename T0, typename... Ts>
 5 void magic(T0 t, Ts... args)
 6 {
 7     cout << t << ",";
 8     if constexpr (sizeof...(args) > 0)
 9     {
10         magic(args...);
11     }
12 }
13 
14 int main()
15 {
16     magic(22);                       //直接调用magic(T0 t, Ts... args),将T0为int型、22赋值给t,args内参数为空
17     magic(1.1, 22, "Hello world");   //将T0定义为double、1.1赋值给t;22,"Hello world"赋值给args
18 
19     return 0;
20 }

 1 #include <iostream>
 2 using std::endl;
 3 using std::cout;
 4 
 5 class T
 6 {
 7 public:
 8     T(int sz) : size(sz > 0 ? sz:1)
 9     {
10         //使用[]为pc申请一个数组大小的内存. pc = new int(sz); 是申请一个int大小的内存,并将值初始化为sz
11         pc = new int[sz];
12         cout << "T's Construct is called pc:" << pc << endl;
13     }
14 
15     T(const T & t)                   //拷贝构造函数(使用深拷贝,不需要delete [] t.pc)
16     {
17         //释放pc原指向的内存空间---windows上会有报错
18         // if(this->pc != nullptr)
19         // {
20         //     delete [] pc;
21         //     pc = nullptr;
22         // }
23 
24         size = t.size;
25         pc = new int[t.size];
26 
27         for(int index = 0; index < t.size; index++)
28         {
29             pc[index] = t.pc[index];
30         }
31         cout << "T's Copy Construct is called pc:" << pc << endl;
32     }
33 
34     ~T()
35     {
36         if(pc != nullptr)
37         {
38             // 注意:必须要判断pc是否为空,因为可能会有匿名对象和临时对象的pc指向是同一块地址,不判断pc可能会导致重复delete
39             delete [] pc;
40             pc = nullptr;
41         }
42         cout << "T's Deconstruct is called pc:" << pc << endl;
43     }
44 
45 private:
46     //pc作为一个数组使用,size是pc的大小
47     int size;
48     int* pc;
49 };
50 
51 T ReturnValue()
52 {
53     return T(5);
54 }
55 
56 
57 int main()
58 {
59     T t = ReturnValue();
60 
61     return 0;
62 }

 1 #include <iostream>
 2 using std::endl;
 3 using std::cout;
 4 
 5 class T
 6 {
 7 public:
 8     T(int sz) : size(sz > 0 ? sz:1)
 9     {
10         //使用[]为pc申请一个数组大小的内存. pc = new int(sz); 是申请一个int大小的内存,并将值初始化为sz
11         pc = new int[sz];
12         cout << "T's Construct is called pc:" << pc << endl;
13     }
14 
15     T(const T & t)                   //拷贝构造函数(使用深拷贝,不需要delete [] t.pc)
16     {
17         //释放pc原指向的内存空间---windows上会有报错
18         // if(this->pc != nullptr)
19         // {
20         //     delete [] pc;
21         //     pc = nullptr;
22         // }
23 
24         size = t.size;
25         pc = new int[t.size];
26 
27         for(int index = 0; index < t.size; index++)
28         {
29             pc[index] = t.pc[index];
30         }
31         cout << "T's Copy Construct is called pc:" << pc << endl;
32     }
33 
34     T(T && rt)    //移动构造函数(不涉及深拷贝,只设计指针的传递)
35     {
36         size = rt.size;
37         pc = rt.pc;
38 
39         //下面这一句非常重要,因为匿名对象.pc和临时对象.pc指向的是同一块内存,当匿名变量析构时,匿名对象.pc=nullptr
40         //但是临时对象.pc还是原来的值,虽然此时临时对象.pc指向的内存delete了,但是临时对象.pc不是nullptr,所以临时对象
41         //析构时,会再次delete 临时对象.pc，造成重复delete
42         rt.pc = nullptr;
43         cout << "Move Construct is called pc:" << pc << endl;
44     }
45 
46     ~T()
47     {
48         if(pc != nullptr)
49         {
50             // 注意:必须要判断pc是否为空,因为可能会有匿名对象和临时对象的pc指向是同一块地址,不判断pc可能会导致重复delete
51             delete [] pc;
52             pc = nullptr;
53         }
54         cout << "T's Deconstruct is called pc:" << pc << endl;
55     }
56 
57 private:
58     //pc作为一个数组使用,size是pc的大小
59     int size;
60     int* pc;
61 };
62 
63 T ReturnValue()
64 {
65     return T(5);
66 }
67 
68 
69 int main()
70 {
71     T t = ReturnValue();
72 
73     return 0;
74 }

 1 #include <iostream>
 2 using std::endl;
 3 using std::cout;
 4 
 5 class T
 6 {
 7 public:
 8     T(int sz) : size(sz > 0 ? sz:1)
 9     {
10         pc = new int[sz];
11     }
12 
13     T(T && rt)    //移动构造函数(不涉及深拷贝,只设计指针的传递)
14     {
15         size = rt.size;
16         pc = rt.pc;
17         rt.pc = nullptr;
18     }
19 
20     ~T()
21     {
22         if(pc != nullptr)
23         {
24             delete [] pc;
25             pc = nullptr;
26         }
27     }
28 
29 private:
30     //pc作为一个数组使用,size是pc的大小
31     int size;
32     int* pc;
33 };
34 
35 
36 int main()
37 {
38     T t(5);
39     T t_1(std::move(t));  
40 
41     cout << *(t_1.pc) << endl;
42 
43     return 0;
44 }

 1 #include <iostream>
 2 using std::endl;
 3 using std::cout;
 4 
 5 class T
 6 {
 7 public:
 8     T(int sz) : size(sz > 0 ? sz:1)
 9     {
10         pc = new int[sz];
11     }
12 
13     T(T && rt)    //移动构造函数(不涉及深拷贝,只设计指针的传递)
14     {
15         size = rt.size;
16         pc = rt.pc;
17         rt.pc = nullptr;
18     }
19 
20     ~T()
21     {
22         if(pc != nullptr)
23         {
24             delete [] pc;
25             pc = nullptr;
26         }
27     }
28 
29 private:
30     //pc作为一个数组使用,size是pc的大小
31     int size;
32     int* pc;
33 };
34 
35 class MoveAble
36 {
37 public:
38     MoveAble() : pint(new int(3)), t(1024)
39     {
40 
41     }
42 
43     MoveAble(MoveAble && mv) : pint(mv.pint), t(std::move(mv.t))  //std::move(mv.t)将mv.t这个左值转成了右值,故会指向T类的移动构造函数
44     {
45         mv.pint = nullptr;
46     }
47 
48 private:
49     int* pint;
50     T t;
51 };
52 
53 MoveAble GetTemp()
54 {
55     return MoveAble();
56 }
57 
58 int main()
59 {
60     MoveAble m(GetTemp());
61 
62     return 0;
63 }

 1 #include <iostream>
 2 
 3 //注这里必须使用万能引用,否则func(a)会找不到定义
 4 template<typename T>
 5 int func(T && t)
 6 {
 7     std::cout << "void func(T && t) is called" << std::endl;
 8     return 0;
 9 }
10 
11 int main()
12 {
13     int a = 3;
14     func(a); //执行func(a),a是一个左值,会被推到为func(int & &&)形式, int & &&会被折叠为int &,故最终形式为func(int &).注:左值会被推到为左值引用
15     func(3); //执行func(3),3是一个右值,会被推到为func(int && &&)形式,int && &&会被折叠为int &&,故最终形式为func(int &&).注:右值会被推到为右值引用
16 
17     return 0;
18 }
19 
20 /*
21 执行结果：
22 void func(T && t) is called
23 void func(T && t) is called
24 */

 1 #include <iostream>
 2 
 3 int func(int & t)
 4 {
 5     std::cout << "void func(T & t) is called" << std::endl;
 6     return 0;
 7 }
 8 
 9 int func(int && t)
10 {
11     std::cout << "void func(T && t) is called" << std::endl;
12     return 0;
13 }
14 
15 int main()
16 {
17     int a = 3;
18     func(a);    //func(a)中的a是一个左值,故会调用左值引用func(int & t)
19     func(3);    //func(3)中的3是一个右值,故会调用左值引用func(int && t)
20 
21     return 0;
22 }
23 
24 /*
25 执行结果：
26 void func(T & t) is called
27 void func(T && t) is called
28 */

 1 #include <iostream>
 2 
 3 template<typename T>
 4 int func(T & t)
 5 {
 6     std::cout << "void func(T & t) is called" << std::endl;
 7     return 0;
 8 }
 9 
10 template<typename T>
11 int func(T && t)
12 {
13     std::cout << "void func(T && t) is called" << std::endl;
14     return 0;
15 }
16 
17 int main()
18 {
19     int a = 3;
20     func(a); 
21     func(3);    
22 
23     return 0;
24 }

 1 #include <iostream>
 2 
 3 int func(int & t)
 4 {
 5     std::cout << "void func(T & t) is called" << std::endl;
 6     return 0;
 7 }
 8 
 9 int func(int && t)
10 {
11     std::cout << "void func(T && t) is called" << std::endl;
12     return 0;
13 }
14 
15 template<typename T>
16 void PerfectForward(T && t)
17 {
18     func(t);
19 }
20 
21 int main()
22 {
23     int a = 3;
24     PerfectForward(a); 
25     PerfectForward(3);    
26 
27     return 0;
28 }

 1 #include <iostream>
 2 
 3 int func(int & t)
 4 {
 5     std::cout << "void func(T & t) is called" << std::endl;
 6     return 0;
 7 }
 8 
 9 int func(int && t)
10 {
11     std::cout << "void func(T && t) is called" << std::endl;
12     return 0;
13 }
14 
15 template<typename T>
16 void PerfectForward(T && t)
17 {
18     // func(static_cast<T &&>(t)); //或 
19     func(std::forward<T>(t));
20 }
21 
22 int main()
23 {
24     int a = 3;
25     PerfectForward(a); 
26     PerfectForward(3);    
27 
28     return 0;
29 }

 1 #include <iostream>
 2 #include <memory>
 3 
 4 using std::shared_ptr;
 5 using std::cout;
 6 using std::endl;
 7 
 8 struct data_pool_t
 9 {
10  int byte_size;
11  int type;
12  void * ptr;
13 };
14 
15 struct input_t
16 {
17  int byte_size;
18  int type;
19  data_pool_t* data_pool;
20  int num_frame;
21 };
22 
23 int process_data(data_pool_t* pIn)
24 {
25  cout << "none shared_ptr" << endl;
26  
27  return 0;
28 }
29 
30 int process_data(shared_ptr<data_pool_t> pIn)
31 {
32  cout << "shared_ptr.use_count: " << pIn.use_count() << endl;  //shared_ptr.use_count: 2
33  return 0;
34 }
35 
36 int main()
37 {
38  input_t* pInput = new input_t;
39  data_pool_t* pool = new data_pool_t;
40  pInput->data_pool = pool;
41  pInput->byte_size = sizeof(input_t);
42  pInput->type = 1;
43  
44  cout << "address show pInData:" << pInput << ",pool:" << pool << endl;
45  
46  auto release_data = [pInput](data_pool_t* p_pool)   //值捕获上面的pInput,这样就可以当 pool 过期时,不只是可以释放pool的内存,还可以释放pInput的内存
47  {
48   cout << "address show in release_data pInData:" << pInput << ",data_pool in pInput:" << pInput->data_pool << ",p_pool:" << p_pool << endl;
49   cout << "release_data is processed, pInData and data_pool in input are deleted\n";
50   data_pool_t* pool_in_input = pInput->data_pool;
51   delete pool_in_input; pInput->data_pool = nullptr;
52   delete pInput; pInput = nullptr;
53  };
54  
55  // shared_ptr<data_pool_t> data_pool_sharptr = shared_ptr<data_pool_t>(pool,release_data);  //把pool转为智能指针,当data_pool_sharptr过期时,执行删除器release_data
56  shared_ptr<data_pool_t> data_pool_sharptr;
57  data_pool_sharptr.reset(pool, release_data);
58 
59 
60  cout << "shared_ptr.use_count:" << data_pool_sharptr.use_count() << endl;   //pInData是一个shared_ptr类对象,use_count()是该类下的一个成员函数,类对象访问类成员函数式要.而不是->
61  
62  process_data(data_pool_sharptr.get());  //data_sharptr.get()返回一个input_t*，故调用的是process_data(input_t* pInData)
63  
64  process_data(data_pool_sharptr);        //直接使用的是智能指针,故调用的是process_data(shared_ptr<input_t> pInData)
65  
66  
67  return 0;
68 }

 1 #include <iostream>
 2 #include <memory>
 3 
 4 using std::shared_ptr;
 5 using std::cout;
 6 using std::endl;
 7 
 8 
 9 int main()
10 {
11  auto del_func = [](int * p_arr) 
12  {
13   delete [] p_arr;
14  };  //注意:这里有个分号
15  
16  int * arr = new int[10];
17  {
18   //指定了删除器,此时不会有内存泄漏的问题
19   shared_ptr<int> p_arr = shared_ptr<int>(arr, del_func); 
20  }
21  
22  return 0;
23 }

 1 #include <iostream>
 2 #include <memory>
 3 
 4 
 5 int main()
 6 {
 7     int* value = new int(5);
 8 
 9     std::cout << value << ", " << *value << std::endl; 
10 
11     {
12         std::unique_ptr<int> pvalue(value); //ok
13 
14         // std::unique_ptr<int> pvalue = value;  // 非智能指针赋值给智能指针 not ok
15 
16         // std::unique_ptr<int> pcopy = pvalue;  // unique_ptr是独占式智能指针, 不可以赋值 not ok
17 
18         std::unique_ptr<int> pvalue_move = std::move(pvalue);  // 转移pvalue的所有权,现在pvalue指向的内存由pvalue_move接管, pvalue为nullptr
19 
20 
21         std::cout << (pvalue.get()) << ", " << *(pvalue.get()) << std::endl;    //出去pvalue的作用域之后, value指向的内存会被delete
22     }
23 
24     std::cout << value << ", " << *value << std::endl; 
25 
26     return 0;
27 }

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(int argc, char* argv[])
 6 {
 7     int value = 9;
 8 
 9     auto copy_value = [value](int a)  //值捕获,此时value是一个int值,此时会把9拷贝给捕获列表
10     {
11         return value * a;
12     };
13 
14     value = 100;
15 
16     auto v = copy_value(2);
17 
18     cout << "value: " << value << ",copy_value: " << v << endl; //打印结果：value: 100,copy_value: 18
19 
20     return 0;
21 }

 1 /*
 2 lambda表达式基本语法:
 3 [捕获列表](参数列表) mutable(可选)异常属性 -> 返回类型
 4 {
 5     //函数体
 6 };
 7 */
 8 
 9 #include <iostream>
10 
11 using namespace std;
12 
13 int main(int argc, char* argv[])
14 {
15     int* value = new int;
16     *value = 9;
17 
18     auto copy_value = [value](int a)  //值捕获,将value指针的地址拷贝给值捕获列表 注：C++11不支持a的类型写成auto, C++14才开始支持
19     {
20         return (*value) * a;
21     };
22 
23     *value = 100;
24 
25     auto v = copy_value(2);
26 
27     cout << "value: " << *value << ",copy_value: " << v << endl; //打印结果：value: 100,copy_value: 200
28 
29     delete value;
30 
31     return 0;
32 }

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 int main(int argc, char* argv[])
 6 {
 7     int value = 9;
 8 
 9     auto copy_value = [&value](int a)  //引用捕获,此时会捕获列表是value的引用,会随着的value的变化而跟着变化(当value的栈内存不存在了,在lambda表达式中也不会找到value的值了)
10     {
11         return value * a;
12     };
13 
14     value = 100;
15 
16     auto v = copy_value(2);
17 
18     cout << "value: " << value << ",copy_value: " << v << endl; //打印结果：value: 100,copy_value: 200
19 
20     return 0;
21 }

 1 int write_json()
 2 {
 3     ofstream json_file_out("write.json");
 4     json j;
 5 
 6     j["pi"]    = 3.1415;
 7     j["happy"] = true;
 8 
 9     json_file_out << std::setw(4) << j << endl;  //序列化 std::setw(4)用于设置增加打印空格
10 
11     json_file_out.close();
12 
13     return 0;
14 }

 1 #include <iostream>
 2 #include <stdio.h>
 3 
 4 #define NONE                 "\e[0m"
 5 #define BLACK                "\e[0;30m"
 6 #define L_BLACK              "\e[1;30m"
 7 #define RED                  "\e[0;31m"    
 8 #define L_RED                "\e[1;31m"    //高亮红色
 9 #define GREEN                "\e[0;32m"
10 #define L_GREEN              "\e[1;32m"
11 #define BROWN                "\e[0;33m"
12 #define YELLOW               "\e[1;33m"
13 #define BLUE                 "\e[0;34m"
14 #define L_BLUE               "\e[1;34m"
15 #define PURPLE               "\e[0;35m"
16 #define L_PURPLE             "\e[1;35m"
17 #define CYAN                 "\e[0;36m"
18 #define L_CYAN               "\e[1;36m"
19 #define GRAY                 "\e[0;37m"
20 #define WHITE                "\e[1;37m"
21 
22 #define BOLD                 "\e[1m"
23 #define UNDERLINE            "\e[4m"
24 #define BLINK                "\e[5m"
25 #define REVERSE              "\e[7m"
26 #define HIDE                 "\e[8m"
27 #define CLEAR                "\e[2J"
28 
29 #define ALG_NAME "log_test"
30 
31 int g_log_level = 0;
32 
33 enum LOGLEVEL
34 {
35     LOG_LEVEL_ERR = 1,
36     LOG_LEVEL_WARN
37 };
38 
39 #define LOGW(fmt,args ...) \
40 do \
41 { \
42     if(g_log_level & LOG_LEVEL_WARN) \
43     { \
44         printf(YELLOW "[%s]WARN[%s|%d]" fmt, ALG_NAME,__func__,__LINE__,##args); \
45         printf(NONE); \
46     } \
47 } \
48 while(0)
49 
50 #define LOGE(fmt,args ...) \
51 do \
52 { \
53     if(g_log_level & LOG_LEVEL_ERR) \
54     { \
55         printf(L_RED "[%s]ERROR (%s|%d): " fmt, ALG_NAME, __func__, __LINE__, args); \
56         printf(NONE); \
57     } \
58 } \
59 while(0)
60 
61 int add(const int & a, const int & b)
62 {
63     LOGW("process is in add(%d,%d)\n",a,b);
64     LOGE("process is in add(%d,%d)\n",a,b);  //fmt = process is in add(%d,%d)  剩余的参数(a和b)给到了args中
65     return a+b;
66 }
67 
68 int main()
69 {
70     g_log_level = 3;
71     int c =  add(1,2);
72 
73     return 0;
74 }

 1 #pragma onece
 2 
 3 #include <memory>  //for std::shared_ptr
 4 
 5 /**< Base类的声明可以放在对外头文件中,供外部继承使用,而Base::Impl声明可以在内部头文件中,供内部实际实现,即封装 */
 6 class Base {
 7 private:
 8     class Impl;
 9     std::shared_ptr<Impl> impl;
10 public:
11     Base();
12     virtual ~Base();
13     virtual int initialize();
14     virtual int create();
15 };
16 
17 /**< 由于Impl是在类Base中声明的,故在声明Impl类时,要加上Base:: */
18 class Base::Impl {
19 public:
20     Impl(){}
21     ~Impl(){}
22 
23     int initializeImpl();
24     int createImpl();
25 };

 1 #include "nested_class.h"
 2 #include <iostream>
 3 
 4 int main(int agrc, char *argv[])
 5 {
 6     Base b;
 7     b.initialize();
 8     b.create();
 9 
10     return 0;
11 }

 1 #include "nested_class.h"
 2 #include <iostream>
 3 
 4 /**< Base类内方法实现 */
 5 Base::Base() : impl(new Impl){}
 6 Base::~Base(){}
 7 
 8 int Base::initialize()
 9 {
10     std::cout << "Base::initializ is called" << std::endl;
11     impl->initializeImpl();
12     return 0;
13 }
14 
15 int Base::create()
16 {
17     std::cout << "Base::create is called" << std::endl;
18     impl->createImpl();
19     return 0;
20 }
21 
22 /**< Base类内声明的Impl类方法实现 */
23 int Base::Impl::createImpl()
24 {
25     std::cout << "Base::Impl::createImpl is called" << std::endl;
26     return 0;
27 }
28 
29 int Base::Impl::initializeImpl()
30 {
31     std::cout << "Base::Impl::initializeImpl is called" << std::endl;
32     return 0;
33 }

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 
 6 #define _LOGINFO 1
 7 
 8 #define LOG(level) _LOG ## level  //把_LOG和入参level代表的字符串拼接起来,注:如果没_LOGINFO的定义编译会报错
 9 
10 
11 int main(int argc, char* argv[])
12 {
13     std::cout << LOG(INFO) << std::endl;  //打印1
14 
15     return 0;
16 }

 1 #include <iostream>
 2 #include <sstream>
 3 
 4 using namespace std;
 5 
 6 
 7 
 8 namespace my_glog
 9 {
10     class MY_LOG
11     {
12     private:
13         std::ostringstream out;
14         int log_level;
15 
16     public:
17         MY_LOG(int v) : log_level(v){ std::cout << "MY_LOG(int v) is called\n"; }
18         
19         template<typename T>
20         MY_LOG& operator<<(const T & a)
21         {
22             std::cout << "operator = is called\n";
23             if(log_level)
24             {
25                 out << a;
26                 std::cout << out.str() << std::endl;
27             }
28             return *this;
29         }
30 
31         MY_LOG(my_glog::MY_LOG&&) { std::cout << "MY_LOG(my_glog::MY_LOG&&) is called\n"; };
32         MY_LOG(my_glog::MY_LOG&) {std::cout << "MY_LOG(my_glog::MY_LOG&) is called\n";};
33     };
34     
35     enum MY_LEVEL
36     {
37         ERROR = 0,
38         WARN,
39         INFO,
40         DEBUG,
41     };
42 
43 }//end my_glog
44 
45 
46 
47 struct glog_info
48 {
49     int level;
50     //待扩展
51 };
52 
53 struct glog_verify
54 {
55     glog_info log_info;
56 
57     glog_verify(){log_info.level = 1;}        //默认值3
58     glog_verify(int v){log_info.level = v;}             
59 
60     int vevify(int value)
61     {
62         std::cout << ((1<<value) & log_info.level) << std::endl;
63         return ((1<<value) & log_info.level);
64     }
65 };
66 
67 static glog_verify g_test;
68 
69 int glog_veiry_other(int level)
70 {
71     return g_test.vevify(level);
72 }
73 
74 
75 // #define _LOGINFO my_glog::MY_LOG(my_glog::INFO)
76 // #define _LOGERROR my_glog::MY_LOG(my_glog::ERROR)
77 // #define _LOGWARN my_glog::MY_LOG(my_glog::WARN)
78 // #define _LOGDEBUG my_glog::MY_LOG(my_glog::DEBUG)
79 
80 
81 #define _LOGINFO   !glog_veiry_other(my_glog::ERROR) ? 0 : my_glog::MY_LOG(my_glog::INFO)
82 
83 #define LOG(level) _LOG ## level  //把_LOG和入参level代表的字符串拼接起来,注:如果没_LOGINFO的定义编译会报错
84 
85 
86 int main(int argc, char* argv[])
87 {
88     LOG(INFO) << "hello";
89 
90     return 0;
91 }

  1 #include <iostream>
  2 #include <sstream>
  3 #include <unordered_map>
  4 
  5 using namespace std;
  6 
  7 static const char green[]       = "\033[0;32;32m";
  8 static const char red[]         = "\033[0;32;31m";
  9 static const char yellow[]      = "\033[1;33m";
 10 static const char cyan[]        = "\033[0;36m";
 11 static const char purple[]      = "\033[0;35m";
 12 static const char blue[]        = "\033[0;32;34m";
 13 static const char no_color[]    = "\033[m";
 14 
 15 enum MY_LEVEL
 16 {
 17     UNKNOW = 0,
 18     ERROR,
 19     WARN,
 20     DEBUG,
 21     INFO,
 22 };
 23 
 24 static std::unordered_map<int, const char*> map_log_color = 
 25 {
 26     {ERROR, red},
 27     {WARN,  yellow},
 28     {DEBUG, purple},
 29     {INFO,  green},
 30 };
 31 
 32 const char* get_log_color(int level)
 33 {
 34     return map_log_color.count(level) ? map_log_color.at(level) : red;
 35 }
 36 
 37 namespace my_glog
 38 {
 39     class MY_LOG
 40     {
 41     private:
 42         std::ostringstream out;
 43         int log_level;
 44 
 45     public:
 46         MY_LOG(int v, const char* module_name, const char* file_name, const char* function_name, const int line) : log_level(v)
 47         {
 48             // 添加一些颜色打印，和模块名字、文件名字、行号打印
 49             out << get_log_color(log_level) << "[" << module_name << "][" << file_name << " " << function_name << ":" << line << "] ";
 50         }
 51         
 52         template<typename T>
 53         MY_LOG& operator<<(const T & a)
 54         {
 55             out << a;
 56             return *this;
 57         }
 58 
 59         MY_LOG(my_glog::MY_LOG&& L) : log_level(L.log_level) {};
 60         MY_LOG(const my_glog::MY_LOG& L) : log_level(L.log_level) {};
 61         ~MY_LOG() {}
 62 
 63         void log_end()
 64         {
 65             out << no_color;  //带颜色打印后恢复无颜色
 66             std::cout << out.str() << std::endl;
 67             std::cout.flush();
 68         }
 69     };
 70 
 71 }//end my_glog
 72 
 73 
 74 /**< 以下可定义在glog_verify.h中,在log_glog.cpp中包含进来 */
 75 struct glog_info
 76 {
 77     int level;
 78     //待扩展
 79 };
 80 
 81 struct glog_verify
 82 {
 83     glog_info log_info;
 84 
 85     glog_verify(){log_info.level = 3;}        //默认值3
 86     glog_verify(int v){log_info.level = v;}             
 87 
 88     glog_info & get_log_info()
 89     {
 90         return log_info;
 91     }
 92 
 93     int set_log_info(int value)
 94     {
 95         log_info.level = value;
 96     }
 97 };
 98 
 99 static glog_verify g_test;
100 
101 //一下是三个对外接口
102 int glog_log_is_on(int level)
103 {
104     glog_info & log = g_test.get_log_info();
105     return (level) & log.level;
106 }
107 
108 bool glog_log_is_off(int level)
109 {
110     return !glog_log_is_on(level);
111 }
112 
113 void glog_log_set_level(int value)
114 {
115     g_test.set_log_info(value);
116     return;
117 }
118 
119 /**< end of glog_verify.h */
120 
121 
122 struct log_write
123 {
124     //这里必须使用引用,否则传进来的实参和形参的地址不一样!!
125     void operator && (my_glog::MY_LOG & L) { L.log_end(); }
126 };
127 
128 #define __MODULENAME__ "mg_glog"
129 #define __FILENAME__ "log_glog.cpp"
130 #define _LOGPERFIX(level) my_glog::MY_LOG(level, __MODULENAME__, __FILENAME__, __FUNCTION__, __LINE__)
131 //这里必须使用(void)0,否则会报错:third operand to the conditional operator is of type ‘void’, but the second operand is neither a throw-expression nor of type ‘void’
132 //my_glog::MY_LOG(my_glog::INFO)返回的MY_LOG对象大概率是作为了log_write类中operator&&方法的实参了
133 #define _LOGINFO   glog_log_is_off(INFO)  ? (void)0 : log_write() && _LOGPERFIX(INFO)
134 #define _LOGERROR  glog_log_is_off(ERROR) ? (void)0 : log_write() && _LOGPERFIX(ERROR)
135 #define _LOGWARN   glog_log_is_off(WARN)  ? (void)0 : log_write() && _LOGPERFIX(WARN)
136 
137 #define LOG(level) _LOG##level  //把_LOG和入参level代表的字符串拼接起来,注:如果没_LOGINFO的定义编译会报错
138 
139 
140 int main(int argc, char* argv[])
141 {
142     glog_log_set_level(15);
143 
144     LOG(INFO) << "INFO" << " you " << 007;
145     LOG(WARN) << "WARN" << " you " << 007;
146     LOG(ERROR) << "ERROR" << " you " << 007;
147 
148     return 0;
149 }

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class Base
 6 {
 7 public:
 8     int a_base;
 9     Base(int a):a_base(a){}
10     Base(const Base & b):a_base(b.a_base){}
11     ~Base(){}
12     virtual void func1(){ cout << "Base::func1" << endl; }
13     void func2();
14     virtual void func3();
15 };
16 
17 void Base::func2()
18 {
19     cout << "Base::func2" << endl; 
20     Base::func3();
21 }
22 void Base::func3()
23 {
24     cout << "Base::func3" << endl;
25 }
26 
27 class Normal : public Base
28 {
29 public:
30     int n_base;
31     Normal(int n, int a):Base(a),n_base(n){}
32     Normal(const Normal& n):Base(0),n_base(n.n_base){}
33     ~Normal(){}
34     virtual void func1(){ cout << "Normal::func1" << endl; }
35     virtual void func3();
36 };
37 
38 void Normal::func3()
39 {
40     cout << "Normal::func3" << endl;
41 }
42 
43 
44 int main()
45 {
46     Base* b = new Normal(12,13);
47 
48     b->func1();
49     b->func2();
50     return 0;
51 }

 1 #include <iostream>
 2 
 3 using namespace std;
 4 
 5 class Base
 6 {
 7 public:
 8     Base(int p) : point(p){ *total_point+= p; }
 9     ~Base(){}
10     static int get_point();
11     static void init_point();
12 
13 private:
14     static int* total_point;
15     int point;
16 };
17 
18 int* Base::total_point = nullptr;  //静态变量必须在类外声明一下,可以先不申请内存 
19 
20 void Base::init_point()
21 {
22     total_point = new int(0);  //在这里即可调用开源库中封装的函数对静态变量进行初始化
23 }
24 
25 int Base::get_point()
26 {   
27     return *total_point;
28 }
29 
30 int main()
31 {
32     Base::init_point();  //必须在创建Base对象之前调用,因为在Base构造函数中使用了total_point,若此时为申请内存,则段错误
33 
34     Base b1(10),c(20);
35 
36     std::cout << "total point:" << Base::get_point() <<std::endl;  //total point:30
37 
38     return 0;
39 }

 1 #include <iostream>
 2 
 3 using uchar_8  = unsigned char;
 4 using sint_32  = signed int;
 5 using uint_32  = unsigned int;
 6 
 7 //以下宏定义类似定义一个uchar_8类型的数组unused##label,用于指针8字节对齐
 8 #define MY_STRUCT_ALIGNE8(label) uchar_8 unused##label[8-sizeof(void*)]
 9 //以下宏定义类似定义一个uchar_8类型的数组check##label,如果大小不相等,则数组大小为-1,进而编译出错,用于检测结构体大小是否正确
10 #define CHECK_SIZE(label,size) uchar_8 check##label[sizeof(label)==size ? 0:-1]
11 
12 struct data
13 {
14     sint_32 size;
15     uint_32 type;  //32位,4个字节
16 
17     sint_32* value;
18     MY_STRUCT_ALIGNE8(value);
19 
20     sint_32 len;
21 
22     sint_32 reverse[11];
23 };
24 CHECK_SIZE(data, 64);
25 
26 
27 
28 int main()
29 {
30     std::cout << "sizeof(data):" << sizeof(data) << std::endl;
31     return 0;
32 }

 1 可以将非const变量作为实参，传递给const变量形参
 2 
 3 #include <iostream>
 4 
 5 using namespace std;
 6 
 7 enum CMD_TEST
 8 {
 9     STRUCT_TEST_UNKNOWN = 0,
10     STRUCT_TEST_V1 = 1
11 };
12 
13 
14 struct struct_test_v1
15 {
16     int v1;
17     float v2;
18 };
19 
20 
21 int working(int cmd, const void * param)
22 {
23   if(cmd == STRUCT_TEST_V1)
24   {
25     //先将param从const void*转成const struct_test_v1*，再使用const_cast去掉const属性
26     struct_test_v1* test_v1 = const_cast<struct_test_v1*>(reinterpret_cast<const struct_test_v1*>(param));
27   }
28   //之后即可使用没有const属性的param了
29   
30   return 0;
31 }
32 
33 
34 
35 int main()
36 {
37     struct_test_v1 v1 = {0};
38 
39     working(1, &v1);  //即可以将非const变量传参传递给const变量
40 
41     return 0;
42 }