程序员面试宝典笔记

第六章

1、sizeof()关键字

(1)、空类的大小是1---相当于一个char做了一个标记，标记这个类的地址是唯一的

1 class A {
2 };
3 sizeof(A)=1

(2)类中只有构造函数函数,类的大小也是1

1 class A {
2 public:
3     A(){}
4 };
5 sizeof(A)=1

(3)类中只有函数,类的大小也是1

1 class A {
2 public:
3     A(){}
4     void fun(){}
5 };
6 sizeof(A)=1

(4)类中有一个int型数据(int占4个字节)

1 class A {
2 public:
3     A(){}
4     void fun(){}
5 private:
6     int a;
7 };
8 sizeof(A)=4

(5)含有静态变量的类大小

1 class A {
2 public:
3     A(){}
4     void fun(){}
5 private:
6     int a;          //保存在栈中
7     static int b;   //保存全局区,而sizeof()只统计在栈中的内存,所以此时sizeof(A)=4
8 };
9 sizeof(A)=4

(6)类中有一个int型数据和一个虚函数

1 class A {
2 public:
3     A(){}
4     virtual void fun(){}  //有虚函数那么在类中就会有一个隐藏的对象,该对象是一个指针,会占四个字节
5 private:
6     int a;          
7     static int b;   
8 };
9 sizeof(A)=8

(7)继承

 1 class A {
 2 public:
 3     A(){}
 4     virtual void fun(){}
 5 private:
 6     int a;          //保存在栈中
 7     static int b;   //保存全局区,而sizeof()只统计在栈中的内存,所以此时sizeof(A)=4
 8 };
 9 class B :public A {           //A中的私有变量虽然不可以继承到B中,但是会占位置的
10     B() {}
11     ~B() {}
12     virtual void fun(){}
13 };
14 sizeof(B)=8                  //A中的int型变量a(4个字节)+B中的隐藏对象(4个字节)

第十一章接口与继承

1、覆盖

1 A* pa = new A();  
2 pa->foo();        
3 B* pb = (B*)pa;   //此时pa仍然是指向A的类对象,因此pb也指向A的类对象

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class A
 5 {
 6 public:
 7     void virtual foo()
 8     {
 9         cout << "A" << endl;
10     }
11 };
12 class B :public A
13 {
14 public:
15     void virtual foo()    //这里不加virtual也是可以的,只要基类中加派生类同名函数自动成为虚函数
16     {
17         cout << "B" << endl;
18     }
19 };
20 int main()
21 {
22     A* pa = new A();  //创建指向A类对象的指针pa
23     pa->foo();        //由于pa是基类指针,所以执行基类A中的函数foo()
24     B* pb = (B*)pa;   //将pa转换为B类型并创建B类型指针,最后将pa赋值给pb,但是pa仍然指向基类的类对象,所以pb也指向基类的类对象
25     pb->foo();        //执行基类A中的函数foo()
26     delete pa, pb;
27 
28     pa = new B();    //此时pa指向了派生类的类对象
29     pa->foo();       //执行派生类中的函数foo()
30     pb = (B*)pa;
31     pb->foo();       //执行派生类中的函数foo()
32 
33     system("pause");
34     return 0;
35 }

View Code

2、虚继承

第十二章位运算与嵌入式编程

