part1

• 关于new
  new可以直接分配单个变量的内存，也可以分配数组。
  在分配单个对象的内存时。
  当对象是普通变量时，可以分配对应的内存
  当对象是类对象时，会调用构造函数，如果没有对应的构造函数，就会报错。
  这就意味这，如下代码无解了

class MyClass
{
public:
	MyClass(int i_) :i(i_) {} //覆盖了空体构造函数
	~MyClass() { }

private:
	int i;
};

int main()
{
	MyClass* ptr = new MyClass[20]; 
        //对于数组无法实现分配及初始化
        //故：MyClass* ptr = new MyClass[20](10)错误 
}

对于普通变量：可以使用“（）”将所有对象全部初始化为0。
对于类对象，有没有“（）”都一样，均使用默认构造函数，如果没有默认构造函数就会报错。

• 使用库的操作

1. 设置包含目录
   

2. 设置静态库
   

3. 设置依赖项
   
   此时是无法运行的，需要包含动态库
   

4. 将动态库移动到当前项目文件夹内 即可

• auto 关键字

int main()
{
	const int i = 100;
	auto i2 = i;      //auto自动推到为 int
	auto& refi = i;   //auto自动推到为 const int
	return 0;
}

这里使用boost库中的类型推断

1. auto只能推断出类型，引用不是类型，所以auto无法推断出引用，要使用引用只能自己加引用符号。

2. auto关键字在推断引用的类型时：会直接将引用替换为引用指向的对象。其实引用一直是这样的，引用不是对象，任何使用引用的地方都可以直接替换成引用指向的对象。

	int i = 100;
	int& j = i;
	auto f = j;  //等价于auto f = i

1. auto关键字在推断类型时，如果没有引用符号，是哪一级的引用就尝试脱掉那一级的const，典型的就是指针。

	const int i = 100;
	auto f = i;	 //推导为int

	int i = 100;
	int* const pi = &i;
	auto f = pi;   //推导为 int*

	int i = 100;
	const int* const pi = &i;
	auto f = pi;    //推导为const int* 也可以说是int const *

	int m = 100;
	int* n = &m;
	int** j = &n;
	const int *const * const * const i = &j;
	auto f = i;    //int const * const * const *      

1. auto关键字在推断类型时，如果有了引用符号，那么值类型的const和修饰指向对象的const都会保留。

	int const i = 100;
	auto& f = i;    //推到类型为 const int

	int m = 100;
	int const * const i = &m;
	auto& f = i;    //类型推导为 int const * const

• 引用的分类

1. 普通左值引用：就是一个对象的别名，只能绑定左值，无法绑定常量对象。

	const int i = 100;
	int& m = i;
        //这是错误的，引用本身就是别名，给i起别名为m，但是m的类型为int，
        //这意味这m的内容是可以修改的，这显然与i为const不可修改矛盾，故错误

1. const左值引用：可以对常量起别名，可以绑定左值和右值。

	const int i = 100;
	const int& m = i;       //给常量对象起别名
	const int& n = (1 + 2); //绑定右值

1. 右值引用，只能绑定右值

	int i = 100;
	int&& m = (i+1);
	int&& n = i++;

1. 万能引用

• lambda 中一些坑

void test(void(*func)(int),int i)
{
	func(i);
}
int main()
{
	int m = 10;
	test([m](int val)->void {               //lambda无法捕获外部变量，需要使用function函数对象
		cout << "lambda " << val;
		}, 200);

}


//  改为：
using f = function<void(int)>;
void test(f func,int i)
{
	func(i);
}
int main()
{
	int m = 10;
	test([m](int val)->void {
		cout << "lambda " << val<<m;
		}, 200);

}
//这里暂时不知道原因