嵌入式C语言面试题汇总(2)

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

void foo(void)

{

unsigned int a = 6;

int b = -20;

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

}

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

极少这些东西。不管如何，这无符号整型问题的答案是输出是 ">6″。原因是当

表达式中存在有符号类型和无符号类型时所有的操作数都自动转换为无符号类

型。因此-20 变成了一个非常大的正整数，所以该表达式计算出的结果大于 6。

这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果

你答错了这个问题，你也就到了得不到这份工作的边缘。

2、评价下面的代码片断：

unsigned int zero = 0;

unsigned int compzero = 0xFFFF;

/*1′s complement of zero */

对于一个 int 型不是 16 位的处理器为说，上面的代码是不正确的。应编写如下：

unsigned int compzero = ~0;

这一问题真正能揭露出应试者是否懂得处理器字长的重要性。在我的经验里，好

的嵌入式程序员非常准确地明白硬件的细节和它的局限，然而 PC 机程序往往把

硬件作为一个无法避免的烦恼。

3、 C 语言同意一些令人震惊的结构,下面的结构是合法的吗，如果是它做些什

么？

int a = 5, b = 7, c;

c = a+++b;

这个问题将做为这个测验的一个愉快的结尾。不管你相不相信，上面的例子是完

全合乎语法的。问题是编译器如何处理它？水平不高的编译作者实际上会争论这

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

c = a++ + b;

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

如果你知道答案，或猜出正确答案，做得好。如果你不知道答案，我也不把这个

当作问题。我发现这个问题的最大好处是这是一个关于代码编写风格，代码的可

读性，代码的可修改性的好的话题。

4、设有以下说明和定义：

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 date)+sizeof(max));的执行结果是？

答 、结果是：52。DATE 是一个 union, 变量公用空间. 里面最大的变量类型是

int[5], 占用 20 个字节. 所以它的大小是 20

data 是一个 struct, 每个变量分开占用空间. 依次为 int4 + DATE20 + double8

= 32.

所以结果是 20 + 32 = 52.

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

double8 = 20

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

#include

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

6、写出下列代码的输出内容

#include

int inc(int a)

{

return(++a);

}

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

{

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

} typedef int(FUNC1)(int in);

typedef int(FUNC2) (int*,int*,int*);

void show(FUNC2 fun,int arg1, int*arg2)

{

INCp=&inc;

int temp =p(arg1);

fun(&temp,&arg1, arg2);

printf(“%d\n”,*arg2);

}

main()

{

int a;

show(multi,10,&a);

return 0;

}

答：110

7、请找出下面代码中的所以错误

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

1、#include”string.h”

2、main()

3、{

4、 char*src=”hello,world”;

5、 char* dest=NULL;

6、 int len=strlen(src);

7、 dest=(char*)malloc(len);

8、 char* d=dest;

9、 char* s=src[len];

10、 while(len–!=0)

11、 d++=s–;

12、 printf(“%s”,dest);

13、 return 0;

14、}

答：

方法 1：

int main(){

char* src = “hello,world”;

int len = strlen(src);

char* dest = (char*)malloc(len+1);//要为\0 分配一个空间

char* d = dest;

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

while( len– != 0 ) *d++=*s–;

*d = 0;//尾部要加\0

printf(“%s\n”,dest);

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

return 0;

}

方法 2：

#include

#include

main()

