C语言笔试题常见错误

1 对sizeof 的理解：

例子1：

void main()

{

int a = 2;

int b = ++a+++a;

sizeof(++a+++a);

}

执行完后b的值变多少？a的值为多少？

答：首先搞明白sizeof只是表示一个运算法，（）内的东西在编译前已经确定，相当于与没有执行。b的值等于8.a的值为4.

2 对结构体组成的考察：

已知 WAV 文件格式如下表，打开一个 WAV 文件，以适当的数据结构组织 WAV 文件头并解析 WAV格式的各项信息。
WAVE 文件格式说明表
偏移地址  字节数  数据类型  内   容
00H  4  Char  "RIFF"标志
04H  4  int32  文件长度
08H  4  Char  "WAVE"标志
0CH  4  Char  "fmt"标志
10H  4    过渡字节（不定）
14H  2  int16  格式类别
16H  2  int16  通道数
18H  2  int16  采样率（每秒样本数），表示每个通道的播放速度
1CH  4  int32  波形音频数据传送速率
20H  2  int16  数据块的调整数（按字节算的）
22H  2    每样本的数据位数
24H  4  Char  数据标记符＂data＂
28H  4  int32  语音数据的长度

解答：
将 WAV 文件格式定义为结构体 WAVEFORMAT：

typedef struct tagWaveFormat

{

char cRiffFlag[4];

UIN32 nFileLen;

char cWaveFlag[4];

char cFmtFlag[4];

char cTransition[4];

UINT16 nFormatTag;

UIN16 nChannels;

UIN16 nSamplesPerSec;

UIN32 nAvgBytesperSec;

UIN16 nBlockAlign;

UIN16 nBitNumPerSample;

char cDataFlag[4];

IN16 nAudioLength;

}WAVEFORMAT;

假设 WAV 文件内容读出后存放在指针 buffer 开始的内存单元内，则分析文件格式的代码很简单，为：
WAVEFORMAT waveFormat;
memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );
直接通过访问 waveFormat 的成员，就可以获得特定 WAV 文件的各项格式信息。

3 试题写一个函数返回 1+2+3+…+n 的值（假定结果不会超过长整型变量的范围）

解答：
int Sum( int n )
{
return ((long)1 + n) * n / 2; //或 return (1l + n) * n / 2;
}
剖析：
对于这个题，只能说，也许最简单的答案就是最好的答案。下面的解答，或者基于下面的解答思路去优化，不管怎么“折腾”，其效率也不可能与直接 return ( 1 l + n ) * n / 2 相比！

int Sum( int n )
{
  long sum = 0;
  for( int i=1; i<=n; i++ )
  {
   sum += i;
  }
  return sum;
}

所以程序员们需要敏感地将数学等知识用在程序设计中。注意long型变量与int变量所占字节是一样的.

4 对于一个字节（8bit）的数据，求其中“1”的个数，要求算法的执行效率尽可能地高。

下面给出两个标准答案：

1方法使用位操作
#include <stdio.h>
#define BYTE unsigned char
int main(int argc, char *argv[])
{
  int i, num = 0;
  BYTE a;

  printf("\nPlease Input a BYTE(0~255):");
  scanf("%d", &a);

  for (i = 0; i < 8; i++)
  {
    num += (a >> i) &0x01;
  }

  printf("\nthe num of 1 in the BYTE is %d", num);
  return 0;
}

看清题目的要求，人家是让尽快的完成，可以以空间换时间达到高效率的目的。

方法2：

方法 4：直接得到结果
#include
#define BYTE unsigned char

BYTE numTable[256] =
{
  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3,
    3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3,
    4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,
    3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3,
    4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6,
    6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4,
    5, 3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3,
    4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4,
    4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6,
    7, 6, 7, 7, 8
};

int main(int argc, char *argv[])
{
   int i, num = 0;
   BYTE a = 0;

  printf("\nPlease Input a BYTE(0~255):");
  scanf("%d", &a);

printf("\nthe num of 1 in the BYTE is %d", checknum[a]);
return 0;
}

这是个典型的空间换时间算法，把0~255中1的个数直接存储在数组中，字节a作为数组的下标， checknum[a]直接就是 a 中“1”的个数！算法的复杂度如下：

时间复杂度：O(1)
空间复杂度：O(2n)

恭喜你，你已经被这家著名的外企录用！老总向你伸出手，说：“Welcome to our company”。

5 C/C++结构体的一个高级特性――指定成员的位数

在大多数情况下，我们一般这样定义结构体：
struct student
{
unsigned int sex;
unsigned int age;
};
对于一般的应用，这已经能很充分地实现数据了的“封装”。

