我的5年计划 最近我的老板在给我画饼的过程中，说了一句令我很有感触的话: "国家都有5年计划，你们有没有自己的5年计划呢"。这句话点醒了我，对呀，国家每5年都有一个计划确定后续发展的大致路线，企业经营也有经营路线，而作为我们个人也应该有自己的人生规划，不应该像现在这样每天浑浑噩噩的混日子。经过几天的思考我想写出我给自己制定的计划，需要达到的目标等等生活上我希望在这5年内解决个人婚姻问题：随着年岁的增加我可能也失去了当初那种一个人闯荡江湖的豪情壮志，并且随着身边的朋友陆续找到对象，准备结婚生子。我想我现在也要开始考虑这个问题，因此我希望在5年以内解决这个问题，通过努力找到一个合适的对象结婚确定定居城市并定居下来：结婚之后自然就是希望安定下来，现在我想在北京安顿下来应该是不可能了，毕竟房价和我的收入差距太大而且北京户口也不好弄后续会影响到小孩上学，因此北京可能不是我想待的城市。目前我心仪的城市可能是武汉。基于这点我的第二个目标是跟以后自己的妻子在武汉定居下来培养自己的兴趣爱好，将其发展为特长。目前我想发展的主要是书法和写作。虽然现在两个都很烂，但是我希望自己能每天坚持练习书法，并且通过更新自己的博客来锻炼写作技巧职业规划如今毕业也已经5年了，就现在来说自己计算机相关的专业知识仍然一塌糊涂，通过我的博客可以看出来仍然是以工作时的应用为主，而底层技术我并没有向下去用心钻研。知识仍然不成体系，想要在这行好好混下去，我想努力弥补一下自己在这方面的欠缺。目前我的计划是专注与c++ 这部分，然后继续学习Linux、网络协议、操作系统、数据库、Web安全、其他的安全技术，这些我想应该至少花2～3年的时间注意改进自己的工作习惯，如今工作写代码已经是轻车熟路了，在工作上现在需要考虑的应该不是怎么写代码的问题而应该是如何提高自己的工作效率，以便节约时间用于学习或者思考如何提升公司产品。从现在开始我应该来思考自己的工作习惯以及如何培养良好的工作流程，我可能会读一些效率改进的书，然后结合自己的实际情况，形成一套自己独特的、高效的工作方式写自己的开源工具，当自己技能达到一定程度之后，我希望能好好的沉下心来，认真经营自己的开源项目，如今我的GitHub上都是一些简单的demo项目，我以前的目标是根据自己的专业知识，写一个开源的Web扫描工具，按照程序员35岁退休的规律，如今留给我的时间已经不多了，我想应该要开始开始考虑并实施这个目标了。学识上坚持读书，这部分不光是工作相关的书籍，应该是自己感兴趣的书籍，继续保持阅读习惯写书评，学习一般是需要输入、吸收、输出的，因此我想写书评也算是一种输出的方式，书评不一定要长，自己看完没啥感觉的书可以写一个简短的评价，自己觉得很有用或者很有感触的书，写一个长的读后感。健康问题坚持进行体育锻炼，科学上说人过了25岁之后体力与精力开始逐渐递减，而且各种慢性病会开始出现，为了保持旺盛的精力，体育锻炼必不可少，我希望自己能坚持进行相应的有氧运动维持体重，年龄增长的一个明显的特征就是代谢下降，而且做为程序员，久坐，缺乏运动会导致体重增长产生油腻感，甚至产生其他的健康问题。所以我希望自己能够控制热量摄入、坚持锻炼来保持体重稳定心理健康，如今社会压力大，时不时会出现各种贩卖焦虑的营销号，这些营销号会放大我们的焦虑，让我们产生技不如人、一无是处的错误认知。为了保持自信，更好的生存下去，我想投入一些时间进行自身心理建设，使自己的心理承受能力更加强大。个人财富学习理财相关的知识，通过几年的工作，我现在也有一些闲钱。都说你不理财，财不理你。经历过被基金割韭菜，我越来越感到理财知识的匮乏。为了未来更好的生活，我想学习理财相关的知识，以便解决未来的不时之需努力存钱，上面我已经定下了未来5年要结婚、定居的需求，那么现在开始就应该努力存钱，认真开始记账，取消不必要的花销，养成存钱的好习惯。我希望自己能够在未来的5年内存够40w。在这里我针对这样几个方面制定了一些计划，从我目前的状态来看，我稍微够一够应该是能够达到的，有了长期计划我也好调整自己短期内的目标，以后每年年终总结的时候也会有一些对比，出了问题也可以及时进行调整

类 最近好像很久没有更新过关于c++ primer 的读书笔记了，一来自己最近遇到了烦心事，中断了一段时间的读书。第二个是因为我有点想写点随笔之类的东西了，中间更新了两篇随笔《关于读书》、《我的五年计划》。第三个是因为关于类这部分的内容确实有点多了，要读完也需要花费一定时间。因此更新就慢了起来。我发现我已经忘记了如何给这类文章取名字了，还是看着以前的项目想起来的。既然我定下来了未来5年的发展计划，那么从现在开始就应该坚持下来了。定义抽象数据类型这里定义抽象数据类型就是定义一个类，只要学过c++的对定义一个类并并不陌生，这里就不再详细的说明该如何定义一个类了。这部分主要需要注意：1类的const成员函数：一般类的成员函数会隐式的传入当前对象的地址即 ClassExample::func(ClassExample* this);const型的成员函数传入的是一个const型的this指针，ClassExample::func(const ClassExample* this); 从这个角度上说不允许在常函数里面修改对象的值。同时由于const类型无法自动转化为非const类型，所以const型对象只能调用const成员函数。类的作用域：类本身就是一个作用域，类中的所有成员定义在类这个作用域中。编译器在编译类的时候分两步，首先编译成员的声明，然后编译成员函数，因此在成员函数中可以随意使用类的其他成员而不用关心这些成员出现的顺序。如果一个函数在概念上属于这个类，但是不定义为类的成员函数，一般将这个类定义在类声明的头文件中访问控制与封装一般来说定义类的时候应该将类中的数据成员定义为私有或者保护类型，通过成员函数来访问类的数据成员，这样有两个好处：当我们发现数据成员的值不正常的时候，由于类外部是无法访问到数据成员的，所以在调试时只用关注改变了该数据成员的函数即可使用者在使用时只需要关注类提供的功能，不需要知道它里面具体的实现。只用调用类方法就好了，不用关注该如何设置数据成员到此为止，书中提到了两种访问权限，public和private：public: 后定义的成员可以在整个程序内被访问private: 后定义的成员只能在类的成员函数中被访问每个访问说明符指定了接下来的成员的访问级别，其有效范围直到出现下一个访问说明符或者达到类的结尾为止使用class或者struct关键字定义的唯一区别是默认的访问控制符，class默认是private、而struct默认的是public友元在某些时候，可能必须要在类外部使用类的私有成员，这个时候可以将对应的函数或者类声明为类的友元函数或者友元类，友元函数或者友元类可以随意使用类的私有成员。如果类想把一个函数作为它的友元，只需要增加一条以friend 关键字开始的函数声明语句即可友元声明只能出现在类内部，但是在类内出现的具体位置不限，友元不是类的成员也不受它所在区域访问控制级别的约束。需要注意在设计时尽量考虑清楚是不是一定要用到友元，毕竟友元已经在一定程度上破坏了类的封装性类的其他特性除了一些基本的使用和访问权限控制外，书中还提到了类的其他特性：在类中，常有一些规模较小的函数合适于被声明成内联函数。定义在类内部的成员是自动inline的，当然也可以显式的声明为inline函数，这样就可以在类外部定义我们可以仅仅只声明而暂时不定义它，这种声明有时候被称作前向声明。这个类在声明之后，定义之前是一个不完全类型。不完全类型可以用于定义该类型的指针或者引用，也可以声明以该类型作为参数或者返回该类型的函数。对一个类来说，在创建它的对象之前必须被定义。因为编译器在创建对象的时候必须知道类对象占多少存储空间如果一个类指定了友元类，那么这个友元类的成员函数可以访问此类包括非公有成员在内的所有成员友元关系不具备传递性，每个类单独控制自己的友元类或者友元函数除了令整个类作为友元之外，还可以只为某个成员函数单独提供访问权限。当把成员函数声明为友元的时候，我们必须明确指出该成员属于哪个类如果一个类想把一组重载函数声明为友元，它需要对这组函数中的每一个分别声明类的作用域一个类就是一个作用域，在类的外部类成员都被隐藏起来了。在c++ 中，内层作用域中的同名成员会覆盖外层，当函数内部或者类内部定义了与全局作用域相同的变量时，要使用全局作用域中的变量可以使用::类构造函数相关在构造函数中初始化列表相当于先定义再赋值，而要做到对成员变量定义的同时初始化，可以使用初始值列表的形式在某些场合下初始值列表必不可少：初始化const成员或者引用成员构造函数初始值列表只说明用于初始化成员的值，而不限定初始化的具体执行顺序成员的初始化顺序与他们在类中定义的顺序一致。构造函数初始值列表中初始值的前后位置关系不会影响实际的初始化顺序最好令构造函数初始值的顺序与成员声明的顺序保持一致。而且如果可能的话，尽量避免使用某些成员初始化其他成员类的静态成员类的静态数据成员存在于任何对象之外，对象中不包含任何与静态数据成员有关的数据。类似的类的静态函数成员也不与任何对象绑定在一起。它们不包含this指针，静态函数成员不能被声明成const类型，也不能在静态函数成员中调用非类的静态成员不能在类的内部初始化类的静态成员，static关键字只能出现在类内部声明语句中，定义的时候不能加static关键字针对constexpr类型的static成员，可以在类内定义类内初始值由于静态数据成员不与类绑定，所以在计算类大小的时候可以不用考虑静态成员。这样就可以在类内定义该类型的静态数据成员，而非静态数据成员只能定义为该类型的指针或者引用+BEGIN_SRC c++class Menu{private:static Menu me1; Menu* me2; Menu& me3;};+END_SRC另外我们可是用静态成员做成员函数的默认实参

