第3章
面试题1：什么是C语言语句，预处理命令是不是语句？
答： 语句就是以分号“；”作为分隔符，编译后产生机器指令的代码。预处理指令不是语句。
面试题2：变量的声明和定义有什么区别？
答： 为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明
，但是只在一个地方定义。加入extern修饰的是变量的声明，说明次变量将在文件以外或在文件后面
部分定义。
面试题3：一下各组中全部都不是C语言关键字的是？
A: int、char、extern B: printf、include、define
C: sizeof、go、cout D: while、for、sizeof
答： 选择B。因为printf是个标准库函数不是关键字，include和define是预处理指令，也不是C语言
关键字。
面试题4：下列变量定义中哪些是合法的？
A: short _b a=1-.1e-1; B: double b=1+5e2.5;
C: long do=0xfdaL; D: float 2_and=1-e-3
答：B。因为A：C语言变量名不能有空格，_b a中有空格，所以是错误的。C：do是C语言的关键字，而
关键字是不允许作为变量标识符的，所以也是错的。D：C语言变量名只能以字母或者下划线开始，不
允许以数字作为变量名的开头，所以也是错的。
面试题5：如何以最简单的方式让电脑蜂鸣器发出声音？
答：（分析，让蜂鸣器发出蜂鸣的声音有很多办法，可以调用beep，可以用汇编直接操作蜂鸣器对应的
管脚，此外，更简单的方法是直接以字符形式printf输出7。）
#include<stdio.h>
int main(int argc,char* argv[])
{
printf("\7");
return 0;
}
面试题6：谈谈你对编程规范的理解或认识？
答：编程规范可总结为：程序的可行性、可读性、可移植性及可测试性。
面试题7：函数、变量等命名都有哪些规则？
答：含数字、ASCII字母、下划线，以字母或者下划线开头，不能用保留字做变量名的情况下，还
要有很高的可读性。
面试题8： 写出bool、int、float、指针变量与“零值”比较的if语句。
答：
bool型数据：
if(flag)
{
A;
}
else
{
B;
}
int型数据：
if(0!=flag)
{
A;
}
else
{
B;
}
指针型数据：
if(NULL==flag)
{
A;
}
else
{
B;
}
float型数据：
if((flag>=NORM)&&(flag<=NORM))
{
A;
}
******数据类型*******
面试题9：根据下列代码写出输出结果：
#include<stdio.h>
#include<conio.h>
int main(void)
{
int a=167;
int b=025;
printf("a: %d b: %d",a,b);
getchar();
}
答：a:167 b:21
注意025为八进制数，代表十进制的21.
面试题10：下列数值中，不是C语言合法int型常数有哪些？
A: 32768 B:0 C: 037 D:0xAF
答： A 因为int型数据范围是-32768~32767。
面试题11： 下列代码中的数组x和数组y相同吗？
char x[] = {"abcd"}
char y[] = {'a','b','c','d'}
答：不同。因为char x[] = {"abcd"}这种写法，是把字符串abcd包括结束符\0存到x，而char y[] = {'a','b'
,'c','d'}这种是存储4个字符a、b、c、d到数组y。
面试题12：在C语言中，char型数据在内存中的存储形式是（）。
A: 补码 B: 反码 C: 源码 D: ASCII码
答：D
**********运算符*****************
面试题13：请写出下列代码的输出内容。
#include<stdio.h>
int main()
{
int a,b,c,d;
a=10;
b=a++;
c=++a;
d=10*a++;
printf("b,c,d:%d,%d,%d",b,c,d);
getchar();
}
答：b,c,d: 10, 12, 120
面试题14：给出下面程序的运行结果：（运算符优先级问题）
#include<stdio.h>
#include<stdlib.h>
int main()
{
if(0 & 1 == 0)
{
printf("0 & 1 == 0\n");
}
else
{
printf("0 & 1 != 0\n");
}
if(0 & 1 !=0)
{
printf("0 & 1 !=0\n");
}
else
{
printf("0 & 1 == 0\n");
}
system("pause");
return 0;
}
答：0 & 1 ！=0
0 & 1 == 0
面试题15：&&和&，||和|有什么区别？
答：(1)&和|对操作数进行求值运算，&&和||只是判断逻辑关系。
(2)&&和||在判断左侧操作数就能确定结果的情况下就不再对右侧操作数求值。
面试题16：什么是左值，什么是右值？
答：右值：存储在某内存地址中的数据。也称为变量的数据。
左值：存储数据值的那块内存的地址。也称为变量的地址值。
面试题17：写出这段程序的运行结果。
#include<stdio.h>
#include<windows.h>
int main()
{
char x='a';
char* p="abcd";
char y[4]={'a','b','c','d'};
int a=10;
int *b=&a;
int c[4]={1,2,3,4};
printf("%d,%d,%d\n",sizeof(x),sizeof(p),sizeof(y));
printf("%d,%d,%d\n",sizeof(a),sizeof(b),sizeof(c));
getchar();
return 0;
}
答：1，4，4
4，4，16
分析：首先要知道指针保存的是一个地址，其长度是和整型数据一致的。在上述代码中，x是一个字符型变量，
其长度肯定是1，因此sizeof(x)的结果是1.p是一个字符指针，其类型为指针类型，指针类型在32位机上占4个
字节（其实应该说是32为编译器），64位机上占8个字节(在64位电脑上因为devc++用gcc版本高一些为64位编译
器所以用vc++6.0和用devc++编译后运行的结果分别为4和8)。y是一个包含4个字符的数组，每个字符长度是1，
因此y的长度是a是整型变量，长度为4，b是指针变量，用vc++6.0编译长度为4，用devc++编译是8。c是包含4个
整型变量的数组，其长度为16。
面试题18：sizeof和strlen都用来返回其参数的长度，那他们有什么不同吗？如果有，请举例说明。
答：sizeof和strlen有以下区别：
* sizeof是一个操作符，strlen是库函数。
* sizeof的参数可以是数据类型，也可以使变量，而strlen只能以结尾为‘\0’的字符串作为参数。
* 编译器在编译时就计算出了sizeof的结果。而strlen函数必须在运行时才能计算出来。并且sizeof计算的是
数据类型占内存的大小，而strlen计算的是字符串实际的长度。
* 数组做sizeof的参数不退化，传递给strlen就退化为指针了。
例子
#include<stdio.h>
#include<windows.h>
int main()
{
int a=3;
int c[4]={1,2,3,4};
printf("%d,%d\n",sizeof(int),sizeof(a));
char *p="hello 123!";
printf("%d\n",strlen(p));
return 0;
}
执行结果是：
4，4
10
#include<stdio.h>
#include<windows.h>
int main()
{
char* str="abcdefg";
int x=strlen(str);
int y=sizeof(str);
printf("%d,%d\n",x,y);
return 0;
}
执行结果是：
7，4
#include<stdio.h>
#include<windows.h>
int main()
{
char str[10]="abcd";
int x=strlen(str);
int y=sizeof(str);
printf("%d,%d\n",x,y);
return 0;
}
执行结果是：
4，10
********结构体********************
面试题19：结构体是____________数据类型。
答： 构造数据类型的
面试题20： 结构体在声明时可以直接赋值吗，在同一个结构体对象之间可以直接赋值吗？
如果可以，请举例说明。
答：声明时可以直接初始化，同一结构体的不同对象之间也可以直接赋值，但是当结构体中含有指针“成员”时
一定要小心。 注意，当有多个指针指向同一段内存时，某个指针释放这一段内存会导致其他指针的非法操作。因
此在释放前一定要确保其他指针不再使用这段内存空间。
数组和结构体都是构造类型数据，数组在声明时可以直接初始化，结构体也可以这样做。
#include<stdio.h>
struct student
{
int id;
char name[30];
char sex;
char addr[50];
};
void main(void)
{
char ch[4] = {'a','b','c','d'};
for (int i = 0; i < 4; i++)
{
printf("char[%d]:%c ",i, ch[i]);
}
printf("\n");
student w={252403,
"WangMing",
'M',
"HaiNan dajie 778hao"};
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
}
运行结果：
char[0]:a char[1]:b char[2]:c char[3]:d
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
同以结构体的不同对象之间可以相互赋值，大多数情况下是可以的，但当结构体中含有指针“成员”的时候是需
要慎重考虑的，虽然不会有编译错误，但是两个结构体的指针，会同时指向同一段内存空间，当其中一个释放掉
该空间后，另一个仍在使用，就会出现不可预料的错误。
没有指针的同一结构体不同对象之间，直接赋值的例子如下：
#include<stdio.h>
struct student //定义一个学生结构体
{
int id; //学生编号
char name[30]; //学生姓名
char sex; //学生性别
char addr[50]; //学生住址
};
void main(void)
{
student y,w={252403, //学号 252403
"WangMing", //姓名WangMing
'M', //性别M（男）
"HaiNan dajie 778hao"}; //地址HaiNan dajie 778hao
printf("This is student w: \n"); //输出w学生的信息
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
y=w; //把学生w直接赋值给y
printf("This is student y: \n"); //输出w学生的信息
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
}
运行结果：
This is student w:
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
This is student y:
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
有指针成员的结构体，直接赋值出错的程序如下：
#include<stdio.h>
#include<string.h>
struct student //定义一个学生结构体
{
int id; //学生编号
char *name; //学生姓名
char sex; //学生性别
char addr[50]; //学生住址
};
void main(void)
{
student y,w={252403, //学号 252403
" ", //姓名WangMing
'M', //性别M（男）
"HaiNan dajie 778hao"}; //地址HaiNan dajie 778hao
printf("This is student w: \n"); //输出w学生的信息
w.name = new char[10]; //申请空间
strcpy(w.name,"WangMing"); //给姓名成员赋值
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
w.name[0] = '\0';
delete w.name; //释放掉指针指向的空间
y=w; //把学生w直接赋值给y
printf("This is student y: \n"); //输出w学生的信息
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
}
运行结果：
This is student w:
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
This is student y:
ID.: 252403
name: 葺葺葺葺葺葺葺
sex: M
address: HaiNan dajie 778hao
Press any key to continue
面试题21：打开一个WAV文件，以适当的数据结构组织WAV文件头并解析WAV格式的各项信息。
WAVE文件格式说明如表3.3所示。
表3.3 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 4 int32 采样率（每秒样本数），表示每个通道的播放速度
1CH 4 int32 波形音频数据传送速率
20H 2 int16 数据块的调整数（按字节算的）
22H 2 每样本的数据位数
24H 4 Char 数据标记符“data”
28H 4 int32 语音数据的长度
答案：（说明，结构体是一种自定义类型数据，其表示灵活，使用方便。在很多数据相关性很强时，可以
把这些数据构成一个结构体来操作。从某种意义上来说，这也是一种面向对象编程的思想。）
typedef struct tagWaveFormat
{
char c;
RiffFlag[4];
UIN32 nFileLen;
char cWaveFlag[4];
char cFmtFlag[4];
char cTransition[4];
UIN16 nFormatTag;
UIN16 nChannel;
UIN32 nAvgBytesPerSec;
UIN16 nBlockAlign;
UIN16 nBitNumPerSam;
char cDataFlag[4];
UIN16 nAudioLength;
} WAVEFORMAT;
面试题22：编程实现记录7个学生的姓名、性别、成绩，计算不及格的人数，并打印出不及格人的姓名、
性别和成绩。
答案：
#include "stdio.h"
struct student
{
char *name;
int score;
char sex;
};
void main()
{
int i = 0, totle = 0;
student stu[7] = { {"LiYi",85,'M'}, {"MaHe",25,'F'}, {"HuNa", 64,'F'},
{"LuKe",47,'M'}, {"DaYu",90,'F'},{"KeFu",12,'M'},{"RuFu",100,'F'}};
// 学生结构体数组
for(i; i<7; i++)
{
if(stu[i].score < 60) //判断当前学生是否及格
{
printf("Name:%s Sex:%c Archive:%d \n",stu[i].name,stu[i].sex,stu[i].score);
totle++; //计算不及格学生总数
}
}
printf("The totle is:%d",totle); //打印不及格学生总数
getchar();
}
运行结果：
Name:MaHe Sex:F Archive:25
Name:LuKe Sex:M Archive:47
Name:KeFu Sex:M Archive:12
The totle is:3
面试题23：（结构体内存对其问题）请写出以下代码的输出结果：
#include "stdio.h"
struct s1
{
int i: 8;
char j: 4;
int a: 4;
double b;
};
struct s2
{
int i: 8;
int j: 4;
double b;
int a: 4;
};
struct s3
{
int i;
char j;
double b;
int a;
};
void main()
{
printf("sizeof(s1)= %d\n",sizeof(s1));
printf("sizeof(s2)= %d\n",sizeof(s2));
printf("sizeof(s3)= %d\n",sizeof(s3));
getchar();
}
运行结果：
sizeof(s1)= 24
sizeof(s2)= 24
sizeof(s3)= 24
面试题24： C和C++都有static关键字，那么static关键字在C和C++中的使用用什么区别？请简述之。
答案：在C中static用来修饰局部静态变量和外部静态变量、函数。而C++除了上述功能外，还用来定
义类的成员变量和函数，即静态成员和静态函数。
例子：
#include "stdio.h"
void staticLoShow()
{
static int a = 0;
printf("a = %d\n",a);
a += 5;
};
void main()
{
for(int i = 0; i < 4; i++)
{
staticLoShow();
}
getchar();
}
输出结果：
a = 0
a = 5
a = 10
a = 15
C++中定义静态成员变量和静态成员函数。
#include <iostream>
#include <string.h>
using namespace std;
class A
{
public:
static int a;
static int geta();
int b;
int getb();
};
int A::a = 10;
int A::geta()
{
return a;
}
int A::getb()
{
return b;
}
void main(void)
{
A m,n;
m.b = 90;
cout<<m.geta()<<endl;
cout<<m.getb()<<endl;
cout<<m.a<<endl;
n.a = 33;
n.b = 44;
cout<<""<<endl;
cout<<m.geta()<<endl;
cout<<m.getb()<<endl;
cout<<m.a<<endl;
return ;
}
输出结果：
10
90
10
33
90
33
面试题25： C语言的结构体和C++有什么不同？
答案：C语言的结构体和C++的结构体主要有以下区别：
（1）C语言的结构体是不能有函数成员的，而C++的类可以有。
（2）C语言的结构体中数据成员是没有private、public和protected访问限定的。而
C++的类的成员有这些访问限定。
（3）C语言的结构体是没有继承关系的，而C++ 的类却有丰富的继承关系。
面试题26：C中的malloc和C++中的new有什么区别？
答案：malloc和new有以下不同：
（1）new、delete是操作符，可以重载，只能在C++中使用。
（2）malloc、free是函数，可以覆盖，C、C++中都可以使用。
（3）new可以调用对象的构造函数，对应的delete调用相应的析构函数。
（4）malloc仅仅分配内存，free仅仅回收内存，并不执行构造和析构函数。
（5）new、delete返回的是某种数据类型指针，malloc、free返回的是void指针。
面试题27： 指针和引用有什么区别？
答案：指针和引用主要有以下区别：
（1）引用必须被初始化，但是不分配内存空间。指针不声明时初始化，在初始化的时候需要分配存储空间。
（2）引用初始化以后不能被改变，指针可以改变被指的对象。
（3）不存在指向空值的引用，但是存在指向空值的指针。
面试题1：什么是C语言语句，预处理命令是不是语句？
答： 语句就是以分号“；”作为分隔符，编译后产生机器指令的代码。预处理指令不是语句。
面试题2：变量的声明和定义有什么区别？
答： 为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明
，但是只在一个地方定义。加入extern修饰的是变量的声明，说明次变量将在文件以外或在文件后面
部分定义。
面试题3：一下各组中全部都不是C语言关键字的是？
A: int、char、extern B: printf、include、define
C: sizeof、go、cout D: while、for、sizeof
答： 选择B。因为printf是个标准库函数不是关键字，include和define是预处理指令，也不是C语言
关键字。
面试题4：下列变量定义中哪些是合法的？
A: short _b a=1-.1e-1; B: double b=1+5e2.5;
C: long do=0xfdaL; D: float 2_and=1-e-3
答：B。因为A：C语言变量名不能有空格，_b a中有空格，所以是错误的。C：do是C语言的关键字，而
关键字是不允许作为变量标识符的，所以也是错的。D：C语言变量名只能以字母或者下划线开始，不
允许以数字作为变量名的开头，所以也是错的。
面试题5：如何以最简单的方式让电脑蜂鸣器发出声音？
答：（分析，让蜂鸣器发出蜂鸣的声音有很多办法，可以调用beep，可以用汇编直接操作蜂鸣器对应的
管脚，此外，更简单的方法是直接以字符形式printf输出7。）
#include<stdio.h>
int main(int argc,char* argv[])
{
printf("\7");
return 0;
}
面试题6：谈谈你对编程规范的理解或认识？
答：编程规范可总结为：程序的可行性、可读性、可移植性及可测试性。
面试题7：函数、变量等命名都有哪些规则？
答：含数字、ASCII字母、下划线，以字母或者下划线开头，不能用保留字做变量名的情况下，还
要有很高的可读性。
面试题8： 写出bool、int、float、指针变量与“零值”比较的if语句。
答：
bool型数据：
if(flag)
{
A;
}
else
{
B;
}
int型数据：
if(0!=flag)
{
A;
}
else
{
B;
}
指针型数据：
if(NULL==flag)
{
A;
}
else
{
B;
}
float型数据：
if((flag>=NORM)&&(flag<=NORM))
{
A;
}
******数据类型*******
面试题9：根据下列代码写出输出结果：
#include<stdio.h>
#include<conio.h>
int main(void)
{
int a=167;
int b=025;
printf("a: %d b: %d",a,b);
getchar();
}
答：a:167 b:21
注意025为八进制数，代表十进制的21.
面试题10：下列数值中，不是C语言合法int型常数有哪些？
A: 32768 B:0 C: 037 D:0xAF
答： A 因为int型数据范围是-32768~32767。
面试题11： 下列代码中的数组x和数组y相同吗？
char x[] = {"abcd"}
char y[] = {'a','b','c','d'}
答：不同。因为char x[] = {"abcd"}这种写法，是把字符串abcd包括结束符\0存到x，而char y[] = {'a','b'
,'c','d'}这种是存储4个字符a、b、c、d到数组y。
面试题12：在C语言中，char型数据在内存中的存储形式是（）。
A: 补码 B: 反码 C: 源码 D: ASCII码
答：D
**********运算符*****************
面试题13：请写出下列代码的输出内容。
#include<stdio.h>
int main()
{
int a,b,c,d;
a=10;
b=a++;
c=++a;
d=10*a++;
printf("b,c,d:%d,%d,%d",b,c,d);
getchar();
}
答：b,c,d: 10, 12, 120
面试题14：给出下面程序的运行结果：（运算符优先级问题）
#include<stdio.h>
#include<stdlib.h>
int main()
{
if(0 & 1 == 0)
{
printf("0 & 1 == 0\n");
}
else
{
printf("0 & 1 != 0\n");
}
if(0 & 1 !=0)
{
printf("0 & 1 !=0\n");
}
else
{
printf("0 & 1 == 0\n");
}
system("pause");
return 0;
}
答：0 & 1 ！=0
0 & 1 == 0
面试题15：&&和&，||和|有什么区别？
答：(1)&和|对操作数进行求值运算，&&和||只是判断逻辑关系。
(2)&&和||在判断左侧操作数就能确定结果的情况下就不再对右侧操作数求值。
面试题16：什么是左值，什么是右值？
答：右值：存储在某内存地址中的数据。也称为变量的数据。
左值：存储数据值的那块内存的地址。也称为变量的地址值。
面试题17：写出这段程序的运行结果。
#include<stdio.h>
#include<windows.h>
int main()
{
char x='a';
char* p="abcd";
char y[4]={'a','b','c','d'};
int a=10;
int *b=&a;
int c[4]={1,2,3,4};
printf("%d,%d,%d\n",sizeof(x),sizeof(p),sizeof(y));
printf("%d,%d,%d\n",sizeof(a),sizeof(b),sizeof(c));
getchar();
return 0;
}
答：1，4，4
4，4，16
分析：首先要知道指针保存的是一个地址，其长度是和整型数据一致的。在上述代码中，x是一个字符型变量，
其长度肯定是1，因此sizeof(x)的结果是1.p是一个字符指针，其类型为指针类型，指针类型在32位机上占4个
字节（其实应该说是32为编译器），64位机上占8个字节(在64位电脑上因为devc++用gcc版本高一些为64位编译
器所以用vc++6.0和用devc++编译后运行的结果分别为4和8)。y是一个包含4个字符的数组，每个字符长度是1，
因此y的长度是a是整型变量，长度为4，b是指针变量，用vc++6.0编译长度为4，用devc++编译是8。c是包含4个
整型变量的数组，其长度为16。
面试题18：sizeof和strlen都用来返回其参数的长度，那他们有什么不同吗？如果有，请举例说明。
答：sizeof和strlen有以下区别：
* sizeof是一个操作符，strlen是库函数。
* sizeof的参数可以是数据类型，也可以使变量，而strlen只能以结尾为‘\0’的字符串作为参数。
* 编译器在编译时就计算出了sizeof的结果。而strlen函数必须在运行时才能计算出来。并且sizeof计算的是
数据类型占内存的大小，而strlen计算的是字符串实际的长度。
* 数组做sizeof的参数不退化，传递给strlen就退化为指针了。
例子
#include<stdio.h>
#include<windows.h>
int main()
{
int a=3;
int c[4]={1,2,3,4};
printf("%d,%d\n",sizeof(int),sizeof(a));
char *p="hello 123!";
printf("%d\n",strlen(p));
return 0;
}
执行结果是：
4，4
10
#include<stdio.h>
#include<windows.h>
int main()
{
char* str="abcdefg";
int x=strlen(str);
int y=sizeof(str);
printf("%d,%d\n",x,y);
return 0;
}
执行结果是：
7，4
#include<stdio.h>
#include<windows.h>
int main()
{
char str[10]="abcd";
int x=strlen(str);
int y=sizeof(str);
printf("%d,%d\n",x,y);
return 0;
}
执行结果是：
4，10
********结构体********************
面试题19：结构体是____________数据类型。
答： 构造数据类型的
面试题20： 结构体在声明时可以直接赋值吗，在同一个结构体对象之间可以直接赋值吗？
如果可以，请举例说明。
答：声明时可以直接初始化，同一结构体的不同对象之间也可以直接赋值，但是当结构体中含有指针“成员”时
一定要小心。 注意，当有多个指针指向同一段内存时，某个指针释放这一段内存会导致其他指针的非法操作。因
此在释放前一定要确保其他指针不再使用这段内存空间。
数组和结构体都是构造类型数据，数组在声明时可以直接初始化，结构体也可以这样做。
#include<stdio.h>
struct student
{
int id;
char name[30];
char sex;
char addr[50];
};
void main(void)
{
char ch[4] = {'a','b','c','d'};
for (int i = 0; i < 4; i++)
{
printf("char[%d]:%c ",i, ch[i]);
}
printf("\n");
student w={252403,
"WangMing",
'M',
"HaiNan dajie 778hao"};
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
}
运行结果：
char[0]:a char[1]:b char[2]:c char[3]:d
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
同以结构体的不同对象之间可以相互赋值，大多数情况下是可以的，但当结构体中含有指针“成员”的时候是需
要慎重考虑的，虽然不会有编译错误，但是两个结构体的指针，会同时指向同一段内存空间，当其中一个释放掉
该空间后，另一个仍在使用，就会出现不可预料的错误。
没有指针的同一结构体不同对象之间，直接赋值的例子如下：
#include<stdio.h>
struct student //定义一个学生结构体
{
int id; //学生编号
char name[30]; //学生姓名
char sex; //学生性别
char addr[50]; //学生住址
};
void main(void)
{
student y,w={252403, //学号 252403
"WangMing", //姓名WangMing
'M', //性别M（男）
"HaiNan dajie 778hao"}; //地址HaiNan dajie 778hao
printf("This is student w: \n"); //输出w学生的信息
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
y=w; //把学生w直接赋值给y
printf("This is student y: \n"); //输出w学生的信息
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
}
运行结果：
This is student w:
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
This is student y:
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
有指针成员的结构体，直接赋值出错的程序如下：
#include<stdio.h>
#include<string.h>
struct student //定义一个学生结构体
{
int id; //学生编号
char *name; //学生姓名
char sex; //学生性别
char addr[50]; //学生住址
};
void main(void)
{
student y,w={252403, //学号 252403
" ", //姓名WangMing
'M', //性别M（男）
"HaiNan dajie 778hao"}; //地址HaiNan dajie 778hao
printf("This is student w: \n"); //输出w学生的信息
w.name = new char[10]; //申请空间
strcpy(w.name,"WangMing"); //给姓名成员赋值
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
w.name[0] = '\0';
delete w.name; //释放掉指针指向的空间
y=w; //把学生w直接赋值给y
printf("This is student y: \n"); //输出w学生的信息
printf("ID.: %1d\nname: %s\nsex: %c\naddress: %s\n",w.id,w.name,w.sex,w.addr);
}
运行结果：
This is student w:
ID.: 252403
name: WangMing
sex: M
address: HaiNan dajie 778hao
This is student y:
ID.: 252403
name: 葺葺葺葺葺葺葺
sex: M
address: HaiNan dajie 778hao
Press any key to continue
面试题21：打开一个WAV文件，以适当的数据结构组织WAV文件头并解析WAV格式的各项信息。
WAVE文件格式说明如表3.3所示。
表3.3 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 4 int32 采样率（每秒样本数），表示每个通道的播放速度
1CH 4 int32 波形音频数据传送速率
20H 2 int16 数据块的调整数（按字节算的）
22H 2 每样本的数据位数
24H 4 Char 数据标记符“data”
28H 4 int32 语音数据的长度
答案：（说明，结构体是一种自定义类型数据，其表示灵活，使用方便。在很多数据相关性很强时，可以
把这些数据构成一个结构体来操作。从某种意义上来说，这也是一种面向对象编程的思想。）
typedef struct tagWaveFormat
{
char c;
RiffFlag[4];
UIN32 nFileLen;
char cWaveFlag[4];
char cFmtFlag[4];
char cTransition[4];
UIN16 nFormatTag;
UIN16 nChannel;
UIN32 nAvgBytesPerSec;
UIN16 nBlockAlign;
UIN16 nBitNumPerSam;
char cDataFlag[4];
UIN16 nAudioLength;
} WAVEFORMAT;
面试题22：编程实现记录7个学生的姓名、性别、成绩，计算不及格的人数，并打印出不及格人的姓名、
性别和成绩。
答案：
#include "stdio.h"
struct student
{
char *name;
int score;
char sex;
};
void main()
{
int i = 0, totle = 0;
student stu[7] = { {"LiYi",85,'M'}, {"MaHe",25,'F'}, {"HuNa", 64,'F'},
{"LuKe",47,'M'}, {"DaYu",90,'F'},{"KeFu",12,'M'},{"RuFu",100,'F'}};
// 学生结构体数组
for(i; i<7; i++)
{
if(stu[i].score < 60) //判断当前学生是否及格
{
printf("Name:%s Sex:%c Archive:%d \n",stu[i].name,stu[i].sex,stu[i].score);
totle++; //计算不及格学生总数
}
}
printf("The totle is:%d",totle); //打印不及格学生总数
getchar();
}
运行结果：
Name:MaHe Sex:F Archive:25
Name:LuKe Sex:M Archive:47
Name:KeFu Sex:M Archive:12
The totle is:3
面试题23：（结构体内存对其问题）请写出以下代码的输出结果：
#include "stdio.h"
struct s1
{
int i: 8;
char j: 4;
int a: 4;
double b;
};
struct s2
{
int i: 8;
int j: 4;
double b;
int a: 4;
};
struct s3
{
int i;
char j;
double b;
int a;
};
void main()
{
printf("sizeof(s1)= %d\n",sizeof(s1));
printf("sizeof(s2)= %d\n",sizeof(s2));
printf("sizeof(s3)= %d\n",sizeof(s3));
getchar();
}
运行结果：
sizeof(s1)= 24
sizeof(s2)= 24
sizeof(s3)= 24
面试题24： C和C++都有static关键字，那么static关键字在C和C++中的使用用什么区别？请简述之。
答案：在C中static用来修饰局部静态变量和外部静态变量、函数。而C++除了上述功能外，还用来定
义类的成员变量和函数，即静态成员和静态函数。
例子：
#include "stdio.h"
void staticLoShow()
{
static int a = 0;
printf("a = %d\n",a);
a += 5;
};
void main()
{
for(int i = 0; i < 4; i++)
{
staticLoShow();
}
getchar();
}
输出结果：
a = 0
a = 5
a = 10
a = 15
C++中定义静态成员变量和静态成员函数。
#include <iostream>
#include <string.h>
using namespace std;
class A
{
public:
static int a;
static int geta();
int b;
int getb();
};
int A::a = 10;
int A::geta()
{
return a;
}
int A::getb()
{
return b;
}
void main(void)
{
A m,n;
m.b = 90;
cout<<m.geta()<<endl;
cout<<m.getb()<<endl;
cout<<m.a<<endl;
n.a = 33;
n.b = 44;
cout<<""<<endl;
cout<<m.geta()<<endl;
cout<<m.getb()<<endl;
cout<<m.a<<endl;
return ;
}
输出结果：
10
90
10
33
90
33
面试题25： C语言的结构体和C++有什么不同？
答案：C语言的结构体和C++的结构体主要有以下区别：
（1）C语言的结构体是不能有函数成员的，而C++的类可以有。
（2）C语言的结构体中数据成员是没有private、public和protected访问限定的。而
C++的类的成员有这些访问限定。
（3）C语言的结构体是没有继承关系的，而C++ 的类却有丰富的继承关系。
面试题26：C中的malloc和C++中的new有什么区别？
答案：malloc和new有以下不同：
（1）new、delete是操作符，可以重载，只能在C++中使用。
（2）malloc、free是函数，可以覆盖，C、C++中都可以使用。
（3）new可以调用对象的构造函数，对应的delete调用相应的析构函数。
（4）malloc仅仅分配内存，free仅仅回收内存，并不执行构造和析构函数。
（5）new、delete返回的是某种数据类型指针，malloc、free返回的是void指针。
面试题27： 指针和引用有什么区别？
答案：指针和引用主要有以下区别：
（1）引用必须被初始化，但是不分配内存空间。指针不声明时初始化，在初始化的时候需要分配存储空间。
（2）引用初始化以后不能被改变，指针可以改变被指的对象。
（3）不存在指向空值的引用，但是存在指向空值的指针。