华清远见成都中心-C语言笔试题答案

C语言笔试题答案

一、简答题

1.程序的局部变量存在于(栈)中，全局变量存在于(静态区)中，动态申请数据存在于

(堆)中。

2.设有以下说明和定义：

typedefunion{longi;intk[5];charc;}DATE;

structdata{intcat;DATEcow;doubledog;}too;

DATEmax;

贝1」语句printfC^d';sizeoftstructdate)+sizeof(max));的执行结果是：

data是一个union,变量公用空间.里面最大的变量类型是屁⑸，占用20个字节;所以

它的大小是20。

data是一个struct,每个变量分开占用空间.依次为int4+DATE20+doubles=32.所以结

果是20+32=52.

3.32位系统下，请问如下语句的值

unsignedchar*pl;

unsignedlong*p2;

pl=(unsignedchar*)0x801000;

p2=(unsignedlong*)0x810000;

请问pl+5=0x801005

p2+5=0x810014

4.inti=10J=10,k=3;k*=i+j;k最后的值是?

答：60,此题考察优先级，实际写成：k*=(i+j);,赋值运算符优先级最低

5.#defineDOUBLE(x)x+x,i=5*DOUBLE(5)；i是多少？

答案：i为30o

6.下面程序的输出是,为什么？

char*ptr;

if((ptr=(char*)malloc(0))==NULL)

(

puts("Gotanullpointer");

)

else

(

puts("Gotavalidpointer")；

)

答：Gotavalidpointe

当malloc分配内存时它除了分配我们指定SIZE的内存块，还会分配额外的内存来存储

我们的内存块信息，用于维护该内存块。因此，malloc(0)返回一个合法的指针并指

向存储内存块信息的额外内存，我们当然可以在该内存上进行读写操作，但是这样做了

会破坏该内存块的维护信息，因此当我们调用free(ptr)时就会出现错误

在MSDN可以找到答案

原话是

"Ifsizeis0,mallocallocatesazero-lengthitemintheheapandreturnsavalidpointe

rtothatitem"

如果申请内存大小为0,还是会返回一个有效指针

返回指针为NULL的条件是申请一定大小内存，内存空间不够的时候

7.以下程序运行后的输出结果是。

main()

(

charm;

m='B'+32;printf("%c\rT,m);

)

答：b

8.已有定义如下：

structnode

(

intdata;

structnode*next;

)*P；

以下语句调用malloc函数，使指针p指向一个具有structnode类型的动态存储空间。

请填空p=(structnode*)malloc();

答：sizeof(structnode)

9.在绝对地址OxXXXXXXXX上写入字符H的语句是。

答：unsignedchar*p=(unsignedchar*)OxFOOOFFOO;

*P=

10.用预处理指令#define声明一个常数，用以表明1年中有多少秒(忽略闰年问题)，

#defineSECONDS_PER_YEAR(60*60*24*365)UL

1)define语法的基本知识(例如：不能以分号结束，括号的使用，等等)

2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有

多少秒而不是计算出实际的值，是更清晰而没有代价的。

3)意识到这个表达式将使•个16位机的整型数溢州-因此要用到长整型符号L,告诉编

译器这个常数是的长整型数。

4)如果你在你的表达式中用到UL(表示无符号长整型)，那么你有了一个好的起点。

记住，第一印象很重要。

11.写一个“标准”宏MIN,这个宏输入两个参数并返回较小的一个。

#defineMIN(A,B)((A)<=(B)?(A):(B))

1)标识#define在宏中应用的基本知识。这是很重要的。因为在嵌入(inline)操作符变

为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为

了能达到要求的性能，嵌入代码经常是必须的方法，

2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比

if-then-else更优化的代码，了解这个用法是很重要的。

3)懂得在宏中小心地把参数用括号括起来，因为#define仅仅做替换，如果我们写

#defineMUL(a,b)a/b的话，那么我写MUL(a+l,b・l)替换之后的表达式就为a+1/替工,

这个结果显然是违背我们定义的目的的。

12.嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？

这个问题用几个解决方案。

while(l){}或者for(;;){}

13.用变量a给出下面的定义

a)—*个整型数(Aninteger)

b)一个指向整型数的指针(Apointertoaninteger)

c)•个指向指针的的指针，它指向的指针是指向■个整型数(Apointertoapointerto

anintege)