c++基础之函数 距离上次更新又过了一周，又该更新新的读书笔记了。本次更新的主要是c++中函数部分的内容c++ 中的函数与c语言中的函数大致用法或者语法是一样的，这里就不就这点详细展开了。需要注意的是c/c++中并没有规定函数中参数的求值顺序，所以在调用函数时需要特别注意，在传递实参的同时不要修改实参的值，也就是不要写类似func(i, ++i)这样的语句局部对象高级语言中，名字只是用来访问对象所在内存的一个工具，一个对象可以分为对象名和它实际所占的内存空间。这个对象名有它的作用域，对象所在内存有自己的声明周期。这二者不是一个概念，不要弄混淆了。变量的作用域一般只在它所定义的语句块中起作用。但是变量本身根据定义位置不同，生命周期也不同，例如int func() { for(int i = 0; i < 10; i++); }上述代码中i这个名称仅仅在for循环中有效，而i所指代的变量，它会一直持续到函数结束(可以参考鄙人曾经写过的关于c++反汇编分析相关的内容)根据定义位置的不同，变量分为局部变量和全局变量；局部变量，或者在书中有一个新的名字叫自动对象，对于局部变量来说，当代码执行到变量定义语句时创建该对象，当到达定义所在语句块的末端时销毁它，只存在于块执行期间的对象称作自动对象全局变量：定义在函数外部的变量称之为全局变量，全局变量的生命周期从程序启动时创建到程序结束时销毁。除了这两类以外，还有在函数中使用static关键字定义的局部静态变量，局部静态变量在程序第一次经过对象定义语句时初始化，并且直到程序终止时才会销毁。在此期间即使对象所在的函数结束执行也不会对它有影响。它与全局变量的生命周期相同，只是它的变量名被限定在了函数内部(关于什么时候为它分配内存，什么时候销毁的详细内容，也可以参考鄙人曾今写过的关于static的汇编分析)参数传递参数传递主要有值传递、指针传递和引用传递值传递：将实参的值拷贝到形参，然后执行函数，函数中对形参的改变不影响函数外的实参指针传递：指针值本身也是一个拷贝，在函数中可以通过对指针进行解引用操作来间接的改变函数外的实参引用传递：引用本身是对象的别名，可以在函数中通过对引用的修改，来修改函数外实参的值（其实本质上也是通过指针来进行修改）根据这几种传参方式，我们总结出来这样几点：需要改变实参的值，只能传递指针或者引用由于存在值拷贝，所以在传递大的结构体的时候尽量传递结构体的指针或者引用，如果不想修改结构体的值，可以将形参定义为const型函数通过return语句只能返回一个值，如果要返回多个值，可以使用指针或者引用。return 语句本身会进行拷贝，并且在赋值给外部变量时也会进行拷贝，尽量返回4或者8个字节的结构，对于大的结构体尽量使用引用来返回当形参有顶层const时，传给它常量对象或者非常量对象都是可以的。int func(const int i); int func(int i);由于顶层const被自动忽略，所以在上面代码会报错，两个函数的名称、形参列表实际上是相同的。数组形参除了上述这样常规的参数传递，函数中也可以传递数组，这个时候数组会自动退化为指针，例如面试或者笔试题中，经常会问到的一个问题size_t size_arr(int[10] i) { return sizeof(i); }这个时候，如果传递数组的首地址，在函数中会退化为指针，所以实际计算的是int*指针所占的内存。根据平台的不同，指针大小为4字节(32位版本)或者8字节(64位版本)如果想要真正的传递数组，可以使用引用的方式size_t size_arr(int (&arr)[10]) { return sizeof(arr); }此时arr表示有10个int型数据的数组的引用，最终得到的结果应该是 sizeof(int) * 10由于传递数组名时，数组名会退化为指针，所以如果只传递数组名，则在函数中无法确定数组的大小，为了解决这个问题，一般有3种方案：使用特殊标记，表示数组的结尾，一般字符串会这么干传递两个指针，表示数组的首地址和尾部地址，可以使用标准库中的begin 和 end 函数分别获取数组的首地址与尾地址显式传递一个表示数组元素个数的形参。这种情况一般使用下标运算，当下标达到这个指定值时退出循环当我们传递的是多维数组时，按照两个思路进行分析，多维数组其实是数组的数组，传递数组名实质上是数组的首元素地址。根据这两个原则进行分析，在传递多维数组时，后面的维度是数组元素类型，不能省略。而真正传递的是第一个该类型元素的地址。void print(int (*matrix)[10]); void print(int matrix[][10], int rowSize); //等价定义上述定义中，数组的第一维被忽略掉，第二维是10个整数的数组。上面的两个定义其实是等价的可变形参与以往使用 ... 来表示可变形参不同的是，在c++ 中新增了一个名为initializer_list 的标准库类型，这个类型只能处理所有实参类型相同的情况，对于实参类型不同的情况，可以使用可变参函数模板。initializer_list 本身是一个类似与list的结构，但是与list不同的是，initializer_list中的对象永远是常量，无法修改该容器中的值，换一个角度来说，也就无法修改实参的值了。void error_msg(initializer_list<string> il) { for(auto beg = il.begin(); beg != il.end(); ++beg) { cout << *beg << " "; } cout << endl; } //由于它是一个容器，所以在传递值的时候应该使用一对花括号把所有值括起来 if(expected != actual) { error_msg({"functionX", "expected", "actual"}); }else { error_msg({"functionX", "okay"}); }返回类型和return语句函数根据返回值类型可以分为三大类，无返回值的函数、返回普通值的函数、返回指针或者引用的函数。无返回值的函数无返回值的函数不要求非要有return 语句，这类函数在最后一句执行完后会隐式的执行return语句如果无返回值的函数需要在中间位置提前退出的话，可以使用return语句另一个使用return的场景是，直接在return后面加上函数调用，不过被调用的函数需要也是无返回值的函数返回普通值的函数有返回值的函数，必须使用return 返回一个值，返回的值必须与函数的返回类型相同，或者能隐式的转化成函数的返回值要注意保证所有路径都有返回值，一般编译器能发现这类情况，但是有的编译器不能，如果执行了没有返回值的分支，将产生未定义错误不要返回局部对象的指针或者引用函数的调用优先级与点运算和箭头运算的优先级相同，并且也附和左结合律函数的返回类型决定函数调用是否是左值，调用一个返回引用的函数得到一个左值，其他返回类型得到右值，我们能为返回类型是非常量引用的函数结果赋值当返回一个容器时，c++ 11开始，可以返回由大括号组成的初始化列表针对main函数来说，最后可以不加return语句，如果最后没有return 则编译器默认给它加上一个return 0返回数组指针的函数因为数组不能被拷贝，所以不能直接返回数组，不过可以返回数组的指针或者引用定义指向数组的指针采用的是int (*p)[10]; 的方式，同样的定义返回数组指针的函数，只需要把p定义为函数形式即可:int (*func(int i))[10];。上述定义写起来比较麻烦，而且也不容易理解，因此可以使用类型别名的方式来简化定义方式int odd[] = {1, 3, 5, 7, 9}; int even[] = {2, 4, 6, 8, 10}; decltype(odd)* arrPtr(int i) { return (i % 2) ? &odd, &even; }当我们直到返回的数组指针具体指向哪个数组，可以使用decltype关键字来声明函数的返回类型。从c++11 开始，提供了一种新的定义方式，即尾置返回类型的方式auto func(int i) -> int (*)[10];函数重载c++ 与 c语言中的一个很大的不同就是c++ 允许函数重载。同一作用域内的几个函数名称相同，但形参列表不同的，称之为函数重载。注意这里的几个前提条件：同一作用域、函数名称相同、形参列表不同；这些条件缺一不可。而且这里说的是形参列表不同，返回值不同的不能算是重载。main函数作为入口函数，只能有一个顶层const不影响传入的参数，因此认为顶层const与普通形参相同，不认为是重载如果传入的参数是引用或者指针，可以根据它所指向的对象是否为const来进行区分，所以底层const可以作为重载由于非const型参数能转化为const型，所以当传参中多个函数都满足，编译器会优先选择const版本在实际使用时，根据调用时的传参，来与一组重载函数中的某一个关联起来，这个过程叫做函数匹配或者叫做重载确定一般情况下函数匹配过程很容易分别出来，要么是形参个数不同，要么是类型毫无关系，但是也有例外，例如：形参中存在默认值形参中一种类型可以转化为另一种类型目前来说调用函数的时候会出现下列三种情况：可以从一堆重载函数中正确匹配，编译通过没有函数复合调用时传入的实惨，此时编译报错，无法找到对应函数多个重载形式都复合传入的实惨，此时编译报错，存在二义性不要在局部作用域中定义函数，因为局部作用域内出现重名情况时，会进行名称覆盖特殊用途的语言特性默认实参在定义函数时，对于后续多次调用时，传入相同实参值的形参，可以给予一个默认值。这样在调用这个函数时，针对提供了默认值的参数，可以传参也可以不传函数调用时按照实参位置解析，默认实参负责填补函数调用缺少的尾部实参内联函数一般函数调用涉及到参数的拷贝，返回值的拷贝，以及最终栈的回收等一系列操作。调用函数存在一定的性能开销，因此为了提高性能或者提高代码的重复使用率，c中可以使用宏定义来定义一个短小的常规操作，最终编译时会被编译器展开。但是宏定义无法对传入参数进行校验，而且需要注意的问题较多，不好理解。C++中引入内联函数，它与宏的功能类似，是一种没有额外开销的函数一般在函数的返回值类型前面加上inline 关键字就定义了一个内联函数并不是所有的函数都可以定义为内联函数。内联函数用于优化规模小、流程直接、调用频繁的函数，很多编译器不支持内联递归函数。而且一个大于75行的函数也不大可能在调用点内联展开constexpr 函数constexpr 函数是指能用于常量表达式的函数。constexpr函数与普通函数的定义相同，不过要遵循几项约定：函数的返回值以及所有形参类型都是字面值类型函数体中必须有且只有一条return语句在编译阶段，constexpr函数会被直接替换为它返回的具体的值，为了便于函数正常展开，constexpr函数默认都是内联函数由于在编译阶段编译器需要知道内联函数和constexpr 函数的定义。因此这两种函数可以重复定义。但是定义时要保证内容完全相同，基于这个理由，可以将这两种函数统一放到一个头文件中，在需要使用的时候包含它调试帮助可以使用assert预处理宏与NODEBUG宏，其中assert只有在调试模式下才会起作用，而NODEBUG宏则表示当前在发布模式下，此时assert函数不会起作用另外C++ 也定义一些名字便于调试：__FILE__: 当前代码所在文件的名称__LINE__: 当前代码所在行数__TIME__: 当前代码文件被编译的时间__DATE__: 当前代码文件被编译的日期__func__: 当前代码所在的函数函数匹配在大多数情况下，很容易分辨某次调用应该选择哪个重载函数，然而当几个重载函数的形参数量相等以及某些形参的类型可以由其他类型转化得来时，这项工作就不那么容易了。void f(); void f(int); void f(int, int); void f(double, double = 3.14); //调用 f(5.6);函数匹配过程一般经历如下步骤：确定候选函数和可行函数第一步选定本次调用对应的重载函数集，集合中的函数被称之为候选函数。候选函数具备两个特点，一是与被调用的函数同名，二是其声明在调用点可见，这步下来，上述例子中所有f函数都满足条件第二步考察本次调用提供的实参，然后从候选函数中选择能被这组实参调用的函数，这些函数被称为可行函数，可行函数也有两个特征，一是其形参数量与本次调用提供的实参数量相同，二是每个实参与对应形参类型相同，或者能转化成形参的类型。上述实例，调用传入的是一个double类型的参数，double可以转化为int，因此这个时候发现满足条件的是 void f(int); 和 void f(double, double=3.14);寻找最佳匹配第三步是从可行函数中寻找与本次调用最匹配的函数，它的基本思想是实参类型与形参类型越接近，它们匹配的越好。如果多个形参都与调用函数的实参较为接近且，如果有且只有一个函数同时满足下面两个条件，则匹配成功：该函数每个实参的匹配不劣与其他可行函数需要的匹配至少有一个实参的匹配优于其他可行函数提供的方案如果检查了所有实参后没有任何一个函数脱颖而出，则调用错误，编译器将报告二义性。调用重载函数尽量避免强制类型转换，如果在实际应用中需要进行强制类型转换，说明我们设计的形参集合不合理分析上面的例子，如果采用 void f(int); 在调用时会进行一次将double转化为int的类型转化，如果使用 void f(double, double=3.14); 5.6作为double的第一个参数进行传递不需要类型转化，而第二个参数使用默认形参，这里可以不传，因此相比较与第一种int的传参方式，后一种显然更加复合实参类型转化为了确定最佳匹配，编译器将实参类型到形参类型的转化划分为几个等级，具体排序如下所示：精确匹配，包括下列情况 1.1. 实参类型和形参类型相同 1.2. 实参从数组类型或者函数类型转化为对应的指针类型 1.3. 像实参添加顶层const或者从实参中删除顶层const通过const转换实现的类型匹配通过类型提升实现的类型匹配通过算术类型转换或者指针转换实现的匹配通过类类型转换实现的匹配函数指针声明函数指针时，只需要将函数声明中的函数名写为指针名即可，但是需要注意使用括号将表示指针的*与指针名称括起来void (*f)(int);当我们把函数名直接作为一个值使用时，该函数自动转化为指针；也可以使用取地址符针对函数名称取地址，二者是等价的。指向不同类型函数的指针不存在类型转化重载函数的指针必须与某个函数精确匹配，不存在形参类型转化之类的规则可以使用typedef来为函数指针类型定义一个类型别名typedef void(*f)(int); //将返回void、传入一个int参数的函数指针取类型别名为f

