中兴手机嵌入式开发笔试题2010_将一个int型整数1002存到磁盘

中兴手机嵌入式开发笔试题
windyleaf07 发表于 2010-5-13 21:45:00
1:将一个整数10002存到磁盘上，以ASCII码形式存储和以二进制形式存储，占用的字节数分别是 c
A.2和2
B.2和5
C.5和2
D.5和5

知识点：数据类型的存储方式

2:表达式 !x 等效于 b
A.x1
**B.x0**
C.x!=1
D.x!=0

知识点：逻辑非

3:执行下列程序

  #include  ″stdio. h″
  main 
  {
    printf(″%d\n″,NULL);
  }
1
2
3
4
5

** 后输出的结果是b**

A.-1
B.0
C.1
D.2

知识点：NULL的含义

4:下列关于C语言的叙述错误的是 d
A.英文字母大小写不加以区分
B.不同类型的变量可以出现在同一个表达式中
C.在赋值表达式中赋值号两边的类型可以不同
D.某些运算符在不同的场合可以有不同的含义

5:设 int a=9,b=20 ;则 printf( ″ %d,%d\n ″ ,a–,--b) ;的输出结果是 a
A.9 ， 19
B.9 ， 20
C.10 ， 19
D.10 ， 20

知识点：运算符的优先级

6:函数调用语句“ f((e1,e2),(e3,e4,e5)) ”中参数的个数是 b
A.1
B.2
C.3
D.5

知识点：函数调用

7:以“只读”方式打开文本文件 a: \ aa.dat, 下列语句中哪一个是正确的 d
A.fp=fopen( ” a: \ aa.dat ” , ” ab ” ) //向二进制文件尾增加数据
B.fp=fopen( ” a: \ aa.dat ” , ” a ” ) //向文本文件尾增加数据
C.fp=fopen( ” a: \ aa.dat ” , ” wb ” )//为输出打开一个二进制文件
D.fp=fopen( ” a: \ aa.dat ” , ” r ” )

知识点：文件的打开方式

8:在C语言中，有值函数的数据类型是指 b
A.函数形式参数的数据类型
B.函数返回值的数据类型
C.调用该函数时的实参的数据类型
D.任意指定的数据类型

知识点：有值函数

9:表达式 !x||a==b 等效于 d
A.!((x||a)b)
B.!(x||y)b
C.!(x||(ab))
**D.(!x)||(ab) **

知识点：运算符的优先级

10:设int a=10, b=20, c=30;条件表达式a B

A.5
B.10
C.20
D.30

11:下列数据中，不是C语言常量的是 c
A.′\n′
B.″a″
C.e-2
D.012

12:C语言中计算a的3次方，正确的表达是 b
A.a^3
B.pow(a,3)
C.a**3
D.power(a,3)
知识点：c的库函数

13:下列标识符中，不是C语言保留字的是 c
A.char
B.while
C.min
D.default

14:调用函数时，若实参是一个数组名，则向函数对应的形参传送的是 b
A.数组的长度
**B.数组的首地址 **
C.数组第一个元素的值
D.整个数组元素的值

16:执行语句“ k=5 | 3; ”后，变量 k 的当前值是 a
A.1
B.8
C.7
D.2

17:完成 C 源文件编辑后、到生成执行文件， C 语言处理系统必须执行的步骤依次为 b
A.连接、编译
B.编译、连接
C.连接、运行
D.运行

18:执行语句 printf( " |%9.4f|\n " ,12345.67); 后的输出结果是 b
A.|2345.6700|
B.|12345.6700|
C.|12345.670|
D.|12345.67|

19:C语言不能选用的字母是 b
A.w
B.π
C.I
D.i

20:若变量定义时未初始化，则其值不确定的是 b
A.静态全局变量
B.局部变量 //堆栈空间
C.静态局部变量
D.全局变量

知识点：变量定义

分析一个细节：C语言中，定义局部变量时如果未初始化，则值是随机的，为什么？
定义局部变量，其实就是在栈中通过移动栈指针来给程序提供一个内存空间和这个局部变量名绑定。因为这段内存空间在栈上，而栈内存是反复使用的（脏的，上次用完没清零的），所以说使用栈来实现的局部变量定义时如果不显式初始化，值就是脏的。如果你显式初始化怎么样？
C语言是通过一个小手段来实现局部变量的初始化的。
int a = 15; // 局部变量定义时初始化
C语言编译器会自动把这行转成：
int a; // 局部变量定义
a = 15; // 普通的赋值语句
--------------------- 
作者：robert_wzf 
来源：CSDN 
原文：https://blog.csdn.net/robert_wzf/article/details/52462923 
版权声明：本文为博主原创文章，转载请附上博文链接！
1
2
3
4
5
6
7
8
9
10
11
12