d)一个有10个整型数的数组(Anarrayof10integers)

e)一个有10个指针的数组，该指针是指向一个整型数的。(Anarrayof10pointersto

integers)

f)一个指向有10个整型数数组的指针(Apointertoanarrayof10integers)

g)一个指向函数的指针，该函数有一个整型参数并返回一个整型数(Apointertoa

functionthattakesanintegerasanargumentandreturnsaninteger)

h)一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返同一

个整型数(Anarrayoftenpointerstofunctionsthattakeanintegerargumentand

returnaninteger)

答案是：

a)inta;//Aninteger

b)int*a;//Apointertoaninteger

c)int**a;//Apointertoapointertoaninteger

d)inta[10];//Anarrayof10integers

e)int*a[10];//Anarrayof10pointerstointegers

f)int(*a)[10j;//Apointertoanarrayof10integerssizeof(a)=4;sizeof(*a)=40;

g)int(*a)(int);//Apointertoafunctionathattakesanintegerargumentandreturnsan

integer

h)int(*a[10])(int);//Anarrayof10pointerstofunctionsthattakeanintegerargumentand

returnaninteger

14.关键字static的作用是什么？

全局变量(外部变量)的说明之前再冠以static就构成了静态的全局变量。全局变量本身

就是静态存储方式，静态全局变量当然也是静态存储方式。这两者在存储方式上并无

不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序，当一个源程序由

多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。而静态全局变量

则限制了其作用域，即只在定义该变量的源文件内有效，在同一源程序的其它源文件

中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的

函数公用，因此可以避免在其它源文件中引起错误。从以上分析可以看出，把局部变

量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静

inta,b;

a=*ptr;

b=*ptr;

returna*b;

)

由于*ptr的值可能被意想不到地该变，因此a和b可能是不同的。结果，这段代只可能

返不是你所期望的平方值！正确的代码如下：

longsquare(volatileint*ptr)

(

inta;

a=*ptr;

returna*a;

)

20.在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa660编译器是一个

纯粹的ANSI编译器.写代码去完成这一任务。

答：

int*ptr;

ptr=(int*)0x67a9;

*ptr=0xaa55;

21.局部变量能否和全局变量重名？

答：能，局部会屏蔽全局。要用全局变量，需要使用“:局部变量可以与全局变量同

名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有

些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都

定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。

22.如何引用一个已经定义过的全局变量？

答：extern

可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某

个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果

你用extern方式引用时，，假定你犯了同样的错误，那么在编译期间不会报错，而在连

接期间报错。

23.全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？

答：可以，在不同的(:文件中以static形式来声明同名全局变量。可以在不同的C文件

中声明同名的全局变量，前提是其中只能有一个C叉件中对此变量赋初值，此时连接不

会出错.

24.语句for(:1：)有仆么问题？它是什么意思？

答：和while(l)相同，死循环。

25.d。.while和while......do17什么区别？

答：前一个循环一遍再判断，后一个判断以后再循环。

26.下列哪种方法更好，为什么？

definedPSstructs*

typedefstructs*tPS;

以上两种情况的意图都是要定义dPS和tPS作为一个指向结构s指针。哪种方法更好

呢？(如果有的话)为什么？

这是一个非常微妙的问题，任何人答对这个问题(正当的原因)是应当被恭喜的。答案

是：typedef更好。思考下面的例子：

dPSpl,p2;

tPSp3,p4;

第一个扩展为

structs*plzp2;

上面的代码定义pl为一个指向结构的指,p2为一个实际的结构，这也许不是你想要的。

第二个例子正确地定义了p3和p4两个指针。

27.下面的结构是合法的吗，如果是它做些什么？

inta=5,b=7,c;

c=a+++b;

根据最处理原则，编译器应当能处理尽可能所有合法的用法。因此，上面的代码被处理

成：

c=a+++b;

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

28.队列和栈有什么区别？

队列先进先出，栈后进先出

29.全局变量和局部变量是否有区别？如果有，是什么区别？

全局变最储存在静态数据库，局部变最在堆栈。

全局变量的作用域在定义之下的任何位置

而局部变量的作用域在函数模块内

全局变量的生命周期从编译开始到程序结束

而局部变量的声明周期从定义开始到函数结束

30.堆栈溢出一般是由什么原因导致的？

没有回收垃圾资源。

31.冒泡排序算法的时间赛杂度是什么？+

时间复杂度是O(N2)。

32.分别写出BOOL,int,float,指针类型的变量a与“零〃的比较语句。

答案：

BOOL:if(!a)orif(a)

int:if(a==0)

float:constEXPRESSIONEXP=0.000001

if(a<EXP&&a>-EXP)

pointer:if(a!=NULL)orif(a==NULL)

33.不能做switch。的参数类型是：

switch的参数不能为实型。

34.某32位系统下，请L算sizeof的值.

charstr[]="http:〃/"

char*p=str;

intn=10;

请计算

sizeof(str)=?(1)

sizeof(p)=?(2)

sizeof(n)=?(3)

voidFoo(charstr[100]){

sizeof(str)=?(4)

)

void*p=mallocf100);