c++基础之语句 上一次总结了一下c++中表达式的相关内容，这篇博文主要总结语句的基础内容简单语句c++ 中语句主要是以分号作为结束符的，最简单的语句是一个空语句，空语句主要用于，语法上需要某个地方，但是逻辑上不需要；最常见的就是循环里面复合语句是用大括号括起来的语句块叫做复合语句，复合语句也叫做块。一个块就是一个作用域，在块中引入的名字只能在块内部以及嵌套在块里面的子块中访问。通常名字在有限的区域内可见，该区域从名字定义开始，到名字所在块的结尾为止。语法上需要一条语句，但是逻辑上需要多条语句的，应该使用语句块，例如if或者while等循环里面。块不以分号结束。{};, 算两条语句空块是指内部没有任何语句的一对花括号语句作用域语句中变量的作用域只在当前语句块中有效，如果其他代码也想访问控制变量，则变量必须定义在语句块的外部。条件语句条件语句需要注意：if语句每个分支尽量加上大括号，即好读，也能避免很多问题switch 语句中case后面必须跟上整型常量表达式一般不要省略case分支最后的break语句，如果是特殊逻辑需要这么做的，使用注释进行说明即使不准备在default分支中做任何事，最好也写上default分支。其目的在于告诉程序的读者，我们已经考虑到了默认的情况，只是目前什么也没有做要在case分支中定义变量应该定义在大括号中，并且只在当前分支中使用它迭代语句迭代语句又叫做循环语句，一般有while、do while、for三种形式这些语句一般的语言中都有，这里就不多做介绍，主要介绍c++ 11中新增的一种范围for的形式范围for可以遍历容器或者其他序列的所有元素，它的简单形式是for(declaration: expression) statementdeclaration 定义一个变量，序列中的每一个元素要都能转化为该变量的类型，然后执行拷贝操作，将每次迭代的值拷贝到该变量中。变量只是序列中元素的拷贝，无法修改元素的值，如果想要修改元素的值，需要将变量定义为引用类型。statement 是一个语句或者语句块，所有元素都处理完后，循环结束跳转语句跳转语句主要有break、continue以及goto语句。break：用于跳出离它最近的while、do while、for或者switch语句，并从这些语句之后的第一条语句开始执行。continue：终止最近的循环语句中当前迭代并立即进入下一次迭代，它只能出现在循环语句中。goto：跳转到对应标签处，标签可以定义在函数任意位置。注意只能作用于函数内部，不能由一个函数跳转到另一个函数。尽量少用goto，因为它可读性差，而且不好控制。异常处理语句c++中的异常处理包括这样几个部分：throw表达式：用于抛出一个异常try: 异常处理部分使用try语句块处理异常，try语句块以关键字try开始，并以一个或者多个catch子句结束。try语句块中代码抛出的异常通常会被某个catch子句处理。因为catch子句处理异常，所以它们也被称之为异常处理代码异常类：用于在throw表达式和相关的catch子句之间传递异常的具体信息throw 后面跟一个表达式，表达式返回值的类型就是抛出异常的类型。跟在try 语句块之后的是一个或者多个catch子句，当try中的异常与某一个catch中捕获的异常类型匹配，则执行该catch块中的内容。注意try块与catch子句是两个语句块，在try中定义的变量无法在catch块中使用。标准异常库标准异常库被分别定义在4个头文件中：exception 头文件定义了最为通用的异常类exception。它只报告异常的发生，不提供任何额外信息stdexcept 头文件中定义几种常见的异常类new 头文件中定义了bad_alloc 异常type_info 头文件定义了bad_cast 异常类型在stdexcept 头文件中定义的异常类主要有:exception: 最常见的问题runtime_error: 只有在运行时才能检测出来的问题range_error: 运行时错误，生成的结果超出了有意义的值域范围overflow_error: 运行时错误，计算上溢underflow_error: 运行时错误，计算下溢logic_error: 程序逻辑错误domain_error: 逻辑错误,参数对应的结果值不存在invalid_argument: 逻辑错误，无效的参数length_error: 逻辑错误，试图创建一个超出该类型最大长度的对象out_of_range: 逻辑就错误，使用一个超出有效范围的值标准库异常类只定义了几种运算，包括创建或者拷贝异常类型的对象，以及为异常类型的对象赋值异常类型中只定义了一个名为what的成员函数，返回值为const char* 的c风格的字符串，该字符串的目的是提供关于异常的一些文本信息。

c++基础之表达式 这次接着更新《c++ primer》 这本书的读书笔记，上一篇博文更新到了书中的第三章，本次将记录书中的第四章——表达式左值与右值在理解表达式之前需要先理解c++中左值和右值的概念。c++ 的表达式要么是右值，要么是左值，这两个名词是从c语言中继承过来的，在c语言中，左值指的是可以位于赋值语句左侧的表达式，右值则不能。在c++中二者的区别就相对复杂一些了。在c++要区分左值和右值，可以采取一个原则：一般来说当一个对象被用作左值时，用的是对象的地址，也就是在内存中的位置，而右值可以采取排他性原则，只要不是左值的都是右值。不同运算符对运算对象的要求各不相同，有的要求左值、有的要求右值；返回值也有差异，有的作为左值返回，有的作为右值返回。一个重要的原则是：凡事需要右值的地方可以使用左值来代替，但是不能把左值当成右值来使用。一般下列运算符需要用到左值赋值运算符的左侧需要一个左值。返回的结果也是一个左值取地址运算符作用于一个左值运算对象，返回一个指向该对象的指针，结果是一个右值内置解引用运算符、下表运算符迭代器解引用运算符、string、vector的下标运算符的求值结果都是左值内置类型和迭代器的递增递减运算符作用于左值对象，其前置版本所得到的结果也是左值优先级与结合律复合表达式是指含有两个或者多个运算符的表达式,计算复合表达式的值需要将运算符和运算对象合理的组织在一起，优先级与结合律决定了运算对象的组合方式。表达式中的括号无视运算优先级与结合律的规则，如果表达式中有括号，先运算括号中的内容。表达式的最终值取决与子表达式的结合方式，在计算表达式的值时，先看运算符的优先级，先处理优先级高的子表达式，而优先级相同的情况下，则由其结合律规则决定3 + 4 * 5 //根据运算符的优先级，乘法高于加法，所以先计算4 * 5 为20，再计算3 + 20 得到23 20 - 15 - 3 //先看运算符的优先级，都是减法优先级相同，再看结合律，减法的结合律是从左到右，所以先计算20 -15 得到 5，然后再计算5 - 3 得到2 6 + 3 * 4 / 2 + 2 //先看运算符的优先集，乘法除法的优先级大于加法，而乘法除法的结合律都是从左到右结合，所以这个表达式先计算 3 * 4 得到12，再计算 12 / 2 得到 6 ，最后加法的结合律也是从左到右，最后计算 6 + 6 + 2 得到 14求值顺序优先级规定了运算对象的组合方式，但是并没有规定运算对象按照什么顺序求值，在大多数情况下不会明确指定求值顺序。例如在表达式 int i = f1() * f2(); 中，先计算函数的返回值，然后再将结果赋值进行乘法运算，最后将结果赋值给i变量，但是究竟是先计算f1函数还是先计算f2函数，这个c++标准没有明确规定。对于没有指定执行顺序的运算符来说，如果表达式指向并修改了同一个对象，将会引发错误并产生未定义的行为，例如int i = 0; int j = i + ++i;根据结合律，会先计算i和 ++i但是不确定是该先计算i还是先计算++i 这里会产生未定义行为。如果先计算i则表达式可以转化为 j = 0 + 1 如果先计算 ++i，则表达式可以转化为 j = 1 + 1;有4中表达式明确规定了求值顺序逻辑与(&&):只有当左侧的结果为真时，才计算右侧的结果逻辑或(||):只有当左侧的运算结果为假时，才会计算右侧结果三目运算符(?:)当条件为真时，计算:左侧的表达式，否则计算右侧的表达式逗号表达式:运算顺序是从左到右，最后返回最右侧的表达式的值在处理复合表达式时，有下面两条准则：在不清楚运算对象的优先级和结合律的时候，按照实际的结合逻辑使用括号如果改变了某个运算对象的值，在表达式的其他地方不要使用这个运算对象，但是能明确知道求值顺序的时候这个规则就不适用了算术运算符算术运算符的求值对象和求值结果都是右值。算术运算符的优先级顺序为：单目运算符(+表示取当前值,-表示取相反数) > 乘除法 > 加减法；结合律：采用从左至右结合的方式算术运算符能作用与所有的算术类型，算术类型的数据在运算前会被转化为精度较大的类型(运算对象只有byte，char, short时会被统一转化为int)，在转化为同一类型后执行再进行运算bool b = false; int k = 1; bool i = +k + -b;在上述代码中，bool类型参与算术运算时，会将true变为1，false变为0，然后针对0和1进行操作，根据优先级得到 i = 1 + 0; 最后再将算术类型转化为bool类型赋值，i最终为true除法运算中如果除数和被除数符号相同，商为正数，否则为负数，c++11 标准中规定负数商一律向0取整取余运算，要求除数和被除数都是整数，如果m/n的结果不为0，则m%n的结果符号与m相同(m/n)*n + m%n = m(-m)/n=m/(-n)=-(m/n)(-m)%n=-(m%n); m%(-n)=m%n逻辑运算符逻辑运算符作用与任何能转化为boo类型的运算对象上优先级为 逻辑非 > 大于/小于/大于等于/小于等于 > 相等/不等 > 逻辑与 > 逻辑非逻辑运算符一般的语言中都有，而且用法基本类似，这里就不再详细说明了，需要注意的是：使用非bool类型来做判断时，不要写成 if(!val) 或者 if(val == true)；同样的使用bool类型来判断时，也不要写成 if(val == true) 或者 if(val == 1)在进行数值相等的比较时，为了防止少写=，习惯上把常量写在前面例如 if(1 == val)赋值运算符赋值运算符一般作用与初始化给对象赋值或者在后续修改对象的值，但是需要注意区分二者的不同，这点在初始化或者给类对象赋初始值的时候尤其重要赋值运算符的左侧必须是一个可修改的左值。赋值运算符的结果是它左侧的运算对象，并且是一个左值。结果的类型就是左侧运算对象的类型，如果赋值运算符左右两个运算对象的类型不同，则运算对象将转化成左侧运算对象的类型。int i, j; i = j = 10; const k = 10; //这里是初始化，不是赋值 k = i; //错误，左侧需要可以修改的左值新的c++ 标准中允许使用初始化列表来给对象进行赋值i = {3.14}; //错误，使用初始化列表时，不能出现精度丢失 i = 3.14; //正确，值为3 vector<int> vi; vi = {0, 1, 2, 3, 4, 5};对于内置类型，初始化列表赋值时，列表中最多只能有一个值，而且值的精度不能大于左侧对象的精度赋值运算符满足右结合律，对于多重赋值语句中的每一个对象，它的类型或者与右边的对象相同，或者可以又右边对象的类型转化得到赋值运算符的优先级较低赋值运算符也包括复合赋值运算符，例如 += 、-=、*= /=递增和递减运算符递增和递减运算符为对象的加一和减一提供了一种简洁的书写形式。这两个运算符还可以应用于迭代器。递增和递减运算符有前置版本和后置版本，前置版本是先加一，然后将改变后对象的值作为求值结果；后置版本是先将对象的结果作为求值结果返回，然后再改变对象的值。在性能上，在涉及复杂的迭代运算时，前置版本会大大优于后置版本，因此尽量养成使用前置版本的习惯。auto pbeg = v.begin() while(pbeg != v.end() && *pbeg >= 0) { cout << *pbeg++ << endl; }这里后置递增运算符的优先级要大于解引用的优先级，所以这里等价于 *(pbeg++)，即先进行后置递增运算，但是返回变化之前的迭代器，然后将变化之前的迭代器进行解引用操作，得到具体元素的值递增和递减运算符可以修改对象的值，而一般的运算符没有严格规定求值的顺序，所以在复合表达式中需要额外注意，不要在可能修改变量值的位置访问该变量string s = "hello world"; auto beg = s.begin(); while(beg != s.end() && !isspace(*beg)) { *beg = toupper(*beg++); }上述例子由于赋值运算符未定义两侧运算对象的求值顺序，可能先求值左侧，那么循环中的语句等效于 beg = toupper(beg); 如果先求值右侧，则等效于 (beg + 1) = toupper(beg);条件运算符条件运算符也叫做三目运算符。cond ? expr1:expr2;条件运算符也可以嵌套使用, 条件运算符满足右结合律。随着嵌套层数的增加，代码的可读性极具下降，因此条件运算的嵌套最好不要超过三层。条件运算符的优先级非常低，一般使用的时候建议加上括号cout << ((grade > 60) ? "pass" : "fail"); // 输出pass 或者 fail cout << (grade > 60)? "pass" : "fail"; // 输出 1或者0，运算结果 是 "pass" 或者 "fail" cout << grade > 60 ? "pass" : "fail"; // 试图将cout 与 60 进行比较，错误位运算符位运算是作用与对象的二进制值的，理论上它可以处理任何对象，但是为了代码安全和可读性，建议只处理整型数据，而且最好是无符号整型运算符功能用法~按位求反~expr<<左移expr << expr2>>右移expr >> expr2&位与expr & expr2^位异或expr ^ expr2\ 位或exprexpr2sizeof 运算符sizeof 返回一个类型或者一个表达式所占的字节数。它满足右结合律针对表达式，sizeof并不计算表达式的值，只返回表达式结果类型的大小由于sizeof 不计算表达式的值，因此即使在sizeof中解引用指针也不会有什么影响逗号表达式逗号运算符含有两个表达式，按照从左至右的顺序依次求值逗号表达式先对左侧表达式进行求值，然后丢弃返回的结果，然后再对右侧表达式进行求值。逗号表达式的返回值是右侧的表达式的值类型转换何时发生隐式转换大多数情况下，比int小的整型值会被转化为int条件中，非布尔值会被转化为布尔类型初始化过程中，初始值转化为变量类型；赋值语句中右侧运算对象转化成左侧运算对象的类型如果是算术运算或者关系运算的运算对象有多种类型，需要转化为同一种类型。而且会尽量往精度较大的一方转化调用函数时也可能会发生类型转化算术类型转换算术转换总是朝着精度更高的一级转换较小的整型会被转化为int，较大的整型会被转化为long、unsigned long、unsigned longlong 等其他隐式类型转换除了算术类型的隐式转换外，还有下面几种数组转化为指针：当数组被用作 decltype、sizeof、取地址符一级typeid 等运算符的运算对象时，该转换不会发生指针的转化：常量整数0和nullptr可以转化为任意类型的指针，指向任意非常量的指针能转化成void，指向任意对象的指针能转化为const void转化为布尔类型: 算术类型或者指针，值为0或者nullptr的被转化为false，其他的值被转化为true转化为常量：常量的指针或者引用可以指向非常量对象，反过来则不行；类类型定义的转化：由程序员预先定义，在需要转化时，由编译器自动调用进行转化显式类型转换显式类型转换绕过了编译器的类型检查，是不安全的一种转化方式显示类型转换的语法规则如下：cast-name<type>(express);其中type是目标类型，express是要转化的值，如果type是引用类型则结果是一个左值。cast-name是 static_cast、dynamic_cast、const_cast 和 reinterpret_cast 中的一种static_cast 只要不包含底层const，都可以使用static_cast，在对指针进行强制类型转化时，要保证转化前与转化后指针所指向的对象类型相同,用于同类型数据之前的转化，如算术类型之前的相互转化。const_cast 只能改变运算对象的底层const、与static_const互相补充reinterpret_cast 重新解释比特位，通常为运算对象的位模式提供较低层次上的重新解释。一般用于指针之间的转化，它没有限制，任何类型间都可以进行转化。但是也十分危险dynamic_cast 动态类型转化，主要用于多重继承类类型之间的转化