1、位值转换

 1 #include <stdio.h>   //for printf()
 2 #include <iostream>  //for system()
 3 
 4 int main()
 5 {
 6     printf("%f
", 5);
 7     printf("%d
", 5.0);
 8 
 9     system("pause");
10     return 0;
11 }

2、int、float等占的字节数

 1 #include <iostream>  //for system()
 2 using namespace std;
 3 int main()
 4 {
 5     cout << "char" << " " << "int" << " " << "float" << " " << "double" << " " << "long" << " " << "short" << "	
";
 6     cout << sizeof(char)<<"  " << sizeof(int) << "  " << sizeof(float) << "  " << sizeof(double) << "  " << sizeof(long) << "  " << sizeof(short) << "	
";
 7 
 8     system("pause");
 9     return 0;
10 }

3、const变量和const指针

(1)const普通变量

1 int const size；
2 const int size；

这两条语句都是把size声明为一个整数，他的值不能被修改。可以在声明的时候对他进行初始化：

1 const const size =10；

(2)const指针一：常量指针（此时常量是形容词，指针式名词，中心词是指针）

1 const int *p；  //定义指向只读变量的指针
2 int const *p;   //定义指向只读变量的指针

两者相同，p是一个指向只读变量的指针，可以p的指向，但不能修改*p。如下：

1 int b = 5；
2 int c = 3；
3 const int *p=&b；
4 *p=6；    //错误，不能通过指针修改所指向的值；
5 p=&c；    //正确，可以修改指针的值

(3)const指针二：指针常量（此时指针式形容词，常量是名词，中词词是常量）

1 int * const p；   //含义是常量指针，p的值不可以修改

p是一个只读指针，p的指向无法修改，但是可以修改*p。如下：

1 int b = 5；
2 int c = 3；
3 int *const p = &b;
4 *p = 6;  //正确，可以修改指针所值向的值
5 p =&c;   //错误，不可以修改指针的值

(4)const指针三

1 const  int * const p；

无论是p还是*p都不可以被修改

简单的判断的方法：

如果const在 * 的左侧，则const用来修饰指针所指向的变量，即指针指向位常量；
如果const位于 * 的右侧，则const就是修饰指针本身，即指针本身就是常量。

4、处理器字长和编写十六进制的unsigned int型变量时候应该注意的问题

解析：

对于十六位机器：

unsigned int compzero = 0xFFFF; //正确,一个F为4位,4个F即16位,所以对于16位机器来说是合适的

对于32位机器：

1 unsigned int compzero = 0xFFFFFFFF; //正确,一个F为4位,8个F即32位,所以对于32位机器来说是合适的

但unsigned int compzero = ~0;更安全，不管有多少位，直接取反，把所有的0都变成1了

5、malloc()参数为0出现的情况

《C语言参考手册》上说“如果请求的长度为0，则标准C语言函数返回一个null指针或不能用于访问对象的非null指针。”或者你也可以直接在linux里man malloc来查阅手册：

因此下面的输出是不确定的：

1 char *ptr;
2 if((ptr = (char *)malloc(0))==NULL)
3     puts("Got a null pointer");
4 else
5     puts("Got a valid pointer");

if是为了鉴别malloc()返回值是NULL，还是一个唯一的待释放指针，因此输出也不是确定的，尽管我用vs2017多次编译运行，输出都是"Got a valid pointer"。

 1 #include <iostream>
 2 using namespace std;
 3 int main()
 4 {
 5     char* p = (char*)malloc(0);
 6     if (p == NULL)
 7         cout << "Got a NULL pointer" << endl;
 8     else
 9         cout << "Got a valid pointer" << endl;
10 
11     cout << sizeof((char*)NULL) << endl;  //打印4
12     //cout << strlen((char*)NULL) << endl;  //会导致运行错误
13 
14     system("pause");
15     return 0;
16 }

View Code

将程序改成：

1 char *ptr=(char *)malloc(0));
2 if(int pp = (strlen(ptr) == 0)
3     puts("Got a null pointer");
4 else
5     puts("Got a valid pointer");

“==”优先级高于"="，所以if语句中其实是一个赋值语句，计入ptr是一个NULL指针，那么strlen(ptr)会导致程序在运行期间崩溃

再次修改程序：

1 char *ptr=(char *)malloc(0));
2 if(int pp = (sizeof(ptr) == 4)
3     puts("Got a null pointer");
4 else
5     puts("Got a valid pointer");

无论ptr是NULL指针还是待释放的指针，sizeof(ptr) == 4恒成立