sizeof(p)=?(5)

答：(1)字符串末尾有‘\0'字符，所以是17

(2)4

(3)4

(4)str是指针而并非数组，所以是4,在形参中不能定义数组，所有以数组形式出

现的都是指针

(5)p的类型是指针所以是4

35.请说出const与#defire相比，有何优点？

答：

1)const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全

检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料

不到的错误。

2)有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

36.回答下面的问题.

a)头文件中的ifndef/define/endif干什么用？预处理

答：防止头文件被重复引用

b)#include<filename.h>fO#include"filename.h”有什么区别?

答：前者用来包含开发环境提供的库头文件，后者用来包含自己编写的头文件。

37.使用malloc()函数时，为什么要将其返回值强制转换成被赋值指针变量的数据类型？

答:因为malloc返回值为void*型指针，对于void*型指针必须先强制类型转换才能够

使用。

38.列举•个软件中时间换空间或者空间换时间的例子。

答：

voidswap(intajntb)

(

intc;c=a;a=b;b=a;

)

空间换时间

voidswapfinta,intb)

(

a=a+b;b=a-b;a=a-b;

)

39.以下C语言语句有什么区别

char*constp;

charconst*p;

constchar*p;

答：

char*constp;〃常量指针,p的值不可以修改

charconst*p；〃指向常量的指针，指向的常量值不可以改

constchar*p：〃和charconst*p

40.下面x,y,*p的值是多少，有什么问题？

intx,y,z=2;

int*p=&z;

x=sizeof*p;