c++基础之字符串、向量和数组 上一次整理完了《c++ primer》的第二章的内容。这次整理本书的第3章内容。这里还是声明一下，我整理的主要是自己不知道的或者需要注意的内容，以我本人的主观意志为准，并不具备普适性。第三章就开始慢慢的接触连续、线性存储的数据结构了。字符串、数组、vector等都是存储在内存的连续空间中，而且都是线性结构。算是c++语言中的基础数据结构了。命名空间与using使用方式如下using namespace::name;其中name表示命名空间的具体名字如标准库都在std 这个命名空间，如果要引用这个命名空间的内容就写作 using namespace::std;另外namespace可以表示作为关键字，也可以作为具体的命名空间，如果作为具体命名空间的话，name此时应该是命名空间中的类或者函数等等成员，例如要引用cin这个函数的话，可以这样写 using std::cin在使用时除了使用命名空间之外也可以直接带上命名空间的名称，例如要使用cout 做输出时可以这么写 std::cout << "hell world" << std::endl;使用using 可以直接引入命名空间，减少代码编写的字符数，但是当引入多个命名空间，而命名空间中又有相同的成员时，容易引发冲突。所以在使用命名空间时有下面几条建议头文件中不要包含using声明尽量做到每个成员单独使用using声明string 对象定义和初始化string对象初始化string对象有如下几种方式:string() : 初始化一个空字符串string(const string&): 使用一个字符串来初始化另一个字符串，新字符串是传入字符串的一个副本string(char*): 使用一个字符数组来初始化字符串string(int, char): 新字符串是由连续几个相同字符组成需要注意的是，在定义的语句中使用赋值操作符相当于调用对应的初始化语句。而在其他位置使用赋值操作符在执行复写操作string str = "hello world"; //此处调用拷贝构造，并没有调用赋值重载函数string 对象的操作string的操作主要有：os << s: 将s的值写入到os流中，返回osis >> s: 从is流中读取字符串，并赋值给s，字符串以空白分分隔，返回isgetline(is, s): 从is中读取一行，赋值给s，返回iss.empty(): 判断字符串是否为空，为空则返回true，否则返回falses.size(): 返回字符串中字符个数， 类型为string::size_type。它是一个无符号类型的值，而且编译器需要保证它能够存放任何string对象的大小。不要使用size()的返回值与int进行混合运算s[n]: 返回第n个字符s+s1: 返回s和s1拼接后的结果s1=s2: 将s2的值赋值给s1，执行深拷贝s1 == s2: 判断两个字符串是否相等s1 != s2:判断两个字符串不等<, <=, >, >=:字符串比较处理string 中的字符string 本身是一个字符的容器，我们可以使用迭代的方式来访问其中的每一个字符。例如// 字符转化为大写 string s = "hello world"; for(auto it = s.begin(); it != s.end(); it++) { *it = toupper(*it); }针对这种需要在循环中迭代访问每个元素的情况，c++针对for语句进行扩展，使其能够像Java等语言那样支持自动迭代每一个元素，这种语句一般被称之为范围for。// 统计可打印字符 string s = "hello world"; int punctt_count = 0; for(auto c : s){ if(ispunct(c)){ ++punct_count; } }上述代码中c 只是s中每一个字符的拷贝，如果想像之前那样修改字符串中的字符，可以在迭代时使用引用类型//字符串转化为大写 s = "hello world"; for(auto& c : s){ c = toupper(c); }所有同时具有连续存储和线性存储两个特点的数据结构都可以使用下标访问其中的元素。字符串中字符是采用线性和连续存储的。所以这里它也可以采用下标运算符// 字符串转化为大写 string s = "hello world"; for(auto index = 0; index < s.size(); ++index) { s[index] = toupper(s[index]); } 在使用下标时需要注意下标是否超过容器中存储的元素个数。由于在编译与链接时不会检查这个，如果超出在运行时将会产生未定义结果。标准库 vector标准库vector 表示对象的集合，里面需要存储相同类型的对象。可以看作是一个动态数组。vector 被定义在头文件 vector中由于vector中存储的是对象，而引用不是对象，所以不存在存储引用的vector定义和初始化除了可以使用与string相同的初始化方法外，新的标准还支持使用初始化列表来初始化vectorvector<string> vec = {"Hello", "World", "Boy", "Next", "Door"};一般来说都是预先定义一个空的vector对象，在需要的时候使用push_back或者push_front添加元素。需要注意的是在使用迭代器的过程中，不要针对容器做删减操作同样的vector可以使用下标来访问元素，但是需要注意下标只能访问已有元素不能使用下标来添加元素，同时使用下标时需要注意范围。访问超过范围的元素，会引起越界的问题迭代器迭代器是一组抽象，是用来统一容器中元素访问方式的抽象。它能保证不管什么类型的容器，只要使用迭代器，就能使用相同的方式方法从头到尾访问到容器中的所有元素。在这里不用过于纠结跌打器究竟是如何实现的，只需要知道如何使用它。另外提一句，我当初在初学的时候一直把c语言的思路带入到c++中，导致我一直认为跌迭代器就是指针或者下标，我试图使用指针和下标的方式来理解，然后发现很多地方搞的很乱，也很模糊。这个概念我是一直等待学习python和Java这种没有指针、完全面向对象的语言之后，才纠正过来。这里我想起《黑客与画家》书中提到的，编程语言的高度会影响我们看待问题高度。从我的经历来看，我慢慢的理解了这句话的意思。所以这也是我当初学习lisp的一个原因。我想看看被作者称之为数学语言，抽象程度目前最高的语言是什么样的，对我以后看问题有什么影响迭代器提供了两种重要的抽象：提供统一的接口来遍历容器中所有元素；另外迭代器提供统一接口，让我们实际操作容器中的元素使用迭代器迭代器的使用如下：迭代器都是使用begin 获取容器中的第一个元素；使用end获取尾元素的下一个元素迭代器自身可以像操作对象的指针一样操作容器中的对象迭代器比较时，比较的是两个迭代器指向的是否是同一个元素,不支持 >、<比较++ 来使迭代器指向容器中下一个位置的对象，--来指向上一个位置的对象如果不想通过迭代器改变容器中元素的值，可以使用const类型的迭代器，即 const_iterator类型的迭代器#+BEGIN_SRC c++ string s = "Hello World"; for(string::const_iterator it = s.begin(); it != s.end(); it++) { cout << *it << endl; } #+END_SRCbegin 和end返回的是普通类型的迭代器，c++ 11中提供了一套新的方法来获取const类型的迭代器，cbegin和 cend迭代器的常见运算迭代器常见运算：iter + n: 迭代器向前可以加上一个整数，类似于指针加上一个整数，表示迭代器向前移动了若干个元素iter - n: 迭代器往前移动了若干个元素，类似于指针减去一个整数iter1 - iter2: 表示两个迭代器之间的间距，类似于指针的减法、<、>=、<=:根据迭代器的位置来判断迭代器的大小，类似于指针的大小比较迭代器与整数运算，如果超过了原先容器中元素的个数，那么最多只会返回容器中最后一个元素的下一个跌打器，也就是返回值为 end函数的返回迭代器相减得到迭代器之间的距离，这个距离指的是右侧的迭代器移动多少个元素后到达左侧迭代器的位置，其类型定义为difference_type使用迭代器来访问元素时，与使用指针访问指向的对象的方式一样，它重载了解引用运算符和箭头运算符。使我们能够像使用指针那样使用迭代器数组数组与vector相似二者都是线性存储二者存储的都是相同类型的元素与vector不同的是：数组大小固定由于大小在初始化就已经确定，所以在性能上优于vector，灵活性上有些不足定义和初始化内置数组在初始化数组的时候需要注意：数组大小的值可以是字面值常量、常量表达式、或者普通常量定义数组时必须指明类型，不允许用auto由初始化值来进行推断const unsigned int cnt = 42; //常量 constexpr unsigned int sz = 42; //常量表达式 int arr[10]; //使用字面常量指定大小 int arr2[cnt]; //使用常量初始化 int arr3[sz]; //使用常量表达式初始化可以在初始化时不指定大小，后续会根据初始化列表中的元素个数自动推导出数组大小同时指定了数组大小和初始化列表，如果指定大小大于初始化列表中的元素个数，那么前面几个元素按照初始化列表中的值进行初始化，后面多余的元素则初始化为默认值如果指定大小小于初始化列表中元素个数，则直接报错const unsigned int sz = 3; int arr1[sz] = {1, 2, 3}; int arr2[sz] = {1}; // 等价与 arr2[sz] = {1, 0, 0} int arr3[] = {1, 2, 3}; int arr4[sz] = {1, 2, 3, 4}; //错误，初始化列表中元素个数不能大于数组中定义的元素个数字符数组可以直接使用字符串常量进行赋值，数组大小等于字符串长度加一我们可以对数组中某个元素进行赋值，但是数组之间不允许直接进行拷贝和赋值和vector中一样，数组中存储的也是对象，所以不存在存储引用的数组。在理解关于数组的复杂声明时，采用的也是从右往左看理解的方式。或者说我们先找到与[] 结合的部分来理解，与[]结合的部分去掉之后就是数组中元素的类型。int * ptrs[10]; int & refs[10]; int (*Parry)[10]; int (&arrRef)[10];上面的例子中：ptrs，首先与[]结合最紧密的是ptrs 去掉这两个部分，剩下的就是int 这部分表示数组中元素类型是int , 也就是这里定义了一个包含10个int指针元素的数组refs, 首先与[]结合最紧密的是ref2,去掉这个部分，剩下的就是int&，这部分表示数组中元素类型是int&，也就是这里定义了一个包含10个指向int数据的引用的数组，由于不存在存储引用的数组，所以这里是错误的Parry，由于有了括号，与[]结合最紧密的就变成了 int，也就是我们先定义了一个包含10个int类型的数组，而Parry本身是一个指针，所以这里定义的其实是一个指向存储了10个int类型数据的数组的指针同样的方式分析，得到arrRef 其实是一个指向存储了10个int类型数据的数组的引用指针和数组在上面的例子中，已经见过了指针和数组的一些定义方式，例如ptrs 是一个存储了指针的数组，这种数组一般称之为指针数组；Parry是一个指向数组的指针，这种指针被称之为数组指针在某些时候使用数组的时候，编译器会直接将它转化为指针，其中在使用数组名时，编译器会自动转化为数组首元素的地址。int ia[] = {1, 2, 3, 4, 5}; auto ia2 = ia; ia2[2] = 10; // 这里ia2是指向ia数组首元素的指针，这里其实是在修改ia第3个元素的值需要注意的是在使用decltype时，该现象不会发生，decltype只会根据表达式推断出类型，而不会具体计算表达式的值，所以它遇到数组名时，根据上下文知道它是一个数组，而不会实际取得数组首元素的地址int ia[] = {1, 2, 3, 4, 5}; decltype(ia) ia2 = {0}; //这里ia2 是一个独立的数组，与ia无关 ia2[2] = 10;指针也可以看作迭代器的一种，进行迭代时终止条件是数组尾元素下一个位置的地址int ai[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; int *pbegin = &ai[0]; int *pend = &ai[10]; for(int* it = pbegin; it != pend; it++) { cout << *it << endl; }c++ 11中引入两个函数来获取数组的begin位置和end位置，分别为begin() 与 end()int ai[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; for(int *p = begin(ai); p != end(ai); p++) { cout << *p << endl; }c 风格的字符串string转化为char 可以使用string.c_str()函数,该函数返回的是const char，以取保无法通过这个指针修改字符串本身的值，另外该函数返回的地址一直有效，如果后续修改了string的值，那么根据字符串的算法，字符串中保存字符的地址可能发生变化，此时再使用原来返回的指针访问新的字符串，可能会出现问题如果执行完c_str函数后，程序想一直访问其返回的数组，最好将该数组重新拷贝一份string s = "hello world"; const char* pszBuf = s.c_str() char* pBuff = new char[s.size() + 1]; memset(pBuff, 0x00, sizeof(char) * s.size() + 1); strcpy(pBuff, pszBuff); //后面可以直接使用pbuf，即使s字符串改变 s = "boy next door"; //do something delete[] pBuf;为了与旧代码兼容，允许使用数组来初始化一个vector容器，只需要指明需要拷贝的首元素地址和尾元素地址int arr[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10}; vector<int> va(begin(arr), end(arr));多维数组多维数组是数组的数组，数组中每一个成员都是一个数组。当一个数组的元素仍是数组时，需要多个维度来表示，一个表示数组本身的大小，一个维度表示元素中数组大小对于二维数组来说，一般把第一个维度称之为行，第二个维度称之为列。int ia[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; //等价于 int ia[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};多维数组的初始化可以用打括号初始化每个维度的数据，也可以省略中间的大括号，这样它会按照顺序初始化但是需要注意int ia[3][4] = { {0}, {1, 2}, {3, 4, 5} }; int ia[3][4] = {0, 1, 2, 3, 4, 5};上述代码中，二者含义完全不一样,上一个表示每个子元素中的数组如何初始化，最终结果为{0, 0, 0, 0, 1, 2, 0, 0, 3, 4, 5, 0}。下面一个是从第一行开始依次初始化所有元素,最终结果为{0, 1, 2, 3, 4, 5, 0, 0, 0, 0, 0, 0}可以使用下标访问数组元素，一个维度对应一个下标int ai[3][4] = {0}; cout << ai[2][3] << endl; //如果下标个数和数组维度一样，将得到具体类型的值 cout << ai[2] << endl; //下标数小于数组维度，得到对应子数组的首地址可以使用for循环遍历数组int a[3][4] = {0}; for(auto row : a){ for(auto i : row) //错误不能对指针使用迭代 { cout << i << endl; } }上述例子中，由于多维数组中存储的是数组元素，所以row默认是数组元素，也就是数组首地址，是指针类型，也就不能使用内层的迭代了我们可以稍微做一些修改int a[3][4] = {0}; for(auto& row : a){ for(auto i : row) //错误不能对指针使用迭代 { cout << i << endl; } }使用引用声明之后，row就表示指向内层子数组的一个数组的引用，也就是一个子数组本身，针对数组就可以使用范围for了注意：使用for范围遍历时，除了最内层元素，其余的都需要声明为引用类型多维数组的名称也是数组的首地址定义多维数组的指针时，需要明确，多维数组是存储数组的特殊数组int ai[3][4] = {0}; int (*p)[4] = ai; // int *p[4] 表示的是指针数组，数组有4个成员，每个成员都是一个int* 上述代码，ai是一个存储3个数组元素的数组，每个元素又是存储4个整型元素的数组，因此定义它的指针的时候，需要明确，指针类型应该是数组元素的类型，也就是有4个int型元素的数组的指针当然如果嫌麻烦或者不会写，可以使用auto来定义一般来说，书写多维数组的指针是比较麻烦的一件事，可以使用类型别名让它变得简单点，上面的例子可以改写一下//typedef int int_array_4[4]; 二者是完全等价的 using int_array_4 = int[4]; int_array_4 *pArr = ai; for(; pArr != ai + 3; ++pArr) { for(int *p = *pArr; p != *pArr+4; ++p) { cout << *p << " "; } cout << endl; } 数组名代表的是数组的首元素，多维数组又可以看作是一个存储数组的数组。所以这里ai的名称代表的是一个存储了3个元素的数组，每个元素都是存储4个整型数据的数组。pArr 的类型是存储了4个整型元素的数组的指针，所以这里与ai表示的指针的类型相同。这里我们将ai的值赋值给指针。在循环中，外层循环用来找到ai数组中每个子数组的指针。内层循环中，使用pArr解引用得到指针指向的每一个对象，也就是一个存储了4个整型元素的数组。针对这个数组进行循环，依次取出数组中每一个元素。

