C++面试用题（二）const和Lambda表达式

const

const在C++中用来修饰内置类型变量，自定义对象，成员函数，返回值，函数参数。

一、修饰普通类型变量

const int a =7;
int b=a;
a=8;//不被允许

最后a仍然是8，在加上了const关键字后，a就被编译器认为是一个常量，不允许修改。
如果非要改，可以在const前面再加上Volatile关键字。

	volatile const int a = 9;
	int *p = (int*)&a;
	*p = 8;
	cout << a << endl;
	
	system("pause");
	return 0;

这样a的值就变成了8，但是注意，直接给a赋值还是不可以的，会有红线。

二、修饰指针类变量
const修饰指针变量有以下三种情况：
A：const修饰指针指向的内容，内容为不可变的量。
B：修饰指针，指针为不可变的量。
C：const修饰指针和指针指向的内容，二者都为不可变的变量。

A：

int a=8;
const int* p=&a;//指针指向的内容，a的地址，不可被改变

B：

int a=8;
int* const p=&a;
*p=9;//这是允许的
int b=7;
//p=&b;这是不可以的

由于此处的const修饰的是p，而不是int* p，所以const对应不可以改变的值，不再是int* p这个指针内存放的内容，所以不可以改变的是地址。

C：都修饰

int a=8;
const int * const  p = &a;

这个时候无论是*p还是p，都无法做任何更改喽。

三、const参数传递和函数返回值
const修饰函数参数也可以分为三种情况:

A:const修饰传入参数：

int test(const int a)
{
	//a++;
}

这种情况一般不需要用const修饰，因为如果不是以引用传递，函数会自动产生临时变量复制实参的值。换句话说，只有传入参数是引用的情况下，

B：const修饰指针参数，防止指针被篡改：

int test(int* const a)
{
	int p = 9;
	*a = p;
	//a = &p;不被允许
}

C：声明类的成员函数为const。

void test()const{cout<<"test"<<endl;}

const类型的函数表明该函数不会修改对象的成员，同时该函数也不可以调用非const函数。例如：

string name="chujialu";
string setname(string& name){name="huyu";return name;}
void test()
{
string another_name="huyu";
name="huyu";//不允许
setname(another_name);//不允许,can't call a non-const function
}

Lambda表达式/匿名函数

当写一个只会被使用一次的函数时，会用到匿名函数。
定义格式：
[捕获列表](参数列表·）->返回值类型{函数主体}
调用：在定义之后直接调用：

int c=[](int a,int b)->int{return a+b;}
(1,2);//最后一个括号是参数列表
等价于
int add(int a,int b){return a+b;}
int c=add(a,b);

那如果我不想立刻使用这个函数，而是保存一下以后再用呢？

auto f=[](int a,int b)->int{return a+b;};
int c=f(1,2);

两个lambda表达式的嵌套

	int c=[](int n)
	{
		return [n](int x) {
			return n + x;
		}(1);
	}(2);

可以实现和上述相同的效果。函数嵌套函数，就称之为函数式编程。有什么好处呢？
在多线程，并发的环境中适用，因为它只依赖于内部。
进阶可以参考：
https://blog.nowcoder.net/n/23157c8ac30b4d479088bab2bd3c9e7d
这里贴出部分回答：
[]:表示不捕获任何外部变量
[=]:以传值的方式捕获外部的所有变量
[&]:以传引用的方式捕获外部的所有变量
[this]:捕获外部的this指针
[=，&a]：以传值的方式捕获外部的所有变量，但是a变量以传引用的方式捕获
[a，b]：以传值的方式捕获外部变量a和b
[a,&b]：a以传值方式捕获，b以传引用的方式捕获