时光：“你说你以前为什么没有女朋友。”
我：“因为你没有出现呀“
时光：”那你以后为什么没有。“
时光：”emmm…因为我不让她出现。”

  时光来了南京，今晚接她下班的时候，我们在路上买了两份面回去，一份鸡腿面，一份呢，是青菜的。在夫子庙地铁站旁上海商业储蓄银行旧址拐角的地方发现一只喵，猫很乖，我们路过的时候它乖兮兮地向我们咪咪叫，眼睛看着我们。我和时光都觉得它是饿了，刚好我们手里拿着打包的面，想喂它鸡腿。猫也闻到了味道，一直意欲走向我们的面。打包的袋子还没打开，它就想往上边蹭。我们便一人挡着猫咪，一人去开袋子，银行墙上有许多的窗子，我们便在一个个窗子上与猫做游击战，它跳过来，我们就换个窗户开袋子。两人一猫，交相流转，好不笑闹。费了好大的功夫，我们终于打开了饭盒，用筷子夹了鸡腿放在窗台上给猫主子。结果猫主子闻了闻，走在了一边，没有吃。当时我就慌了，妈耶，这可是我俩唯一的鸡腿呀，没有吃喂给主子了主子却不待见，我俩只有青菜了，TAT。我和时光用手指指着鸡腿，想告诉猫咪来这里吃鸡腿，它闻了闻，还是没有次。我们猜可能是整个鸡腿太大又有些烫，它不好下嘴，时光又特意用窗台上的签子给它分开。时光欺负起我来的时候凶巴巴，这时候却是温柔的要死，我站在一旁注视着她。晚风刚好，时间像是暂停了，满心的幸福。这曾是异地时幻想多少次的场景呀，晚上接她下班，回家的路上牵着手，想着一天的生活。一霎时，突然想写篇文章来记录和时光在一起的生活，记录下生活中那些触动心灵的点点滴滴。

秋招的一些经验（后台开发方向）

秋招可以说是学生时代的重要一战，秋招的成败牵系着职业的起点。想在秋招中得到心仪的 offer，正确的意识和打法就尤为重要。有很多学生以为秋招是在自己毕业后的那个秋天，到了八九月份才意识到是现在这个秋天，再慌乱地进行准备，结果可想而知了，虽不能一棒子打死，但总归不能够充分发挥出自己的实力。意识如此，打法也是这样子，有了意识，却没有正确的打法，也极有可能事倍功半。

读 《Effective C++》条款 31 的时候一直模模糊糊的，因为不了解 C++ 编译依存的原理，不知道什么时候会重新编译，什么时候不会。所以读的时候很是纠结，不明白该条款的意义。后来读了这篇文章，就清晰了很多。博主用一个简短的程序例子，展示了 C++ 基本的编译依存原则。感谢。

读完条款 31 ，我也更加深刻的明白了 C 语言为什么头文件和实现文件分开。大一时老师说的结构更加清晰或许是更次要的作用。其主要作用是降低文件间的编译依存关系，加快编译速度。

下面是我读的文章，原文链接

在说这一条款之前，先要了解一下C/C++的编译知识，假设有三个类ComplexClass, SimpleClass1和SimpleClass2，采用头文件将类的声明与类的实现分开，这样共对应于6个文件，分别是ComplexClass.h，ComplexClass.cpp，SimpleClass1.h，SimpleClass1.cpp，SimpleClass2.h，SimpleClass2.cpp。

ComplexClass复合两个BaseClass，SimpleClass1与SimpleClass2之间是独立的，ComplexClass的.h是这样写的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

#ifndef COMPLESS_CLASS_H
#define COMPLESS_CLASS_H

#include “SimpleClass1.h”
#include “SimpleClass2.h”

class ComplexClass
{
    SimpleClass1 xx;
    SimpleClass2 xxx;
};
…

#endif /* COMPLESS _CLASS_H */

我们来考虑以下几种情况：

Case 1：

现在SimpleClass1.h发生了变化，比如添加了一个新的成员变量，那么没有疑问，SimpleClass1.cpp要重编，SimpleClass2因为与SimpleClass1是独立的，所以SimpleClass2是不需要重编的。

那么现在的问题是，ComplexClass需要重编吗？

答案是“是”，因为ComplexClass的头文件里面包含了SimpleClass1.h（使用了SimpleClass1作为成员对象的类），而且所有使用**ComplexClass**类的对象的文件，都需要重新编译！