2021年阅读清单 之前在新年总结中提到，自己读书数量不够，希望扩大这个数量。也提到过，针对读过的每本书，写点读书感悟什么的。这个算是这个想法的实践。一来可以根据这个清单来统计自己今年到底阅读量有多大，二是简单写点什么，防止读了就忘记了。这里我也不打算写多长，也不作为正式的读书笔记。就搞简单点，类似于朋友圈或者豆瓣读书那样，简单写点文字，主要是自己的感悟和书中的主要内容。《自私的基因》这个是源于我高中教科书上推荐的一本书，去年翻到我一个弟弟的生物书的时候突然想起来这本书还没看过，所以就在kindle上买了来读一下书中将基因作为进化的实际单位，而生物本身只是基因的生存机器。生物繁殖只是基因的赋值。本书采用拟人的手法，将基因看作一个个活生生的人，而基因自身只有一个目的，生存和繁殖。基因的本质是自私的，它能想到的仅仅是如何扩大自身在基因库中的数量，从这点出发，本书探讨了我们在平常生物界看到的利他行为几乎都可以采用自私基因理论进行解释，对他人友善仅仅是为了换取日后他人对自己的友善，族群的舍己为人可以看作是为了保留同样基因的大部分复制，而牺牲少部分。亲情也可以解释为含有一半或者四分之一的父辈或者祖父辈基因等等这些。相对于一般的学术著作，它的写作手法更像是科普著作，书中的内容并不复杂，结构安排合理，一环套一环。是一本值得一看的好书《万物简史》看到这本书名，我以为是一本人类的发明史，结果证明我的眼界确实不够，里面的万物真的是世间万物。从宇宙、到太阳系、到地球、到生物。维度从大到小，依次介绍跟这些发现相关的历史。里面涉及到的人名、时间太多。内容我并没有记住多少。看完这本书给我的感觉是，宇宙到生物，存在的时间跨度太长，人类只是微不足道的一环，而当今科技看似繁荣，看似我们已经在逐渐成为上帝，但是我们连我们居住的宇宙环境、地球、甚至是跟我们做邻居的各种生物都没有搞清楚。 现在人类的未知领域仍然很多，仍需要我辈的努力。《许三观卖血记》这本书是我在闲暇之余，用来打发时间而看的。本书中主人公，许三观通过卖血多次使家庭成功摆脱困境，在看似喜剧的结尾下实际展示出了一出悲剧。小说通过许三观这个小人物从成家到老年，向读者展示了中国近半个世纪的历史变迁。书中最感人的是当然是最后一次为了给儿子治病一路卖血到上海，儿子的病险些将他击垮，但是一路上凭借他的意志以及路人的帮助，最终克服难关。随着孩子的长大，他再也不需要卖血了。最后一家人其乐融融吃了炒猪肝和黄酒。故事到此结束《乌合之众》乌合之众被认为是社会心理学中最具影响力的著作。当初冲着它的各种名头来读它的，但是实际读起来的效果可能并没有那么好。书中反复在强调群体的情绪化、极端化以及低智化的特点，并针对此特点进行扩展说明。但是我总觉得本书在论证时逻辑性不强，扩展的也不够深入，其中许多实例似乎是为了论证而论证，并不具有普适性。书中主要的观点总结起来就是：群体是具有共同目的的集合，这个集合不局限于物理意义上的集合。集合起来的群众智力低下、盲目而又极端，充满原始的暴力和血腥，具有各种情绪化的体现。在当今的互联网时代中，在针对一件事进行讨论之时很容易形成群体，这就给我们理解当今互联网中的各种怪象提供了一些理论依据。《小狗钱钱》这是一本针对儿童的理财启蒙书，书中主要一个类似童话的故事，告诉我们幸福和富足应该是我们与生俱来的权利。我们不应该以挣钱或者拥有很多金钱而感到耻辱。本书通过一只会说话的小狗给我我们讲述了一堂生动的理财课程，包括通过坚持写成功日记建立自信确定梦想，以便有挣钱的动力。同时坚持为梦想储蓄学会分配收入，使金钱变为我们的工具，做到用钱来生钱对于我这样的理财小白来说，书中并没有高深的理论，也没有具体教你如何变得富有。本书对我的作用应该是树立正确的金钱观，让我有理财意识。《福尔摩斯探案全集》这是我最近在书荒时在kindle上找到的一套特价的书，全套不到10块钱，而这套书对我来说有特殊的意义，之前又没有完全看完，因此这里我决定乘着这个机会将这套书给读完。书中的经典故事像血字研究、四签名、红发会、最后一案、巴斯克维尔的猎犬、空屋等等已经深入人心，这些故事很好的塑造了一个个性鲜明、业务能力突出的侦探形象。福尔摩斯这个形象如今已经深入人心，这些故事本身读起来也颇为有趣，有些故事即使已经了熟于心，再读一次乐趣也丝毫不减。这本书与我有着不解的渊源。它成功将我从读漫画过度到读文字类的书，同时也使我对侦探推理类小说产生了浓厚的兴趣。它使我产生了读书的爱好。同时也承载了我上中学时白嫖新华书店的美好记忆。总之如果我想培养我的孩子良好的阅读习惯，这本书将是我必定会带领他读的书。《一胜九败》由于某些特殊原因，我找到了这本书。这是一本讲述优衣库创业与主要历程的书，书中穿插了创始人柳井正对于企业经营的相关思考与理念。并且结合优衣库相关历史进行了通俗的阐述。书中以优衣库的发展历史为主线，详细讲述了从接班父亲的男士西服店，到创立优衣库，到第一家门店，再到关东第一家门店，到最后迈入全球市场。在讲述这些历史的同时也夹杂了创始人对各个时期经营理念的思考。例如店铺开遍日本时确立的以店铺为核心，总部围绕店铺运行的理念。在一定公司发展壮大的时候强调以效率为主体，要做到快的目标，并且为此成立讯销集团作为优衣库的母公司。也体现了他这一理念。需要重视人才培养，当公司成长到一定阶段就开始重视人才的培养，书中提到需要招募培养与个人价值与公司价值观相匹配的员工。对于那些不符合要求的，提出可以尊重对方的意愿离职。这对整个以终身雇用制的日本来说确实是一个先例提出在实干中成长，制定计划或者人才培养不能纸上谈兵，提倡在实际店铺中感受这一行业。广告要考虑顾客的真实需求，并且在这方面进行宣传，而不要采用猎奇、洗脑风。这个对当今中国广告业有一定的借鉴意义书中更是总结了经营者的23条理念。对于希望创业的人来说很有参考意义。对我来说，经营企业与经营自己的人生，有异曲同工之妙。例如说上说，经营者需要为企业制定大胆的经营目标。我想人生也是一样，需要为自己制定人生目标，并且为目标制定计划，并按照计划执行。而且不用担心目标是否过高，只要制定严密的可行计划，然后经常将努力之后的结果与目标进行对比、总结、更正。总能实现目标的。正如书的标题所言，经营企业经常面临的结果是一胜九败，针对失败只要认真分析失败的原因，及时止损，坚持下来总会有成功的那一天。《十分钟冥想入门指南》这是一本介绍冥想入门的书籍，最近我比较焦虑，网上推荐采用冥想可以更好的注重当下，体会当前生活。本书的作者安迪当初为了学习冥想有到喜马拉雅山脉上进行冥想训练的体验，后来成立了头脑空间项目，专注于提供冥想指导服务。科学上已经验证冥想能有效改善抑郁症和失眠症。对于缓解焦虑有一定的效果。同时经常冥想的人注意力更加集中，幸福感会增加。书中采用大量比喻说明冥想中可能会出现的问题，以及我们该如何应对，同时对冥想的相关操作和技法也有详细的描述，目前我也是处于刚入门阶段，无法判断冥想到底是否有效，我决定尝试一段时间，如果真的有效果或者我感觉比较舒适了，后续我会将冥想的相关体验以及使用的技法整理出来。《穷爸爸富爸爸》继《小狗钱钱》之后，这是我看的第二本理财的书，。书中着重强调了实现财富自由的前提就是有相应的财商，书中将财商分为拥有会计知识、法律知识、以及对金钱的正确认识。结合《小狗钱钱》这本书，我理解了金钱是我们追求幸福生活的手段而不是目的。不要耻于谈论金钱以及如何挣钱。书中指出，富人与穷人的区别并不在于挣钱的能力，而在于财商或者说对金钱的态度与认知上面。书中使用图表清晰的表述出，富人主要将挣到的钱购买资产，使用资产增值的部分进行消费。而穷人则是将大部分钱用于购买消费品。从而在失去劳动能力或者收入无法平衡支出时陷入财务危机。这与马克思所说的生产资料与生活资料有异曲同工之妙。我们应该将挣到的钱投入到购买生产资料或者能增值的资本，而不是大量用来购买生活资料。只有依靠资本的增值才能实现个人的财务自由。本书主要介绍财富观念，或者说理财的观念。对与如何理财以及如何购买股票、基金等资产提到的少之又少，甚至说没有。如果希望从中能够找到如何挑选靠谱的股票与基金或者其他理财产品，那么可能要失望了。《明朝那些事》本书是我在微信阅读中，利用上下班通勤期间读完的。读完之后我给出5星评价。给5星是因为满分只有5星。这本书是我读过的关于历史最有趣的书，书共7册，利用现代化的、俏皮的、通俗的语言，将明朝从朱元璋到朱由检的历史娓娓道来。让我看到在一个封建王朝中，士族、皇族、外戚、宦官这几股势力之间的斗争以及各种高级宫斗。同时科普了一些封建王朝中政治制度。例如科举制、三省六部制等等。不光如此，书中还包含着作者对历史的思考，同时也会有作者对像于谦、张居正、徐阶这样正直无私，充满光芒的人物的敬佩之情。也有对像魏忠贤、严嵩这样奸臣的唾弃之情。从书中的语言或者作者所占的立场来看作者与明代这些名臣一样，拥有为天下苍生谋福利的伟大的政治理想。这本书让我有这样一些感悟：原来历史、历史书也能如此有趣原来封建社会并不是皇帝一家独大，也涉及到各种政治势力之间的斗争原来好人并不是伟光正的，贪官要奸，清官要更奸原来手无缚鸡之力的文人也可以散发出如此强烈的气场原来除了戏文中，真实历史上还有这么多可歌可泣的故事原来毛主席说的路线错误知识越多越反动是对的。知识分子坏起来造成的危害比流氓更甚最后不管你是否对历史感兴趣，是男是女都可以读一下这本书。不喜欢历史的也一定会喜欢这本书。原来历史还可以如此有趣《当我谈跑步时,我谈些什么》这是我看的第一本村上春树的书，书中主要是将作者关于跑步的相关感悟以及跑步的一些历程。比如多次参加马拉松和铁人三项。从书中我读到跑步的乐趣，例如迎着清晨的微风一边欣赏美景一边跑步。在跑步时放空大脑，或者任由大脑中思绪来来去去。 另外我从书中读到作者通过跑步这件事告诉我一个自律的人是一种怎样的体验，以及如何在一件看似枯燥的事情中去寻找快乐。读完这本书后我对跑步有了一个新的认识，甚至作为一个厌恶跑步的人我也有了想要跑步的念头。《人类群星闪耀时》该书作者被誉为最会写历史的作家。书中主要采用速写的方式，快速记录了作者认为对人类历史产生深远影响的历史瞬间。我在读这本书的时候发现，很多可能在教科书中一笔带过的历史事件，在书中被描述的如此戏剧化。甚至可以说如此的惊心动魄，有时候感觉比追剧更加精彩，虽然我知道故事最终的结局是什么，但是它仍然让我产生了追剧过程中期待反转，期待故事的结局这种感觉。书中选取的历史瞬间是作者凭主观意识决定的，并不一定代表真实的历史研究，甚至很多时候的细节并不严谨。而且主要是西方历史，这对于对那段历史并不怎么理解的我来说读起来带入感并没有难么强烈，但这并不是书的缺点，反而激发了我对于某段西方历史的兴趣。《占星术杀人魔法》很早就听说过该书的大名，但是最近才有时间拜读。由于早期接触到的一些推理剧已经将书中的诡计展示的玲离尽致，在刚开始阅读时已经知晓谜底了，使这次阅读的乐趣减少了很多，但是仍然不妨碍这是一个十分优秀的诡计，该作品是一部十分优秀的推理小说。读起来仍让人觉得乐趣无穷。推理小说诡计虽然是重中之重，但是好的推理小说不能仅仅只有诡计。我想这本书除去优秀的诡计，在叙事上也十分值得称道。在阅读这部作品的时候，我时常想，我多想清除掉脑海中关于这个诡计的记忆，这样读起来会更加欲罢不能，更加令人沉醉其中。《万历十五年》该书似乎是一本严肃的历史学术著作，通过万历年间朝中的重大人物和重大事件，还原了万历朝的一些重大历史事件的全貌，展示了作者的大历史观，同时阐述了古代中国历史上以道德代替法律的种种弊端。历史人物对于历史进程的影响是如此的微小，即使是皇帝、首辅大臣、边关大吏也无法做到扭转乾坤。该书作为一本历史学术著作读起来确实有些无聊，但是不妨碍它是一本值得一读的好书《病者生存》以前就有一些疑问：既然是适者生存，那么为什么现在人类身上有如此多的不和谐呢，有如此多的遗传病和治病基因呢？这本书回答了我的一些问题。例如书中提到糖尿病层冰帮助我们的祖先度过了漫长的冰河时期，母亲在怀孕期间吃大量的垃圾食品，会使婴儿误认为外部生存条件恶劣，从而调整身体结构，对能量的消耗减少，从而更容易导致肥胖；书中提到生命是落魄的，为了生存，必须妥协。 为了让我们明天存活下来的东西，可能几十年后会要了我们的命，这就是生命的妥协。进化中也无时无刻不在发生这样的事情。另外书中也向我门展示了进化中与我们所想不一样的东西，例如进化是会受外界干扰的，并不是完全随机的。基因中有许多开关，会根据实际生存环境来调整生物性状。这也体现了生命本身对外界的一种妥协。虽然生命中存在妥协，但是我们也不需要为此沮丧，因为生命本身就是奇迹。《禅宗 六祖惠能》这是一本介绍六祖惠能大师生平的书籍，类似与人物的传记。总体来说，本书语言轻快明朗，写出了惠能生平的主要事迹，并且通过一些具体的事迹，向我展示了佛法的一些基本原理，例如心静，顿悟成佛。这些原理加上作者或者说惠能的一些心理描写，将深奥的佛法铺展开来，是我更好的理解的部分佛法。本书对了解惠能法师的生平，入门基本的佛教有一定的帮助。但是书中也有许多不足的地方，太过于唯心主义，将惠能描述为全知全能的神，有点过于神话他了。有些文字我觉得从文言中翻译为白花有点牵强。而且叙事整体结构散乱，这些都是我不太喜欢这本书的原因。《毛泽东传》之前读毛选的时候，有很多地方并没有读的很明白，毛泽东思想作为一种实用主义科学，它是一套分析问题、解决问题的方法论。要想读懂毛选，需要对毛主席的生平以及对应的历史时期有一点认识，因此我开始读这本毛泽东传书中描述了毛主席传奇而又平淡的一生。从书中可以看出毛主席的一生是斗争的一生。开始与父亲斗，后面开始封建压迫、帝国主义压迫以及国内资产阶级的压迫。建国以后又在与党内各种势力，各种思想斗争。其中有成功也有失败，从本书中可以看到毛主席并不都是英明神武的，他也只是一个普通人，也会有错误，也会迷茫，伤心之类的。从这本书中，我有点理解毛泽东思想了，它并不完全是毛泽东本人个时期的想法，而是我党在革命战争与建国初期通过实践形成的一整套科学的思想，并不完全属于毛主席，而是代表着我党不断探索实践，不断总结经验而形成的一整套思想和方法论。本书相比与其他人物传记来说，显得比较偏学术，用词比较枯燥，这也造成了阅读的过程中少了一丝趣味。但是也不失为一本了解毛主席的不错的书籍《岩田先生如是说》作为一名全新的任粉，我最近迷上了任天堂各位制作人的故事，说到各种制作人的故事，就不得不提到岩田聪社长了。这本书汇集了岩田聪公开演讲以及一些回忆录性质的内容，记录了岩田先生的一些习惯和日常。书中有几点令我十分动容，一个是岩田聪的以他人的快乐为自己的快乐，为他人的快乐而工作。还有他拿出很大一部分精力来跟每一名员工面谈。企图站在员工的立场上，为员工着想。他一直给人一种和蔼可亲的感觉，我想在聪哥手下工作应该是一件非常幸福的事情吧。另外一个地方是在他去世之后，宫本茂说“现在唯一困扰的是，我在周末想到的那些无足轻重的点子，周一没有人倾听了”。看到这里我有一种好朋友突然离我而去，再也没有人听我平日里那种碎碎念的感觉。瞬间击中了我的泪腺。聪哥在演讲中说的著名的话：”在我的名片上我是一个公司的社长。在我头脑里我是一名游戏开发者。但是在我的心里我是一名游戏玩家“。在此缅怀一直为我们带来欢乐的永远的聪哥。《睡眠革命》很早以前我听说成年人的健康睡眠时间是8小时，过去我睡觉只追求数量没有追求质量，这本书改变我关于睡眠的一些认知。书中提到一个R90方针，即人体睡眠是一个周期性的，从浅睡到深睡，再到浅睡形成多个周期，一个周期大概持续90分钟，在睡眠中需要注重的是深度睡眠的时长而不是关注总体时间。而且睡眠时间应该周期为单位而不是单纯的以小时计算。应该是90分钟的整数倍每天尽量固定起床时间，以这个固定时间来推算自己睡觉时间。应该把睡眠时间放在更长的时间范围来评估，比如评估一周一共睡了多少个90周期，而不要为某一天晚上睡眠时间不够而焦虑。同时注重白天适当的补充睡眠影响人体周期的是光，当光照不足的时候人体会产生褪黑色素让人产生睡意。光照分为强光和柔光，强光指太阳光、电子屏辐射光，而柔光则是黄光，强光会让我们更有精神，而柔光则会让我们更加舒适。所以在需要睡眠的时候放下电子产品，在卧室装上柔和的灯光，调暗家里的光线，保证你的褪黑色素的正常分泌从而产生困意。需要打起精神的时候，使用强光。例如早晨起床后打开窗帘，出去晒晒太阳，在感到倦怠的时候打开日光灯。

