计算机网络--错题集

1、FTP服务和SMTP服务的端口默认分别是()

20，21与25

1、HTTP：使用80端口。

HTTP属于超文本传输协议，所有的WWW文件都必须遵守这个标准，HTTP是一个客户端和服务器端请求和应答的标准（TCP），客户端是终端用户，服务器端是网站，通过使用Web浏览器、网络爬虫或者其它的工具，客户端发起一个到服务器上指定端口（默认端口为80）的HTTP请求。

2、FTP：使用20/21端口。

主要是用来传输文件，比如建站常常用来上传主页或者下载文件进行修改，FTP是一个8位的客户端-服务器协议，能操作任何类型的文件而不需要进一步处理，就像MIME或Unicode一样。但是，FTP有着极高的延时，这意味着，从开始请求到第一次接收需求数据之间的时间，会非常长。

3、SMTP：使用25端口。

SMTP定义了简单邮件传送协议，现在很多邮件服务器都用的是这个协议，用于发送邮件。如常见的免费邮件服务中用的就是这个邮件服务端口。

4、TELNET：使用23端口。

Telnet它是一种用于远程登陆的端口，用户可以以自己的身份远程连接到计算机上，通过这种端口可以提供一种基于DOS模式下的通信服务。

5、NTP：使用UDP123端口

NTP基于UDP报文进行传输，使用的UDP端口号为123；报文48字节

发送时只写第1个字节即可， 闰秒标识器（00）+版本号（000~111）+客户端模式（011）：第一个字节以0xa3（版本4） 、0x1b, （版本3）、0x13（版本2） 、0x0b（版本1）

接受时第个字节比发送时+1，闰秒标识器（00）+版本号（000~111）+服务器模式（100）：第一个字节以0xa4（版本4） 、0x1c, （版本3）、0x14（版本2） 、0x0c（版本1），返回的数据中带有4个时间戳，如果精度要求不高，直接采用最后一个时间戳即可。

64位时间戳：前32位表示从1900年到目前为止所有秒数的整数部分，后32位是小数部分，若精度要求不高，直接取整数部分32位即可。
time_t：是一个32位无符号整数类型，但该类型的数据均代表从2000年1月1日0点0分起开始计时的秒数。

struct tm      *localtime(const time_t * timer);
/* time.h文件中的localtime函数，将秒计数值转换为当前的时间 */

temp=(u32)(Second>>32);
	temp-=NTP_TIMESTAMP_DELTA;					//减去1900->1970年的秒数，得到的起点是1970年
	temp+=SEC_TIME_ZONE;								//加上时区补偿秒数
	Net_time = localtime(&temp); 			//格式转变
	
				time[0]=Net_time->tm_year+1900-2000;//得到年数的十位、个位
				time[1]=Net_time->tm_mon+1;
				time[2]=Net_time->tm_mday;
				time[3]=Net_time->tm_hour;
				time[4]=Net_time->tm_min;
				time[5]=Net_time->tm_sec;

LI 闰秒标识器，占用2个bit
VN 版本号，占用3个bits，表示NTP的版本号，现在为3
Mode 模式，占用3个bits，表示模式
stratum（层），占用8个bits
Poll 测试间隔，占用8个bits，表示连续信息之间的最大间隔
Precision 精度，占用8个bits，，表示本地时钟精度
Root Delay根时延，占用8个bits，表示在主参考源之间往返的总共时延
Root Dispersion根离散，占用8个bits，表示在主参考源有关的名义错误
Reference Identifier参考时钟标识符，占用8个bits，用来标识特殊的参考源

Reference Timestamp：系统时钟最后一次被设定或更新的时间。
Originate Timestamp：NTP请求报文离开发送端时发送端的本地时间。
Receive Timestamp：NTP请求报文到达接收端时接收端的本地时间。
Transmit Timestamp：应答报文离开应答者时应答者的本地时间。

Authenticator：验证信息。

2、有一个如下的结构体：请问在64位编译器下用sizeof(struct A)计算出的大小是多少?

8+2+（2+4）+8=24

struct A{
	long a1;		//8
	short a2;		//2，前面8，是2的整数倍，不需要补齐，直接填入a2
	int a3;			//4，前面10，先补齐12，再填入a3
	int *a4;		//8，前面16，是8的整数不，不需要补齐，直接填入a4
					// 结尾，总长24，是最长数据类型8的整数倍，尾部不需要补齐。
};

