《程序员面试宝典》（第三版）笔记整理

      不怎样的一本书，具体表现为：1）该详细讲解的地方，或者一笔带过或者讲得不全面或者讲些不相关内容；2）该略过的地方，反而详细起来；3）有一部分错误，如sizeof不计算static变量的大小之类的。虽说如此，收获还是有的——知道了在笔试中常见的知识点。这里的笔记就是对我不熟悉或者理解不全面的知识点去Google和查书而来的。

C++的关键字
1. 使用extern "C"的理由
函数被C编译器编译后不带参数信息，被C++编译器编译后会带上参数信息。这是因为C++支持函数重载。所以函数被C编译器编译和被C++编译器编译是不同的。例如：void Zero(int lin)，被C编译后，可能得到_Zero，被C++编译后，可能得到_Zero_int。那如果要在C++中使用被C编译过的库呢？使用extern "C"就可以！它会告诉C++编译器，被它修饰的函数是以C语言的编译方式编译的。
 
2. const的作用
a. 声明常量     
b. 声明函数形参     -> 提高自定义类型的调用效率。注意，如果是内部类型，如int，没必要写成const int&
c. 声明函数返回值
d. 修饰类成员函数     -> 防止成员函数对成员变量进行修改。注意，const成员函数内只能调用类的其他const成员函数
备注：如果要在const成员函数修改某个成员变量，那么可以给这个变量的声明加上mutable
 
3. static的作用
a. 用于函数内部的局部变量时，能保证函数退出作用域后不回收其空间（即其值保持不变）
b. 用于全局变量时，使变量的作用域限制在一个文件内
c. 用于函数时，使函数只在一个文件内可见
d. 用于类成员变量时，代表该变量属于类的（即所有对象共享这个变量）
e. 用于类成员函数时，代表该函数为整个类所有。注意，该函数不接收this指针，也意味着不能调用一般的成员函数或者变量
 
4. sizeof操作符
a. 作用：返回一个对象或者类型所占的内存
b. sizeof 不计算类/结构体的static成员 -> 因而可将a中提到所占的内存理解为存储某个类型的对象所需要空间
c. 对空类使用sizeof会返回1     -> 占用内存为0，无法实例化，所以编译器为了使空类也能实例化，就给其分配了1Byte
d. 如果类中有虚函数，那么最终结果要多加4Byte     -> 此时多出一个指针，指向虚函数表
e.g:
static int a;     //sizeof(a) = 4，因为这不是类内/结构体内的
 
class Zero {
int a;
static int b;
virtual void fun() {}
};    //sizeof(Zero) = 8
 
class Lin {
virtual void fun() {}
};     //sizeof(Lin) = 4，由d可知其为lin至少有4Byte，所以在这个例子中规则c不成立，因而最终结果为4Byte
 
class Child: public Zero {
     int a;
     virtual void fun() {}
};     //sizeof(Child) = 12
 
5. inline
a. inline只是一种建议，建议编译器将指定的函数在被调用点展开，因此编译器是可以忽略inline的（即不展开）
b. inline以代码膨胀（复制）为代价，省去了函数调用的开销，从而提高函数的执行效率
c. 每一处inline函数的调用都要复制代码，这将使得程序的总代码量增大，消耗更多的内存空间
d. inline必须与函数定义放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用
e. 定义在类声明之中的成员函数将自动地成为内联函数
 
6. explicit
禁止单参数构造函数被用于隐式类型转换
class Zero {
public:
     Zero(int i): lin(i) {}
private:
     int lin;
};
int Fun(Zero z) {}     //如果不用explicit的话，可以这样调用Fun(1);
 
-------------------------------------------------------------------------------------------
C++的规则
1. 在声明赋值语句中，变量先声明，然后赋值
int i = 1;
int main() {
     int i = i;     //这里声明的i 覆盖了全局变量的i，之后的赋值就是局部变量的i 给自己赋值，因而其值是未定义的
     return 0;
}
 
2. 从右到左压参数
int main() {
     int i = 1;
     printf("%d, %d\n", i, ++i);     //VS2010输出2, 2
}
其它：
虽然压参数的顺序是固定的，但计算顺序是编译器相关的，因此最后的结果与编译器相关。
 
3. 写宏时要注意
a. 括号的使用
b. 不要使用分号
e.g: 写一个找出两者中较小的宏
#define MIN(a, b) ( (a) < (b) ? (a) : (b) )
 
4. 结构体对齐原则
 a. 数据成员对齐规则：结构(struct或union)的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小的整数倍开始（e.g: int在32位机为４字节，则要从4的整数倍地址开始存储)
b. 结构体作为成员：如果一个结构里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存(e.g: struct a里存有struct b，b里有char，int，double等元素，那b应该从8的整数倍开始存储)
c. 结构体的总大小，必须是内部最大成员的整数倍，不足的要补齐
备注：设计结构体，最好把占用空间小的类型排在前面，占用空间大的类型排在后面，这样可以相对节约一些对齐空间
struct Zero {
char b;
int a;     //a的起始位置要按4字节对齐，所以b之后要补3个字节
short c;
};     //sizeof(Zero) = 12
struct OreZ {
char b;
short c;     //c的起始位置要按2字节对齐，所以b之后要补1个字节
int a;
}     //sizeof(Orez) = 8
 