c++基础之变量和基本类型 之前我写过一系列的c/c++ 从汇编上解释它如何实现的博文。从汇编层面上看，确实c/c++的执行过程很清晰，甚至有的地方可以做相关优化。而c++有的地方就只是一个语法糖，或者说并没有转化到汇编中，而是直接在编译阶段做一个语法检查就完了。并没有生成汇编代码。也就是说之前写的c/c++不能涵盖它们的全部内容。而且抽象层次太低，在应用上很少会考虑它的汇编实现。而且从c++11开始，加入了很多新特性，给人的感觉就好像是一们新的编程语言一样。对于这块内容，我觉得自己的知识还是有欠缺了，因此我决定近期重新翻一翻很早以前买的《c++ primer》 学习一下，并整理学习笔记背景介绍为什么会想到再次重新学习c++的基础内容呢？目前来看我所掌握的并不是最新的c++标准，而是“c with class” 的内容，而且很明显最近在关注一些新的cpp库的时候，发现它的语法我很多地方都没见过，虽然可以根据它的写法来大致猜到它到底用了什么东西，或者说在实现什么功能，但是要自己写，可能无法写出这种语法。而且明显感觉到新的标准加入了很多现代编程语言才有的内容，比如正则表达式、lambda表达式等等。这些都让写c++变得容易，写出的代码更加易读，使其脱离了上古时期的烙印更像现代的编程语言，作为一名靠c++吃饭的程序员，这些东西必须得会的。看书、学编程总少不了写代码并编译运行它。这次我把我写代码的环境更换到了mac平台，在mac平台上使用 vim + g++的方式。这里要提一句，在mac 的shell中，g++和gcc默认使用的是4.8的版本，许多新的c++标准并不被支持，需要下载最新的编译器并使用替换环境中使用的默认编译器，使其更新到最新版本gcc / g++ 使用在shell环境中，不再像visual studio开发环境中那样，只要点击build就一键帮你编译链接生成可执行程序了。shell中所有一切都需要你使用命令行来搞定，好在gcc/g++的使用并不复杂，记住几个常用参数就能解决日常80%的使用场景了，下面罗列一些常用的命令-o 指定生成目标文件位置和名称-l 指定连接库文件名称，一般库以lib开头但是在指定名称时不用加lib前缀，例如要链接libmath.o 可以写成-lmath-L 指定库所在目录-Wall 打印所有警告，一般编译时打开这个-E 仅做预处理，不进行编译-c 仅编译，不进行链接-static 编译为静态库-share 编译为动态库-Dname=definition 预定义一个值为definition的，名称为name的宏-ggdb -level 生成调试信息，level可以为1 2 3 默认为2-g -level 生成操作系统本地格式的调试信息 -g相比于-ggdb 来说会生成额外的信息-O0/O1/O2/O3 尝试优化-Os 对生成的文件大小进行优化常用的编译命令一般是 g++ -Wall -o demo demo.cpp开启所有警告项，并编译demo.cpp 生成demo程序 ## 基本数据类型与变量 ### 算术类型 这里说的基本数据类型主要是算术类型，按占用内存空间从小到大排序 char、bool(这二者应该是相同的)、short、wchar_t、int、long、longlong、float、double、long double。当然它们有的还有有符号与无符号的区别，这里就不单独列出了 一般来说，我们脑袋中记住的它们的大小好像是固定，比如wchar_t 占2个字节，int占4个字节。单实际上c++ 并没有给这些类型的大小都定义死，而是固定了一个最小尺寸，而具体大小究竟定义为多少，不同的编译器有不同的实现，比如我尝试的wchar_t 类型在vc 编译环境中占2个字节，而g++编译出来的占4一个字节。下面的表是c++ 规定的部分类型所占内存空间大小 | 类型 | 含义 | 最小尺寸 | |:----------|:--------------|:-----| | bool | 布尔类型 | 未定义 | | char | 字符 | 8位 | | wchar_t | 宽字符 | 16位 | | char16_t | Unicode字符 | 16位 | | char32_t | Unicode字符 | 32位 | | short | 短整型 | 16位 | | int | 整型 | 32位 | | long | 长整型 | 32位 | | longlong | 长整型 | 64位 | | float | 单精度浮点数 | 32位 | | double | 双精度浮点数 | 64位 | 另外c++的标准还规定 一个int类型至少和一个short一样大，long至少和int一样大、一个longlong至少和一个long一样大。 ### 有符号数与无符号数 数字类型分为有符号和无符号的，默认上述都是有符号的，在这些类型中加入unsigned 表示无符号，而char分为 signed char、char、unsigned char 三种类型。但是实际使用是只能选有符号或者无符号的。根据编译器不同，char的表现不同。 一般在使用这些数据类型的时候有如下原则 1. 明确知晓数值不可能为负的情况下使用unsigned 类型 2. 使用int进行算数运行，如果数值超过的int的表示范围则使用 longlong类型 3. 算术表达式中不要使用char或者bool类型 4. 如果需要使用一个不大的整数，必须指定是signed char 还是unsigned char 5. 执行浮点数运算时使用double ### 类型转化 当在程序的某处我们使用了一种类型，而实际对象应该取另一种类型时，程序会自动进行类型转化，类型转化主要分为隐式类型转化和显示类型转化。 数值类型进行类型转化时，一般遵循如下规则： 1. 把数字类型转化为bool类型时，0值会转化为false，其他值最后会被转化为true 2. 当把bool转化为非bool类型时，false会转化为0，true会被转化为1 3. 把浮点数转化为整型时，仅保留小数点前面的部分 4. 把整型转化为浮点数时，小数部分为0；如果整数的大小超过浮点数表示的范围，可能会损失精度 5. 当给无符号类型的整数赋值一个超过它表示范围的数时，会发生溢出。实际值是赋值的数对最大表示数取余数的结果 6. 当给有符号的类型一个超出它表示范围的值时，具体结果会根据编译器的不同而不同 7. 有符号数与无符号数混用时，结果会自动转化为无符号数 (使用小转大的原则,尽量不丢失精度) **由于bool转化为数字类型时非0即1，注意不要在算术表达式中使用bool类型进行运算** 下面是类型转化的具体例子 ```cpp bool b = 42; // b = true int i = b; // i = 1 i = 3.14; // i = 3; double d = i; // d = 3.0 unsigned char c = -1; // c = 256 signed char c2 = c; // c2 = 0 gcc 中 255在内存中的表现形式为0xff，+1 变为0x00 并向高位溢出，所以结果为0 ``` 上述代码的最后一个语句发生了溢出，**对于像溢出这种情况下。不同的编译器有不同的处理方式，得到的结果可能不经相同，在编写代码时需要避免此类情况的出现** 尽管我们知道不给一个无符号数赋一个负数，但是经常会在不经意间犯下这样的错误，例如当一个算术表达式中既有无符号数，又有有符号数的时候。例如下面的代码 ```cpp unsigned u = 10; int i = -42; printf("%d\r\n", u + i); // -32 printf("%u\r\n", u + i); //4294967264 ``` 那么该如何计算最后的结果呢，这里直接根据它们的二进制值来进行计算，然后再转化为具体的10进制数值，例如u = 0x0000000A，i = 0xffffffd6;二者相加得到 0xffffffEO， 如果转化为int类型，最高位是1，为负数，其余各位取反然后加一得到0x20，最终的结果就是-32，而无符号，最后的值为4294967264 ### 字面值常量 一般明确写出来数值内容的称之为字面值常量，从汇编的角度来看，能直接写入代码段中数值。例如32、0xff、"hello world" 这样内容的数值 #### 整数和浮点数的字面值 整数的字面值可以使用二进制、8进制、10进制、16进制的方式给出。而浮点数一般习惯上以科学计数法的形式给出 1. 二进制以 0b开头，八进制以0开头,十六进制以0x开头 2. 数值类型的字面值常量最终会以二进制的形式写入变量所在内存，如何解释由变量的类型决定，默认10进制是带符号的数值，其他的则是不带符号的 3. 十进制的字面值类型是int、long、longlong中占用空间最小的（前提是类型能容纳对应的数值） 4. 八进制、十六进制的字面值类型是int、unsigned int、long、unsigned long、longlong和unsigned longlong 中尺寸最小的一个（同样的要求对应类型能容纳对应的数值） 5. 浮点数的字面值用小数或者科学计数法表示、指数部分用e或者E标示 #### 字符和字符串的字面值常量 由单引号括起来的一个字符是char类型的字面值，双引号括起来的0个或者多个字符则构成字符串字面值常量。字符串实际上是一个字符数组，数组中的每个元素存储对应的字符。**这个数组的大小等于字符串中字符个数加1，多出来一个用于存储结尾的\0** 有两种类型的字符程序员是不能直接使用的，一类是不可打印的字符，如回车、换行、退格等格式控制字符，另一类是c/c++语言中有特殊用途的字符，例如单引号表示字符、双引号表示一个字符串，在这些情况下需要使用转义字符. 1. 转义以\开头，后面只转义仅接着的一个字符 2. 转义可以以字符开始，也可以以数字开始，数字在最后会被转化为对应的ASCII字符 3. \x后面跟16进制数、\后面跟八进制数、八进制数只取后面的3个；十六进制数则只能取两个数值(最多表示一个字节) ```cpp '\\' // 表示一个\字符 "\"" //表示一个" "\155" //表示一个 155的8进制数，8进制的155转化为10进制为109 从acsii表中可以查到，109对应的是M "\x6D" ``` 一般来讲我们很难通过字面值常量知道它到底应该是具体的哪种类型，例如 15既可以表示short、int、long、也是是double等等类型。为了准确表达字面值常量的类型，我们可以加上特定的前缀或者后缀来修饰它们。常用的前缀和后缀如下表所示： | 前缀 | 含义 | |:------|:-----------------------| | L'' | 宽字节 | | u8"" | utf-8字符串 | | 42ULL | unsgined longlong | | f | 单精度浮点数 | | 3L | long类型 | | 3.14L | long double | | 3LL | longlong | | u'' | char16_t Unicode16字符 | | U'' | char32_t Unicode32字符 | ## 变量 变量为程序提供了有名的，可供程序操作的内存空间，变量都有具体的数据类型、所在内存的位置以及存储的具体值(即使是未初始化的变量，也有它的默认值)。变量的类型决定它所占内存的大小、如何解释对应内存中的值、以及它能参与的运算类型。在面向对象的语言中，变量和对象一般都可以替换使用 ### 变量的定义与初始化 变量的定义一般格式是类型说明符其后紧随着一个或者多个变量名组成的列表，多个变量名使用逗号隔开。最后以分号结尾。 一般在定义变量的同时赋值，叫做变量的初始化。而赋值语句结束之后，在其他地方使用赋值语句对其进行赋值，被称为赋值。从汇编的角度来看，变量的初始化是，在变量进入它的生命有效期时，对那块内存执行的内存拷贝操作。而赋值则需要分解为两条语句，一个寻址，一个值拷贝。 c++11之后支持初始化列表进行初始化，在使用初始化列表进行初始化时如果出现初始值存在精度丢失的情况时会报错 c++11之后的列表初始化语句，支持使用赋值运算幅、赋值运算符加上{}、或者直接使用{}、直接使用() ```cpp int i = 3.14; //正常 int i(3.14); //正常 int i{3.14}; //报错,使用初始化列表进行初始化时，由double到int可能会发生精度丢失 int i(3.14); //正常 ``` 如果变量在定义的时候未给定初始值，则会执行默认初始化操作，全局变量会被赋值为0，局部变量则是未初始化的状态；它的值是不确定的。这个所谓的默认初始化操作，其实并不是真的那个时候执行了什么初始化语句。全局变量被初始化为0，主要是因为，在程序加载之初，操作系统会将数据段的内存都初始化为0，而局部变量，则是在进入函数之后，初始化栈，具体初始化为何值，根据平台的不同而不同 ### 声明与定义的关系 为了允许把程序拆分为多个逻辑部分来编写，c++支持分离式编译机制，该机制允许将程序分割为若干个文件，每个文件可被独立编译。 如果将程序分为多个文件，则需要一种在文件中共享代码的方法。c++中这种方法是将声明与定义区分开来。在我之前的博客中，有对应的说明。声明只是告诉编译器这个符号可以使用，它是什么类型，占多少空间，但前对它执行的这种操作是否合法。最终会生成一个符号表，在链接的时候根据具体地址，再转化为具体的二进制代码。而定义则是真正为它分配内存空间，以至于后续可以通过一个具体的地址访问它。 声明只需要在定义语句的前面加上extern关键字。如果extern 关键字后面跟上了显式初始化语句，则认为该条语句是变量的定义语句。变量可以声明多次但是只能定义一次。另外在函数内部不允许初始化一个extern声明的变量 ```cpp int main() { extern int i = 0; //错误 return 0; } ``` 一个好的规范是声明都在放在对应的头文件中，在其他地方使用时引入该头文件，后续要修改，只用修改头文件的一个地方。一个坏的规范是，想用了，就在cpp文件中使用extern声明，这样会导致声明有多份，修改定义，其他声明都得改，项目大了，想要找起来就不那么容易了。 ### 变量作用域 变量的作用域始于声明语句，终结于声明语句所在作用域的末端 1. 局部变量在整个函数中有效 2. 普通全局变量在整个程序中都有效果 3. 花括号中定义的变量仅在这对花括号中有效 作用域可以存在覆盖，并且以最新的定义的覆盖之前的 ```cpp int i = 10; void func() { int i = 20; { string i = "hello world"; cout

