- 关于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。
对于类对象，有没有“（）”都一样，均使用默认构造函数，如果没有默认构造函数就会报错。
- 使用库的操作
-
设置包含目录
-
设置静态库
-
设置依赖项
此时是无法运行的，需要包含动态库
-
将动态库移动到当前项目文件夹内 即可
- auto 关键字
int main()
{
const int i = 100;
auto i2 = i; //auto自动推到为 int
auto& refi = i; //auto自动推到为 const int
return 0;
}
这里使用boost库中的类型推断
-
auto只能推断出类型，引用不是类型，所以auto无法推断出引用，要使用引用只能自己加引用符号。
-
auto关键字在推断引用的类型时：会直接将引用替换为引用指向的对象。其实引用一直是这样的，引用不是对象，任何使用引用的地方都可以直接替换成引用指向的对象。
int i = 100;
int& j = i;
auto f = j; //等价于auto f = i
- 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 *
- 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
- 引用的分类
- 普通左值引用：就是一个对象的别名，只能绑定左值，无法绑定常量对象。
const int i = 100;
int& m = i;
//这是错误的，引用本身就是别名，给i起别名为m，但是m的类型为int，
//这意味这m的内容是可以修改的，这显然与i为const不可修改矛盾，故错误
- const左值引用：可以对常量起别名，可以绑定左值和右值。
const int i = 100;
const int& m = i; //给常量对象起别名
const int& n = (1 + 2); //绑定右值
- 右值引用，只能绑定右值
int i = 100;
int&& m = (i+1);
int&& n = i++;
- 万能引用
- 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);
}
//这里暂时不知道原因