第一天
1.sizeof 一个对象，求得的数据部分的尺寸，而不求代码（也就是函数）的尺寸。
一个对象数据和函数是分开存储的，有数据段，代码段等。涉及到C++对象模型的知识。
这样的设计即多份数据共用一份代码（函数）只适用于单cpu执行的情况。一个CPU一次只能执行一条指令，所以每个对象都有自己的函数代码
所生成的指令是没用的，因为cpu每次只能执行一条指令，也就是只能访问一个对象的指令。但是这样的对象模型如果是并行计算则会出现问题。
例如对象A在CPU1里面跑，对象B在CPU2里面跑，那么编译器只生成一份函数指令则会出现问题，因为两个对象要同时执行这个指令，即两个CPU
的程序指针同时指向该函数指令所在的内存。设计到并行机的知识。
第二天
1.一个类声明和实现分别写到头文件和源文件中，这样成员函数是非inline的。声明时用inline修饰就可以使该成员函数成为inline的。
如果一个类声明和实现写在一起，也就是在类里面直接写实现，这样成员函数是inline的。
2.C语言函数是禁止嵌套定义，必须嵌套调用。
第三天
1.静态先于main函数的执行而存在。
2.所有计算机理论在杨力祥看来不外乎两个词：序和可识别。
3.数据结构的那些设计就是由于硬件的设计所导致的，物质基础决定上层建筑。
4.鉴赏力：例如拿一本书翻几页，知道它要实现个什么东西，然后合上书，自己去思考，
去设计。自己设计完之后，再打开书和别人的去对比，这样就能发现大师设计的想法是多么优秀。
可以看到自己跟大师的差距。学东西最怕的就是学了十几二十年看不到自己和别人差在哪里。
一个人有没有水平就体现在鉴赏力上面，能不能看出它好在哪里。
5.用体系性思维去思考问题，把一个东西放到体系里面去思考。
6.C语言调用函数时将局部变量压栈出栈，那么如果将所有的局部变量都定义为静态可以吗？
不难发现静态全局的访问速度更快，而压栈还需要不断的进栈出栈。栈是动态使用内存，
静态变量是静态使用内存，也就是编译器已经算好它的大小及数量等。如果将局部变量定义为静态，
所有的情况都可以解决，但是有一个问题解决不了，就是自己调用自己，或者说递归。
说明C语言在设计时，递归在整个体系结构中占了很重要的地位。
7.指针是地址吗？如果指针是地址为什么还要起这么个名字，直接叫地址不就好了。
在计算机里指针主要分为两大类，一个是指令指针，也就是程序指针，另一个就是数据指针，
数据指针往往用寄存器来代替。指针就是一个指向数据的地址吗？在计算机中每个字节就是一个地址，
但是一个数据不一定只占有一个地址。指针指向的是一个数据的首地址，且指针是有类型的。当拿到一个指针的时候，
也就是拿到了一个数据的首地址，拿到首地址后应该向下数几个字节来拼成这个数据，就由指针的类型确定，
拼成这个数据之后，编译器如何解析这个数据，例如4个字节，该解析为int还是float，这个也由指针的类型来确定。
8.指针的三个优点。第一，以小搏大。即就地解决，山不过来，我过去的思想。用于函数传参时传址。
传参时不把所有数据都带过去，复制一遍，而是将所有数据的内存地址传过去。
第二，切换。指令的切换，函数指针，也就是指令指针，例如动态链接库，用指针在动态链接库里来回切换函数，
调用里面的各种函数。数据的切换，数组不是一个类型，只是一个组数据的打包。数据的切换例如数组中的行指针列指针的应用。
第三，就是挂接，最常用的挂接就是链表。用指针把一组数据连接起来。
9.指令指针寄存器IP（X86型CPU）相当于ARM型CPU中的程序计数器PC。
10.IP在main函数指令执行中遇到调用函数，也就是跳转指令，跳转到另一个函数的指令位置，然后开始
执行，执行完该函数的指令之后，IP又跳回到原来main函数指令的位置。CPU中有一大堆寄存器用来计算等。
当调用函数IP还没跳转时，CPU中的寄存器存储的是现在正在计算的那些数据，也就是跳转前的状态。但是
IP跳转之后，CPU开始做新的是事情，也就是CPU中的寄存器开始处理新的计算，而跳转前正在处理数据寄存器
的值就会丢失。当该函数调用完之后，IP返回原来的位置，CPU的寄存器也应该会返回到跳转之前的状态，继续
干原来的事情，但是调用函数的时候，CPU的寄存器已经处于调用函数时的状态了。该怎么解决这个问题？
将寄存器的数据进行压栈和出栈，即保护现场和恢复现场。 内存的栈区，其实就是纯粹的数据。
返回值为基本类型的直接走寄存器，而返回值为自定义类型的往栈里走。
11.调用一个函数栈里面存放的东西依次是（由编译器决定）：CPU原来的状态（现场保护），返回值，形参，然后是一些局部变量的数据。
例如在调用函数时，执行char a = 'a';时，实际就是将'a'这个值进行压栈，将这个数据放到栈的内存里面来进行使用。
压栈出栈其实就是一个栈指针的来回走动。调用函数传参，其实就是向栈里面的形参的那块内存直接写一个值，
12.程序是如何运行的？点击一个exe，实在操作系统上运行一个程序，操作系统将exe的一些有效文件从磁盘装载到内存中，
对于C来说装载两类数据，一类是代码，另一类是静态数据。静态数据又分全局变量和静态局部变量。
然后指令指针IP指向main函数入口点的对应位置。然后开始执行。可以发现静态数据是先于main函数的执行而存在，
这也是静态数据的一个巨大的作用，一般而言函数都是在main函数执行之后才能执行，
但是一个全局对象的构造函数是先于main函数的执行而执行的。IP指向main函数入口之后，程序开始执行，也就是IP开始自动往下走，
IP走的方式有两种（有硬件决定），一种是顺序执行（沿着指令的顺序自动往下走，CPU的功能，不需要人为干预），
另一种是跳转（由程序员控制，例如循环（向上跳）和条件判断执行（向下跳））。
13.静态数据在被加载到内存而不是在硬盘上的证明：
int a[N];
int main(){}
build如上程序，将N设置为10000，而1，比较两个程序的可执行文件exe的大小，发现两个文件一样大，也就是说这个静态数据
并不在硬盘上，而是操作系统加载时，开辟到内存的。
第四天
1.c/c++中有一个先声明后使用的原则。
声明（声明变量和函数）是给编译器看的。定义变量时才会开辟内存，声明不会开辟，声明是个编译器看的，如果声明了一个变量，
且后面没有使用，则编译器会将其优化，视为不存在，不会开辟内存。
2.写一个函数的顺序是先声明，再定义，最后调用。但是声明和定义可以合起来写。例如下面的写法：
void Swap(int, int);
void main() {
Swap(a ,b);
}
void Swap(int x, int y) {
int temp = x;
...
}
首先声明函数Swap是为了给编译器看，知道了其返回值类型和参数类型几个数，只是为了计算其在
栈中占用空间，方便栈指针跳转等（不得而知），所以不用写参数名字，有了其类型就够了。
而定义的时候，是必须要知道参数的名字的，第一因为函数中要用到这个参数。但是问题来了，如果
不写参数名字，调用函数时形参在从左到右一个一个的进栈时，由此每个参数在栈中的内存地址
我都知道了，函数中的使用不就可以直接访问那个地址了吗？这也就导致了第二个原因，函数参数
进栈的顺序是不一定的，所以必须为其加上名字，后面才能准确拿到参数。
3.编译是以*.c或*.cpp文件为单位编译的。一个程序里面有几个cpp编译几次，一个cpp只编译一次。
#include "a.h"是将该文件a.h的内容嵌入到当前位置。例如下面某个文件的代码。
#include "Circle.h"
int main() {
Circle circle(1, 2);
}
由c/c++先声明后使用的原则，只要在该cpp文件中声明了Circle这个类，就可以使用。所以写上了
#include "Circle.h"这句话，将Circle的声明代码嵌入到当前这个文件。
4.地址重定位：例如在main.c中调用了a.h中的函数，a.h中的函数只声明而不定义，所以
在main.obj中，也就是在main.c编译之后的机器码中，IP跳转到该函数的地址是不知道的，因为该函数的
.obj还没有链接到一起，所以这些调用函数地方指针都空出来了，当所有obj都拼到一起之后，编译器算出
该函数地址的值赋值给原来指针的地方，也就是地址重定位。
5.一个.cpp文件编译之后一般来说生成一个.obj文件（目标文件，机器码，可执行，但不是立即可执行）。
然后将多个编译生成的.obj文件以及标准库等其他的.obj文件拼在一起后，然后进行地址重定位，将
其之间的关系全部联系起来。最后加入一些头等打包成exe。
6.所谓lib库等，就是将一大堆的.obj文件合起来，然后加入一些引导头之类的。
7.上述讲的这些链接，都是静态链接，链接之后还是在硬盘中，执行的时候加载到内存中。
例如printf这个函数的代码，在运行之前已经存在于exe，这就是静态链接。
相对的就是动态链接dll。
8.链接printf的时候，不是讲"stdio.h"这个库连接进去，而是将printf链接进去，以最简化原则，
需要谁连接谁。
9.静态链接中，例如连续调用多次printf函数，实际上就链接了一次，只产生一份代码，只是传的参数不同。
但是站在操作系统的角度来看，系统中有多个程序在执行，每个程序都调用了printf，也就是每个程序都
链接了一次printf。站在程序的角度看，自己已经很节约了只链接了一次，但是站在操作系统的角度看，
链接了多次，产生了浪费，其实只要搞出一份代码就可以，自己的程序访问别人程序的代码，
但是这样就导致了跨进程的问题，十分不安全。而动态链接库就解决了这个问题。动态链接库没有将代码
放到某个程序中，而是放到操作系统中，当某个程序使用其的时候，应用loadLibrary这个技术，加载该库。
如果要用printf函数，就从dll中找到该函数的地址。原来是静态的算好printf函数的地址，现在变成了动态
获取printf函数的地址。
10.作用域，生存周期。
例如static局部变量，全局的生存周期，局部的作用域。
11.资料：
http://blog.chinaunix.net/uid-23069658-id-3981406.html 深入理解C语言的函数调用过程
http://blog.csdn.net/wu5215080/article/details/38899259 C语言之内存四区模型和函数调用模型
http://blog.csdn.net/wu5215080/article/details/38899259 C语言之内存四区模型和函数调用模型
http://blog.chinaunix.net/uid-25667116-id-3064937.html 栈的一点理解
http://blog.csdn.net/pi9nc/article/details/12419819 程序的链接与装入（动、静态重定位）
第五天
1.讨论：对象定义时，为什么要对象自动调用构造函数，而不是外部调用？
思想猜测：面向对象是尽量将一个类进行物化，它自己就是一个物，产生之后就是一个完整的物体，而不需要别人调用构造函数
来进行物体的组装，初始化等。面向对象，一切皆对象，里面是物与物之间的交互，模拟人类社会，如果一个物产生之后还需要
别的物来调用它的函数将它初始化，这是非常诡异的。所以一个对象应该在它被使用之前就初始化好了，它不应该由对象的使用
者来初始化。
2.为什么要设计构造函数，析构函数？
a.更好的体现“物化”思想（自动性）。
b.更好的封装性，避免从外部初始化。很显然外部初始化对象的成员变量破坏了对象的封装性。
c.更有效地使类架构设计与程序架构设计分开。
d.促进更清晰地面向接口编程（所谓的接口都是public的函数），更有效地复用。
3.例如一个类里面维护了一个数组，然后写了一大堆public函数，来操作这个数组。既然可以直接操作
数组，为什么要将其封装提供接口呢？好处就是提供接口，面向接口编程，松耦合，更容易复用。并且
将其物化后，提供接口跟别人交互，更像是一个人用语言去跟别人交流。并且将数据封装，更好的保护
了数据，不将其暴露出来。
4.new和delete是操作符，不是函数。malloc函数只是分配出一块内存，而不管分配出什么类型的。需要什么类型
自己去强转。而new操作符不但分配了内存，并且赋予了其类型，引发其构造函数的调用。
第六天
1.程序一开始写的时候最难，无法下手。当程序写了一大堆时，思路打开后，却不难了。
2在当解决问题时，会遇到问题难度大于自己能力的情况。此时人们采取的方法有两种，一种是提升自己的能力，
快速学习相关知识等。但是能力并不是短时间能够提升的。能力的提升是金字塔状的，一层一层铺上去的。
真正的大师站在金字塔的顶端的时候，底下是铺了一大层的。第二种就是将问题的难度往下缩。缩小的办法
之一就是去掉问题包装层，留下问题最主要的东西，是它的最小完备集。
3.看传记，最好是看大师本人写的，不要去看其他阿猫阿狗写的，他们怎么可能理解大师所想的。
4.书读了十几年，是时候去动脑思考问题了。遇到一个问题有没有能力去解决，就看你有没有能力去将问题解剖，
然后用已学过的知识去分析。世界的本原是相通的，所以所有的知识都是相通的，那么就可以用自己学过的知识
去解决其他陌生领域的问题。通过这个思想，那么你是否可以通过十五天的时间去成为某个其他领域的专家？
因为知识是相同的，思想是相通的，世界的本原是相通的。
5.函数重载时，为什么函数参数和参数个数是可识别的，但是函数的返回值是不可识别的?
因为调用这个函数时，调用语法是没有返回值信息的，由此导致调用时不可识别。
从定义函数的表面上可以通过返回值识别，eg：
int Fun();
float Fun();
从定义语法上，以上两个函数可以识别。但是在调用语法上面是不可识别的。eg：
void main() {
Fun();
}
从语法上如何识别调用的是哪个Fun函数呢？不能识别。
如果语规定说调用的时候，前面必须写返回值类型，那么这可以识别。
从这个问题可以分析到，一个语法中，哪个行为可以这样做，哪个行为不能这样做，
是在整个语法体系中相互制约的，所以可以从整个语法体系去分析某个行为为什么
是这样的，一定是有原因的，是有其他行为与其相互作用，相互制约，相生相克。
6.void在当返回值类型时，表示不返回，并不是返回无类型，不返回任何值，不去建栈。
7.构造函数可以显示调用，匿名对象。
8.构造函数没有返回值，是编译器造出来自动调用用来初始化对象的，它不需要返回值，返回给谁呢？
第七天
1.析构函数不能重载，不能显示调用。
2.C++的发明者喜欢用一个词代表多个意思。例如static有多种用法，const也有好多种用法。
3.静态局部对象。静态变量的产生早于main函数的调用，但是构造函数的调用不会早于main函数。
可能是在main函数一开始的时候，也可能第一次使用的时候，例如静态局部。
分析：代码如下，
A a; // 构造函数输出a。
int main() {
cout << "b" << endl;
}
输出为 a, b
先输出a，后输出b，那么是不是就是首先调用A的构造函数，然后调用main函数？
如果是这样，那么是不是和C语言是一个悖论，C规定函数必须嵌套使用，但是不能
嵌套定义。但在这种情况下A的构造函数不是在main函数中调用使用！并且如果A的构造
函数可以在main之前调用，那么是不是可以把所有的事都放到构造函数中去做，main函数
其实就没什么用了？
事实证明这种想法是错误的，通过查看编译生成的机器码可以看到，全局A的构造函数
是在刚进入main函数的时候，就调用的A的构造函数。
由此也可以看出C++是一个不纯粹的面向对象的语言，因为它要进入main函数，在里面先做这个，
后做那个，很面向过程的一种风格。如果更纯粹点的话，就把main函数去掉，也就是把main函数做成一个
类，由该类来带领队伍去做各种事，也就是将其对象化，而不是面向过程的，在main这个函数中进行动作。
在现实中的面向对象都是纯粹的面向对象，因为不论做什么事，都是有人，有角色去带领，去做。
4.面向过程，把一个问题的解决方案步骤后，过程化，先做这个，然后做那个，最后再做什么什么。
而面向对象是将问题进行角色划分，进行物化，进行专业化分工。
5.问题分析：代码如下，
int a = 5;
cout << &5 << endl;
5是常量吗，为什么不能对其取地址？
5是一个常量，不能对其进行赋值。5是int a = 5;这条指令中的立即数，这个5是这条指令中的一部分，
是不能将其取出来的。指针虽然有指令指针，但是指令指针是指向某条指令的，
而不能将某条指令拆分开来，取到其中的某一部分。
在C++中常数即常量， 如：int a = 5；
常量5，不在数据中，而在指令中,没有指针，不能赋值。
6.const常量，具有常量性质的数据（编译器“把门”）。常量必须初始化。
const int a = 10;
a = 12; // 错误，这个赋值错误是因为编译器把门，不让它通过，而不是因为其他的原因。
7.const推测：
const int a = 10;
cout << a << endl;
int b = a;
推测一：如果代码中没有对常量a取地址的行为，那么，编译器就直接将其视为宏的作用。也就是
在编译初期，直接将a替换成10。
const int a = 10;
cout << &a << endl;
推测二：如果代码中有对常量a进行取地址的行为，那么const的作用之一就是将a进行内存分配，
将其变成一个普通局部变量。const的作用之二就是提示编译器进行把门，不要让程序员对其
进行赋值。
8.const 成员函数：约束成员函数的只读性。const很巧妙地解决了野指针的问题。
9.引用，是一个变量的别名，引用本身并不是没有存储空间的。引用不会为值去开辟一个
地址空间，但是其本身要占用空间。引用确实占用了栈空间，也确实是存储了目标变量的
地址。
10.初始化非const引用必须用左值，const引用则不必。
eg：
int& a = 5; // 错误
const int& a = 5; // 正确
引用在内部存放的是一个变量的地址，它是变量的别名。对于不可寻址的值，编译器为了实现引用，
必须生成一个临时对象，引用必须指向该对象，但是用户不能访问它.
一种不准确的解释为：编译器产生的临时产生的中间变量都是const的，即其为常量，
所以必须用const的引用。
eg：
const int a;
const int& b = a; // 因为a是const的，所以其引用也必须是const。
这种解释是有悖论的，如果其为const，那么其应该在指令区，是不能做左值的。
但在《Thinking in C++》中说到编译器产生的临时的中间变量是可以做左值的。
例如const int& a = 5;编译器会为5这个常量产生一个临时的中间变量，且这个临时
中间变量是可以作为左值得。
比较正确的解释为：临时中间变量是程序员是不能对其进行操作的，而且其在使用完之后
就会释放，所以我们修改一个其是没有意义的。所以编译器就为其加入了不能作为非const
引用的这个语义限制，防止用户错误使用。也就是说临时中间变量有const的性质，但不是const
变量，所以编译器加入了这个语义限制。
第八天
1.C++体系性的思考特别多。体系性思考特别重要。
第九天
1.世界上最难做好的就是最简单的道理。人有一个毛病，越是聪明的人越有的一个毛病，
追求复杂很难理解的道理。
2.在拷贝构造函数中为什么可以访问引用对象的私有变量？
一种解释：因为C++的封装层次达到类的层次，而不是对象。所以对于C++来说访问权限是针对“类”
来说的。也就是说private的访问权限是其他类不能访问的，而不是这个类的不同对象之间不能访问。
3.成员函数和非成员函数之间最大的区别就是，成员函数的参数里面有一个你看不见的参数，
这个参数传的是this指针。
4.this指向当前对象的指针。
第十天
1.学习，学会规则只能达到解决温饱的问题，真正要达到衣食无忧，靠的是悟性。
悟性对一个事物的思考，把握。学过一个东西，然后能掌握它，抓住它的主要矛盾，这是只是一个基本的本事，
真正的本事是没有学过一个东西，能够抓住它的主要矛盾。
2.其实很多高考新课标的修改就是一种思路。新课标的题目被称为很开放，开放并不是乱七八糟的无厘头，而是
一种思想的开放。通过已有已学过的知识，去分析一个问题，然后设计解决方案。这就是新课标的设计类题目。
这也就是其被称为开放的原因。学习，去思考，去推理，达到设计的境界。
3.对事物要有一种“敏”，也就是对事物有一种敏感，快速感知其思路，其设计的伟大之处，以及要达到的目的。
4.生物的继承进化，基因既有自己的基因，又有继承前人的基因（加机制），但是并没有完全加入了前人的基因
（减机制），一些前人的基因可能没有继承。但是在C++中，虽然有priave，但是还是完全继承了前人的基因。
也就是C++只有加机制，没有减机制。
eg：
class Base {
private:
int a;
int b;
};
class Derived : public Base {
private:
int c;
};
int main() {
cout << sizeof(Base) << endl; // 输出8
cout << sizeof(Derived) << endl; // 输出12
return 0;
}
生物不断地进化，可能进化出新的物种。如果C++就像生物一样，既能继承一些基因，
也能丧失一些基因，那么通过不断地继承之后，可能出现一个新的类，一个功能完全不同于最初
基类的类。
5.程序能不能实现自己编程呢，程序一定要人去写吗？如果程序模仿生物，不断地进行继承，进行
进化，自我繁衍出新的类，那么是否可以实现程序的自我编程呢？未来的程序是不是可以这样写，
大致写出一个框架，然后让它自己去跑，程序在那里自适应，自己创造新的东西。
6.思考：用人类繁衍的思想，想出一个语言的设计方案。
人类两性繁殖，减数分裂，然后父母双方各一半基因的随机融合等等，这些思想是否可以做出
一个语言，可以达到这个效果。
7.上述的思考只是一个想法而已，人要有许多此类的想法，对基本的事物要敏感，要有想法，
并且对其进行一些思考，与其他发展已经很成熟的事物进行类比，万事万物都是相通的。
就像拿面向对象语言的设计去和生物进行类比，因为面向对象语言人类设计了几十年，发展其实
并不是很成熟，而生物的发展已经有几亿年，是一个很成熟的事物，所以可以将这两个事物
进行类比。
第十一天
1.真正要干成点什么事，想象力和创造力显得尤为重要。
传统教育对技术细节重视最大，在最基础的时候，技术细节确实很重要，但是达到一定高度之后，
想象力，创造力，体系性显得特别重要，是真正的突破口。
2.想象力，创造力，其实可以这样做，想到一个想法，然后就去做，去实现，然后搞出个水落石出！
不要一想而过！
3.设计类架构的方法，如果从上往下设计，也就是从基类开始思考，思考下面要派生什么类，这样的
思考方法其实是有一定问题的，很难想到下面该派生什么类。但是可以反向思考，从小往上思考。想
好最下层的类，然后不断从中抽取基类。
类是抽象出来的，不是从上往下拍脑袋想出来的。
4.一个人都优秀是他思考问题的方法优秀，有和他人不同的思考角度。一个人要快速的调转自己的思考方式，
也就是随机应变的能力强。而不是十分固执，死磕于自己的一种角度，人改变自己的思想方法很难。《柳丁思考的帽子》
5.人类一切美好高雅的东西都应该去尝试，因为这些都是艺术，是人类伟大智慧的结晶，给人带来美好感受。
第十二天
1.程序中，小问题要及时解决，不要试图去绕过去，程序越来越庞大，小问题越滚越多，最终达到毁灭性灾难。
小问题不要积累，不要去妥协，一定要及时解决。
2.读书也要有敏感性，对其里面的内容要敏感，快速抓住其思考，精髓，核心等等。
1.sizeof 一个对象，求得的数据部分的尺寸，而不求代码（也就是函数）的尺寸。
一个对象数据和函数是分开存储的，有数据段，代码段等。涉及到C++对象模型的知识。
这样的设计即多份数据共用一份代码（函数）只适用于单cpu执行的情况。一个CPU一次只能执行一条指令，所以每个对象都有自己的函数代码
所生成的指令是没用的，因为cpu每次只能执行一条指令，也就是只能访问一个对象的指令。但是这样的对象模型如果是并行计算则会出现问题。
例如对象A在CPU1里面跑，对象B在CPU2里面跑，那么编译器只生成一份函数指令则会出现问题，因为两个对象要同时执行这个指令，即两个CPU
的程序指针同时指向该函数指令所在的内存。设计到并行机的知识。
第二天
1.一个类声明和实现分别写到头文件和源文件中，这样成员函数是非inline的。声明时用inline修饰就可以使该成员函数成为inline的。
如果一个类声明和实现写在一起，也就是在类里面直接写实现，这样成员函数是inline的。
2.C语言函数是禁止嵌套定义，必须嵌套调用。
第三天
1.静态先于main函数的执行而存在。
2.所有计算机理论在杨力祥看来不外乎两个词：序和可识别。
3.数据结构的那些设计就是由于硬件的设计所导致的，物质基础决定上层建筑。
4.鉴赏力：例如拿一本书翻几页，知道它要实现个什么东西，然后合上书，自己去思考，
去设计。自己设计完之后，再打开书和别人的去对比，这样就能发现大师设计的想法是多么优秀。
可以看到自己跟大师的差距。学东西最怕的就是学了十几二十年看不到自己和别人差在哪里。
一个人有没有水平就体现在鉴赏力上面，能不能看出它好在哪里。
5.用体系性思维去思考问题，把一个东西放到体系里面去思考。
6.C语言调用函数时将局部变量压栈出栈，那么如果将所有的局部变量都定义为静态可以吗？
不难发现静态全局的访问速度更快，而压栈还需要不断的进栈出栈。栈是动态使用内存，
静态变量是静态使用内存，也就是编译器已经算好它的大小及数量等。如果将局部变量定义为静态，
所有的情况都可以解决，但是有一个问题解决不了，就是自己调用自己，或者说递归。
说明C语言在设计时，递归在整个体系结构中占了很重要的地位。
7.指针是地址吗？如果指针是地址为什么还要起这么个名字，直接叫地址不就好了。
在计算机里指针主要分为两大类，一个是指令指针，也就是程序指针，另一个就是数据指针，
数据指针往往用寄存器来代替。指针就是一个指向数据的地址吗？在计算机中每个字节就是一个地址，
但是一个数据不一定只占有一个地址。指针指向的是一个数据的首地址，且指针是有类型的。当拿到一个指针的时候，
也就是拿到了一个数据的首地址，拿到首地址后应该向下数几个字节来拼成这个数据，就由指针的类型确定，
拼成这个数据之后，编译器如何解析这个数据，例如4个字节，该解析为int还是float，这个也由指针的类型来确定。
8.指针的三个优点。第一，以小搏大。即就地解决，山不过来，我过去的思想。用于函数传参时传址。
传参时不把所有数据都带过去，复制一遍，而是将所有数据的内存地址传过去。
第二，切换。指令的切换，函数指针，也就是指令指针，例如动态链接库，用指针在动态链接库里来回切换函数，
调用里面的各种函数。数据的切换，数组不是一个类型，只是一个组数据的打包。数据的切换例如数组中的行指针列指针的应用。
第三，就是挂接，最常用的挂接就是链表。用指针把一组数据连接起来。
9.指令指针寄存器IP（X86型CPU）相当于ARM型CPU中的程序计数器PC。
10.IP在main函数指令执行中遇到调用函数，也就是跳转指令，跳转到另一个函数的指令位置，然后开始
执行，执行完该函数的指令之后，IP又跳回到原来main函数指令的位置。CPU中有一大堆寄存器用来计算等。
当调用函数IP还没跳转时，CPU中的寄存器存储的是现在正在计算的那些数据，也就是跳转前的状态。但是
IP跳转之后，CPU开始做新的是事情，也就是CPU中的寄存器开始处理新的计算，而跳转前正在处理数据寄存器
的值就会丢失。当该函数调用完之后，IP返回原来的位置，CPU的寄存器也应该会返回到跳转之前的状态，继续
干原来的事情，但是调用函数的时候，CPU的寄存器已经处于调用函数时的状态了。该怎么解决这个问题？
将寄存器的数据进行压栈和出栈，即保护现场和恢复现场。 内存的栈区，其实就是纯粹的数据。
返回值为基本类型的直接走寄存器，而返回值为自定义类型的往栈里走。
11.调用一个函数栈里面存放的东西依次是（由编译器决定）：CPU原来的状态（现场保护），返回值，形参，然后是一些局部变量的数据。
例如在调用函数时，执行char a = 'a';时，实际就是将'a'这个值进行压栈，将这个数据放到栈的内存里面来进行使用。
压栈出栈其实就是一个栈指针的来回走动。调用函数传参，其实就是向栈里面的形参的那块内存直接写一个值，
12.程序是如何运行的？点击一个exe，实在操作系统上运行一个程序，操作系统将exe的一些有效文件从磁盘装载到内存中，
对于C来说装载两类数据，一类是代码，另一类是静态数据。静态数据又分全局变量和静态局部变量。
然后指令指针IP指向main函数入口点的对应位置。然后开始执行。可以发现静态数据是先于main函数的执行而存在，
这也是静态数据的一个巨大的作用，一般而言函数都是在main函数执行之后才能执行，
但是一个全局对象的构造函数是先于main函数的执行而执行的。IP指向main函数入口之后，程序开始执行，也就是IP开始自动往下走，
IP走的方式有两种（有硬件决定），一种是顺序执行（沿着指令的顺序自动往下走，CPU的功能，不需要人为干预），
另一种是跳转（由程序员控制，例如循环（向上跳）和条件判断执行（向下跳））。
13.静态数据在被加载到内存而不是在硬盘上的证明：
int a[N];
int main(){}
build如上程序，将N设置为10000，而1，比较两个程序的可执行文件exe的大小，发现两个文件一样大，也就是说这个静态数据
并不在硬盘上，而是操作系统加载时，开辟到内存的。
第四天
1.c/c++中有一个先声明后使用的原则。
声明（声明变量和函数）是给编译器看的。定义变量时才会开辟内存，声明不会开辟，声明是个编译器看的，如果声明了一个变量，
且后面没有使用，则编译器会将其优化，视为不存在，不会开辟内存。
2.写一个函数的顺序是先声明，再定义，最后调用。但是声明和定义可以合起来写。例如下面的写法：
void Swap(int, int);
void main() {
Swap(a ,b);
}
void Swap(int x, int y) {
int temp = x;
...
}
首先声明函数Swap是为了给编译器看，知道了其返回值类型和参数类型几个数，只是为了计算其在
栈中占用空间，方便栈指针跳转等（不得而知），所以不用写参数名字，有了其类型就够了。
而定义的时候，是必须要知道参数的名字的，第一因为函数中要用到这个参数。但是问题来了，如果
不写参数名字，调用函数时形参在从左到右一个一个的进栈时，由此每个参数在栈中的内存地址
我都知道了，函数中的使用不就可以直接访问那个地址了吗？这也就导致了第二个原因，函数参数
进栈的顺序是不一定的，所以必须为其加上名字，后面才能准确拿到参数。
3.编译是以*.c或*.cpp文件为单位编译的。一个程序里面有几个cpp编译几次，一个cpp只编译一次。
#include "a.h"是将该文件a.h的内容嵌入到当前位置。例如下面某个文件的代码。
#include "Circle.h"
int main() {
Circle circle(1, 2);
}
由c/c++先声明后使用的原则，只要在该cpp文件中声明了Circle这个类，就可以使用。所以写上了
#include "Circle.h"这句话，将Circle的声明代码嵌入到当前这个文件。
4.地址重定位：例如在main.c中调用了a.h中的函数，a.h中的函数只声明而不定义，所以
在main.obj中，也就是在main.c编译之后的机器码中，IP跳转到该函数的地址是不知道的，因为该函数的
.obj还没有链接到一起，所以这些调用函数地方指针都空出来了，当所有obj都拼到一起之后，编译器算出
该函数地址的值赋值给原来指针的地方，也就是地址重定位。
5.一个.cpp文件编译之后一般来说生成一个.obj文件（目标文件，机器码，可执行，但不是立即可执行）。
然后将多个编译生成的.obj文件以及标准库等其他的.obj文件拼在一起后，然后进行地址重定位，将
其之间的关系全部联系起来。最后加入一些头等打包成exe。
6.所谓lib库等，就是将一大堆的.obj文件合起来，然后加入一些引导头之类的。
7.上述讲的这些链接，都是静态链接，链接之后还是在硬盘中，执行的时候加载到内存中。
例如printf这个函数的代码，在运行之前已经存在于exe，这就是静态链接。
相对的就是动态链接dll。
8.链接printf的时候，不是讲"stdio.h"这个库连接进去，而是将printf链接进去，以最简化原则，
需要谁连接谁。
9.静态链接中，例如连续调用多次printf函数，实际上就链接了一次，只产生一份代码，只是传的参数不同。
但是站在操作系统的角度来看，系统中有多个程序在执行，每个程序都调用了printf，也就是每个程序都
链接了一次printf。站在程序的角度看，自己已经很节约了只链接了一次，但是站在操作系统的角度看，
链接了多次，产生了浪费，其实只要搞出一份代码就可以，自己的程序访问别人程序的代码，
但是这样就导致了跨进程的问题，十分不安全。而动态链接库就解决了这个问题。动态链接库没有将代码
放到某个程序中，而是放到操作系统中，当某个程序使用其的时候，应用loadLibrary这个技术，加载该库。
如果要用printf函数，就从dll中找到该函数的地址。原来是静态的算好printf函数的地址，现在变成了动态
获取printf函数的地址。
10.作用域，生存周期。
例如static局部变量，全局的生存周期，局部的作用域。
11.资料：
http://blog.chinaunix.net/uid-23069658-id-3981406.html 深入理解C语言的函数调用过程
http://blog.csdn.net/wu5215080/article/details/38899259 C语言之内存四区模型和函数调用模型
http://blog.csdn.net/wu5215080/article/details/38899259 C语言之内存四区模型和函数调用模型
http://blog.chinaunix.net/uid-25667116-id-3064937.html 栈的一点理解
http://blog.csdn.net/pi9nc/article/details/12419819 程序的链接与装入（动、静态重定位）
第五天
1.讨论：对象定义时，为什么要对象自动调用构造函数，而不是外部调用？
思想猜测：面向对象是尽量将一个类进行物化，它自己就是一个物，产生之后就是一个完整的物体，而不需要别人调用构造函数
来进行物体的组装，初始化等。面向对象，一切皆对象，里面是物与物之间的交互，模拟人类社会，如果一个物产生之后还需要
别的物来调用它的函数将它初始化，这是非常诡异的。所以一个对象应该在它被使用之前就初始化好了，它不应该由对象的使用
者来初始化。
2.为什么要设计构造函数，析构函数？
a.更好的体现“物化”思想（自动性）。
b.更好的封装性，避免从外部初始化。很显然外部初始化对象的成员变量破坏了对象的封装性。
c.更有效地使类架构设计与程序架构设计分开。
d.促进更清晰地面向接口编程（所谓的接口都是public的函数），更有效地复用。
3.例如一个类里面维护了一个数组，然后写了一大堆public函数，来操作这个数组。既然可以直接操作
数组，为什么要将其封装提供接口呢？好处就是提供接口，面向接口编程，松耦合，更容易复用。并且
将其物化后，提供接口跟别人交互，更像是一个人用语言去跟别人交流。并且将数据封装，更好的保护
了数据，不将其暴露出来。
4.new和delete是操作符，不是函数。malloc函数只是分配出一块内存，而不管分配出什么类型的。需要什么类型
自己去强转。而new操作符不但分配了内存，并且赋予了其类型，引发其构造函数的调用。
第六天
1.程序一开始写的时候最难，无法下手。当程序写了一大堆时，思路打开后，却不难了。
2在当解决问题时，会遇到问题难度大于自己能力的情况。此时人们采取的方法有两种，一种是提升自己的能力，
快速学习相关知识等。但是能力并不是短时间能够提升的。能力的提升是金字塔状的，一层一层铺上去的。
真正的大师站在金字塔的顶端的时候，底下是铺了一大层的。第二种就是将问题的难度往下缩。缩小的办法
之一就是去掉问题包装层，留下问题最主要的东西，是它的最小完备集。
3.看传记，最好是看大师本人写的，不要去看其他阿猫阿狗写的，他们怎么可能理解大师所想的。
4.书读了十几年，是时候去动脑思考问题了。遇到一个问题有没有能力去解决，就看你有没有能力去将问题解剖，
然后用已学过的知识去分析。世界的本原是相通的，所以所有的知识都是相通的，那么就可以用自己学过的知识
去解决其他陌生领域的问题。通过这个思想，那么你是否可以通过十五天的时间去成为某个其他领域的专家？
因为知识是相同的，思想是相通的，世界的本原是相通的。
5.函数重载时，为什么函数参数和参数个数是可识别的，但是函数的返回值是不可识别的?
因为调用这个函数时，调用语法是没有返回值信息的，由此导致调用时不可识别。
从定义函数的表面上可以通过返回值识别，eg：
int Fun();
float Fun();
从定义语法上，以上两个函数可以识别。但是在调用语法上面是不可识别的。eg：
void main() {
Fun();
}
从语法上如何识别调用的是哪个Fun函数呢？不能识别。
如果语规定说调用的时候，前面必须写返回值类型，那么这可以识别。
从这个问题可以分析到，一个语法中，哪个行为可以这样做，哪个行为不能这样做，
是在整个语法体系中相互制约的，所以可以从整个语法体系去分析某个行为为什么
是这样的，一定是有原因的，是有其他行为与其相互作用，相互制约，相生相克。
6.void在当返回值类型时，表示不返回，并不是返回无类型，不返回任何值，不去建栈。
7.构造函数可以显示调用，匿名对象。
8.构造函数没有返回值，是编译器造出来自动调用用来初始化对象的，它不需要返回值，返回给谁呢？
第七天
1.析构函数不能重载，不能显示调用。
2.C++的发明者喜欢用一个词代表多个意思。例如static有多种用法，const也有好多种用法。
3.静态局部对象。静态变量的产生早于main函数的调用，但是构造函数的调用不会早于main函数。
可能是在main函数一开始的时候，也可能第一次使用的时候，例如静态局部。
分析：代码如下，
A a; // 构造函数输出a。
int main() {
cout << "b" << endl;
}
输出为 a, b
先输出a，后输出b，那么是不是就是首先调用A的构造函数，然后调用main函数？
如果是这样，那么是不是和C语言是一个悖论，C规定函数必须嵌套使用，但是不能
嵌套定义。但在这种情况下A的构造函数不是在main函数中调用使用！并且如果A的构造
函数可以在main之前调用，那么是不是可以把所有的事都放到构造函数中去做，main函数
其实就没什么用了？
事实证明这种想法是错误的，通过查看编译生成的机器码可以看到，全局A的构造函数
是在刚进入main函数的时候，就调用的A的构造函数。
由此也可以看出C++是一个不纯粹的面向对象的语言，因为它要进入main函数，在里面先做这个，
后做那个，很面向过程的一种风格。如果更纯粹点的话，就把main函数去掉，也就是把main函数做成一个
类，由该类来带领队伍去做各种事，也就是将其对象化，而不是面向过程的，在main这个函数中进行动作。
在现实中的面向对象都是纯粹的面向对象，因为不论做什么事，都是有人，有角色去带领，去做。
4.面向过程，把一个问题的解决方案步骤后，过程化，先做这个，然后做那个，最后再做什么什么。
而面向对象是将问题进行角色划分，进行物化，进行专业化分工。
5.问题分析：代码如下，
int a = 5;
cout << &5 << endl;
5是常量吗，为什么不能对其取地址？
5是一个常量，不能对其进行赋值。5是int a = 5;这条指令中的立即数，这个5是这条指令中的一部分，
是不能将其取出来的。指针虽然有指令指针，但是指令指针是指向某条指令的，
而不能将某条指令拆分开来，取到其中的某一部分。
在C++中常数即常量， 如：int a = 5；
常量5，不在数据中，而在指令中,没有指针，不能赋值。
6.const常量，具有常量性质的数据（编译器“把门”）。常量必须初始化。
const int a = 10;
a = 12; // 错误，这个赋值错误是因为编译器把门，不让它通过，而不是因为其他的原因。
7.const推测：
const int a = 10;
cout << a << endl;
int b = a;
推测一：如果代码中没有对常量a取地址的行为，那么，编译器就直接将其视为宏的作用。也就是
在编译初期，直接将a替换成10。
const int a = 10;
cout << &a << endl;
推测二：如果代码中有对常量a进行取地址的行为，那么const的作用之一就是将a进行内存分配，
将其变成一个普通局部变量。const的作用之二就是提示编译器进行把门，不要让程序员对其
进行赋值。
8.const 成员函数：约束成员函数的只读性。const很巧妙地解决了野指针的问题。
9.引用，是一个变量的别名，引用本身并不是没有存储空间的。引用不会为值去开辟一个
地址空间，但是其本身要占用空间。引用确实占用了栈空间，也确实是存储了目标变量的
地址。
10.初始化非const引用必须用左值，const引用则不必。
eg：
int& a = 5; // 错误
const int& a = 5; // 正确
引用在内部存放的是一个变量的地址，它是变量的别名。对于不可寻址的值，编译器为了实现引用，
必须生成一个临时对象，引用必须指向该对象，但是用户不能访问它.
一种不准确的解释为：编译器产生的临时产生的中间变量都是const的，即其为常量，
所以必须用const的引用。
eg：
const int a;
const int& b = a; // 因为a是const的，所以其引用也必须是const。
这种解释是有悖论的，如果其为const，那么其应该在指令区，是不能做左值的。
但在《Thinking in C++》中说到编译器产生的临时的中间变量是可以做左值的。
例如const int& a = 5;编译器会为5这个常量产生一个临时的中间变量，且这个临时
中间变量是可以作为左值得。
比较正确的解释为：临时中间变量是程序员是不能对其进行操作的，而且其在使用完之后
就会释放，所以我们修改一个其是没有意义的。所以编译器就为其加入了不能作为非const
引用的这个语义限制，防止用户错误使用。也就是说临时中间变量有const的性质，但不是const
变量，所以编译器加入了这个语义限制。
第八天
1.C++体系性的思考特别多。体系性思考特别重要。
第九天
1.世界上最难做好的就是最简单的道理。人有一个毛病，越是聪明的人越有的一个毛病，
追求复杂很难理解的道理。
2.在拷贝构造函数中为什么可以访问引用对象的私有变量？
一种解释：因为C++的封装层次达到类的层次，而不是对象。所以对于C++来说访问权限是针对“类”
来说的。也就是说private的访问权限是其他类不能访问的，而不是这个类的不同对象之间不能访问。
3.成员函数和非成员函数之间最大的区别就是，成员函数的参数里面有一个你看不见的参数，
这个参数传的是this指针。
4.this指向当前对象的指针。
第十天
1.学习，学会规则只能达到解决温饱的问题，真正要达到衣食无忧，靠的是悟性。
悟性对一个事物的思考，把握。学过一个东西，然后能掌握它，抓住它的主要矛盾，这是只是一个基本的本事，
真正的本事是没有学过一个东西，能够抓住它的主要矛盾。
2.其实很多高考新课标的修改就是一种思路。新课标的题目被称为很开放，开放并不是乱七八糟的无厘头，而是
一种思想的开放。通过已有已学过的知识，去分析一个问题，然后设计解决方案。这就是新课标的设计类题目。
这也就是其被称为开放的原因。学习，去思考，去推理，达到设计的境界。
3.对事物要有一种“敏”，也就是对事物有一种敏感，快速感知其思路，其设计的伟大之处，以及要达到的目的。
4.生物的继承进化，基因既有自己的基因，又有继承前人的基因（加机制），但是并没有完全加入了前人的基因
（减机制），一些前人的基因可能没有继承。但是在C++中，虽然有priave，但是还是完全继承了前人的基因。
也就是C++只有加机制，没有减机制。
eg：
class Base {
private:
int a;
int b;
};
class Derived : public Base {
private:
int c;
};
int main() {
cout << sizeof(Base) << endl; // 输出8
cout << sizeof(Derived) << endl; // 输出12
return 0;
}
生物不断地进化，可能进化出新的物种。如果C++就像生物一样，既能继承一些基因，
也能丧失一些基因，那么通过不断地继承之后，可能出现一个新的类，一个功能完全不同于最初
基类的类。
5.程序能不能实现自己编程呢，程序一定要人去写吗？如果程序模仿生物，不断地进行继承，进行
进化，自我繁衍出新的类，那么是否可以实现程序的自我编程呢？未来的程序是不是可以这样写，
大致写出一个框架，然后让它自己去跑，程序在那里自适应，自己创造新的东西。
6.思考：用人类繁衍的思想，想出一个语言的设计方案。
人类两性繁殖，减数分裂，然后父母双方各一半基因的随机融合等等，这些思想是否可以做出
一个语言，可以达到这个效果。
7.上述的思考只是一个想法而已，人要有许多此类的想法，对基本的事物要敏感，要有想法，
并且对其进行一些思考，与其他发展已经很成熟的事物进行类比，万事万物都是相通的。
就像拿面向对象语言的设计去和生物进行类比，因为面向对象语言人类设计了几十年，发展其实
并不是很成熟，而生物的发展已经有几亿年，是一个很成熟的事物，所以可以将这两个事物
进行类比。
第十一天
1.真正要干成点什么事，想象力和创造力显得尤为重要。
传统教育对技术细节重视最大，在最基础的时候，技术细节确实很重要，但是达到一定高度之后，
想象力，创造力，体系性显得特别重要，是真正的突破口。
2.想象力，创造力，其实可以这样做，想到一个想法，然后就去做，去实现，然后搞出个水落石出！
不要一想而过！
3.设计类架构的方法，如果从上往下设计，也就是从基类开始思考，思考下面要派生什么类，这样的
思考方法其实是有一定问题的，很难想到下面该派生什么类。但是可以反向思考，从小往上思考。想
好最下层的类，然后不断从中抽取基类。
类是抽象出来的，不是从上往下拍脑袋想出来的。
4.一个人都优秀是他思考问题的方法优秀，有和他人不同的思考角度。一个人要快速的调转自己的思考方式，
也就是随机应变的能力强。而不是十分固执，死磕于自己的一种角度，人改变自己的思想方法很难。《柳丁思考的帽子》
5.人类一切美好高雅的东西都应该去尝试，因为这些都是艺术，是人类伟大智慧的结晶，给人带来美好感受。
第十二天
1.程序中，小问题要及时解决，不要试图去绕过去，程序越来越庞大，小问题越滚越多，最终达到毁灭性灾难。
小问题不要积累，不要去妥协，一定要及时解决。
2.读书也要有敏感性，对其里面的内容要敏感，快速抓住其思考，精髓，核心等等。
扫一扫
1675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