{

char str[]=”hello,world”;

int len=strlen(str);

char t;

for(int i=0; i

{

t=str[i];

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

}

printf("%s",str);

return 0;

}

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

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;

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

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

. #define Max_CB 500

void LmiQueryCSmd(Struct MSgCB * pmsg)

{

unsigned char ucCmdNum;

......

for(ucCmdNum=0;ucCmdNum<MAX_CB;UCCMDNUM++)

{

......;

}

答案：死循环 10、以下 3 个有什么区别

char * const p; //常量指针，p 的值不可以修改

char const * p；//指向常量的指针，指向的常量值不可以改

const char *p； //和 char const *p

11、写出下面的结果

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 是指针，它们指向相同的常量区域。

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

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

{

for( size_t i=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 实际只是一个指向字符串的指针，没有

任何额外的与数组相关的信息，因此 sizeof 作用于上只将其当指针看，一个指

针为 4 个字节，因此返回 4。 13、写出输出结果

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].

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

int main()

{

char a;

char *str=&a;

strcpy(str,"hello");

printf(str);

return 0;

}

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

问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结

果，但因为越界进行内在读写而导致程序崩溃。

char* s="AAA";

printf("%s",s);

s[0]='B';

printf("%s",s);

有什么错？

"AAA"是字符串常量。s 是指针，指向这个字符串常量，所以声明 s 的时候就有

问题。 cosnt char* s="AAA";

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

15、有以下表达式：

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; 禁止

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

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

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

.#include

#include

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 操作很

危险 18、下面的语句会出现什么结果？

char szstr[10];

strcpy(szstr,”0123456789″);

答案：长度不一样，会造成非法的 OS，应该改为 char szstr[11]；

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

答：其中 ptr 为同一个指针

.(void *)ptr 和 (*(void**))ptr 值是相同的

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

int main()

{

int x=3;

printf(“%d”,x);

return 1;

}

答：mian 中，c 标准认为 0 表示成功，非 0 表示错误。具体的值是某中具体出错

信息

21、对绝对地址 0×100000 赋值且想让程序跳转到绝对地址是 0×100000 去执行

(unsigned int*)0×100000 = 1234;

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

(void (*)())0×100000

然后再调用它:

*((void (*)())0×100000)();

用 typedef 可以看得更直观些:

typedef void(*)() voidFuncPtr;

*((voidFuncPtr)0×100000)();

22、输出多少？并分析过程

unsigned short A = 10;

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

char c=128;

printf(“c=%d\n”,c);

第一题，～A ＝0xfffffff5,int 值 为－11，但输出的是 uint。所以输出

4294967285

第二题，c＝0×10,输出的是 int，最高位为 1，是负数，所以它的值就是 0×00

的补码就是 128，所以输出－128。

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

23、分析下面的程序：

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 指向的内存空间,它本身的值还是存在的.

所以 free 之后，有一个好的习惯就是将 str=NULL.

此时 str 指向空间的内存已被回收,如果输出语句之前还存在分配空间的操作的

话,这段存储空间是可能被重新分配给其他变量的,

尽管这段程序确实是存在大大的问题（上面各位已经说得很清楚了），但是通常

会打印出 world 来。

这是因为，进程中的内存管理一般不是由操作系统完成的，而是由库函数自己完

成的。

当你 malloc 一块内存的时候，管理库向操作系统申请一块空间（可能会比你申

请的大一些），然后在这块空间中记录一些管理信息（一般是在你申请的内存前

面一点），并将可用内存的地址返回。但是释放内存的时候，管理库通常都不会

将内存还给操作系统，因此你是可以继续访问这块地址的，只不过。。。。。。。。

楼上都说过了，最好别这么干。

24、char a[10],strlen(a)为什么等于 15？运行的结果

#include “stdio.h”

#include “string.h”

void main()

{

char aa[10];

printf(“%d”,strlen(aa));

}

sizeof()和初不初始化，没有关系；

strlen()和初始化有关。

char (*str)[20];/*str 是一个数组指针，即指向数组的指针．*/

char *str[20];/*str 是一个指针数组，其元素为指针型数据．*/ 25、long a=0×801010;a+5=?

答：0×801010 用二进制表示为：“1000 0000 0001 0000 0001 0000”，十进

制的值为 8392720，再加上 5 就是 8392725

26、给定结构 struct A

{

char t:：4;

char k:4;

unsigned short i:8;

unsigned long m;

};问 sizeof(A) = ?

给定结构 struct A

{

char t:4; 4 位

char k:4; 4 位

unsigned short i:8; 8 位

unsigned long m; // 偏移 2 字节保证 4 字节对齐

}; // 共 8 字节

27、下面的函数实现在一个数上加一个数，有什么错误？请改正。

int add_n ( int n )

{

static int i = 100;

i += n;

return i;

}

当你第二次调用时得不到正确的结果，难道你写个函数就是为了调用一次？问题

就出在 static 上

28、给出下面程序的答案

#include

#include

#include

#include

#include

#include

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 和１

29、求函数返回值，输入 x=9999;

int func （ x ）

{

int countx = 0;

while ( x )

{

countx ++;

x = x&(x-1);

}

return countx;

}

结果呢？

知道了这是统计 9999 的二进制数值中有多少个 1 的函数，且有

9999＝9×1024＋512＋256＋15

9×1024 中含有 1 的个数为 2；

512 中含有 1 的个数为 1；

256 中含有 1 的个数为 1；

15 中含有 1 的个数为 4；

故共有 1 的个数为 8，结果为 8。

1000 - 1 = 0111，正好是原数取反。这就是原理。

用这种方法来求 1 的个数是很效率很高的。

不必去一个一个地移位。循环次数最少。

30、分析：

struct bit

{ int a:3;

int b:2;

int c:3;

};

int main()

{ bit s;

char *c=(char*)&s;

cout<<SIZEOF(BIT)<<ENDL;

*c=0x99;

cout << s.a <<<s.b<<endl<<s.c<<endl;

int a=-1;

printf("%x",a);

return 0;

}

输出为什么是

4

1

-1

-4

ffffffff

因为 0x99 在内存中表示为 100 11 001 , a = 001, b = 11, c = 100

当 c 为有符合数时, c = 100, 最高 1 为表示 c 为负数，负数在计算机用补码表

示，所以 c = -4;同理

b = -1;

当 c 为有符合数时, c = 100,即 c = 4,同理 b = 3

31、下面这个程序执行后会有什么错误或者效果:

#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了..无限循环下去.

32、写出 sizeof(struct name1)=,sizeof(struct name2)=的结果

struct name1{

char str;

short x;

int num;

} struct name2{

char str;

int num;

short x;

}

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

在第二个结构中，为保证 num 按四个字节对齐，char 后必须留出 3 字节的空间；

同时为保证整个结构的自然对齐（这里是 4 字节对齐），在 x 后还要补齐 2 个字

节，这样就是 12 字节。

33、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));

result: 16, 24

第一个 struct s1

{

int i: 8;

int j: 4;

int a: 3;

double b;

};

理论上是这样的，首先是 i 在相对 0 的位置，占 8 位一个字节，然后，j 就在相

对一个字节的位置，由于一个位置的字节数是 4 位的倍数，因此不用对齐，就放

在那里了，然后是 a，要在 3 位的倍数关系的位置上，因此要移一位，在 15 位

的位置上放下，目前总共是 18 位，折算过来是 2 字节 2 位的样子，由于 double

是 8 字节的，因此要在相对 0 要是 8 个字节的位置上放下，因此从 18 位开始到

8 个字节之间的位置被忽略，直接放在 8 字节的位置了，因此，总共是 16 字节。

第二个最后会对照是不是结构体内最大数据的倍数，不是的话，会补成是最大数

据的倍数 34、在对齐为 4 的情况下

struct BBB

{

long num；

char *name;

short int data;

char ha;

short ba[5];

}*p;

p=0x1000000;

p+0x200=____;

(Ulong)p+0x200=____;

(char*)p+0x200=____;

希望各位达人给出答案和原因，谢谢拉

解答：假设在 32 位 CPU 上，

sizeof(long) = 4 bytes

sizeof(char *) = 4 bytes

sizeof(short int) = sizeof(short) = 2 bytes

sizeof(char) = 1 bytes

由于是 4 字节对齐，

sizeof(struct BBB) = sizeof(*p)

= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经 Dev-C++验

证)

