1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

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操作很危险。
    
void main()
{
	char aa[10];
     printf(“%d”,strlen(aa));
}
// 会出现什么问题？打印结果是是多少？
【标准答案】sizeof()和初不初始化，没有关系，strlen()和初始化有关，打印结果值未知。

1
2
3
4

char szstr[10]; 
strcpy(szstr,"0123456789"); 
// 产生什么结果？为什么？
【标准答案】长度不一样，出现段错误。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

struct A
{
    char t:4; 
    char k:4;
    unsigned short i:8;
    unsigned long m;
};
// 问sizeof(A) = ?
【标准答案】8

struct name1{
     char str;
	short x; int num;
}；
// 求sizeof(name1)?
【标准答案】8
    
struct name2{ 
    char str;
    int num; 
    short x;
};
// 求sizeof(name2)？
【标准答案】12

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// 程序哪里有错误
wap( int* p1,int* p2 )
{
    int *p;
    *p = *p1;
    *p1 = *p2;
    *p2 = *p;
}
【标准答案】p为野指针
    
(void *)ptr 和 (*(void**))
//ptr的结果是否相同？其中ptr为同一个指针。
【标准答案】(void *)ptr 和 (*(void**))ptr值是相同的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

/* 要对绝对地址0x100000赋值，我们可以用(unsigned int*)0x100000 = 1234;
那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？ */

【标准答案】*((void (*)( ))0x100000 ) ( );
首先要将0x100000强制转换成函数指针,即: (void (*)())0x100000
然后再调用它:
*((void (*)())0x100000)();


/* 嵌入式系统经常具有要求程序员去访问某特定的内存位置的特点。在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器。写代码去完成这一任务。 */
【参考答案】这一问题测试你是否知道为了访问一绝对地址把一个整型数强制转换（typecast）为一指针是合法的。这一问题的实现方式随着个人风格不同而不同
。典型的类似代码如下：
int *ptr;
ptr = (int *)0x67a9;
*ptr = 0xaa55;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// 1. 请写出下列代码的输出内容#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）;
    return 0;
}
【标准答案】10，12，120
           
unsigned char *p1; unsigned long *p2;
p1=(unsigned char *)0x801000; p2=(unsigned long *)0x810000; 
// 2. 请问p1+5= ;   p2+5= ;
【标准答案】0x801005、0x810020
           
void main()
{
    int a[5]={1,2,3,4,5};
    int *ptr=(int *)(&a+1); 
    printf(“%d，%d”,*(a+1),*(ptr-1));
}
// 3. 请问输出：
【标准答案】2,5
      
// 4. 以下是求一个数的平方的程序,请找出错误: #define SQUARE(a)((a)*(a))
int a=5; int b;
b=SQUARE(a++);
【标准答案】宏在预编译时会以替换的形式展开，仅仅会替换。涉及到宏的地方，不要用++ --，标准中对此没有规定，因此最终结果将会依赖于不同的编译器。执行程序的答案可能是25、也有可能是36。
           
#define Max_CB 500
void LmiQueryCSmd(Struct MSgCB * pmsg)
{
    unsigned char ucCmdNum;
    ......
    for(ucCmdNum=0;ucCmdNum<Max_CB;ucCmdN um++)
    {
        ......;
    }
}
// 5. 这段代码执行有什么问题？
【标准答案】死循环
unsigned char //无符号字符型 表示范围0~255 char //有符号字符型 表示范围-128~127

int modifyvalue()
{
    return(x+=10);
}
int changevalue(int x)
{
    return(x+=1);
}
void main()
{
    int x=10; x++;
    changevalue(x); x++;
    modifyvalue();
    printf("First output:%dn",x); x++;
    changevalue(x); printf("Second output:%dn",x); modifyvalue();
    printf("Third output:%dn",x);
}
// 6. 输出?
【 标准答案】12、13、13

// 7. 请写出下列代码的输出内容
＃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

1
2
3
4
5
6
7
8

