C语言面试程序阅读整理

一、数组和指针

1、数组和指针的存储

写出下面的输出结果：

char str1[] = "abc";

char str2[] = "abc";

const char str3[] = "abc";

const char str4[] = "abc";

const char *str5 = "abc";

const char *str6 = "abc";

char *str7 = "abc";

char *str8 = "abc";

cout << ( str1 == str2 ) << endl;

cout << ( str3 == str4 ) << endl;

cout << ( str5 == str6 ) << endl;

cout << ( str7 == str8 ) << endl;

结果是：0 0 1 1

解答：str1,str2,str3,str4是数组变量，它们有各自的内存空间；

而str5,str6,str7,str8是指针，它们指向相同的常量区域。

2、数组和指针的取值

写出输出结果

void main()

{

int a[5]={1,2,3,4,5};

int *ptr=(int *)(&a+1);

printf("%d,%d",*(a+1),*(ptr-1));

}

输出：2,5

*(a+1）就是a[1]，*(ptr-1)就是a[4],执行结果是2，5

注意：&a+1不是首地址+1，系统会认为加一个a数组的偏移，是偏移了一个数组的大小（本例是5个int），int *ptr=(int *)(&a+1);则ptr实际是&(a[5]),也就是a+5。原因如下：

&a是数组指针，其类型为 int (*)[5]；而指针加1要根据指针类型加上一定的值，

不同类型的指针+1之后增加的大小不同，a是长度为5的int数组指针，所以要加 5*sizeof(int)，所以ptr实际是a[5]；但是prt与(&a+1)类型是不一样的(这点很重要)，所以prt-1只会减去sizeof(int*)；a, &a的地址是一样的，但意思不一样，a是数组首地址，也就是a[0]的地址，&a是对象（数组）首地址，a+1是数组下一元素的地址，即a[1],&a+1是下一个对象的地址，即a[5]。

3、数组越界

下面这个程序执行后会有什么错误？

#define MAX 255

int main()

{

unsigned char A[MAX],i;//i被定义为unsigned char

for (i=0;i<=MAX;i++)

A[i]=i;

}

答：死循环加数组越界访问（C/C++不进行数组越界检查）。

其一，MAX=255，数组A的下标范围为:0...MAX-1。

其二，当i循环到255时,循环内执行:A[255]=255;这句本身没有问题，但是返回for (i=0;i<=MAX;i++)语句时,由于unsigned char的取值范围在(0...255)，i++以后i又为0了，会无限循环下去。

4、指针变量存储

请问以下代码有什么问题：

int  main()

{

char a;

char *str=&a;

strcpy(str,"hello");

printf(str);

return 0;

}

没有为str分配内存空间，将会发生异常

问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。

5、指针变量的赋值

以下程序有什么错？

char* s="AAA";

printf("%s",s);

s[0]='B';

printf("%s",s);

"AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。应写成const char* s="AAA";

然后又因为是常量，所以对是s[0]的赋值操作是不合法的。

6、指针计算

分析以下代码的输出：

int arr[] = {6,7,8,9,10};

int *ptr = arr;

*(ptr++)+=123;

printf(“ %d %d ”, *ptr, *(++ptr));

答：输出：8，8

对于*(ptr++)+=123;先做加法6+123，然后++，指针指向7；对于printf(“ %d %d ”, *ptr, *(++ptr));从后往前执行，指针先++，指向8，然后输出8，紧接着再输出8。

7、指针存储

分析下面的代码：

char *a = "hello";

char *b = "hello";

if(a= =b)

printf("YES");

else

printf("NO");

答：在VC是YES 在C是NO。

hello是一个常量字符串，位于静态存储区，它在程序生命期内恒定不变。如果编译器优化的话，会有可能a和b同时指向同一个hello的，则地址相同。如果编译器没有优化，那么就是两个不同的地址，则不同。

8、空指针

(void *)ptr 和 (*(void**))ptr的结果是否相同？

答：其中ptr为同一个指针，(void *)ptr 和 (*(void**))ptr值是相同的

二、关键字

1、sizeof求字节

某32位系统下,计算sizeof 的值:

char str[] = “abcde”;

char *p = str ;

int n = 10;

（1）sizeof (str ) = ？

（2）sizeof ( p ) = ？

（3）sizeof ( n ) = ？

void Foo ( char str[100]){

（4）sizeof( str ) = ？

}

void *p = malloc( 100 );

（5）sizeof ( p ) = ？

答：（1）5 （2）4 （3） 4 （4）4 （5）4

2、sizeof求字节

给出下面程序的答案

typedef struct  AA

{

int b1:5;

int b2:2;

}AA;

void main()

{

AA aa;

char cc[100];

strcpy(cc,"0123456789abcdefghijklmnopqrstuvwxyz");

memcpy(&aa,cc,sizeof(AA));

cout << aa.b1 <<endl;

cout << aa.b2 <<endl;

}

答：是 -16和１。

首先sizeof(AA)的大小为4,b1和b2分别占5bit和2bit，经过strcpy和memcpy后,aa的4个字节所存放的值是:0,1,2,3的ASC码，即00110000,00110001,00110010,00110011；所以，最后一步：显示的是这４个字节的前５位，和之后的２位，分别为：10000和01；因为int是有正负之分，所以：答案是-16和１。

3、sizeof用于数组作为函数参数

以下代码中的两个sizeof用法有问题吗？

void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母

{

for( size_t i=0; i<sizeof(str)/sizeof(str[0]); ++i )

if( 'a'<=str[i] && str[i]<='z' )

str[i] -= ('a'-'A' );

}

char str[] = "aBcDe";

cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;

UpperCase( str );

cout << str << endl;

答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str是一个静态定义的数组，因此其大小为6，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此只将其当指针看，一个指针为4个字节，因此返回4。

4、const的使用

有以下表达式：

int a=248; b=4;

int const c=21;

const int *d=&a;

int *const e=&b;

int const *f const =&a;

请问下列表达式哪些会被编译器禁止？为什么？

*c=32; d=&b; *d=43; e=34; e=&a; f=0x321f;

*c 这是个什么东东，禁止；

*d 说了是const，禁止；

e = &a 说了是const 禁止；

const *f const =&a; 禁止。

5、static的使用

下面的函数实现在一个数上加一个数，有什么错误？

int add_n ( int n )

{

static int i = 100;

i += n;

return i;

}

答：不应该用static，因为static只保留第一次初始化的值，第二次调用时得不到正确的结果。

6、static的应用

写出程序运行结果：

int sum(int a)

{

auto int c=0;

static int b=3;

c+=1;

b+=2;

return(a+b+c);

}

void main()

{

int i;

int a=2;

for(i=0;i<5;i++)

{

printf("%d,", sum(a));

}

}

答：输出：8,10,12,14,16,

static会保存上次结果，记住这一点

三、函数

1、主函数的返回值

主函数既然不会被其它函数调用，为什么要返回1？

int main()

{

int x=3;

printf("%d",x);

return 1;

}

答：main函数的返回值，用于说明程序的退出状态。如果返回0，则代表程序正常退出；返回其它数字的含义则由系统决定。通常，返回非零代表程序异常退出。

2、指针用于函数参数

(1)void GetMemory(char **p, int num){

*p = (char *)malloc(num);

}

void Test(void){

char *str = NULL;

GetMemory(&str, 100);

strcpy(str, "hello");

printf(str);

}

请问运行Test 函数会有什么样的结果？

答：输出“hello”

(2)void Test(void){

char *str = (char *) malloc(100);

strcpy(str, “hello”);

free(str);

if(str != NULL){

strcpy(str, “world”);

printf(str);

}

}

请问运行Test 函数会有什么样的结果？

答：输出“world”

(3)char *GetMemory(void){

char p[] = "hello world";

return p;

}

void Test(void){

char *str = NULL;

str = GetMemory();

printf(str);

}

请问运行Test 函数会有什么样的结果？

答：无效的指针，输出不确定

3、函数调用先后关系

写出输出结果：

#include <stdio.h>

void foo(int m, int n)

{

printf("m=%d, n=%d\n", m, n);

}

int main()

{

int b = 3;

foo(b+=3, ++b);

printf("b=%d\n", b);

return 0;

}

答：输出：m=7,n=4,b=7(VC6.0)

这种方式和编译器中得函数调用关系相关即先后入栈顺序。不过不同编译器得处理不同。也是因为C标准中对这种方式说明为未定义，所以各个编译器厂商都有自己得理解，所以最后产生得结果完全不同。

4、函数地址

请问一下程序将输出什么结果？

char *RetMemoy(void)

{

char p[] = “hello world”;

return p;

}

void Test(void)

{

char *str = NULL;

str = RetMemory();

printf(str);

}

RetMemoy执行完毕，p资源被回收，指向未知地址。返回地址，str的内容应是不可预测的, 打印的应该是str的地址。

5、字符串赋值函数strcpy

下面的语句会出现什么结果？

char szstr[10];

strcpy (szstr,"0123456789");

答：长度不一样，会造成非法的OS，应该改为char szstr[11] ，注意strcpy会拷贝”\0”。

6、用strcpy赋值字符串

对下面程序进行分析：

void test2()

{

char string[10], str1[10];

int i;

for(i=0; i<10; i++)

{

str1[i] = 'a';

}

strcpy( string, str1 );

}

答： str1不能在数组内结束:因为str1的存储为：{a,a,a,a,a,a,a,a,a,a},没有'\0'(字符串结束符)，所以不能结束；strcpy( char *s1,char *s2)他的工作原理是，扫描s2指向的内存，逐个字符付到s1所指向的内存，直到碰到'\0',因为str1结尾没有'\0'，所以具有不确定性。

正确应如下：

void test2()

{

char string[10], str1[10];

int i;

for(i=0; i<9; i++)

{

str1[i] = 'a'+i; //把abcdefghi赋值给字符数组

}

str[i]='\0';//加上结束符

strcpy( string, str1 );

}

四、结构体

1、结构体和联合体字节计算

设有以下说明和定义：

typedef union {long i; int k[5]; char c;} DATE;

struct data { int cat; DATE cow; double dog;} too;

DATE max;

则语句 printf("%d",sizeof(struct data)+sizeof(max DATE));的执行结果是？

结果是：52。

DATE是一个union, 变量公用空间，里面最大的变量类型是int[5], 占用20个字节，所以它的大小是20；data是一个struct, 每个变量分开占用空间，依次为int4 + DATE20 + double8 = 32，所以结果是 20 + 32 = 52。

当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20。

2、结构体字节计算

struct name1{

char  str;

short x;

int   num;

}

struct name2{

char str;

int num;

short x;

}

sizeof(struct name1),sizeof(struct name2)的结果是多少？

答：sizeof(struct name1)=8,sizeof(struct name2)=12

在第二个结构中，为保证num按四个字节对齐，char后必须留出3字节的空间；同时为保证整个结构的自然对齐（这里是4字节对齐），在x后还要补齐2个字节，这样就是12字节。

3、结构体位域字节计算

struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

struct s2

{

int i: 8;

int j: 4;

double b;

int a:3;

};

printf("sizeof(s1)= %d\n", sizeof(s1));

printf("sizeof(s2)= %d\n", sizeof(s2));

答：输出是: 16, 24

对于struct s1，理论上是这样的，首先是i在相对0的位置，占8位一个字节，然后，j就在相对一个字节的位置，由于一个位置的字节数是4位的倍数，因此不用对齐，就放在那里了，然后是a，要在3位的倍数关系的位置上，因此要移一位，在15位的位置上放下，目前总共是18位，折算过来是2字节2位的样子，由于double是8字节的，因此要在相对0要是8个字节的位置上放下，因此从18位开始到8个字节之间的位置被忽略，直接放在8字节的位置了，因此，总共是16字节。

对于struct s2，最后会对照是不是结构体内最大数据的倍数，不是的话，会补成是最大数据的倍数。

五、动态内存分配

1、动态内存分配

下面的程序会出现什么结果？

#include <stdio.h>

#include <stdlib.h>

void getmemory(char *p)

{

p=(char *) malloc(100);

strcpy(p,"hello world");

}

int main( )

{

char *str=NULL;

getmemory(str);

printf("%s/n",str);

free(str);

return 0;

}

答：程序崩溃，getmemory中的malloc 不能返回动态内存， free（）对str操作很危险。

2、动态内存分配

下面程序的输出结果是什么？

void GetMemory(char **p,int num)

{

*p=(char *)malloc(num);

}

int main()

{

char *str=NULL;

GetMemory(&str,100);

strcpy(str,"hello");

free(str);

if(str!=NULL)

{

strcpy(str,"world");

}

printf("\n str is %s",str);

getchar();

}

答：输出str is world。

free 只是释放的str指向的内存空间,它本身的值还是存在的。

六、其他

1、无符号类型整数自动转换

下面的代码输出是什么，为什么？

void foo(void)

{

unsigned int a = 6;

int b = -20;

(a+b > 6) ? puts("> 6") : puts("<= 6");

}

这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6"。原因是当表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。

2、表达式是否合理

下面的结构是合法的吗？

int a = 5, b = 7, c;

c = a+++b;

上面的例子是完全合乎语法的。根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理成：c = a++ + b;

因此, 这段代码持行后a = 6, b = 7, c = 12。

3、自增运算

请写出下列代码的输出内容

#include<stdio.h>

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）;

return 0;

}