p=0x1000000;

p+0x200=____;

= 0x1000000 + 0x200*24

(Ulong)p+0x200=____;

= 0x1000000 + 0x200

(char*)p+0x200=____;

= 0x1000000 + 0x200*4

35、找错

Void test1()

{

char string[10];

char* str1="0123456789";

strcpy(string, str1);// 溢出，应该包括一个存放'\0'的字符 string[11]

}

Void test2()

{ char string[10], str1[10];

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

{

str1[i] ='a';

}

strcpy(string, str1);// I，i 没有声明。

}

Void test3(char* str1)

{

char string[10];

if(strlen(str1)<=10)// 改成<10,字符溢出，将 strlen 改为 sizeof 也可以

{

strcpy(string, str1);

}

}

36、写出输出结果

void g(int**);

int main()

{

int line[10],i;

int *p=line; //p 是地址的地址

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

{

*p=i;

g(&p);//数组对应的值加 1

}

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

printf("%d\n",line[i]);

return 0;

}

void g(int**p)

{

(**p)++;

(*p)++;// 无效

}

输出：

1

2

3

4

5

6 7

8

9

10

37、写出程序运行结果

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

}

}

// static 会保存上次结果，记住这一点，剩下的自己写

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

38、评价代码

int func(int a)

{

int b;

switch(a)

{

case 1: 30;

case 2: 20;

case 3: 16;

default: 0

}

return b;

}

