1. C++风格数组初始化：
#include <iostream> #include <array> using namespace std; void main() { //CPP一维数组初始化 array<int, 10>MyInt{ 1,2,3,4,5,6,7,8,9,10 }; for (auto i : MyInt) { cout << i << " " << (void *)&i << endl; } //CPP二维数组初始化 array<int, 10>MyInt1{ 11,2,3,4,5,6,7,8,9,10 }; array<int, 10>MyInt2{ 21,2,3,4,5,6,7,8,9,10 }; array<int, 10>MyInt3{ 31,2,3,4,5,6,7,8,9,10 }; array<array<int, 10>, 3>myInt{ MyInt1,MyInt2,MyInt3 }; for (auto j : myInt) { for (auto i : j) { cout << i << " "; } cout << endl; } cin.get(); }
2. CPP别名：
#include <iostream> using namespace std; //一般情况，原则上都用using取代typedef //typedef处理不了模板，处理不了命名空间，统一用using typedef double DB; //C风格 using DBCPP = double; //CPP风格别名 //数组别名 typedef int a[10]; using IntArray = int[10]; //函数指针 typedef int(*p)(int a, int b); //函数指针类型，p using pFun = int(*)(int a, int b); //CPP函数指针别名 //函数指针数组 typedef int(*pa[10])(int a, int b); using ppFun = int(*[10])(int a, int b); void main() { cout << sizeof(DB) << endl; //8 cout << sizeof(DBCPP) << endl; //8 IntArray int1; cout << sizeof(int1) << endl; //40 cin.get(); }
3. auto 使用：
#include <iostream> using namespace std; //C++14自动推理返回值类型 //C++11需要指定返回值类型 auto add(int a, int b)->int //此处int可换为decltype(a+b) { return a + b; } //数控科技面试题：请问f是什么？ auto (*f)()->int(*)(); //int(* (*fx)() )() //返回值是函数指针 //请推理下面pf是什么类型? auto pf1()->auto(*)()->int(*)() { return nullptr; //返回空指针 } auto pf2(void)->auto(*)(int x)->int(*)(int a,int b) { return nullptr; //返回空指针 } //int(* (*)(int x) )(int a,int b) //int(* (* pf2(void) )(int x) )(int a,int b) //int(*(* (void) )(int))(int,int) auto go(int a, int b)->auto(*)()->int (*)(int, int(*)(int, int)); //int (* (*)() )(int, int(*)(int, int)) //int (* (* go(int a, int b) )() )(int, int(*)(int, int)) //int (* (* (int, int))(void))(int, int (*)(int,int)) void main() { cout << typeid(f).name() << endl; cout << typeid(pf1).name() << endl; cout << typeid(pf2).name() << endl; cout << typeid(go).name() << endl; cin.get(); }
4. 函数模板的别名：
#include <iostream> #include <array> using namespace std; //C++14自动推理返回值类型 //C++11需要指定返回值类型 template<class T1,class T2> auto add(T1 t1, T2 t2)->decltype(t1 + t2) //此处int可换为decltype(a+b) { return t1 + t2; } //函数模板的别名 template<class T> using t = T; template<class T> using tp = T*; template<class T> void show(T tx) { t<int> t1(tx); //一旦使用别名必须指定类型 <int> tp<int> tp1(&tx); //初始化指针 cout << t1 << " " << tp1 << endl; } template<class T> using ten = array<T, 10>; void main() { cout << add(1, 2) << endl; //3 cout << add(1.1, 2.2) << endl; //3.3 int a = 10; show(a); using IntArray = array<int, 10>; //相当于为模板起了别名，明确地指明了类型为array<int, 10> array<int, 10> MyInt; //此时array<int, 10>代表一个类型 IntArray MyInt2; //template<class T> using t = array<T, 10>; //error C2951: 模板 声明只能在全局、命名空间或类范围内使用 ten<int> t1{ 1,2,3,4,5,6,7,8,9,10 };//模板别名不明确类型 for (auto i : t1) { cout << i << " "; } cin.get(); }
5. 收缩转换：
#include <iostream> using namespace std; void main() { char ch1(787878); char ch2{ 787878 }; //赋初始值最好用大括号,保证数据类型安全转换 cout << (int)ch1 << endl; //-90 编译通过，产生溢出 cout << (int)ch2 << endl; //编译不通过，error C2397: 从“int”转换到“char”需要收缩转换 cin.get(); }
6. 二进制：
#include <iostream> using namespace std; void main() { int a = 0b1001; int b = 0B1101; cout << a << endl; //9 cout << b << endl; //13 cin.get(); }
7. 常量表达式constexpr ：
#include <iostream> using namespace std; int get1() { return 5; } constexpr int get2() //constexpr返回值或其他表达式为常量 { return 5; } void main() { //int a[5+get1()]; //error C2131: 表达式的计算结果不是常数 int a[5 + get2()]; //编译成功 cin.get(); }
8. lambda 表达式：
#include <iostream> using namespace std; void main() { [] {cout << "hello world!" << endl; }(); //解决函数怀孕现象 auto fun = [] {cout << "hello" << endl; }; //函数指针 fun();//调用 [] {cout << "hello C" << endl; }(); //匿名lambda表达式 [](char *str) {cout << str << endl; }("你好！");//带参数(匿名) auto fun1 = [](double a, double b) {return a + b; }; cout << fun1(10, 20.1) << endl; //30.1 auto fun2 = [](double a, double b)->int {return a + b; }; //指定返回值类型,->在()与{}之间 cout << fun2(10, 20.1) << endl; //30 int num = 100; auto func = [](int num) {num = 5, cout << num << endl; };//遵循副本机制 func(num); //5 cout << "main=" << num << endl; //main=100 cin.get(); }
#include <iostream> #include <array> #include <algorithm> using namespace std; void main() { int num1 = 100; int num2 = 99; //[]() {cout << num1 << " " << num2 << endl; }();//error C3493: 无法隐式捕获“num1”，因为尚未指定默认捕获模式 [=]() {cout << num1 << " " << num2 << endl; }(); //100 99 //[=]() {num1=10,num2=20,cout << num1 << " " << num2 << endl; }();//error C3491: “num1”: 无法在非可变 lambda 中修改通过复制捕获 [&]() {num1 = 10, num2 = 20, cout << num1 << " " << num2 << endl; }();//=只能读不可写；&读写外部变量 cout << "main=" << num1 << " " << num2 << endl; //main=10 20 int num3 = 100; int num4 = 99; [=]()mutable {num3 = 10, num4 = 20, cout << num3 << " " << num4 << endl; }(); //10 20 mutable起到副本作用 cout << "main=" << num3 << " " << num4 << endl; //100 99 int a = 10, b = 9, c = 8; //a可读可写，bc只可读 [&a, b, c]() {a = 20, cout << a << " " << b << " " << c << endl; }(); //20 9 8 //mutable副本，能读能写,读的原本，写的副本 [a, b, c]()mutable {a = 1, b = 2, c = 3, cout << a << " " << b << " " << c << endl; }(); //1 2 3 array<int, 10>MyInt{ 1,2,3,4,5,6,7,8,9,10 }; //lambda表达式嵌入使用 for_each(MyInt.begin(), MyInt.end(), [](int num) {cout << num << " "; }); //显示 cout << endl; for_each(MyInt.begin(), MyInt.end(), [](int &num) {num += 1, cout << num << " "; }); //修改 cout << endl; for_each(MyInt.begin(), MyInt.end(), [](int num) {cout << num << " "; }); //显示 cin.get(); }
9. 函数包装器：
#include <iostream> #include <functional> //函数包装器头文件 using namespace std; using std::function; //函数包装器 void go() { cout << "go" << endl; } int ADD(int a, int b) { return a + b; } void main() { function<void(void)> fun1 = go; //包装函数 fun1(); function<void(void)> fun2 = []() {cout << "go lambda" << endl; };//包装lambda表达式 fun2(); function<int(int, int)> fun3 = ADD; cout << fun3(10, 19) << endl; function<int(int, int)> fun4 = [](int a, int b)->int {return a + b; }; cout << fun4(10, 19) << endl; cin.get(); }
10. 模板元
#include <iostream> using namespace std; int get50(int n) { if (n == 1) return 1; else if (n == 2) return 2; else return get50(n - 1) + get50(n - 2); } //递归调用：函数反复调用，等待返回，浪费时间较多 //模板元实现递归加速 //执行速度快，编译的时候慢，代码会增加 //把运行的时间节约在编译的时候 //常使用在递归加速，游戏优化，此处的模板元仅仅适用于C++11 template<int N> struct data { //递归表达式 enum { res = data<N - 1>::res + data<N - 2>::res }; }; template<> struct data<1> { enum { res = 1 }; }; template<> struct data<2> { enum { res = 2 }; }; void main() { cout << data<40>::res << endl; //模板元，代码加速(将运行时间放在编译中执行) cout << get50(40) << endl; cin.get(); }
11. C++中的const :
#include <iostream> using namespace std; void run1(const int *p); //可改变地址，不可改内容 void run2(int const *p); // void run3(int * const p); //不可改地址，可改内容 void run4(const int * const p); //地址内容均不能改 void run5(int const * const p); // void main() { //C语言中： //const int num = 10; //*(int *)(&num) = 4; //printf("%d ", num); //4 //const int n = 10; //int a[n]; //C++编译器自动优化，将n直接替换为10 //int a = 10; //const int n = a; //此时C++编译器不敢乱优化，不敢把n直接替换为a //int data[n]; //error C2057: 应输入常量表达式 //const int a = 10; //const int n = a; //int data[n]; //const int num = 10; //*(int *)(&num) = 3; //cout << (void *)&num << endl; //优化，强行替换为10，寄存器 //cout << *(&num) << endl; //10 //cout << num << endl; //10 //int a = 10; //const int num = a; //*(int *)(&num) = 3; //cout << (void *)&num << endl; //直接读内存，此时为变量，不敢优化 //cout << *(&num) << endl; //3 //cout << num << endl; //3 const int num[5] = { 1,2,3,4,5 }; const int *p = num; *(int *)p = 100; //const数组没有优化，可以间接改变 for (auto i : num) cout << i << " "; //100 2 3 4 5 cout << endl; cin.get(); }
12. 智能指针：
#include <iostream> #include <memory> #include <Windows.h> using namespace std; void cmem() { while (1) { double *p = new double[1024 * 1024 * 10]; Sleep(3000); delete p; //释放 Sleep(3000); } } void autoptr() { while (1) { double *p(new double[1024 * 1024 * 10]); auto_ptr<double>autop(p); //创建智能指针，接管这片内存，会自动回收 Sleep(3000); } } void autoptrnew() { while (1) { Sleep(6000); unique_ptr<double>p(new double[1024 * 1024 * 10]); Sleep(6000); } } void main() { //cmem(); autoptr(); autoptrnew(); cin.get(); }
13. 多元数组 tuple ：
#include <iostream> #include <tuple> using namespace std; //多元数组，存取不同的数据类型 void main() { char ch = 'X'; short sh = 12; int num = 1234567; double db = 123; char *p = "calc"; tuple<char, short, int, double, char *>MyTuple(ch, sh, num, db, p); auto autov1 = get<0>(MyTuple); //多元数组不能用for(auto i:MyTuple)的方式遍历 cout << autov1 << endl; auto autov2 = get<1>(MyTuple); cout << autov2 << endl; auto autov3 = get<2>(MyTuple); cout << autov3 << endl; auto autov4 = get<3>(MyTuple); cout << autov4 << endl; auto autov5 = get<4>(MyTuple); cout << autov5 << endl; cin.get(); }
14. 左值引用与右值引用：
#include <iostream> using namespace std; //C++能用引用的情况，就别用指针 void change(int & rnum) { rnum = 111; } void main0501() { //int num(10); //num是左值，有内存实体，可以赋值 int num=10; //int & rnum(num); //引用&就是变量的别名 // //rnum = 1; //rnum等价于num的别名 //change(num); //cout << num << endl; //111 //int num = 1; //int data = 0; //cout << (void *)&data << endl; //data = num + 1; //data = num + 2; //data = num + 3; //cout << data << endl; //右值引用 int num = 1; int && rnum(num + 4); //右值引用,快速备份寄存器的值。编译器会自动回收 printf("%p ", &rnum); //若是左值引用，需要两步： int data = num + 4; int &rdata(data); int a[5]{ 1,2,3,4,5 }; int *p(a); cout << *p << endl; //1 int * & rp(p); //左值引用改变指针 & 放在类型与变量名之间 rp += 1; cout << *p << endl; //2 int * && rrp(p + 2); //右值引用改变指针 && //int * && rrp(&a[1]); cout << *rrp << endl; //4 cin.get(); } void showit(int && rrnum) //右值引用 { cout << rrnum << endl; } void main() { int a[5]{ 1,2,3,4,5 }; showit(a[3] + 2); //移动语义：将左值转化为右值(左值一定可以变为右值，右值不一定可变为左值) showit(move(a[3])); cin.get(); }
15. 引用的本质：
#include <iostream> using namespace std; void main0601() { int num = 10; int data = 20; int & rnum(num); //引用一旦初始化，就不会再引用其他变量 rnum = data; cout << num << endl; //20 cout << data << endl; //20 cin.get(); } void main() { double db; //double & rdb; //error C2530: “rdb”: 必须初始化引用 double & rdb(db); cout << sizeof(rdb) << endl; //8 struct MyStruct //引用的本质是指针实现的，为了简化程序 { double & rdb; }; cout << sizeof(MyStruct) << endl; //4 cin.get(); }
16. 引用指针以及作为函数参数和函数返回值：
#include <iostream> using namespace std; //改变指针，需要二级指针 //C++中可用引用 void main0701() { int a(4); //初始化为4 int *p(new int(5)); //开辟int大小空间,值为5 cout << a << endl; //4 cout << *p << endl; //5 //int & ra(a); //引用变量 //int * & rp(p); //引用指针 //ra = 3; //*rp = 12; //cout << a << endl; //3 //cout << *p << endl; //12 int && rra(move(a)); //右值引用，有内存实体就直接引用，没有内存实体则新开辟内存 int * && rrp(move(p)); rra = 1; cout << rra << endl; cout << a << endl; //int 整数类型 //int & 引用整数，本质是指针 //int && 引用整数，本质是指针，能处理左值（move） 和右值 cin.get(); } int num1 = 10; int num2 = 20; void change(int * &rp) //C++中能用引用就别用指针 { rp = &num2; } void main0702() { int *p = &num1; change(p); cout << *p << endl; //20 cin.get(); } void main0703() { int *p(nullptr); int **pp(&p); int ** &rpp(pp); //VS2015 C++14 //int **pp(&p); //int(** (&rpp))(pp); //VS2013 C++11 cin.get(); } void main0704() { int ***ppp(nullptr); int *** & rppp(ppp); cin.get(); } int data1 = 10; int data2 = 20; int *p = &data1; void changeit(int ** &rpp) { *rpp = &data2; } void main0705() { int **pp = &p; //二级指针 cout << **pp << endl; //10 changeit(pp); cout << **pp << endl; //20 cin.get(); } //返回一个引用a int getdata() { int num = 10; return num; //函数返回值有副本机制 } void main0706() { cout << getdata() << endl; //10 cin.get(); } //函数返回值有副本机制,返回变量 //栈区，自动回收、释放，返回为指针不能指向栈区，返回为引用不能应用栈区 int & getdata1() { int num = 10; return num; //函数返回值有副本机制 } void main0707() { int & rnum = getdata1(); //此时引用的是原来的内存，调用后已经释放 cout << "hello" << endl; cout << rnum << endl; //此处结果并不是10 int rnum2 = getdata1(); //拷贝到新的内存rnum2中 cout << rnum2 << endl; //10 cin.get(); } int & getdata2() { int *p(new int(5)); //堆区 return *p; } void main0708() { int & rnum = getdata2(); //此时引用的是堆区 cout << "hello" << endl; cout << rnum << endl; //5 cin.get(); } char * & getcode() { char *p = "hellohellohello"; //常量字符串-->代码区（与程序供存亡） return p; //p在栈上，但指向内容在代码区 } void main() { char * &rp = getcode(); //指针，引用p,但这个p在栈上，消亡了 char * newp = rp; //保存rp存储代码区地址 cout << "hello china" << endl; cout << newp << endl; //hellohellohello cout << rp << endl; //乱码 cin.get(); }
17. 引用数组：
#include <iostream> using namespace std; void main0801() { int a[5]{ 1,2,3,4,5 }; //一维数组 int *pa[5]{ a,a + 1,a + 2,a + 3,a + 4 }; //指针数组 int b[2][3]{ 1,2,3,4,5,6 }; //二维数组 //二维数组，每一个元素是一个指针 int *pb[2][3]{ &b[0][0],&b[0][0] + 1,&b[0][0] + 2,&b[0][0] + 3,&b[0][0] + 4,&b[0][0] + 5 }; int *p1(new int[5]{ 1,2,3,4,5 }); //堆上的一维数组 int(*p2)[4] = new int[3][4]{ {1,2,3,4},{5,6,7,8},{9,10,11,12} }; //堆上的二维数组 cin.get(); } void main0802() { int a[5]{ 1,2,3,4,5 }; int(&ra)[5](a); //引用一维数组 for (auto i : ra) cout << i << " "; cout << endl; int *pa[5]{ a,a + 1,a + 2,a + 3,a + 4 }; int *(&rpa)[5](pa); //引用指针数组 for (auto i : rpa) cout << *i << " "; cout << endl; cin.get(); } void main0803() { int *p1(new int[5]{ 1,2,3,4,5 }); int **pp(new int *[5]{ p1,p1 + 1,p1 + 2,p1 + 3,p1 + 4 }); //堆上指针数组 int * &rp(p1); int ** &rpp(pp); cin.get(); } void main0804() { int b[2][3]{ 1,2,3,4,5,6 }; //二维数组 //二维数组，每一个元素是一个指针 int *pb[2][3]{ &b[0][0],&b[0][0] + 1,&b[0][0] + 2,&b[0][0] + 3,&b[0][0] + 4,&b[0][0] + 5 }; int(&rb)[2][3](b); //引用二维数组 int *(&rpb)[2][3](pb); //引用二维指针数组 cin.get(); } void main() { //int(*p2)[4] = (new int[3][4]{ { 1,2,3,4 },{ 5,6,7,8 },{ 9,10,11,12 } }); //堆上的二维数组 //指向数组的指针，用{}初始化 int(*p2)[4]{ new int[3][4]{ { 1,2,3,4 },{ 5,6,7,8 },{ 9,10,11,12 } } }; int(*&rp)[4](p2); //引用行指针 for (int i = 0; i < 3; i++) { for (int j = 0; j < 4; j++) cout << rp[i][j]<<" "; cout << endl; } int * (*pp)[4]{ new int *[3][4] }; //堆上开辟二维指针数组 int * (*&rpp)[4](pp); //引用二维指针数组 cin.get(); }
18. const 与引用：
#include <iostream> using namespace std; void main0901() { int num = 100; int const & rnum(num); //const限定引用权限,只能读不能写 //const int & rnum(num); //与上面一样 //rnum=3; //不能写 cout << rnum << endl; cin.get(); } //void main0902() //{ // int num = 100; // int & const rnum(num); //const放在&右边没有影响 // rnum=3; // cout << rnum << endl; // // cin.get(); //} void main0903() { int a[5]{ 1,2,3,4,5 }; const int(&ra)[5](a); //只能读不能写 for (auto i : ra) cout << i << " "; cout << endl; cin.get(); } void main0904() { //int *p(new int(5)); //堆上指针初始化 //int *(&rp)(p); //*rp = 3; //cout << *p << endl; const int *p(new int(5)); //指针，指向常量 const int (*(&rp))(p); //引用一个指向常量的指针 //*rp = 3; cout << *p << endl; cin.get(); } void main0905() { int * const p(new int(4)); //地址不能变，值可以变 int * const (&rp)(p); //引用一个常量指针 *p = 1; cin.get(); } void main0906() { const int * const p(new int(4)); //地址不能变，值也不能变 const int * const (&rp)(p); //引用一个指向常量的常量指针 //*p = 1; cin.get(); } void main() { int *p(new int(4)); //const int *(&rp)(p); //error C2440: “初始化”: 无法从“int *”转换为“const int *&” const int *(&rp)((const int *&)p); //强制转换 cin.get(); }
19. 引用与函数指针：
#include <iostream> #include <cstdlib> using namespace std; //函数指针引用作为参数，可以改变函数指针 //函数指针引用作为返回值，可以实现调用getitp(p)("hello world"); int gocmd(const char *cmd) { system(cmd); return 1; } int showcmd(const char *cmd) { cout << cmd << endl; return 1; } void change(int(* & p)(const char *cmd)) //函数指针的引用做参数 { p = showcmd; } //getp()返回一个函数指针 int(* getp() )(const char *cmd) { int(*( p))(const char *cmd)(gocmd); return p; } //getitp()返回一个函数指针的引用，并且参数是一个函数指针的引用 int(* & getitp( int(*& p)(const char *cmd) ) )(const char *cmd) { p = showcmd; return p; } void main() { int(*p)(const char *cmd)(gocmd); //定义函数指针并初始化 //p("calc"); ////change(p); //p = getp(); //通过返回值来赋值 //p("echo hello world"); getitp(p)("hello world"); //首先getitp(p)返回一个函数指针的引用，然后继续执行后面语句 cin.get(); }
20. 引用与指针的差别：
#include <iostream> using namespace std; struct MyStruct { int *p1; //4 int & p2; //4 double & p3; //4 }; //引用本质就是指针 //int & getint1() //{ // int a = 5; // return a; //返回局部变量或临时变量的地址 //} int & getint2(int & rint) //参数、返回都是地址,此时引用的是外部传入的参数 { rint = 1; return rint; } void main() { //cout << sizeof(MyStruct) << endl; int a = 10; int *p(new int(5)); //getint2(a); //getint2(*p); int & ra(a); //引用，栈上,4个字节 cin.get(); }