如果把ComplexClass里面的#include “SimpleClass1.h”给去掉，当然就不会重编ComplexClass了，但问题是也不能通过编译了，因为ComplexClass里面声明了SimpleClass1的对象xx。那如果把#include “SimpleClass1.h”换成类的声明class SimpleClass1，会怎么样呢？能通过编译吗？

答案是“否”，因为编译器需要知道ComplexClass成员变量SimpleClass1对象的大小，而这些信息仅由class SimpleClass1是不够的，但如果SimpleClass1作为一个函数的形参，或者是函数返回值，用class SimpleClass1声明就够了。如：

1
2
3
4
5

1 // ComplexClass.h
2 class SimpleClass1;
3 …
4 SimpleClass1 GetSimpleClass1() const;
5 …

但如果换成指针呢？像这样：

1
2
3
4
5
6
7
8
9
10

 1 // ComplexClass.h
 2 #include “SimpleClass2.h”
 3 
 4 class SimpleClass1;
 5 
 6 class ComplexClass: 
 7 {
 8     SimpleClass1* xx;
 9     SimpleClass2 xxx;
10 };

这样能通过编译吗？

答案是“是”，因为编译器视所有指针为一个字长（在32位机器上是4字节），因此class SimpleClass1的声明是够用了。但如果要想使用SimpleClass1的方法，还是要包含SimpleClass1.h，但那是ComplexClass.cpp做的，因为ComplexClass.h只负责类变量和方法的声明。

那么还有一个问题，如果使用SimpleClass1*代替SimpleClass1后，SimpleClass1.h变了，ComplexClass需要重编吗？

先看Case2。

Case 2：

回到最初的假定上（成员变量不是指针），现在SimpleClass1.cpp发生了变化，比如改变了一个成员函数的实现逻辑（换了一种排序算法等），但SimpleClass1.h没有变，那么SimpleClass1一定会重编，SimpleClass2因为独立性不需要重编，那么现在的问题是，ComplexClass需要重编吗？

答案是“否”，因为编译器重编的条件是发现一个变量的类型或者大小跟之前的不一样了，但现在SimpleClass1的接口并没有任务变化，只是改变了实现的细节，所以编译器不会重编。

Case 3：

结合Case1和Case2，现在我们来看看下面的做法：

1
2
3
4
5
6
7
8
9
10

 1 // ComplexClass.h
 2 #include “SimpleClass2.h”
 3 
 4 class SimpleClass1;
 5 
 6 class ComplexClass
 7 {
 8     SimpleClass1* xx;
 9     SimpleClass2 xxx;
10 };

1
2
3
4
5
6

1 // ComplexClass.cpp
2 
3 void ComplexClass::Fun()
4 {
5     SimpleClass1->FunMethod();
6 }

请问上面的ComplexClass.cpp能通过编译吗？

答案是“否”，因为这里用到了SimpleClass1的具体的方法，所以需要包含SimpleClass1的头文件，但这个包含的行为已经从ComplexClass里面拿掉了（换成了class SimpleClass1），所以不能通过编译。

如果解决这个问题呢？其实很简单，只要在ComplexClass.cpp里面加上#include “SimpleClass1.h”就可以了。换言之，我们其实做的就是将ComplexClass.h的#include “SimpleClass1.h”移至了ComplexClass1.cpp里面，而在原位置放置class SimpleClass1。

这样做是为了什么？假设这时候SimpleClass1.h发生了变化，会有怎样的结果呢？

SimpleClass1自身一定会重编，SimpleClass2当然还是不用重编的，ComplexClass.cpp因为包含了SimpleClass1.h，所以需要重编，但换来的好处就是所有用到ComplexClass的其他地方，它们所在的文件不用重编了！因为ComplexClass的头文件没有变化，接口没有改变！

总结一下，对于C++类而言，如果它的头文件变了，那么所有这个类的对象所在的文件都要重编，但如果它的实现文件（cpp文件）变了，而头文件没有变（对外的接口不变），那么所有这个类的对象所在的文件都不会因之而重编。

因此，避免大量依赖性编译的解决方案就是：在头文件中用class声明外来类，用指针或引用代替变量的声明；在cpp文件中包含外来类的头文件。