5. 结构体位制
a. 位段成员的类型仅能够为unsigned或者int, 并且指定的位数不能超过类型的长度
b. 存储规则：如果下一个位段能存放在之前的存储单元中(存储后长度不超过类型长度)，则存储，否则，存储到新的存储单元中。因为位段不能跨单元存储
struct Zero {
     unsigned short a : 4;
     unsigned short b : 5;
     unsigned short c : 7;     //刚好16，符合unsigned short的长度，所以存放在同一单元中
}zero;
int main() {
     zero.a = 2;
     zero.b = 3;
     int i = *((short*)&zero);
     printf("%d", i);     //输出50(VS2010测试结果)，这说明先声明的变量在低位
     return 0;
}
 
6. C++风格类型转换
a. const_cast<type>(varible): 去掉变量的const或volatile属性
b. static_cast<type>(varible): 类似C的强制转换，但功能上有所限制(如：不能去掉const属性)     -> 常用于基本类型转换，void指针与目标指针转换
c. dynamic_cast<type>(varible): 有条件转换，运行时进行类型安全检查(如果失败则返回NULL)     -> 用于基类与子类之间的类型转换(必须要有虚函数)
d. reinterpret_cast<type>(varible): 仅仅重新解释二进制内容    -> 常用于不同类型的指针转换
class Base {
public:
     virtual void fun() {}
};
class Zero: public Base {
public:
     virtual void fun() {}
};
int main() {
     Base *pb = new Base;
     (dynamic_cast<Zero*>(pb)) -> fun();     //由于实际指向的是基类，所以此转换失败，返回NULL，导致运行时错误
     delete pb;
     return 0;
}
 
7. 指针与引用的差异
a. 初始化：指针可以不初始化；引用必须在定义时初始化
b. 非空性：指针可以为NULL，因而指针可能是无效的；引用不能为空，因而引用总是有效的
c. 内存占用：指针要占用内存，引用不占     -> 引用只是一个逻辑概念，通常在编译时就优化掉了
d. 可修改性：指针可以重新指向其它变量；引用不可以
《Effective C＋＋》：在一般情况下，引用和指针是一样的，但是根据条款23：在返回一个对象时，尽量不要用引用，而是用指针
 
8. 指针与句柄(handle)
指针标记一个内存的地址
句柄是Windows用来标识被应用程序建立或使用的对象（窗口，菜单，内存等）的唯一整数。从构造上看，句柄是一个指针，但其不指向存储对象的内存位置，而是一个包含了对象所在的内存位置的结构（结构的复杂度由所指的对象决定）
 
9. 指针与浅拷贝
浅拷贝在复制指针时，只是单纯地将指针指向同一内存，并不对所指向的内容进行复制。因而，当成员变量有指针时，最好考虑是否要写深拷贝函数和赋值函数
class Zero {
public:
     Zero(): ptr(NULL) {}
     ~Zero() { if( ptr )     delete[] ptr; }
     char* ptr;
};
 
int main() {
     Zero z;
     z.ptr = new char[100];
     strcpy(z.ptr, "zero");
     vector<Zero> * vz = new vector<Zero>();
     vz->push_back(z);
     delete vz;
     return 0;
}　　 //退出main时会出现运行时错误
由于Zero没有定义拷贝函数，所以有一个默认的浅拷贝函数。在main函数中，delete vz已经释放过一次ptr指向的内存，然后在离开main的作用域时z的析构函数启动，再次释放该内存
 
10. 迭代器失效
在容器中增加/删除元素时，可能会使部分或者全部的迭代器失效
 
11. C++编译器默认产生的成员函数
构造函数，析构函数，拷贝函数，赋值函数
 
12. 类中静态成员变量与常量
a. 静态成员变量一定要在类外初始化
b. 成员常量一定要在初始化列表初始化
c. 静态成员常量一定要初始化，初始化时可以直接在声明时写上，也可以像一般的静态成员变量那样写
class Zero {
public:
     Zero():lin2(1) {}
private:
     static int lin;
     const int lin2;
     static const int lin3 = 1;
};
int Zero::lin = 0;
 
13. 初始化列表的初始化顺序根据成员变量的声明顺序执行
class Zero {     //不要写这样的代码
public:
     Zero(int i):lin2(i), lin1(lin2) {}     //此时先初始化lin1，再初始化lin2，因而最后的结果是lin1的值是随机数，lin2的值是i
private:
     int lin1;
     int lin2;
};
 
14. 构造函数不可以为virtual，析造函数有时必须为virtual
虚函数在运行时动态绑定，动态绑定需要知道动态类型才能进行绑定。而一个类的对象在没有运行构造函数前，其动态类型不完整，因而无法进行动态绑定
delete指向子类对象的基类指针时，如果析构函数不是virtual，则只会调用基类的析构函数，从而造成内存泄漏
 