但是，在实际工程中，往往碰到这样的情况：那就是要用一个基本类型变量中的不同的位表示不同的含义。譬如一个 cpu 内部的标志寄存器，假设为 16 bit，而每个 bit 都可以表达不同的含义，有的表示结果是否为 0，有的表示是否越界等等。这个时候我们用什么数据结构来表达这个寄存器呢？

答案还是结构体！

为达到此目的，我们要用到结构体的高级特性，那就是在基本成员变量的后面添加： : 数据位数组成新的结构体：
struct xxx
{
       成员 1类型成员 1 : 成员 1 位数;
       成员 2类型成员 2 : 成员 2 位数;
       成员 3类型成员 3 : 成员 3 位数;
};
基本的成员变量就会被拆分！这个语法在初级编程中很少用到，但是在高级程序设计中不断地被用到！

例如：
struct student
{
unsigned int sex : 1;
unsigned int age : 15;
};
上述结构体中的两个成员sex和age加起来只占用了一个unsigned int的空间（假设unsigned int为16位）。基本成员变量被拆分后，访问的方法仍然和访问没有拆分的情况是一样的，例如：

  struct student sweek;
  sweek.sex = MALE;
  sweek.age = 20;

虽然拆分基本成员变量在语法上是得到支持的，但是并不等于我们想怎么分就怎么分，例如下面的拆分显然是不合理的：
struct student
{
       unsigned int sex : 1;
       unsigned int age : 12;
};
这是因为 1+12 = 13，不能再组合成一个基本成员，不能组合成 char、int 或任何类型，这显然是不能“自圆其说”的。
在拆分基本成员变量的情况下，我们要特别注意数据的存放顺序，这还与CPU是Big endian还是Little endian来决定。Little endian 和 Big endian 是 CPU 存放数据的两种不同顺序。对于整型、长整型等数据类型，Big endian 认为第一个字节是最高位字节（按照从低地址到高地址的顺序存放数据的高位字节到低位字节）；而Little endian 则相反，它认为第一个字节是最低位字节（按照从低地址到高地址的顺序存放数据的低位字节到高位字节）。
我们定义 IP 包头结构体为：
struct iphdr {
#if defined(__LITTLE_ENDIAN_BITFIELD)
       __u8       ihl:4,
              version:4;
#elif defined (__BIG_ENDIAN_BITFIELD)
       __u8       version:4,
            ihl:4;
#else
#error       "Please fix <asm/byteorder.h>"
#endif
       __u8       tos;
       __u16       tot_len;
       __u16       id;
       __u16       frag_off;
       __u8       ttl;
       __u8       protocol;
       __u16       check;
       __u32       saddr;
       __u32       daddr;

};
在 Little endian 模式下，iphdr 中定义：
       __u8       ihl:4,
              version:4;
其存放方式为：
第 1字节低 4位 ihl 第 1字节高 4位 version （IP的版本号）
若在 Big endian 模式下还这样定义，则存放方式为：
第 1字节低 4位 version （IP的版本号）
第 1字节高 4位 ihl
这与实际的 IP协议是不匹配的，所以在 Linux 内核源代码中，IP 包头结构体的定义利用了宏：
#if defined(__LITTLE_ENDIAN_BITFIELD)
…
#elif defined (__BIG_ENDIAN_BITFIELD)
…
#endif
来区分两种不同的情况。
由此我们总结全文的主要观点：
（1）C/C++语言的结构体支持对其中的基本成员变量按位拆分；
（2）拆分的位数应该是合乎逻辑的，应仍然可以组合为基本成员变量；
要特别注意拆分后的数据的存放顺序，这一点要结合具体的 CPU 的结构。
6 假设网络节点 A 和网络节点 B中的通信协议涉及四类报文，报文格式为“报文类型字段+报文内容的结构体”，四个报文内容的结构体类型分别为 STRUCTTYPE1~ STRUCTTYPE4，请编写程序以最简单的方式组织一个统一的报文数据结构。

   typedef unsigned char BYTE;

  //报文内容联合体
  typedef union tagPacketContent
  {
       STRUCTTYPE1 pkt1;
      STRUCTTYPE2 pkt2;
      STRUCTTYPE3 pkt1;
      STRUCTTYPE4 pkt2;
  }PacketContent;

//统一的报文数据结构
typedef struct tagPacket
{
       BYTE pktType;
       PacketContent pktContent;
}Packet;

7 下面谈谈struct结构体的巨大作用。