记一次内存泄露调试 首先介绍一下相关背景。最近在测试一个程序时发现，在任务执行完成之后，从任务管理器上来看，内存并没有下降到理论值上。程序在启动完成之后会占用一定的内存，在执行任务的时候，会动态创建一些内存，用于存储任务的执行状态，比如扫描了哪些页面，在扫描过程中一些收发包的记录等等信息。这些中间信息在任务结束之后会被清理掉。任务结束之后，程序只会保存执行过的任务列表，从理论上讲，任务结束之后，程序此时所占内存应该与程序刚启动时占用内存接近，但是实际观察的结果就是任务结束之后，与刚启动之时内存占用差距在100M以上，这很明显不正常，当时我的第一反应是有内存泄露内存泄露排查既然有内存泄露，那么下一步就是开始排查，由于程序是采用MFC编写的，那么自然就得找MFC的内存泄露排查手段。根据网上找到的资料，MFC在DEBUG模式中可以很方便的集成内存泄露检查机制的。首先在 stdafx.h 的头文件中加入#define _CRTDBG_MAP_ALLO #include <crtdbg.h>再在程序退出的地方加入代码_CrtDumpMemoryLeaks();如果发生内存泄露的话，在调试运行结束之后，观察VS的输出情况可以看到如下内容Detected memory leaks! Dumping objects -> .\MatriXayTest.cpp(38) : {1301} normal block at 0x0000000005584D30, 40 bytes long. Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD Object dump complete.在输出中会提示有内存泄露，下面则是泄露的具体内容，MatriXayTest.cpp 是发生泄露的代码文件，括号中的38代表代码所在行数，大括号中1301代表这是程序的第1301次分配内存，或者说第1301次执行malloc操作，再往后就是内存泄露的地址，以及泄露的大小，这个地址是进程启动之后随机分配的地址，参考意义不大。下面一行表示，当前内存中的具体值，从值上来看应该是分配了内存但是没有初始化。根据这个线索，我们来排查，找到第38行所在位置int *p = new int[10]; _CrtDumpMemoryLeaks(); return nRetCode;内存泄露正是出现在new了10个int类型的数据，但是后面没有进行delete操作，正是这个操作导致了内存泄露。到此为止，检测工具也找到了，下面就是加上这段代码，运行发生泄露的程序，查看结果再漫长的等待任务执行完成并自动停止之后，我发现居然没有发现内存泄露！！！我又重复运行任务多次，发现结果是一样的，这个时候我开始怀疑是不是这个库不准，于是我在数据节点的类中添加构造函数，统计任务执行过程中创建了多少个节点，再在析构中统计析构了多少个节点，最终发现这两个数据完全相同。也就是说真的没有发生内存泄露。在这里我也疑惑了，难道是任务管理器有问题？带着这个疑问，我自己写了一段代码，在程序中不定时打印内存占用情况，结果发现虽然与任务管理器有差异，但是结果是类似的，释放之后内存并没有大幅度的下降。我带着疑问查找资料的过程的漫长过程中，发现任务管理器的显示内存占用居然降下去了，我统计了一下时间，应该是在任务结束之后的30分钟到40分钟之间。带着这个疑问，我又重新发起任务，在任务结束，并等待一定时间之后，内存占用果然降下去了。这里我得出结论 程序中执行delete操作之后，系统并不会真的立即回收操作，而是保留这个内存一定时间，以便后续该进程在需要分配时直接使用结论验证科学一般来说需要大胆假设，小心求证，既然上面根据现象做了一些猜想，下面就需要对这个猜想进行验证。首先来验证操作系统在程序调用delete之后不会真的执行delete操作。我使用下面的代码进行验证//定义一个占1M内存的结构 struct data{ char c[1024 * 1024]; } data* pa[1024] = {0}; for (int i = 0; i < 1024; i++) { pa[i] = new data; //这里执行一下数据清零操作，以便操作系统真正为程序分配内存 //有时候调用new或者malloc操作，操作系统只是保留对应地址，但是并未真正分配物理内存 //操作会等到进程真正开始操作这块内存或者进程需要分配的内存总量达到一个标准时才真正进行分配 memset(pa[i], 0x00, sizeof(data)); } printf("内存分配完毕，按任意键开始释放内存...\n"); getchar(); for (int i = 0; i < 1024; i++) { delete pa[i]; } printf("内存释放完毕,按任意键退出\n"); _CrtDumpMemoryLeaks(); char c = getchar();通过调试这段代码，在刚开始运行，没有执行到new操作的时候，进程占用内存在2M左右，运行到第一个循环结束，分配内存后，占用内存大概为1G，在执行完delete之后，内存并没有立马下降到初始的2M，而是稳定在150M左右，过一段时间之后，程序所占用内存会将到2M左右。接着对上面的代码做进一步修改，来测试内存使用时间长度与回收所需时间的长短的关系。这里仍然使用上面定义的结构体来做尝试data* pa[1024] = {0}; for (int i = 0; i < 1024; i++) { pa[i] = new data; memset(pa[i], 0x00, sizeof(data)); } printf("内存分配完毕，按任意键开始写数据到内存\n"); getchar(); //写入随机字符串 srand((unsigned) time(NULL)); DWORD dwStart = GetTickCount(); DWORD dwEnd = dwStart; printf("开始往目标内存中写入数据\n"); while ((dwEnd - dwStart) < 1 * 60 * 1000) //执行时间为1分钟 { for (int i = 0; i < 1024; i++) { for (int j = 0; j < 1024; j++) { int flag = rand() % 3; switch (flag) { case 1: { //生成大写字母 pa[i]->c[j] = (char)(rand() % 26) + 'A'; } break; case 2: { //生成小写字母 pa[i]->c[j] = (char)(rand() % 26) + 'a'; } break; case 3: { //生成数字 pa[i]->c[j] = (char)(rand() % 10) + '0'; } break; default: break; } } } dwEnd = GetTickCount(); } printf("数据写入完毕，按任意键开始释放内存...\n"); getchar(); for (int i = 0; i < 1024; i++) { delete pa[i]; } printf("内存释放完毕,按任意键退出\n"); _CrtDumpMemoryLeaks(); char c = getchar();后面就不放测试的结果了，我直接说结论，同一块内存使用时间越长，操作系统真正保留它的时间也会越长。短时间内差别可能不太明显，长时间运行，这个差别可以达到秒级甚至分。我记得当初上操作系统这门课程的时候，老师说过一句话：一个在过去使用时间越长的资源，在未来的时间内会再次使用到的概率也会越高，基于这一原理，操作会保留这块内存一段时间，如果程序在后面再次申请对应结构时，操作系统会直接将之前释放的内存拿来使用。为了验证这一现象，我来一个小的测试int *p1 = new int[1024]; memset(p, 0x00, sizeof(int) * 1024); delete[] p; int* p2= new int[1024];通过调试发现两次返回的地址相同，也就验证了之前说的内容总结最后来总结一下结论，有时候遇到delete内存后任务管理器或者其他工具显示内存占用未减少或者减少的量不对时，不一定是发生了内存泄露，也可能是操作系统的内存管理策略：程序调用delete后操作系统并没有真的立即回收对应内存，它只是暂时做一个标记，后续真的需要使用相应大小的内存时会直接将对应内存拿出来以供使用。而具体什么时候真正释放，应该是由操作系统进行宏观调控。我觉得这次暴露出来的问题还是自己基础知识掌握不扎实，如果当时我能早点回想起来当初上课时所讲的内容，可能也就不会有这次针对一个错误结论，花费这么大的精力来测试。当然这个世界上没有如果，我希望看到这篇博文的朋友，能少跟风学习新框架或者新语言，少被营销号带节奏，沉下心了，补充计算机基础知识，必将受益匪浅。