V=x/*p；

答：如果你按这个写出来，肯定编译不过去。最明显的：y=x/*p;应该改为y=x/(*p)

还有sizeof*p改为sizeof(*p)；

y=2,x=4,z=2,*p=2;

41.下面的语句是什么意思？如何声明或定义才使它们更易懂？(10分)

int(*foo())();*foo()为一指针函数，inta()函数

int(*foo())[];*foo()为一指针函数，inta。数组

int(*foo[])();*foo口为一指针数组，inta()函数

(*(void(*)())0)();void(*)()为一函数指针，⑶0,数据类型转换，(*a川函数指针

void(*signal(int,void(*)(int)))(int);

void(与(int)函数指针，*signal(int,a)指针函数，voidb(int)函数

答：

第一个：int(*foo())();

先一步一步的分析：首先是被左边的()括起来的*匕。()。

(1)里面()的优先级高于*,所以foo()先是一个函数；

⑵*foo()说明这个函数返回一个指针；

(3)(*foo())()这个函数返回的指针指向一个函数；

(4)int(*foo())();

(5)最后这个函数返回一个整型数。

第二个：int(*foo(皿；

有上面的打基础了，这回好多了。大致还是那个意思，但是就是由函数变成了数组，

所以还更简单些，具体的含义是：f。")函数返回的指针指向一个具有整型数的数组。

第三个：int(*foo[])();

这个就是上两个的翻版：一个存有指针的数组叶。。口，该指针指向一个函数，该函

数返回一个整型数。

第四个：(*(void(*)())0)();

(1)最里面的(*)()意思是一个指向函数的指针；

(2)加个前缀void(>(),表示一个指向返I口I类型为void的函数的指针；

(3)套个马甲(void(*M))的意思就是类型强制转换：

(4)(void(*)())0就是把0强制转换成前面说的那个类型的指针；

(5)那么好，现在(void(*)())0是一个指计了，这个指针指向了一个函数，我任用宏

定义简化一下，看着太麻烦：

(6)#defineptr(void(*)())0,现在(*(void(*)())0)();这个怪物就可以简化成：(*ptr");

(7)别忘了ptr是一个指向函数的指针，既然这样*ptr就是函数了，那么上面的结

果再次被简化成：ptr();,这不就是函数的调用么！

至此这个怪物函数的含义和简化形式就都给出了，我就不再总结了。不过我还想再

给出一个简化形式，这会对下面的问题有启示：

使用typedef,typedefvoid(*ptij();,然后就可以用(*(ptr)O)();来表示这个怪物函数

了，其灵活性比使用#€12例€要高。

第五个：

void(*signal(intzvoid(*)(int)))(int);

这是著名的signal函数的原型，可以如此声明：

typedefvoid(*H^NDLER)(int);

HANDLERsignal(int,HANDLER);

或者：

typedefvoidHANDLER(int);

HANDLER*signal(int,HANDLER*);

42.如何定义Bool变量的TRUE和FALSE的值。

答：#defineTURE1

#defineFALSE0

43.运行chara[]=〃abc〃后，内存会开辟几块内存，这此内存共占多少个字节？

答：这句话为定义数组，省略下表后根据元素个数决定，因为“abc”为字符串，加上

末尾’\0'共有4个元素所以是四个字节。

44.运行char*p=〃abc"后，内存会开辟几块内存，这此内存共占多少个字节？

答：这句话为定义指计指向字符串常量区字符串“abc”，任何指针都为4个字节，所以

共占4个字节。

45.说出⑶；p是什么变量？如果p是指针变量，那么p+1的偏移量是多少？

答：P为指针变量，P指向类型为装了三个元素的指针数组，因为所有指针在32位系

统下都是四个字节，所以偏移量为12个字节。

46.一个32位的机器，该机器的指针是多少位？

答:32位

47.已知一个数组table,用一个宏定义，求出数据的元素个数

答：ttdefinelength(table)(sizeof(table)/sizeof(table[0]»

二、程序分析题

1.下面的代码有什么问题？

char*_strdup(constchar*strSource)

staticcharstr[MAX_STR_LEN];

strcpy(stcstrSource);

returnstr;

)

答：返I可局部变量地址。

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

voidfoo(void)

(

unsignedinta=6;

intb=-20;

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

)

答：这个问题测试你是否懂得C语言中的整数自动转换原则，我发现有些开发者懂得极

少这些东西。不管如何，这无符号整型问题的答案是输出是”>6,原因是当表达式中

存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类型。因此-20变成

了一个非常大的正整数，所以该表达式计算出的结果大于6。

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

#include

main{)

(

•nta,b,c,d;

a=10;

b=a++;

c=++a;

d=10*a++;

printff'b,c,d：%d,%d,%d",b,c,d);

return0;

)

答:10,12,120

4.lest函数的运行结果如何？

voidGetMemory(char*p)

(

p=(char*)malloc(100);

)

voidTest(void)

(

char*str=NULL;

GetMemory(str);

strcpyfstr,"helloworld");

printf(str);

)

答：段错误，GetMemory(str)传的是str地址并没有改变str的值，所以p并不能够

改变str的指向，str依然是NULL,strcpy向NULL赋值造成段错误。

5.Test函数的运行结果如何？

char*GetMemory(void)

charp[]="hellov/orld";

returnp;

)

voidTest(void)

(

char*str=NULL;

str=GetMemoryl);

printf(str);

)

答：返回局部变量地址。

6.Test函数的运行结果如何？

VoidGetMemory2(char**p,intnum)

(

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

)

voidTest(void)

(

char*str=NULL;

GetMemoryf&str,100);

strcpy(str,"hello");

printf(str);

)

答：内存溢出，malloc申请的空间使用结束之后没有释放

7.Test函数的运行结果如何？

voidTest(void)

(

char*str=(char4)malloc(lOO);

strcpy(str,"hello");

free(str);

if(str!=NULL)

(

strcpy(str,"world");

printf(str);

)

)

答：一内存溢出，二free释放malloc申请的内存空间之后继续操作该空间，但是该程

序能够打印出world但是操作是非法的。

8.写出下列代码的输出内容

#indude

intinc(inta)

(

return(++a);

)

intmulti(int*a,int*b,int*c)

return(*c=*a**b);

)

typedefint(FUNCl)(intin);

typedefint(FUNC2)(int*Jnt*zint*);

voidshow(FUNC2fcnjntargl,int*arg2)show(multi,10.&a)

(

INCp=&inc;

inttemp=p(argl);

funt&temp^argl,arg2);

printf("%dn"/arg2);

)

main()

(

inta;

show(multi,10,&c);

return0;

)

答：110

9.请找出下面代码中的所以错误

说明：以下代码是把一个字符串倒序，如"abed”倒序后变为"dcba〃

#include"string.h"

main()

(

char*src="hello/world";

char*dest=NULL;

intlen=strlen(src);

dest=(char*)malloc(len);

char*d=dest;

char*s=src[len];

while(len-!=0)

d++=s-;

printf(“%s”,dest);

return0;

)

答：

方法1：

intmain()

|

char*sre="heIo,world";

intlen=strlen(src);

char*dest=(char*)malloc(len+l);〃要为0分配一个空间

char*d=dest;

char*s=&src[len-l];〃指向最后一个字符

while(len-!=0)

*d++=*s—;

*d=0;〃尾部要加0

printf(”％sn”,dest);

free(dest);//便用完，应当释放空间，以免造成内存汇泄露

return0;

)

方法2：

Intmain()

(

charstr[]="hello/world";

intlen=strlen(str);

chart;

for(inti=0;i{

t=str[i];

str[i]=str[len-i-l];str[len-i-l]=t;

)

printf("%s",str);

return0;

)

10.以下程序有什么错误

试题1：

voidtestlf)

(

charstring[10];

char*strl="0123456789";

strcpy(string,strl);

)

答:数组越界string数组只有十个元素空间，字符串strl有11个字节

试题2：

voidtest2()

(

charstring[10]zstrl[10];

inti;

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

(

strl='a"；

)

strcpyfstring,strl)；

)

答:有可能造成数组越界，stC里所有元素都是字符‘a',strcpy及制遇到‘\0'才会

停止，而strl数组里没有字符串结束标志'\01所以有可能造成数组越界。

试题3：

voidtest3(char*strl)

(

charstring[10];

if(strlen(strl)<=10)

(

strcpy(string,strl);

}

)

答：if(strlen(strl)<=10)应改为if(strlen(strl)<10),因为strlen的结果未统计所占用

的1个字节。

11.下面程序的运行结果：

main()

(

inta[5]={lz2,3A5};

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

printf("%d/%d"/*(a+l)/*(ptr-l));

)

答：2,5

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

intmain()

(

chara;char*str=&a;

strcpy(str,"hello");

printf(str);

return0;

)

答：没有为str分配内存空间，将会发生异常问题出在将一个字符串复制进一个字符变

最指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。

13.交换两个变量的值，不使用第三个变量。即a=3,b=5,交换之后a=5,b=3;

答：

a=aAb;

b=aAb;

a=aAb;

14.以下是求一个数的平方的程序，请找出错误：

#defineSQUARE(a)((a)*(a))

inta=5;

intb;

b=SQUARE(a++);

答：要写成inta=5;a++;b=SQUARE(a),不然直接传a++的值还是5。

15.下面的程序运行结果是()

设

intarr[]={6/7,8,9,10);

int*ptr=arr;

(ptr++)+=123;//

print—"%d,%dM,*ptr,*(++ptr));

答：8,8

16.下面的两段代吗？有什么区别？什么时候需要使用代码2?

1、

inti=10;

intj=i;

intk=i;

2、

volatileinti=10;

intj=i;

intk=i;

答：代码1,这时候编译器对代码进行优化，因为在代码1中的两条语句之间i没有被

用作左值(即没有被赋值)，这时候编译器认为i的值没有发生改变，所以在第1条语

句时从内存取出i的值赋给j之后，这个值并没有被丢掉，而在第2条语句时，继续用

这个值给k赋值。编译器不会生成汇编代码重新从内存读取i的值。

代码2,volatile关键字告诉编译器，i是随时可能发生的变化的，每次使用它的时候，

必须从内存中取出i的值。因而编译器生成的汇编代码会重新从i的地址处读取数据放

在k中。

代码2,的使用时机，如果i是一个寄存器变量，表示一个商品数据或者是多个线程的

共享数据，那么就容易出错，所以说volatile可以保证对特殊地址的稳定访问。

17.printf("%d",OxOl«2+3);输出?

答：7。〃应该为32,因为在操作符的优先级中，算术操作符的优先级高于移位运算操

作符的优先级

18.在32位的X86系统下，输出的值为多少？

include<stdio.h>

intmain()

(

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

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

int*ptr2=(int*)((int)a+1);

printf("%d,%x",p:rl[-l],*ptr2);

〃注意从高字节开始打印

return0;

)

答:5,2

19.下面代码的有问题吗？为什么？

include<stdio.h>

voidfunc(chara(10])/相当于voidfunc(char*a)

(

charc=a[3];

}

intmain()

(

charb[10]="abcdefg";

func(b[10]);

return0;

)

答：这里至少有两上严重错误，

第一，b[10]并不存在，在编译的时候，由于没有去实际地址取值，所以没有出错。但

在运行的时，

将计算b[10]的实际地址，并且取值。这时候发生越界错误。

第二，func函数会将传入的char类型的数据当作地址处理，同样会发生错误。

20.下面代码输出的结果是多少？

#include<stdio.h>

voidfun(inti)

(

if(i>0)

(

fun(i/2);

)

printf("%d\n"J);

)

intmain()

(

fun(10);

return0;

)

答：0,1,2,5,10析：递归展开

三、编程题

1.不调用库函数，自己实现memcpy困数。

typedefintsize_tt;

〃源串要有修饰

void*memcpy(void*dest,constvoid*srczsize_ttcount)const

(

char*pDest=(char*)(dest);〃将原始指针赋给新变量

constchar*pSrc=(constchar*)(src);

〃判断传参是否合法

if(NULL==dest11NULL==src)

(

returnNULL;

)

〃目的地址和源地址重叠，从源地址的末尾方向开始拷贝

if(pDest>pSrc&&pDest<pSrc+count)

〃将指针指向末尾

pDest=pDest+count-1;

pSrc=pSrc+count-1;

while(count-)

*pDest--=*pSrc--;

)

)

〃目的地址和源地址不重叠，从源地址的开始方向拷贝

else

(

while(count-)

(

*pDest++=*pSrc++;

)

)

returnpDest;〃返I可，这样可以嵌套使用

}

2.不调用库函数，自己实现strcpy函数。

intStrcmp(constchar*strl,constchar*str2)

(

assert(strl&&srt2);

while(*strl&&*str2&&(*strl==*str2))

(

strl-i-+;

str2++;

}

return(*strl-*str2);

)

3.

a)编写strcat函数，已知strcat函数的原型是char*strcat(char*strDest,constchar

*strSrc);其中strDest是目的字符串,strSrc是源字符串(不能调用库函数)。

include<stdio.h>

char*strcat(char*dst,constchar*src)

{

if(NULL==dst11NULL==src)

{

returnNULL;

)

char*cp=dst;

whilef*cp)

cp++;/*findendofdst*/

