定义宏#define DECLARE(name, type) type name##_##type##_type，
则DECLARE(val, int)替换结果为（）
则DECLARE(val, int)替换结果为（）
正确答案: A 你的答案: B (错误)
int val_int_type
int val_int_int
int name_int_int
int name_int_name
解析：##相当于强制分割，所以分成了 name,_,type,_type 所以答案显而易见了
以下数字在表示为double（8字节的双精度浮点数）时存在舍入误差的有（）。
正确答案: A B C 你的答案: A B (错误)
2的平方根
10的30次方
0.1
0.5
100
解析:小数看是否有误差的时候就是化为二进制，如果能够化开那就可以，如果不行的话那么就要舍入
下列运算符重载函数中，属于友元函数的是（ ）
正确答案: B C D 你的答案: C D (错误)
Base operator+(Base);
Base operator--(Base);
Base operator&&(Base, Base);
Base operator++(Base,int);
解析：看出是否是友元的话主要是看是否能够调用this指针，这样就会少传进一个参数，
下面关于"指针"的描述不正确的是()
正确答案: A 你的答案: C (错误)
当使用free释放掉一个指针内容后,指针变量的值被置为NULL
32位系统下任何类型指针的长度都是4个字节
指针的数据类型声明的是指针实际指向内容的数据类型
野指针是指向未分配或者已经释放的内存地址
解析：当free释放内存之后，指针还指向原来的那块地址，需要我们设置 p = NULL；如果不手动设置 p = NULL，此时P就变成了野指针
C++中关于堆和栈的说法，哪个是错误的:
正确答案: C 你的答案: D (错误)
堆的大小仅受操作系统的限制，栈的大小一般一般较小
在堆上频繁的调用new/delete容易产生内存碎片，栈没有这个问题
堆和栈都可以静态分配
堆和栈都可以动态分配
解析：选C，静态分配是指在编译阶段就能确定大小，由编译器进行分配，堆不可以进行静态分配，堆的申请都是在执行过程中进行的。
A，堆和栈的大小都可以设置，栈一般只有几KB。
B，堆在动态分配时，要申请连续的内存空间，释放后会产生碎片。
D，堆是使用malloc()、calloc()、realloc()等函数动态分配的，而使用alloca()函数可以动态分配栈的内存空间，释放的时候由编译器自己释放。
以下关于内联函数，说法正确的是：
正确答案: A B C 你的答案: A C (错误)
一般用于加快程序执行速度
可能减小可执行文件大小
可能增加可执行文件大小
以上说法都不正确
解析：AC选项不说了，直接说B选项。若这个函数被调用了一次，那么内联直接被插入到函数调用出，就直接没有了这个函数符号了，若加上优化，这一句代码可能会被优化没有，所以，可执行文件可能会减少。
Math.round(11.5) 等于多少 (). Math.round(-11.5) 等于多少 ( ).
正确答案: C 你的答案: A (错误)
11 ,-11
11 ,-12
12 ,-11
12 ,-12
解析：floor ： 意为地板，指向下取整，返回不大于它的最大整数 ceil ： 意为天花板，指向上取整，返回不小于它的最小整数 round ： 意为大约，表示“四舍五入”，
而四舍五入是往大数方向入。Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11而不是-12。
下面的程序输出可能是
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
class
Printer{
public
:
Printer(std::string name) {std::cout << name;}
};
class
Container{
public
:
Container() : b(
"b"
), a(
"a"
) {}
Printer a;
Printer b;
};
int
main(){
Container c;
return
0;
}
|
正确答案: C 你的答案: A (错误)
可能是 "ab" 或 "ba"。 依赖于具体的实现
一直都是 "ba"
一直都是 "ab"
解析：只和结构体定义的时候变量顺序有关
如下代码一共创建多少个进程（包含主进程）：
|
1
2
3
4
5
|
int
main(
int
argc,
char
* argv[]) {
fork();
fork() && fork() && fork();
fork() || fork();
}
|
正确答案: D 你的答案: B (错误)
15
18
21
24
解析：首先需要明白的是fork()生成1个子进程，fork()之后有两个进程处于执行状态。因此执行完第一个fork()，生成的进程数是1（main）+1（子进程）看第二行的fork() && fork() && fork()，
执行完第一个fork()，父进程返回非0，子进程返回0，子进程后面的fork()均不会执行，此时产生了1个子进程，那么三个fork()就产生了3个子进程（注意，这是1个进程产生的），
因此执行完第二行，产生了6个子进程，系统中一共有8个进程在执行，要是不明白的自己画个二叉树就清楚了。在看第三行，fork() || fork()，原理和第二行相同，只是只有子进程才能继续，
父进程只能执行第一个fork()，执行这一行每个进程可以产生两个子进程，也就是一***生2 * 8 = 16个子进程所以答案就是 2 + 6 + 16 = 24
请指出以下程序的错误：
void
GetMemory(
char
**p,
int
num)
{
if
(NULL==p && num<=
0
)
//1
return
;
*p=(
char
*)malloc(num);
return
;
}
void
main(
void
){
char
*str=NULL;
GetMemory(&str,
80
);
//2
if
(NULL!=str){
strcpy(&str,
"hello"
);
//3
printf(str);
}
return
true
;
//4
}
正确答案: A C D 你的答案: C D (错误)
1
2
3
4
解析： if(NULL==p && num<=0)//1 应该为 if(NULL==p || num<=0) strcpy(&str,"hello"); //3 应为 strcpy(str,"hello"); return true; //4 与void冲突
下面这个程序执行后会有什么错误或者效果:
#define MAX
255
int
main()
{
unsigned
char
A[MAX], i;
for
(i =
0
; i <= MAX; i++)
A[i] = i;
}
正确答案: A B 你的答案: A (错误)
数组越界
死循环
栈溢出
内存泄露
解析：这个问题能将面试者的能力分为三类；
一：没错。。。那么说明面试者的C语言基础能力不行；
二：有个错，是哪个i<=MAX; 数组下标越界。。嗯，还行；
三：死循环，C的基本功很强。。达到了该题的测试目的；
分析了一下：
出现了两个问题;
一：下标越界可以说是个问题，但不是问题的本质； 当i=MAX；即i=MAX是，对数组来说，255是越界了，那如果我把数组下标改了是不是就对了呢？比如说如下：
#include <stdio.h>
#define MAX 255
int main() {
unsigned char a[256],i;//这里改成256是不是就对了呢？ 还是不对；
for(i=0;i< =MAX;i++)
a[i]=i;
for(i=0;i< =MAX;i++)
printf("%d ",a[i]);
}
其实越界了编译还是能通过的，因为编译器不检查越界问题；
问题二： 上例还是错的，原因在于unsigned char 这个数据类型，它占了 8位，表示范围是 0~255（00000000~11111111，八位）； 当改成256后，虽说看似数组下标没越界，但是当i=255; i++ ；因为 i本身是unsigned char类型，占8位，所以此时i+1变成了100000000 9位，又因为i只能占8位，所以舍掉了最高位，此时的i值又变成00000000了，即就是0；然后就成了死循环了。。。