15. C++编译的程序占用的内存
a. stack(栈区): 由OS自动分配释放空间，主要用来存放函数的参数，局部变量等
b. heap(堆区): 一般由程序员分配释放空间， 若程序员不释放，程序结束时可能由OS回收
c. static(全局/静态区): 存放全局变量和静态变量。值得注意的是，初始化和未初始化的这两种变量是分开存放的。
d. 文字常量区: 存放常量字符串
e. 程序代码区: 存放函数的二进制代码
 
-------------------------------------------------------------------------------
杂项
1. 不用循环，判断一个数X是否为2的N的次方(N >= 0)
X & (X - 1)     //最后结果为0，则是2的N次方
分析：2，4，8的二进制式为10, 100, 1000，当其与1, 3, 7的二进制式相与时，其结果为0
 
2. 不用判断语句，找出两个数中的最大值
((a + b) + abs(a - b)) / 2
 
3. 不用中间变量，交换两者的值
a = a ^ b;     //得到a与b的哪些位不相同（即一共有多少位不同）
b = a ^ b;     //去掉b的不同位，换上a的不同位，从而得到a
a = a ^ b;
 
4. 写一个宏FIND，求结构体struc里某个变量相对struc的偏移量
#define FIND(struc, e) (size_t)&(((struc*)0)->e)
解析：(struc*)0将0强制转换为struc*的指针类型，然后再取(struc*)0的成员e的地址，从而得到e离结构体首地址的偏移量
 
5. 数组名再取地址
int a[] = {1, 2, 3};
int *ptr = (int*)(&a + 1);     //&a相当于得到二维数组指针，因而&a + 1相当于移动一行
printf("%d\n", *(ptr - 1));    //输出3
 
6. 指针的移动
int main() {
     int *pi = NULL;
     pi += 15;
     printf("%d\n", pi);     //输出60
     return 0;
}
 
7. 整数超范围
如果是有符号数，那么最大正整数 + 1 等于最小负整数
如果是无符号数，那么最大正整数 + 1 等于零
bool IsOdd(int i) {
     return (i & 1) == 1;    //不要写成(i % 2) == 1，因为这样写判断负数时会出问题
}
int main() {
     for(int i = 0xFFFFFFFF; i <= 0x7FFFFFFF; ++i) {     //这会陷入死循环，因为最大正整数 + 1 等于最小负数
          cout<<i<<" is "<<IsOdd(i) ? "odd" : "even"<<endl;
     }
     return 0;
}
 
8. 基类指针与子类指针
class Base {
     int a;
};
class Zero: public Base {
     int b;
};
int main() {
     Zero *pz = new Zero();
     Base *pb = dynamic_cast<Base*>(pz);
     (pz == pb) ? (cout<<"Yes\n") : (cout<<"No\n");     //VS2010输出"Yes"
     (int(pz) == int(pb)) ? (cout<<"Yes\n") : (cout<<"No\n");     //VS2010输出"Yes"
     return 0;
}
 
9. strcpy的写法
char* strcpy(char* dst, const char* src) {     //返回char*是为了方便链式调用
     assert( (src != NULL) && (dst != NULL) );     //特别注意检查
     char* tmp = dst;
     while( *dst++ = *src++ );    //++和*的优先级一样，而双者均为右结合，所以*dst++相当于*(dst++)
     return tmp;
}
 
10. 概率题
int main() {
     int cnt = 0;
     for(int i = 0; i < 10000; ++i) {
          int x = rand();
          int y = rand();
          if( x * x + y * y < RAND_MAX * RAND_MAX )     ++cnt;     //实质上是1/4圆与正方形的面积的比较
     }
     printf("%d\n", cnt);     //结果约为PI/4 * 10000
}
 
11. 以下程序在编译时，哪句会出错
struct Zero {
     void Lin() {}
};
int main() {
     Zero z();     //这样写会被编译器认为是声明一个函数，而不是调用构造函数
     z.lin();     //这句会出错，因为此时的z被认为是未声明的变量
     return 0;
} 
 
12. 各种排序总结
算法 稳定性 时间复杂度 空间复杂度 备注
选择排序 F O(n^2) O(1)  
插入排序 T O(n^2) O(1) 当序列有序时，时间复杂度为O(n)
冒泡排序 T O(n^2) O(1) 当序列有序时，时间复杂度为O(n)
希尔排序 F O(nlogn) O(1) 具体的时间复杂度与所选的增量序列有关
归并排序 T O(nlogn) O(n)  
堆排序 F O(nlogn) O(1)  
快速排序 F O(nlogn) O(logn) 当序列有序时，时间复杂度恶化为O(n^2)
桶排序 T O(n) O(k)  

 

      

posted @ 2012-10-31 10:03  风中之炎  阅读(12114)  评论(6)  编辑  收藏  举报