21:char **p, a[16][8]; 问：p=a是否会导致程序在以后出现问题？为什么？

可能，有可能指针指向的地址为0，引起系统崩溃

a[0][0]=0,*p=a[0][0],**p的未知

22:命令tail用来打印文件中最后n行。命令格式为：
　　tail [-n] filename
　　其中
　　-n: n表示需要打印的行数，当省略此参数时，n的缺省值为10。
　　filename: 给定文件名。
　　例如，命令tail –20 example.txt表示打印文件example.txt的最后20行。
　　请用C语言实现该程序，该程序应具有一定的错误处理能力，例如能处理非法命令参数和非法文件名。
　　提示1：使用命令行参数;
　　提示2：可以使用下面的C库函数：

• int atoi(char *s)将数字串转换为相应整数;
• fopen, fclose, printf, fprintf, exit;
• fgets(char *s, int n, FILE *fp)从文件中读入一行;
• void *malloc(unsigned size), free申请和释放内存;
• strlen计算字符串长度;
• strcpy将一个字符串拷贝到另一个字符串中。
  除此之外，不允许使用其它库函数。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define DEFLINS 10
#define LINES  100     
#define MAXLEN 100     //每一行最大字符数量

void error(char *);
int getline(char *, int);

int main(int argc, char *argv[])
{
    char *p;                 //用于指示缓冲区中当前指针的位置 
    char *buf;               //用于指示分配出来的内存块开始处
    char *bufend;            //用于指示分配出来的内存块结尾处
    char line[MAXLEN];       //用于保存当前输入
    char *lineptr[LINES];    //定义一个字符指针数组，这样能节省很多空间
    int first, i, last, len, n, nlines;

    if (argc == 1)           //没有可选项，则使用默认配置
        n = DEFLINS;
    else if (argc == 2 && (*++argv)[0] == '-')  
        n = atof(argv[0] + 1);
    else
        error ("usgae: tail [-n]");

    if (n < 1 || n > LINES)   //容错处理
        n = LINES;

    for (i = 0; i < LINES; i++)   //字符指针数组初始化
        lineptr[i] = NULL;

    //分配一块内存，用于保存输入的文本行
    if ((p = buf = (int *)malloc(LINES * MAXLEN)) == NULL)   
        error ("tail: cannot allocate buf");

    bufend = buf + LINES * MAXLEN;   //指向内存末尾后一个字符
    last = 0;         //用于指示最新输入行所保存的位置
    nlines = 0;       //用于保存输入的文本行总数

    while ((len = getline(line, MAXLEN)) > 0)
    {
        //判断剩余空间是否充足，如果不充足则将p重新指向缓冲区的开头
        if (p + len + 1 >= bufend) 
            p = buf;

        lineptr[last] = p;       //保存当前缓冲区的地址
        strcpy (lineptr[last], line);   //字符串拷贝
        if (++last >= LINES)     //若大于限制的最大行数，则重置  
            last = 0;
        p += len + 1;            //p指到下一个未被使用的缓冲区地址处
        nlines++;
    }
    if (n > nlines)        
        n = nlines;
    first = last - n;   
    if (first < 0)    //轮回情况，即超过了最大行数，last重置了重新使用数组，所以小于0
        first += LINES;  //调整起始索引

    for (i = first; n-- > 0; i = (i + 1) % LINES)
        printf ("%s", lineptr[i]);

    return 0;
}

void error(char *s)
{
    printf ("%s\n", s);
    exit (1);
}

int getline(char *s, int lim)
{
    int c, i;

    for (i = 0; i < lim - 1 && (c = getchar()) != EOF && c != '\n'; ++i)
        s[i] = c;

    if (c == '\n')
    {
        s[i] = c;
        ++i;
    }
    s[i] = '\0';
    return i;
}
--------------------- 
作者：talent_CYJ 
来源：CSDN 
原文：https://blog.csdn.net/talent_CYJ/article/details/51820488 
版权声明：本文为博主原创文章，转载请附上博文链接！
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

23:重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
重写：是指子类重新定义复类虚函数的方法。
从实现原理上来说：
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！
重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

24:讲述const，static，extern的作用；

const:
1.修饰右边的基本变量和指针变量;
2.被const修饰的变量只读,也就是只能获取，不能修改。
static:

1、扩展生存期；
2、限制作用域；
3、唯一性
1
2
3

extern:
extern作用:声明外部全局变量。

25:耶稣有13个门徒，其中有一个就是出卖耶稣的叛徒，请用排除法找出这位叛徒：13人围坐一圈，从第一个开始报号：1，2，3，1，2，3……，凡是报到“3”就退出圈子，最后留在圈内的人就是出卖耶稣的叛徒，请找出它原来的序号。