我发现勇气根本靠不住，只有完全的疯狂才有意义。

请带着批判的眼光看这篇文章。或许我的一些答案是不对的。如果您发现了错误，烦请指出。

1. C++对象模型

   这个要重点掌握， 要明白类里有什么，每个类的对象里又有什么。尤其是对虚函数表的了解。这块知识较多，不在这篇文章中详述。网上有着很多优秀的博客来介绍。

   https://coolshell.cn/articles/12176.html

   https://www.jianshu.com/p/9fb37bb3094f

2. C++多态机制的实现原理

   主要就是上面问题中的虚函数表。

3. 如果一个类的指针为 nullptr ，那么调用他的成员函数会不会出错。出错的话是在哪一阶段出错。

   也是对C++内存模型的一个考察以及动态绑定静态绑定。每个类的成员函数都在.text代码段，静态绑定的时候如果成员函数不访问成员变量的话那么这个函数不会出问题。如果说是虚函数或这个函数访问了成员变量，那么就会出错。虚函数出错是因为其动态绑定，因为是 nullptr， 无法确定其虚函数表。

   阅读全文 »

在地平线面试时和面试官聊到进程和线程的区别，自己说到线程切换要比进程切换快，面试官问到具体是为什么。

orz，无奈自己没有好好学操作系统，也没有复习这个。

面试官非常 nice，告诉我是因为有关CPU的缓存问题，其关键是 TLB。

线程共享资源：

a. 堆 由于堆是在进程空间中开辟出来的，所以它是理所当然地被共享的；因此new出来的都是共享的（16位平台上分全局堆和局部堆，局部堆是独享的）

b. 全局变量 它是与具体某一函数无关的，所以也与特定线程无关；因此也是共享的

c. 静态变量 虽然对于局部变量来说，它在代码中是“放”在某一函数中的，但是其存放位置和全局变量一样，存于堆中开辟的.bss和.data段，是共享的

d. 文件等公用资源 这个是共享的，使用这些公共资源的线程必须同步。

e. 地址空间

f. 子进程、闹铃、信号及信号服务程序、记账信息

g. 进程代码段

线程独享资源

栈

寄存器

程序计数器

状态字

线程优先级

错误返回码

• 内核态、用户态区别，如何进入内核态
• 为什么使用 B+ 树作为索引的数据结构。
• extern “C”
• 自由存储区和堆的区别

今天做题的时候遇到这样一个问题。

以下程序片段输出内容为：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Demo {
public:
    Demo():count(0) {}
      ~Demo() {}
  
      void say(const std::string&msg) {
          fprintf(stderr,"%s\n", msg.c_str());
      }   
   private:
      int count;
};
  
int main(int argc, char **argv) {
    Demo* v = NULL;
    v->say("hello world");
}

突然想起小伙伴前段时间给我看的一段神仙代码。实在特有诱惑力了。。当时女票喊我吃饭我都在看这段代码，话不多说，放码过来。

1

printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);

要解开这道题，我们首先要知道下面几点。

• a[3] == 3[a]
  转换为指针角度看， a[3] = *(a+3) = *(3+a) = 3[a]
• "abcdefg"[3]这种表示相当于 char str[]="abcdefg"; str[3]
• 知道了上面那点后，我的目光就聚焦在 unix 上，我感觉它应该是一个数字，一开始以为它是个变量，但代码中没有描述，我问小伙伴这是不是全量代码，小伙伴说文章里没有看到其他的。。于是我就开始猜他的值，一开始猜的3，是因为忘记了字符串中“\0xx”的意义，把他们当成了3个字符来看。其实它们是一个字符的，这种格式表示八进制的ASCII码。然后猜 unix 值为1，后面才晓得 unix 是个宏定义， #define unix 1，这样，我们可以将上面的题目转换成较易看懂的。

1

printf( &("\021%six\012\0"[1]), "have"[1]+"fun"-0x60);

众所周知， printf()的第一个参数为字符串，或者说字符串的起始地址，我们分析后可知为%six\012\0, '%s'表示一个字符串，故我们看第 2 个参数， have[1] 也便是 'a'，'a'-0x60 = 97 - 96 = 1, "fun"+1 也便是字符串 "un" 的起始地址，\012 = 10， 对应 ASCII 码也便是\n。

所以这段代码其实是 printf("unix\n"); 。

unix

很棒很惊艳的代码。