while(*cp++=*src++);/*Copysrctoendofdst*/

returndst;/*returndst*/

)

intmain()

(

charstrl[100]="helloworld";

charstr2[]="Jt'sbeautiful!";

printf("%s\n”,strcat(strl,st⑵)；

return0;

)

b)strcat能把strSrc的内容连接到strDest,为什么还要char*类型的返回值？

答：方便赋值给其他变量

4.两个字符串，s,t;把t字符串插入到s字符串中，s字符串有足够的空间存放t字符串。

char*insert(char*t,constchar*s)

(

char*q=t;

constchar*p=s;

if(NULL==q]

returnNULL;

while(*p!='\0')

{

P++；

)

while(+q!=0)

(

*p=*q;

P++；

q++；

)

*P='\0';

returnt;

)

5.写一函数，实现删除字符串strl中含有的字符串str2。

ftinclude<stdio.h>

char*delstr(char*src,constchar*sub)

(

char*st=src,*sl=NULL;

constchar*s2=NULL;

while(*st&&*sub)

si=st;

s2=sub;

while(*sl&&*s2&&!(*sl-*s2))

(

sl-+；

s2-+;

)

if(I*s2)

(

while(*st++=*sl++);

st=src;

)

st++;

)

return(src);

)

intmain()

(

charstrl[]="nihaowodepengyou";

charstr2[]="hao";

printf("%s\n",delstr(strl,st⑵);

return0;

}

6.编程，判断存储方式是大端存储，还是小端存储，并说出为什么要进行大小端的判定？

intcheck_little_endian()

(

union{

inta;

charb;

)c；

c.a=l;

return(c.b==1);

)

intcheck_little_endian()

(

inti=0x00000001;

char*p=&a;

return*P;

)

staticunion

(

charc[4];

unsignedlongI;

}endian_test={{'l'；?7?7b,}};

"defineENDIANNESS((char)endian_test.l)

7.不调用库函数，自己实现longatol(constchar*nptr)函数。

long_cdeclatol(constchar*nptr)/*1.const修饰*/

(

intc;/*currentchar*/

longtotal;/*currenttotal*/

intsign;/*ifthennegative,otherwisepositive*/

/*skipwhitespace*/

/♦char,signedcharunsignedchar类型的数据具有相同的特性然而当你把一

个单字节的数赋给一个整型数时，便会看到它们在符号扩展上的差异。*/

/*ascii码当赋给整形数时要转为unsignedchar再转为int*/

while(isspace((int)(unsignedchar)*nptr))/*2.去掉首部的空格*/

++nptr;

c=(int)(unsignedchar)*nptr++;/*取得第一个非空格的字符*/

sign=c;/*savesignindication*/

if(c==c=='+')〃如果笫一个非空格字符为符号”/

c=(int)(unsignedchar)*nptr++;/*skipsign*/

/*跳过符号，将符号后的那个字符给c*/

total=0;/*结果置为0*/

while(isdigit(c)){/*3.如果碰到非法字符则停止*/

total=10*total+(c-'0');/*accumulatedigit*/

c=(int)(unsignedchar)*nptr++;/*getnextchar*/

)

if(sign==

return-total;

else

returntotal;/*returnresult,negatedifnecessary*/

}

8.编写strcat函数0。已知strcat函数的原型是char*str:at(char*strDest,constchar*strSrc);

其中strDest是目的字符串，strSrc是源字符串。

a)不调用C++/C的字符串库函数，请编写函数strcato

char*_cdeelstrcat(char*dst,constchar*sre)

{

insert(dest!=NULL&&sre!=NULL);

char*cp=dst;

whilef*cp)

cp++;/*findendofdst*/

while(*cp++=*src++);/*Copysretoendofdst*/

return(dst);/*returndst*/

)