面对一个人的大型 C/C++程序时，只看其对 struct 的使用情况我们就可以对其编写者的编程经验进行评估。因为一个大型的 C/C++程序，势必要涉及一些(甚至大量)进行数据组合的结构体，这些结构体可以将原本意义属于一个整体的数据组合在一起。从某种程度上来说，会不会用 struct，怎样用struct 是区别一个开发人员是否具备丰富开发经历的标志。
在网络协议、通信控制、嵌入式系统的 C/C++编程中，我们经常要传送的不是简单的字节流（char型数组），而是多种数据组合起来的一个整体，其表现形式是一个结构体。
经验不足的开发人员往往将所有需要传送的内容依顺序保存在 char 型数组中，通过指针偏移的方法传送网络报文等信息。这样做编程复杂，易出错，而且一旦控制方式及通信协议有所变化，程序就要进行非常细致的修改。
一个有经验的开发者则灵活运用结构体，举一个例子，假设网络或控制协议中需要传送三种报文，其格式分别为 packetA、packetB、packetC：

struct structA
{
int a;
char b;
};

struct structB
{
char a;
short b;
};

struct structC
{
int a;
char b;
float c;
}

优秀的程序设计者这样设计传送的报文：
struct CommuPacket
{

  int iPacketType;  //报文类型标志
   union       //每次传送的是三种报文中的一种，使用 union
   {
       struct structA packetA;

       struct structB packetB;
       struct structC packetC;
   }
};

在进行报文传送时，直接传送 struct CommuPacket 一个整体。
假设发送函数的原形如下：
// pSendData：发送字节流的首地址，iLen：要发送的长度
Send(char * pSendData, unsigned int iLen);
发送方可以直接进行如下调用发送 struct CommuPacket 的一个实例 sendCommuPacket：
Send( (char *)&sendCommuPacket , sizeof(CommuPacket) );
假设接收函数的原形如下：
// pRecvData：发送字节流的首地址，iLen：要接收的长度
//返回值：实际接收到的字节数
unsigned int Recv(char * pRecvData, unsigned int iLen)；
接收方可以直接进行如下调用将接收到的数据保存在 struct CommuPacket 的一个实例 recvCommuPacket 中：
Recv( (char *)&recvCommuPacket , sizeof(CommuPacket) );

接着判断报文类型进行相应处理：
switch(recvCommuPacket. iPacketType)
{
case PACKET_A:
…    //A 类报文处理
break;
case PACKET_B:
…   //B 类报文处理
break;
case PACKET_C:
…   //C 类报文处理
break;
}
以上程序中最值得注意的是
Send( (char *)&sendCommuPacket , sizeof(CommuPacket) );
Recv( (char *)&recvCommuPacket , sizeof(CommuPacket) );
中的强制类型转换：(char  *)&sendCommuPacket、(char *)&recvCommuPacket，先取地址，再转化为 char 型指针，这样就可以直接利用处理字节流的函数。

利用这种强制类型转化，我们还可以方便程序的编写，例如要对 sendCommuPacket所处内存初始化为 0，可以这样调用标准库函数 memset()：
memset((char *)&sendCommuPacket,0, sizeof(CommuPacket));

8 struct的成员对齐

Intel、微软等公司曾经出过一道类似的面试题：

#include <iostream.h>

#pragma pack(8)
struct example1
{
short a;
long b;
};
struct example2
{
char c;
example1 struct1;
short e;
};
#pragma pack()
int main(int argc, char* argv[])
{
   example2 struct2;
   cout << sizeof(example1) << endl;
   cout << sizeof(example2) << endl;
   cout << (unsigned int)(&struct2.struct1) - (unsigned int)(&struct2) << endl;
       return 0;
}

问程序的输入结果是什么？

答案是：

8 //四字节对其，很正常

16 //结构体中包含结构体，对其的时候按包含结构体的最大元素进行对其，而不是整体作为对其字节；对于example2中的example1而言最大元素：long b；四个字节，所以example2按四个字节对其。

9 位定义

union {
  struct
  {
   unsigned short s1:2;
   unsigned short s2:3;
   unsigned short s3:3;
  }x;
  char c;
}v;
v.c=0xa5;
  printf("%d\n",v.x.s3);
printf("%d\n",v.x.s2);

问：改程序应该输出什么？？？

华为的这个题是出得有问题的。在little endian机器上（如PC）答案为1；在big endian机器上答案才是4。可能出题这个人是做PowerPC开发板的，呵呵。

CPU字节序不同，bit存放的顺序也会不同的。

现在大多数系统都是将低字位放在前面，而结构体中位域的申明一般是先声明高位。

100 的二进制是 001 100 100

低位在前高位在后

001----s3

100----s2

100----s1

所以结果应该是 1

如果先申明的在低位则：

001----s1

100----s2

100----s3

结果是 4