编译器不同，宽度是不相同，分别如下：
short 至少16位，int至少与short一样长，long至少32位，且至少和int一样长，long long至少64位，且至少与long一样长
//—64位编译器—//
char ：1个字节
char*(即指针变量): 8个字节

short int : 2个字节
int： 4个字节
unsigned int : 4个字节

float: 4个字节
double: 8个字节

long: （Linux64位系统是8字节）
long long: 8个字节
unsigned long: 8个字节

//—32位编译器—//（看这里就行了，与16位机，64位机比较，粗体为不同的，其余的都是相同）
char ：1个字节
char（即指针变量）*: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）（16位机，32位机，64位机各不相同）

short int : 2个字节
int： 4个字节（16位机是2B，32位&64位是4B）
unsigned int : 4个字节（16位机是2B,32位&64位是4B）

float: 4个字节
double: 8个字节

long: 4个字节
long long: 8个字节
unsigned long: 4个字节（16&32位是4B,64位是8B）

3、在一个10阶的B-树上，每个树根结点中所含的关键字数目最多允许为( )个，最少允许为( )个

9，4。因为M阶B树（等同B-树）的孩子节点个数为[M/2,M]小数向上取整。而关键字个数=孩子数-1

4、操作系统采用缓冲技术,通过减少对CPU的()次数,提高资源的利用率

中断
引入缓冲的主要原因包括：缓和CPU与I/O设备间速度不匹配的矛盾；减少对CPU的中断频率，放宽对中断时间的限制；提高CPU和I/O设备之间的并行性。所以采用缓冲技术，可减少对CPU的中断次数，从而提高系统效率。

5、ls会引起哪些系统调用

execve、open、read
…