int a[13] = {1,2,3,4,5,6,7,8,9,10,11,12,13};
    int number = 13;//记录当前人数
    int count = 0;//1,2,3报数
    int i = 0;
    while (number > 1) {
        if (a[i] != 0) {
            count++;
        }
        if (count == 3) {
            a[i] = 0;//剔除的人
            count = 0;
            number--;
        }
        i++;
        if (i == 13) {
            i = 0;
        }
      }
    for ( i = 0; i < 13; i++) {
        if (a[i] > 0) {
            printf("%d", a[i]);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

26:C/C++源代码中，检查花括弧“（”与 “）”，“{”与“}”）是否匹配，若不匹配，则输出不匹配花括弧所在的行与列。

代码模型
char c;
while(1){
c = getc(std);//从文件或输入流、控制台读入一个字符
if(c=='\n')   line++;//如果读到回车行数加一
if(c=='(')  push(c,line);//no代表当前行号
if(c==')'){  
       if(isempty()==0){//判断栈空否
            pop();
           //如果不空说明(有不匹配，则把不匹配的行号都打出来
       }else{
           //如果空了则说明)括号不匹配
       }
}
同理{ }也能判断出来。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

27:写一个病毒。

28:一堆数在一个集合中，总共2n个，问如何将这些数分成A，B两分，每分n个，要求A中的数均小于B中的数，需要考虑时间复杂度。

摘要：利用对手论证法证明中位数问题的比较次数下界 
 
 
5个数通过6次比较求中位数的方法如下：

5个数之间的大小关系构成的一个树形图T。T中的一个结点代表一个数，而一条边代表它所关联的两个数的大小关系，T的根就是中位数。显然T中的一条边要由一次比赛来确定。在下面的图中，如果x大于y，则节点x在节点y的上方且x和y有一条边相连。另外，*表示一般的数，o表示下一次即将进行比较的两个数。

第1步，先任取两个数比较，结果为：

  *
  |
  *  o o *

第2步，再取另外两个数比较，结果为：

  o  o
  |  |
  *  *  *
 
第3步，按照上图比较其中两个标记为o的数，比较结果只有一种情况：

   *
  / \
 *   o
 |  
 *      o
 
第4步，按照上图比较其中两个标记为o的数，比较结果有两种情况：

   *    o               *
  /  \ /               / \
 o    *               o   o
 |                    |   |
 *                    *   *
 
第5步，按照上图比较其中两个标记为o的数，比较结果有两种情况：

  *    *               *
 / \  / \             /
/   \/   \           /
|   /\   |          /
|  /  \  |         *
| /    \ |         | \
|/      \|         |  \
o        o         |   \
|                  o    o
|                       |
|                       |
*                       *

第6步，按照上图比较其中两个标记为o的数，比较结果有两种情况：

 
*   *         *   *            *               *
 \ /           \ /             |               |
  x             x              *               *
  |            / \             |               |
  *           *   *            x               x
  |                            |              / \
  *                            *             *   *
                               |
                               *

其中的x就是中位数。


事实上，可以证明：对于n个数求中位数，至少需要3(n-1)/2次比较，并且存在一个O(n)次比较的算法。

下面介绍如何利用对手论证方法来证明中位数问题的比较次数下界。

首先介绍“对手论证（Adversary Argument）”方法。

若用P表示所讨论的问题，I表示问题的输入，A表示求解问题P的基于比较运算的算法T(A,I)表示对于输入I算法A的计算时间复杂性，那么，函数
       U(n)=min{max{T(A,I)}, for each I}, for each A，
是问题P当输入的大小为n时在最坏情况下的最好下界。它是问题所固有的。

问题P的这个最好下界通常很难按其定义计算得到，因为对于一个具体的A，要得到
       max{T(A,I)}, for each I
就是一件很难的事，更何况对于一切的A。因此，人们往往不去精确地求U(n)，而是退而求其次，即找一个f(n)，它不大于U(n)但尽量地接近于U(n)，使f(n)成为问题P的一个好下界。
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
73
74
75
76
77
78
79

29:设计一函数，求整数区间[a,b]和[c,d]的交集

public int[] rangeOfOveride(int a, int b, int c, int d) {
	int begin = Math.max(a, c);
	int end = Math.min(b, d);
	int[] range = new int[2];
	if(begin > end) return null;
	else {
		range[0] = begin;
		range[1] = end;
	}
	return range;
}
1
2
3
4
5
6
7
8
9
10
11

**30:unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问： p1+5=（unsigned char *)0x801005; **

     p2+5=（unsigned long *)0x810019;
1