答：10，12，120

4、自增运算

写出表达式计算 a的值：

int a = 4;

a += (a++);

a += (++a) ;

(++a) += a;

(++a) += (a++);

答：依次为9,10,10,11

5、循环嵌套

请问下面程序有什么错误?

int a[60][250][1000],i,j,k;

for(k=0;k<=1000;k++)

for(j=0;j<250;j++)

for(i=0;i<60;i++)

a[i][j][k]=0;

答案：把循环语句内外换一下

6、死循环

请问下面程序会出现什么情况?

.    #define Max_CB 500

void LmiQueryCSmd(Struct MSgCB * pmsg)

{

unsigned char ucCmdNum;

......

for(ucCmdNum=0;ucCmdNum<Max_CB;ucCmdNum++)

{

......;

}

}

答案：死循环

7、绝对地址赋值

对绝对地址0x100000赋值且想让程序跳转到绝对地址是0x100000去执行：

(unsigned int*)0x100000 = 1234;

首先要将0x100000强制转换成函数指针,即:

(void (*)())0x100000

然后再调用它:

*((void (*)())0x100000)();

用typedef可以看得更直观些:

typedef void(*)() voidFuncPtr;

*((voidFuncPtr)0x100000)();

8、二进制转换

下列代码的输出值为多少？

unsigned short A = 10;

printf("~A = %u\n", ~A);

char c=128;

printf("c=%d\n",c);

答：～A ＝0xfffffff5,int值 为－11，但输出的是uint。所以输出4294967285；

c＝0x10,输出的是int，最高位为1，是负数，所以它的值就是0x00的补码就是128，所以输出－128。

这两道题都是在考察二进制向int或uint转换时的最高位处理。

9、交换两个变量的值，不使用第三个变量。

即a=3,b=5,交换之后a=5,b=3;

有两种解法, 一种用算术算法, 一种用^(异或)

a = a + b;

b = a - b;

a = a - b;

or

a = a^b;// 只能对int,char..

b = a^b;

a = a^b;

or

a ^= b ^= a;

10、用宏定义写出swap（x，y）

#define swap(x, y)/

x = x + y;/

y = x - y;/

x = x - y;

11、一句代码实现x是否为2的若干次幂的判断

int i = 512;

cout << boolalpha << ((i & (i - 1)) ? false : true) << endl;

---------------END-------------------

（人言落日是天涯，望极天涯不见家）