jw@pc:~/w$ strace ls .
execve("/bin/ls", ["ls", "."], 0x7ffd4c677808 /* 63 vars */) = 0
brk(NULL)                               = 0x55e5088c7000
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
access("/etc/ld.so.preload", R_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/etc/ld.so.cache", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=74466, ...}) = 0
mmap(NULL, 74466, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fc619ef9000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libselinux.so.1", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\20b\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0644, st_size=154832, ...}) = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fc619ef7000
mmap(NULL, 2259152, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fc619abd000
mprotect(0x7fc619ae2000, 2093056, PROT_NONE) = 0
mmap(0x7fc619ce1000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x24000) = 0x7fc619ce1000
mmap(0x7fc619ce3000, 6352, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fc619ce3000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libc.so.6", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\3\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0\260\34\2\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=2030544, ...}) = 0
mmap(NULL, 4131552, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fc6196cc000
mprotect(0x7fc6198b3000, 2097152, PROT_NONE) = 0
mmap(0x7fc619ab3000, 24576, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x1e7000) = 0x7fc619ab3000
mmap(0x7fc619ab9000, 15072, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fc619ab9000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpcre.so.3", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0 \25\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0644, st_size=464824, ...}) = 0
mmap(NULL, 2560264, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fc61945a000
mprotect(0x7fc6194ca000, 2097152, PROT_NONE) = 0
mmap(0x7fc6196ca000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x70000) = 0x7fc6196ca000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libdl.so.2", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0P\16\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0644, st_size=14560, ...}) = 0
mmap(NULL, 2109712, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fc619256000
mprotect(0x7fc619259000, 2093056, PROT_NONE) = 0
mmap(0x7fc619458000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x2000) = 0x7fc619458000
close(3)                                = 0
access("/etc/ld.so.nohwcap", F_OK)      = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/lib/x86_64-linux-gnu/libpthread.so.0", O_RDONLY|O_CLOEXEC) = 3
read(3, "\177ELF\2\1\1\0\0\0\0\0\0\0\0\0\3\0>\0\1\0\0\0000b\0\0\0\0\0\0"..., 832) = 832
fstat(3, {st_mode=S_IFREG|0755, st_size=144976, ...}) = 0
mmap(NULL, 2221184, PROT_READ|PROT_EXEC, MAP_PRIVATE|MAP_DENYWRITE, 3, 0) = 0x7fc619037000
mprotect(0x7fc619051000, 2093056, PROT_NONE) = 0
mmap(0x7fc619250000, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_DENYWRITE, 3, 0x19000) = 0x7fc619250000
mmap(0x7fc619252000, 13440, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) = 0x7fc619252000
close(3)                                = 0
mmap(NULL, 8192, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0) = 0x7fc619ef5000
arch_prctl(ARCH_SET_FS, 0x7fc619ef6040) = 0
mprotect(0x7fc619ab3000, 16384, PROT_READ) = 0
mprotect(0x7fc619250000, 4096, PROT_READ) = 0
mprotect(0x7fc619458000, 4096, PROT_READ) = 0
mprotect(0x7fc6196ca000, 4096, PROT_READ) = 0
mprotect(0x7fc619ce1000, 4096, PROT_READ) = 0
mprotect(0x55e50876c000, 8192, PROT_READ) = 0
mprotect(0x7fc619f0c000, 4096, PROT_READ) = 0
munmap(0x7fc619ef9000, 74466)           = 0
set_tid_address(0x7fc619ef6310)         = 8782
set_robust_list(0x7fc619ef6320, 24)     = 0
rt_sigaction(SIGRTMIN, {sa_handler=0x7fc61903ccb0, sa_mask=[], sa_flags=SA_RESTORER|SA_SIGINFO, sa_restorer=0x7fc619049890}, NULL, 8) = 0
rt_sigaction(SIGRT_1, {sa_handler=0x7fc61903cd50, sa_mask=[], sa_flags=SA_RESTORER|SA_RESTART|SA_SIGINFO, sa_restorer=0x7fc619049890}, NULL, 8) = 0
rt_sigprocmask(SIG_UNBLOCK, [RTMIN RT_1], NULL, 8) = 0
prlimit64(0, RLIMIT_STACK, NULL, {rlim_cur=8192*1024, rlim_max=RLIM64_INFINITY}) = 0
statfs("/sys/fs/selinux", 0x7ffe7cb6d170) = -1 ENOENT (No such file or directory)
statfs("/selinux", 0x7ffe7cb6d170)      = -1 ENOENT (No such file or directory)
brk(NULL)                               = 0x55e5088c7000
brk(0x55e5088e8000)                     = 0x55e5088e8000
openat(AT_FDCWD, "/proc/filesystems", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0444, st_size=0, ...}) = 0
read(3, "nodev\tsysfs\nnodev\ttmpfs\nnodev\tbd"..., 1024) = 369
read(3, "", 1024)                       = 0
close(3)                                = 0
access("/etc/selinux/config", F_OK)     = -1 ENOENT (No such file or directory)
openat(AT_FDCWD, "/usr/lib/locale/locale-archive", O_RDONLY|O_CLOEXEC) = 3
fstat(3, {st_mode=S_IFREG|0644, st_size=10281936, ...}) = 0
mmap(NULL, 10281936, PROT_READ, MAP_PRIVATE, 3, 0) = 0x7fc618668000
close(3)                                = 0
ioctl(1, TCGETS, {B38400 opost isig icanon echo ...}) = 0
ioctl(1, TIOCGWINSZ, {ws_row=28, ws_col=79, ws_xpixel=0, ws_ypixel=0}) = 0
stat(".", {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
openat(AT_FDCWD, ".", O_RDONLY|O_NONBLOCK|O_CLOEXEC|O_DIRECTORY) = 3
fstat(3, {st_mode=S_IFDIR|0755, st_size=4096, ...}) = 0
getdents(3, /* 3 entries */, 32768)     = 80
getdents(3, /* 0 entries */, 32768)     = 0
close(3)                                = 0
fstat(1, {st_mode=S_IFCHR|0620, st_rdev=makedev(136, 0), ...}) = 0
write(1, "ls.txt\n", 7ls.txt
)                 = 7
close(1)                                = 0
close(2)                                = 0
exit_group(0)                           = ?
+++ exited with 0 +++

6、简述嵌入式系统的定义、应用和特点?

答：嵌入式系统定义：以应用为中心，以计算机技术为基础，其软硬件可裁剪配置，对功能、可靠性、成本、体积、功耗有严格约束的一种专用计算机系统。
嵌入式系统应用：应用于军事设备、信息终端、汽车电子、制造工业、航天航空等领域。
嵌入式系统特点：专用性、可裁性、实时性好、可靠性高、功耗低。

7、结构体struct与union区别？struct与class区别？

struct与union：
   最大的区别在于内存利用。 struct各成员各自拥有自己的内存，各自使用互不干涉，同时存在的，遵循内存对齐原则。一个struct变量的总长度等于所有成员的长度之和。union 各成员共用一块内存空间，并且同时只有一个成员可以得到这块内存的使用权(对该内存的读写)，各变量共用一个内存首地址。
struct与class：
   C++中struct与class关键字一般可以通用，只有一个很小的差别。struct成员默认属性是public，而class默认为private。

8、结构体使用需要注意什么？

字节对齐，需要字节对齐的根本原因在于CPU访问数据的效率问题。
如果一个int型（假设为32位系统）如果存放在0x00000004，那它就是自然对齐的。

如果变量在0x00000002，则CPU如果取它的值的话需要访问两次内存，第一次取从0x00000002-0x00000003的一个short，第二次取从0x00000004-0x00000005的一个short然后组合得到所要的数据。

如果变量在0x00000003地址上的话则要访问三次内存，第一次为char，第二次为short，第三次为char，然后组合得到整型数据。而如果变量在自然对齐位置上，则只要一次就可以取出数据。

规则一：结构体中元素按照定义顺序依次置于内存中，但并不是紧密排列。从结构体首地址开始依次将元素放入内存时，元素会被放置在其自身对齐大小的整数倍地址上。

struct A{
     int a;
     double b;
     float c;
    };

struct B{
     char e[2];
     int f;
     double g;
     short h;
     struct A i;
    };

       sizeof(A) = 24; 这个比较好理解，int为4，double为8，float为4，总长为8的倍数，补齐，所以整个A为24。
       sizeof(B) = 48; 看看B的内存布局。
            e         f       g         h                         i 
B的内存布局：11* *,   1111,   11111111, 11 * * * * * *,        1111* * * *, 11111111, 1111 * * * *

i其实就是A的内存布局。i的起始位置要为24的倍数，所以h后面要补齐。

我们可以按照自己设定的对齐大小来编译程序，GNU使用__attribute__选项来设置，比如我们想让刚才的结构按一字节对齐，我们可以这样定义结构体

struct stu{
　　 char sex;
　　 int length;
　　 char name[10];
}__attribute__ ((aligned (1)));
struct stu my_stu;

则sizeof(my_stu)可以得到大小为15。

9、有一个函数，这个函数是在中断和主程序都有调用，请问这个函数有什么要求？

引发的问题：
①结果改变。此函数不是一个可重入函数，而当此函数已经在执行时它可能被另一个ISR所调用。这样就会导致结果是可变的而且很可能会导致一些参数的错误。
②内存错误。如果函数中执行malloc时被中断所调用又开始执行malloc。这会引起某些内存错误。
解决办法：
使此函数可重入

• 1）在写函数时候尽量使用局部变量（例如寄存器、堆栈中的变量）；

• 2）对于要使用的全局变量要加以保护（如采取关中断、信号量等互斥方法），这样构成的函数就一定是一个可重入的函数。

10、volatile和const可以同时使用么？这两个组合在什么情况下使用？

可以同时使用，例如只读的状态寄存器。

11、描述内存分配方式及它们的区别？

（1）静态存储区分配。内存在程序编译时已分配好，在整个运行器件都存在。
（2）栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动释放。
（3）堆上分配。动态内存分配生存期由程序员决定。

12、解释下位域，为什么要用位域，位域的好处？

在计算机中，有些信息存储时并不需要占用一个完整的字节，而只需占用一个或几个二进制位。比如在存放一个只有0和1两种状态的开关量时，用一位二进制位即可表示。因此，为了节省存储空间，C语言提供了一种称为“位域”的数据结构来充分利用存储空间。

struct k     
{     
	int a:1     
	int :2 		 /*该2位不能使用*/     
	int b:20     /* 拼接在前面的int类型中 */
	int c:16     /* 32位int不够了，重新开一个int，所以该结构体长度8 */
};  

13、const

const int* p; //p可变，p指向的内容不可变
int* const p; //p不可变，p指向的内容可变
int const* p; //p可变，p指向的内容不可变
const int* const p; // p和p指向的内容都不可变

14、typedef和#define 的区别？

#define只是简单的文本替换，在预处理的时候就被展开了，容易出错。
typedef会声明一种新的类型，等同自带的基本类型，是类型安全的。

15、bootloader经过哪些过程？

BL0----------------------> BL1 -->BL2-------> Linux kernel --> file system --> application
系统启动RomBoot --> SPL --> u-boot --> Linux kernel --> file system --> start application
bootloader的启动过程：
第一阶段：
   ① 设置CPU工作模式svc特权模式
   ② 关闭MMU和cache
   ③ 关看门狗
   ④ 屏蔽中断(防止程序跑飞)
   ⑤ 初始化时钟
   ⑥ 初始化RAM，为第二阶段做准备（非必须，例如对于NOR Flash可以直接在上面执行）
   ⑦ 设置栈，第二阶段是C程序
   ⑧ 拷贝第二阶段到RAM
   ⑨ 跳转到第二阶段的程序入口
第二阶段：
   ① 硬件初始化，时钟、串口、网卡、LED灯…
   ② 检测系统内存映射(memory map)
   ③ 将内核映像和根文件系统映像从Flash上读到RAM空间中。
   ④ 为内核设置启动参数。
   ⑤ 拷贝dtb（设备树）到RAM空间中。
   ⑥ 启动内核
   
Cache和MMU的设置
MMU和Cache必须必须关闭，指令Cache可以打开也可以关闭。
由于MMU在上电之初是没有任何作用的，也就是说U-boo第一阶段的汇编代码以及第二阶段的源代码初始化相关外设时访问的都是都是实际地址，MMU起不到任何作用，为了启动之初不影响对程序的启动常关闭MMU。

Cache是位于RAM和CPU内部寄存器之间的一个存储设施，用来加速二者之间的数据传输速度，即用来加快CPU从内存中取出指令的速度。但是在上电后CPU的初始化要比内存RAM更快一步，当CPU初始化完成后，若内存还没有准备好那势必会造成异常。

15、uboot怎么传参给内核的？

简单的讲，uboot利用函数指针及传参规范，它将
R0: 0x0
R1: 机器号
R2: 参数地址
三个参数传递给内核。
其中，R2寄存器传递的是一个指针，这个指针指向一个TAG区域。

16、有如下程序段，请问运行Test函数结果是：

程序崩溃

void GetMemeory(char* p)
{
    p = (char*) malloc (100);
｝
void test()
{
    char *str=NULL;
    GetMemory(str);
    strcpy(str,”Thunder”);
    strcat(str+2, “Downloader”);
    printf(str);
}

因为调用GetMemory(str);时只传入了str内容的副本。而不是str的地址，因此str仍然为NULL。

换个角度理解，void GetMemeory(char* p)函数内部操作的都是局部变量，函数结束后局部变量都被回收，不会对外部的str变量造成任何改变。

所以执行strcpy(str,”Thunder”);程序崩溃

17、两个等价线程并发的执行下列程序，a为全局变量，初始为0，假设printf、++、–操作都是原子性的，则输出肯定不是哪个？

原子性；单次执行没有循环，因此只有初值为0的情况。

void foo() {
    if(a <= 0) {
        a++;
    }
    else {
        a--;
    }
    printf("%d", a);
}

A、01
B、10
C、12
D、22

A、如果要第一个值输出0，线程1进入判断并实现++，线程2此时进入判断实现–，a=0，两个线程下一句都是print，结果将是00；
B、线程1判断，执行++，打印1，线程2判断，执行–，打印0，结果10；
C、线程1进入判断，线程2进入判断，线程1执行++，打印1，线程2执行++，打印2，结果12；
D、线程1进入判断，线程2进入判断，线程1执行++，线程2执行++，各自打印出2，结果22。

18、若从键盘输入：abc def， 则输出结果是

char *p, *q;
p = (char*) malloc(sizeof(char) * 20);
q = p;
scanf(“%s %s”, p, q);
printf(“%s %s\n”, p, q);

def def

19、下面有关c++线程安全，说法错误的是？

A、线程安全问题都是由全局变量及静态变量引起的
B、若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全
C、c++标准库里面的string保证是线程安全的
D、POSIX线程标准要求C标准库中的大多数函数具备线程安全性

• C：因为标准库里面的string在多线程下并不保证是都是安全的，只提供两种安全机制：
  1.多个线程同时读取数据是安全的。
  2.只有一个线程在写数据是安全的。

20、volatile能保证全局整形变量是多线程安全的么？

不能。 volatile仅仅是告诫compiler不要对这个变量作优化，每次都要从memory取数值，而不是从register读取。

21、下列选项中，会导致用户进程从用户态切换到内核的操作是?

I. 整数除以零
II. sin( )函数调用
III. read系统调用

用户态切换到内核态的 3 种方式
a. 系统调用
b. 异常
c. 外围设备的中断

所以答案是：
I. 异常
III. 系统调用

21、如果系统的umask设置为244，创建一个新文件后，它的权限：（）

–w-r–r--
-r-xr–r--
-r—w–w-
-r-x-wx-wx
umask是从权限中“拿走”相应的位,且文件创建时不能赋予执行权限.
创建时，文件 默认666，目录默认777，减去umask的位就是结果。
666-244=422（-r—w–w-）

22、分析下面代码有什么问题？

void test1()
{
 char string[10];
 char* str1 = "0123456789";
 strcpy( string, str1 );
}

代码有数组越界的问题，如果将str1拷贝到string中，string的长度会增加，并且也可以正确的输出string。
但是存在潜在的危险，string定义的长度是10，而拷入str1之后string的长度增为11，也就是说，在内存中，如果紧接string之后有内容，将被覆盖，这样会导致string之后的内存存取错误。

23、设int a=3,b=5,执行表达式m=a<=3&&a+b<8后，m的值为（）

m=((a<=3) && ((a+b)<8))=0
简单记就是：！ > 算术运算符 > 关系运算符 > && > || > 赋值运算符

24、对于继承方式和可见性，下面哪一种说法是错误的？

• A、继承方式有3种选择：私有、公有和保护，继承方式决定了基类成员在派生类中的可见性
• B、默认为私有继承，但常用的却是公有继承
• C、无论哪一种继承方式，派生类中都不能访问其基类中的私有成员，但能访问基类中的保护成员和公有成员
• D、在公有继承方式中，派生类没有继承基类的私有成员

选D
公有继承意味着继承派生类的类能访问基类的公有和保护成员。
私有继承意味着继承派生类的类也不能访问基类的成员。如果一个派生类要访问基类中声明的私有成员，可以将这个派生类声明为友元。
保护继承意味着继承派生类的类能访问基类的公有和保护方法。

公有继承时，同样继承了基类的私有成员**，对基类的公有成员和保护成员的访问属性不变，派生类的新增成员可以访问基类的公有成员和保护成员，但是访问不了基类的私有成员。派生类的对象只能访问派生类的公有成员（包括继承的公有成员），访问不了保护成员和私有成员。

24、C语言中， 32768 是不正确的 int 类型常数。请问这句话的说法是正确的吗？

错误

考察C语言中int类型的常数的范围。

• ①int的取值范围依赖于计算机系统：

在16位机器中，int占16位，是两个字节，取值范围为前面所说的-32768～32767（-2^16～216-1）。此时题中表述是正确的。
在32位和64位机器中，int占32位，即4个字节长度，取值范围为-2147483648～2147483647（-2^32～232-1）。此时题中表述是错误的。

• ②int的取值范围也和语言标准有关：

ISO/ANSI C规定，int类型的最小范围为-32768到32767。因此int类型常数的范围不限于-32768到32767，可以得到题中表述是错误的。
在C++官网中给出的C99标准中的宏定义，int类型的范围为-32767到32767。

25、关于对象成员的访问，下面哪一种说法是错误的？

• A、对于一个对象，可用“．”运算符来访问其成员
• B、对于一个对象引用，可用“一>”运算符来访问其成员
• C、如果被访问成员是公有的，该访问表达式可以出现在main函数中
• D、如果被访问成员是私有的，该访问表达式只能出现在类中

本题选B和D
B对于一个对象引用，也是用“.”运算符来访问其成员
D如果类A把类B声明为自己的友元类，那么在类B中的所有函数中都可以访问类A的私有和保护成员。

26、对于默认构造函数，下面哪一种说法是错误的？

• A、一个无参构造函数是默认构造函数
• B、只有当类中没有显式定义任何构造函数时，编译器才自动生成一个公有的默认构造函数
• C、默认构造函数一定是一个无参构造函数
• D、一个类中最多只能有一个默认构造函数

本题选C。考察对C++构造函数的理解。
A选项，无参构造函数一定是默认构造函数，正确。
B选项，当类中没有显式定义任何构造函数时，编译器自动生成一个公有的默认构造函数。如果一个类显式地声明了任何构造函数，编译器不生成公有的默认构造函数。在这种情况下，如果程序需要一个默认构造函数，需要由类的设计者提供。正确。
C选项，无参构造函数一定是默认构造函数, 而默认构造函数可能是无参构造函数,也可能是所有参数都有默认值的构造函数。容易遗漏参数缺省时还可以预设默认值的机制！因此C选项错误。
D选项，一个类只能有一个默认构造函数，一般选择 testClass(); 这种形式的默认构造函数 ，因此D选项描述正确。

class Sample {
public:
    /* 默认构造函数。虽然有形参，但有默认值，
     * 调用的时候可以不显示的传入实参。 */
    Sample(int m = 10) {
        // do something
    }
};

27、简述浏览器访问一个网页的过程？

当我们在浏览器中输入一个网址，比如www.google.cn，浏览器就会加载出百度的主页。那么浏览器背后完成的具体是怎么样的呢？
总结起来大概的流程是这样的：

• （1）浏览器本身是一个客户端，当你输入URL的时候，首先浏览器会去请求DNS服务器，通过DNS获取相应的域名对应的IP
• （2）然后通过IP地址找到IP对应的服务器后，要求建立TCP连接
• （3）浏览器发送完HTTP Request（请求）包后，服务器接收到请求包之后才开始处理请求包
• （4）在服务器收到请求之后，服务器调用自身服务，返回HTTP Response（响应）包
• （5）客户端收到来自服务器的响应后开始渲染这个Response包里的主体（body），等收到全部的内容随后断开与该服务器之间的TCP连接。

28、在使用 IP 地址时，如果网络号和主机号全1时，则表示（ ）

• A、源地址可以使用，目的地址不可以使用，只在本网络进行广播
• B、源地址不可以使用，目的地址可以使用，只在本网络进行广播
• C、源地址可以使用，目的地址也可以使用，只在本网络进行广播
• D、源地址和目的地址都不可以使用，各路由器可以对广播进行转发

全1的地址只在本网络上进行广播。目的地址为全1代表的是本机所在网络的全部主机。
源地址不能用全1的地址，因为如果用的话无法知晓数据报究竟是哪台主机发送来的。
在IP地址中全1的地址表示仅在本网络上（就是发送这个IP数据报的主机所连接的局域网）进行广播，这种广播也叫受限的广播。而不是向整个因特网进行广播，假设如果真的是向整个因特网进行广播，那么一定会在网络上产生巨大的通信量，会严重影响因特网的正常工作。
因此本题选B

28、共有4个站进行码分多址通信。4个站的码片序列为

A：（－1－1－1＋1＋1－1＋1＋1）B：（－1－1＋1－1＋1＋1＋1－1）

C：（－1＋1－1＋1＋1＋1－1－1）D：（－1＋1－1－1－1－1＋1－1）

现收到这样的码片序列S：（－1＋1－3＋1－1－3＋1＋1）。问哪个站发送数据了？发送数据的站发送的是0还是1？

由题设存在：
a(-1,-1,-1,1,1,-1,1,-1)+b(-1,-1,1,-1,1,1,1,-1)+c(-1,1,-1,1,1,1,-1,-1)+d(-1,1,-1,-1,-1,1,-1)=(-1,1,-3,1,-1,-3,1,1);

其中a、b、c、d取值都在-1,0,1之中，则：

①：-a-b-c-d=-1

②：-a-b+c+d=1

③：-a+b-c-d=-3

④：a-b+c-d=1

联立求解可得：a=1,b=-1,c=0,d=1

因此可知A和D发送了1，B发送了0，C没有发送数据！

29、计算机网络通信的一个显著特点是（ ）

• A 稳定性
• B 间歇性、突发性
• C 安全性
• D 易用性

B；《网络工程师教程》第三版11页有答案。选择B：“间歇性和突发性”。当用户坐在终端前思考时候，间歇。用户发送信息，突发。

30、122.171.2.254 属于哪一类 IP 地址 ( )

• A类 0.0.0.0-127.255.255.255（ 255 - 128 = 127）
• B类128.0.0.0-191.255.255.255（ 255 - 64 = 191）
• C类192.0.0.0-223.255.255.255（ 255 - 32 = 223）
• D类224.0.0.0-239.255.255.255（255 - 16 = 239）
• E类240.0.0.0-255.255.255.255
  

31、RARP的作用是（ ）

• A、将自己的IP地址转换为MAC地址
• B、将对方的IP地址转换为MAC地址
• C、将对方的MAC地址转换为IP地址
• D、知道自己的MAC地址，通过RARP协议得到自己的IP地址

D

ARP和RARP都是工作在网络层，具体场合如下：

• ARP即地址解析协议，是根据IP地址获取物理地址的一个TCP/IP协议。主机发送信息时将包含目标IP地址的ARP请求广播到网络上的所有主机，并接收返回消息，以此确定目标的物理地址；收到返回消息后将该IP地址和物理地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。地址解析协议是建立在网络中各个主机互相信任的基础上的，网络上的主机可以自主发送ARP应答消息，其他主机收到应答报文时不会检测该报文的真实性就会将其记入本机ARP缓存；由此攻击者就可以向某一主机发送伪ARP应答报文，使其发送的信息无法到达预期的主机或到达错误的主机，这就构成了一个ARP欺骗。ARP命令可用于查询本机ARP缓存中IP地址和MAC地址的对应关系、添加或删除静态对应关系等。
• RARP反向地址转换协议，允许局域网的物理机器从网关服务器的 ARP 表或者缓存上请求其 IP 地址。网络管理员在局域网网关路由器里创建一个表以映射物理地址（MAC）和与其对应的 IP 地址。当设置一台新的机器时，其 RARP 客户机程序需要向路由器上的 RARP 服务器请求相应的 IP 地址。假设在路由表中已经设置了一个记录，RARP 服务器将会返回 IP 地址给机器，此机器就会存储起来以便日后使用。 RARP 可以使用于以太网、光纤分布式数据接口及令牌环。

32、C类地址最大可能子网位数是（ ）

答案是6位 ，C类IP地址网络号24位，本地主机号8位。开辟子网需要占用本地主机号的位置，原本是8位，那如果子网位是7位，11111110, 本地主机位只有1位，意味着这个子网只有两个IP地址，其中一个是网络地址，另一个是广播地址，无实际使用价值。所以C类地址最大可能的子网位数是6位。

33、UDP使用（ ）提供可靠性

网际协议
应用层协议
网络层协议
传输控制

UDP本身不提供可靠性，可以在应用层上加一些ACK之类的可靠性机制

34、以太网的协议结构包括（ ）。

物理层、数据链路层和网络层
物理层、LLC子层和MAC子层
只有LLC子层和MAC子层
只有物理层

答案B
以太网的协议结构包括理层、数据链路层
数据链路层分层为逻辑链路控制子层（LLC）和媒体访问控制子层(MAC)。不同的物理层对应不同的MAC子层，LLC子层则完全独立。

35、某网络的IP地址空间为202.38.195.200/22，则该网络的网络地址为（ ).

202.38.192.0
202.38.193.0
202.38.194.0
202.38.195.0

IP地址由两部分构成：网络地址+主机地址。网络地址即我们常说的网段，主机地址就是唯一确定了你在此网段内使用的IP，一个网段内可以有多台主机。
下面讲下怎么求网络地址（网段），求网络地址必须要知道子网掩码，题目给出的是255.255.252.0。将子网掩码与题目中给出的IP地址做与运算（&）即得出网络地址：
202.38.195.200 & 255.255.252.0
答案为：202.38.192.0，即A选项

36、在一个IP数据包到达目的地之前，可能发生很多的情况，以下哪个说法是正确的（）？

不能成为碎片或者重组
不能成为碎片，但是会重组
可能成为碎片或者重组
可能成为碎片，但是不会重组

答案D，ip数据包到达目的地才能重组