则 func(1)=?

// b 定义后就没有赋值

int a[3];

a[0]=0; a[1]=1; a[2]=2; int *p, *q;

p=a;

q=&a[2];

则 a[q-p]=a[2]

解释：指针一次移动一个 int 但计数为 1

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

char *RetMenory(void)

{

char p[] = “hellow world”;

return p;

}

void Test(void)

{

char *str = NULL;

str = RetMemory();

printf(str);

}

RetMenory 执行完毕，p 资源被回收，指向未知地址。返回地址，str 的内容应

是不可预测的, 打印的应该是 str 的地址

40、写出输出结果

typedef struct

{

int a:2;

int b:2;

int c:1;

}test;

test t;

t.a = 1;

t.b = 3;

t.c = 1;

printf("%d",t.a);

printf("%d",t.b);

printf("%d",t.c);

t.a 为 01,输出就是 1

t.b 为 11，输出就是－1

t.c 为 1，输出也是-1

3 个都是有符号数 int 嘛。

这是位扩展问题

01

11 1

编译器进行符号扩展

41、对下面程序进行分析

void test2()

{

char string[10], str1[10];

int i;

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

{

str1[i] = 'a';

}

strcpy( string, str1 );

}

解答：如果面试者指出字符数组 str1 不能在数组内结束可以给 3 分；如果面试

者指出 strcpy(string, str1)调用使得从 str1 内存起复制到 string 内存起所

复制的字节数具有不确定性可以给 7 分，在此基础上指出库函数 strcpy 工作方

式的给 10 分；

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

}

42、分析：

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

43、分析下面的代码：

char *a = "hello";

char *b = "hello";

if(a= =b)

printf("YES");

else

printf("NO");

这个简单的面试题目,我选输出 no(对比的应该是指针地址吧),可在 VC 是 YES

在 C 是 NO

lz 的呢，是一个常量字符串。位于静态存储区，它在程序生命期内恒定不变。

如果编译器优化的话，会有可能 a 和 b 同时指向同一个 hello 的。则地址相同。

如果编译器没有优化，那么就是两个不同的地址，则不同

44、写出输出结果

#include

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 标准中对这种方式说明为未定义，所以

各个编译器厂商都有自己得理解，所以最后产生得结果完全不同。

因为这样，所以遇见这种函数，我们首先要考虑我们得编译器会如何处理

这样得函数，其次看函数得调用方式，不同得调用方式，可能产生不同得

结果。最后是看编译器优化。

45、找出错误

#include string.h

main(void)

{ char *src=”hello,world”;

char *dest=NULL;

dest=(char *)malloc(strlen(src));

int len=strlen(str); char *d=dest;

char *s=src[len];

while(len–!=0)

d++=s–;

printf(“%s”,dest);

}

找出错误！！

#include “string.h”

#include “stdio.h”

#include “malloc.h”

main(void)

{

char *src=”hello,world”;

char *dest=NULL;

dest=(char *)malloc(sizeof(char)*(strlen(src)+1));

int len=strlen(src);

char *d=dest;

char *s=src+len-1;

while(len–!=0)

*d++=*s–;

*d=’\0′;

printf(“%s”,dest);

}