2020年回顾与2021年展望 时光荏苒，数月如梭，转眼间2020年已经过去。回顾2020年，确实有些不不容易，从年初一直持续到现在仍然不能放松警惕的新冠疫情；由疫情带来的生活上的不便，经济上的停滞不前，还有大规模的企业倒闭，资金链断裂等等问题。很庆幸我所在的公司仍然存活，我还有能力与时间在这里跟大家鬼扯一些有的没的。接下来我想按照往年的惯例开始反省过去，展望未来，给自己定一个小目标2020年回顾过去刚刚我翻看了去年这个时候写的新年规划，似乎每一个都没能实现。首先我每年都在说的要每周更新博客，甚至在年中的时候想过要更新有质量的博客，尽量减少学习笔记之类的。但是现实总是残酷的，今年似乎我除了学习笔记之外，没别的什么好写的东西。原来是想把java继续学习下去了，但是看看公司那些java代码，我完全没有兴趣，甚至浇灭了我之前燃烧起来的学习Java的热情。Java又变成我可有可无的技能了。今年疫情期间我被困武汉，而且又更换了电脑，博客之前没有导入到新的电脑上来，原本想着春节期间偷个懒，断更一周的。好家伙，这一断，直接断到年中的6月了，6月份我将之前用hexo搭建的博客环境给导入到新电脑中，然后更新了一篇类似年中总结的博客，原本打算继续更新博客，但是Java学习也停了，自己在疫情期间也沉迷游戏无法自拔，周末养成了打游戏的习惯，博客一直断更，之前腾讯云社区的小编，联系过我，劝我更新博客，我以工作忙为理由，说服了自己断更，现在想想有点后悔把，所以新年的第一步就是把博客继续更新下去，在这里我也不纠结与是否是高质量的干货了，还是按照之前的路子，学习笔记加上工作总结，供自己翻阅之用，如果有幸能帮助到大家自然也是不甚荣幸。我也不知道为什么，会产生了想要练字的冲动，随着这个冲动，我买了一整套字帖，田字格的纸以及钢笔，当初坚持到了10月份，每天练习一小时，后来没有进展。我自己也已耽误学习为由放弃了。如今已经搁置了快3个月了，现在想想有点惭愧，放弃练字省下的时间我似乎并没有拿去做什么正事，学习仍然搁置，游戏照打不误，省下了的这个时间似乎不是消耗在手机上就是消耗在ns上。工作上没了目标，也变的唯唯诺诺，做事不求更好，只求按时完成，甚至在工作上开始花大把的时间摸鱼，太多时间花在手机和逛论坛上，美其名曰学习新新技术，但是很多都是看过了，知道了这个名字，没有花时间去深究它究竟该用在哪种场合，有什么优缺点，甚至连官方demo都没有运行过。这个也是浪费了大量时间。后续当然需要浏览论坛，但是得改变策略了，碰到感兴趣的，或者觉得有用的，应该先记下来，后续花成块的时间去仔细研究它，甚至考虑在项目上使用它，达到学以致用的目的项目上就不说了，从年中开始，没有做过任何新的项目，仍然在针对老的项目做一些优化，功能上的提升，这个部分似乎没有什么很大感触或者有什么好的经验可以聊的。今年陆陆续续有很多想学的，最开始想学Django，并且写了一个博客的demo，但是使用起来效果太差，没有开源的好用，所以就放弃了。后来想学emacs，但是elisp这块几乎没有什么进步，到现在仍然无法很好的改造emac，反倒是用起来的开箱即用的vs code，这个也算是失败了把。后面在分析c++的开源代码时，发现自己一直自诩为c++的高级程序员，但是连c++11有的标准都不会用，看不明白，这也导致我想要重新学习c++11以及以后的标准，这个是目前仍然在坚持，但是进度很慢的事，在学习过程中，我发现自己开始慢慢建立面向对象的概念，对对象、容器、迭代、数据类型这些有了新的认识，我记得当时写Java相关的博客时说过，Java是面向对象的代表，能给你关于对象的完整性认识，但是现在我想不光Java是，c++其实也是。Java能带来的思想上的转变，c++当然也能，如果你没有这个感觉，只能说学习的不够深入，就好像我学了elisp，对函数式编程没有什么感觉，就是我自己elisp不过关。在读书上，我的进度似乎并没有比往年快多少，仍然是睡前读读书，促进睡眠而已，有的读过似乎就忘记了，没有什么感悟，没觉得有网上吹的那么神，这个应该是自己完全没有读进去，只是机械的读书中的文字，到底有多少化为自己的思考，或者成为自己的养料的，这个我也不清楚在学习上除了这些花的时间比较长之外，我中间也陆续的尝试学习了go、rust、lua、c#。但是这些我在很短的时间内就放弃了，也就不提了2021年的小目标整个2020就这样稀里糊涂的就过去了，想学的东西很多，但是花的时间却很少，我想在每个上面都分配时间，然后全方位开花的方针并不合适我，我还是喜欢把时间集中消耗在某一件事情上，说的再明白点，我自己脑袋性能不够，是一个单核的cpu,无法做到多线程切换，强制使用线程，只会造成性能的损失。基于上述反思，与自我认知，我决定指定如下计划：学习上，将想学的东西列清单，并给出一个小目标，比如做一个项目，不达目标就不进行下一个内容的学习。实在有问题的，写悔过书，详细分析为啥不行。不强求一定得学，但是也不能轻易放弃记录自己学习的过程形成笔记，作为博客发出，博客这块仍然坚持每周更新读书上，我准备开一个书评的文章，每读完一本，在博客上更新关于它的简短的读后感。坚持睡前读书。锻炼，NS上的我最近刚买了《有氧拳击》，既然自己不喜欢健身房那种人多的场合，就自己在加默默打拳，记录自己的体重与运动量。好好锻炼减肥工作上不急于完成工作，希望自己动手前认真思考一下，如何更优雅的实现功能。写出更容易被理解的代码与文档工作上及时总结，中间的经验、处理的问题、搜索到的资料进行整理形成博客少玩游戏，少熬夜、坚持每天早起半小时（多了估计也坚持不下来）目前能想到的就是这些，在这里给各位愿意看到最后的朋友送上迟到的新年祝福，预祝各位心想事成，早日脱单，最后再祝各位新年大吉吧（别问为什么又是这句，问就是没文化，想不出什么高级词汇，再问就是我就是喜欢玩老梗）