// 9. 下面的代码输出是什么，为什么？ 
void foo(void)
{
    unsigned int a = 6; int b = -20;
    (a+b > 6)? puts("> 6") : puts("<= 6");
}
【参考答案】这个问题测试你是否懂得C语言中的整数自动转换原则，
我发现有些开发者懂得极少这些东西。不管如何，这无符号整型问题的答案是输出是“>6”。原因是当表达式中存在有符号类型和无符号类型时所有的数都自动转换为无符号类型。因此-20变成了一个非常大的正整数，所以该表达式计算出的结果大于6。这一点对于应当频繁用到无符号数据类型的嵌入式系统来说是丰常重要的。如果你答错了这个问题，你也就到了得不到这份工作的边缘。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 1. 一语句实现x是否为2的若干次幂的判断。
void main()
{
    int a; scanf(“%d”,&a);
    printf(“%c”,(a)&(a-1)?’n’:’y’); //  若是打印y，否则n
}

// 2. 中断是嵌入式系统中重要的组成部分，这导致了很多编译开发商提供一种扩展—让标准C支持中断。具代表事实是，产生了一个新的关键字interrupt。下面的代码就使用了	interrupt关键字去定义了一个中断服务子程序(ISR)，请评论一下这段代码的。
interrupt double compute_area (double radius)
{
double area = PI * radius * radius; printf(" Area = %f", area);
return area;
}
【参考答案】这个函数有太多的错误了，以至让人不知从何说起了：
1).	ISR 不能返回一个值。如果你不懂这个，那么你不会被雇用的。
2).	ISR 不能传递参数。如果你没有看到这一点，你被雇用的机会等同第一项。
3).	在许多的处理器/编译器中，浮点一般都是不可重入的。有些处理器/编译器需要让额处的寄存器入栈，有些处理器/编译器就是不允许在ISR中做浮点运算。此外，ISR应该是短而有效率的，在ISR中做浮点运算是不明智的。
4).	与第三点一脉相承，printf()经常有重入和性能上的问题。如果你丢掉
了第三和第四点，我不会太为难你的。不用说，如果你能得到后两点，那么你的被雇用前景越来越光明了

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

// 1. 编写 strcpy 函数, 已知 strcpy 函数的原型是 char *strcpy(char *strDest, const char *strSrc);其中 strDest 是目的字符串， strSrc 是源字符串。
（1）	不调用 C++/C 的字符串库函数，请编写函数
strcpy 。

（2）	strcpy 能把 strSrc 的内容复制到 strDest，为什么还要 char * 类型的返回值？

// 2. 请编写一个 C 函数，该函数给出一个字节中被置 1 的位的个数。
unsigned int TestAsOne0(char log)
{
    int i;
    unsigned int num=0, val; for(i=0; i<8; i++)
    {
        val = log >> i; //移位val &= 0x01; //与1相与if(val)
        num++;
    }
    return num;
}

// 3. 实现strcmp函数


// 4. 华为面试题：怎么判断链表中是否有环？
【参考答案】答：用两个指针来遍历这个单向链表，第一个指针p1，每次走一步；第二个指针p2，每次走两步； 当p2 指针追上 p1的时候，就表明链表当中有环路了。
int	testLinkRing(Link *head)
{
    Link *t1=head,*t2=head; while( t1->next && t2->next)
    {
        t1 = t1->next;
        if (NULL == (t2 = t2->next->next)) return 0;	//无环
        if (t1 == t2)
        return 1;
    }
    return 0;
}

// 5. 实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数。


// 6. 把一个链表反向 。
【参考答案】从第一个元素开始，ps指向他，将他（ps）指向头节点(ps->next= head)，将ps设为头节点（head = ps;）操作下一个元素（ps = pe->next;）等于是依次将每个元素翻到原头节点前面。

// 7. 取一个整数a从右端开始的4～7位。
void main()
{
	unsigned a,b,c,d; 
    scanf("%o",&a); 
    b=a>>4; c=~(~0<<4);
	d=b&c; 
    printf("%o\n%o\n",a,d);
}