b)strcat能把strSrc的内容连接到strDest,为什么还要char*类型的返回值？

答：方便赋值给其他变量

9.写一个函数，它的原形是intcontinumax(char*outputstr,char*intputstrj。功能：在字符串

中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个

函数参数outputstr所指内存。例如："abcdl2345edl25ssi23456789”的首地址传给

intputstr后，函数将返回9,outputstr所指的值为123456789

intcontinumax(char*outputstr,char*inputstr)

(

char*in=inputstr,*out=outputs"*temp,“final;

intcount=0,maxlen=0;

while(*in!='\0')

(

if(*in>47&&*in<58)

(

for(temp=in;*in>47&&*in<58;in++)

count++;

)

else

in++;

if(maxlen<count)

(

maxlen=count;

count=0;

final=temp;

)

)

for(inti=0;i<maxlen;i++)

*out=*final;

out++;

final++;

)

*out='\0';

returnmaxlen;

)

10,不用库函数，用C语言实现将一整型数字转化为字符串。

intgetlen(char*s)

(

intn;

for(n=0;*s!='\0';s++)

n++；

returnn;

)

voidreverse(chars[])

(

intc,i,j;

for(i=0J=g2tlen(s)-1;i<j;i++J-)

(

c=s[i];

s[i]=s[j]；

sUl=c;

)

)

voiditoa(intn,chars[])

(

inti,sign;

if((sign=n)<0)

n=-n;

i=0;

do{/*以反序生成数字*/

s(i++]=n%10+'O';/*getnextnumber*/

}while((n/=10)>0);/*deletethenumber*/

if(sign<0)

s[i++]=

s[i]='\0';

reverse(s);

)

#inclu