1将一个字符串逆序
2、将一个链表逆序
3、计算一个字节里（byte）里面有多少bit被置1
4、搜索给定的字节(byte)
5、在一个字符串中找到可能的最长的子字符串
6、字符串转换为整数
7、整数转换为字符串
答案：
1、方法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;
}
2、
链表题：一个链表的结点结构
struct Node
{
int data ;
Node *next ;
};
typedef struct Node Node ;
(1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel)
Node * ReverseList(Node *head) //链表逆序
{
if ( head == NULL || head->next == NULL )
return head;
Node *p1 = head ;
Node *p2 = p1->next ;
Node *p3 = p2->next ;
p1->next = NULL ;
while ( p3 != NULL )
{
p2->next = p1 ;
p1 = p2 ;
p2 = p3 ;
p3 = p3->next ;
}
p2->next = p1 ;
head = p2 ;
return head ;
}
(2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）
Node * Merge(Node *head1 , Node *head2)
{
if ( head1 == NULL)
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
Node *p1 = NULL;
Node *p2 = NULL;
if ( head1->data < head2->data )
{
head = head1 ;
p1 = head1->next;
p2 = head2 ;
}
else
{
head = head2 ;
p2 = head2->next ;
p1 = head1 ;
}
Node *pcurrent = head ;
while ( p1 != NULL && p2 != NULL)
{
if ( p1->data <= p2->data )
{
pcurrent->next = p1 ;
pcurrent = p1 ;
p1 = p1->next ;
}
else
{
pcurrent->next = p2 ;
pcurrent = p2 ;
p2 = p2->next ;
}
}
if ( p1 != NULL )
pcurrent->next = p1 ;
if ( p2 != NULL )
pcurrent->next = p2 ;
return head ;
}
(3)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。 (Autodesk)
答案：
Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
if ( head1->data < head2->data )
{
head = head1 ;
head->next = MergeRecursive(head1->next,head2);
}
else
{
head = head2 ;
head->next = MergeRecursive(head1,head2->next); }
return head ;
}
3、
考点：各种位操作符的使用
出现频率：☆☆☆
解析：
源程序如下所示：
1 #include
2
3 #define BIT7 (0x1 << 7)
4
5 int calculate(unsigned char c)
6 {
7 int count = 0;
8 int i = 0;
9 unsigned char comp = BIT7;
10
11 for (i = 0; i < sizeof(c) * 8; i++)
12 {
13 if ((c & comp) != 0)
14 {
15 count++;
16 }
17 comp = comp >> 1;
18 }
19
20 return count;
21 }
22 int main(int argc, char* argv[])
23 {
24 unsigned char c = 0;
25 int count = 0;
26
27 printf("c = ");
28 scanf("%d", &c);
29
30 count = calculate(c);
31 printf("count = %d\n", count);
32 return 0;
33 }
程序说明：
一个字节（byte）有8位，因此首先在宏定义BIT7中将最高位置成1。然后在calculate 函数中比较每个位是否被置成1，如果是则为count++，循环结束后返回count的值。最后在main函数中进行测试：如果输入的值为97（二进制为1100001），则最后打印出count= 3。
4、
5、编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是
由同一字符组成的。
char * search(char *cpSource, char ch)
{
char *cpTemp=NULL, *cpDest=NULL;
int iTemp, iCount=0;
while(*cpSource)
{
if(*cpSource == ch)
{
iTemp = 0;
cpTemp = cpSource;
while(*cpSource == ch)
++iTemp, ++cpSource;
if(iTemp > iCount)
iCount = iTemp, cpDest = cpTemp;
if(!*cpSource)
break;
}
++cpSource;
}return cpDest;}
6、
在c语言库函数中将一个字符转换成整型的函数是atool()吗，这个函数的原型是什么？函数名: atol
功能: 把字符串转换成长整型数
用法: long atol(const char *nptr);
程序例:
#include
#include
int main(void)
{
long l;
char *str = "98765432";
l = atol(lstr);
printf("string = %s integer = %ld\n", str, l); return(0);
}
7、
图5-15 程序执行流程图程序代码如下:
#include “stdio.h”
void long2string(long lNum,char chWord[])
{
int i=0,j;
char chTemp;
/*依次取整数的末位，存入chWord*/
while(lNum!=0)
{
chWord[i]='0'+lNum%10;/*转换为数字的ASCII码*/
i++;
lNum=lNum/10;
}
/*字符串最后一位加'\0'*/
chWord[i]='\0';
/*将字符串逆序*/
for(j=0;j
{
chTemp=chWord[j];
chWord[j]=chWord[i-1-j];
chWord[i-1-j]=chTemp;
}
}
main()
{
/* lNum是输入的整数，chWord是转换后的字符串*/
long lNum;
char chWord[50];
/*输入一个整数*/
printf("\nPlease input a integer:\n");
scanf("%ld",&lNum);
/*调用函数进行处理*/
long2string(lNum,chWord);
/*打印输出结果*/
printf("The outputed string=%s",chWord);
}
42. 写一个函数找出一个整数数组中，第二大的数（microsoft）答案：
const int MINNUMBER = -32767 ;
int find_sec_max( int data[] , int count)
{
int maxnumber = data[0] ;
int sec_max = MINNUMBER ;
for ( int i = 1 ; i < count ; i++)
{
if ( data > maxnumber )
{
sec_max = maxnumber ;
maxnumber = data ;
}
else
{
if ( data > sec_max )
sec_max = data ;
}
}
return sec_max ;
}
用两个栈实现一个队列的功能？要求给出算法和思路！
设2个栈为A,B, 一开始均为空.
入队:
将新元素push入栈A;
出队:
(1)判断栈B是否为空；
(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B；
(3)将栈B的栈顶元素pop出；
这样实现的队列入队和出队的平摊复杂度都还是O(1), 比上面的几种方法要好。13.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现? c用宏定义，c++用inline
17.软件测试都有那些种类?
黑盒：针对系统功能的测试
白合：测试函数功能，各函数接口
18.确定模块的功能和模块的接口是在软件设计的那个队段完成的?
概要设计阶段
38. 如何判断一段程序是由C 编译程序还是由C++编译程序编译的？
答案：
#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif
34.类成员函数的重载、覆盖和隐藏区别？
答案：
a.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
b.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）
33.简述数组与指针的区别？
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。
(1)修改内容上的差别
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p 为指针得到的是一个指针变量的字节数，而不是p 所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 字节
cout<< sizeof(p) << endl; // 4 字节
计算数组和指针的内存容量
void Func(char a[100])//a[]在此处知识作为指针传递数组
{
cout<< sizeof(a) << endl; // 4 字节而不是100 字节
}
24. C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。
25. main 函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main 函数之前执行。
26. 描述内存分配方式以及它们的区别?
1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。
2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。
27.struct 和 class 的区别
答案：struct
而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。
从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。
28.当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）
答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。
29. 在8086 汇编下，逻辑地址和物理地址是怎样转换的？（Intel）
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。
18. 重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？
常考的题目。从定义上来说：
重载：是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
重写：是指子类重新定义复类虚函数的方法。
从实现原理上来说：
重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！
重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。19. 多态的作用？
主要是两个：1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。
21. New delete 与malloc free 的联系与区别?
答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.
17.面向对象的三个基本特征，并简单叙述之？
1. 封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)
2. 继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。
3. 多态：是将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象
就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
面向对象的三个基本特征是：封装、继承、多态。
封装
封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。
封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。
继承
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。
通过继承创建的新类称为“子类”或“派生类”。
被继承的类称为“基类”、“父类”或“超类”。
继承的过程，就是从一般到特殊的过程。
要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。
在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。
继承概念的实现方式有三类：实现继承、接口继承和可视继承。
? 实现继承是指使用基类的属性和方法而无需额外编码的能力；
? 接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力；
? 可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。
在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。
抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。
OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。
多态
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
实现多态，有二种方式，覆盖，重载。
覆盖，是指子类重新定义父类的虚函数的做法。
重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。
其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定
的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。”
那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了——代码重用。而多态则是为了实现另一个目的——接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。
9. 结构与联合有和区别？
1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。
2. 对于联合的不同成员赋值, 将会对其它成员重写, 原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。
①链表反转
单向链表的反转是一个经常被问到的一个面试题，也是一个非常基础的问题。比如一个链表是这样的： 1->2->3->4->5 通过反转后成为5->4->3->2->1。
最容易想到的方法遍历一遍链表，利用一个辅助指针，存储遍历过程中当前指针指向的下一个元素，然后将当前节点元素的指针反转后，利用已经存储的指针往后面继续遍历。源代码如下：
1. struct linka {
2. int data;
3. linka* next;
4. };
5. void reverse(linka*& head) {
6. if(head ==NULL)
7. return;
8. linka *pre, *cur, *ne;
9. pre=head;
10. cur=head->next;
11. while(cur)
12. {
13. ne = cur->next;
14. cur->next = pre;
15. pre = cur;
16. cur = ne;
17. }
18. head->next = NULL;
19. head = pre;
20. }
还有一种利用递归的方法。这种方法的基本思想是在反转当前节点之前先调用递归函数反转后续节点。源代码如下。不过这个方法有一个缺点，就是在反转后的最后一个结点会形成一个环，所以必须将函数的返回的节点的next域置为NULL。因为要改变head指针，所以我用了引用。算法的源代码如下：
1. linka* reverse(linka* p,linka*& head)
2. {
3. if(p == NULL || p->next == NULL)
4. {
5. head=p;
6. return p;
7. }
8. else
9. {
10. linka* tmp = reverse(p->next,head);
11. tmp->next = p;
12. return p;
13. }
14. }
六、编写用C语言实现的求n阶阶乘问题的递归算法：
long int fact(int n)
{
int x;
long int y;
if(n<0)
{
printf("error!");
}
if(n==0)
return 1;
x=n-1;
y=fact(x);
return (n*y);
}
8、简述建立TCP连接三次握手的三个步骤。
解答：
1) 请求端（通常称为客户）发送一个S Y N段指明客户打算连接的服务器的端口，以及初始序号（I S N）。S Y N段为报文段1。
2) 服务器发回包含服务器的初始序号的S Y N报文段（报文段2）作为应答。同时，将确认
序号设置为客户的I S N加1以对客户的S Y N报文段进行确认。一个S Y N将占用一个序号。
3) 客户必须将确认序号设置为服务器的I S N加1以对服务器的S Y N报文段进行确认（报文
段3）。
这三个报文段完成连接的建立。这个过程也称为三次握手（three-way handshake）
另外：
建立一个连接需要三次握手，而终止一个连接要经过4次握手。这由T C P的半关闭（h a l f -
c l o s e）造成的。既然一个T C P连接是全双工（即数据在两个方向上能同时传递），因此每个方
向必须单独地进行关闭。这原则就是当一方完成它的数据发送任务后就能发送一个F I N来终止这个方向连接。当一端收到一个F I N，它必须通知应用层另一端几经终止了那个方向的数据传送。发送F I N通常是应用层进行关闭的结果。
的七层网络结构图（功能及特点）OSI
1) 物理层：为数据链路层提供物理连接，在其上串行传送比特流，即所传送数据的单位是比特。此外，该层中还具有确定连接设备的电气特性和物理特性等功能。
2) 数据链路层：负责在网络节点间的线路上通过检测、流量控制和重发等手段，无差错地传送以帧为单位的数据。为做到这一点，在每一帧中必须同时带有同步、地址、差错控制及流量控制等控制信息。
3) 网络层：为了将数据分组从源（源端系统）送到目的地（目标端系统），网络层的任务就是选择合适的路由和交换节点，使源的传输层传下来的分组信息能够正确无误地按照地址找到目的地，并交付给相应的传输层，即完成网络的寻址功能。
4) 传输层：传输层是高低层之间衔接的接口层。数据传输的单位是报文，当报文较长时将它分割成若干分组,然后交给网络层进行传输。传输层是计算机网络协议分层中的最关键一层，该层以上各层将不再管理信息传输问题。
5) 会话层：该层对传输的报文提供同步管理服务。在两个不同系统的互相通信的应用进程之间建立、组织和协调交互。例如，确定是双工还是半双工工作。
6) 表示层：该层的主要任务是把所传送的数据的抽象语法变换为传送语法，即把不同计算机内部的不同表示形式转换成网络通信中的标准表示形式。此外，对传送的数据加密（或解密）、正文压缩（或还原）也是表示层的任务。
7) 应用层：该层直接面向用户，是OSI中的最高层。它的主要任务是为用户提供应用的接口，即提供不同计算机间的文件传送、访问与管理，电子邮件的内容处理，不同计算机通过网络交互访问的虚拟终端功能等。
2. （功能及特点）TCP/IP
1) 网络接口层：这是TCP/IP协议的最低一层，包括有多种逻辑链路控制和媒体访问协议。网络接口层的功能是接收IP数据报并通过特定的网络进行传输，或从网络上接收物理帧，抽取出IP数据报并转交给网际层。
2) 网际网层（IP层）：该层包括以下协议：IP（网际协议）、ICMP（Internet Control Message Protocol,因特网控制报文协议）、ARP（Address Resolution Protocol，地址解析协议）、RARP （Reverse Address Resolution Protocol，反向地址解析协议）。该层负责相同或不同网络中计算机之间的通信,主要处理数据报和路由。在IP层中，ARP协议用于将IP地址转换成物理地址,RARP协议用于将物理地址转换成IP地址，ICMP协议用于报告差错和传送控制信息。IP协议在TCP/IP协议组中处于核心地位。
3) 传输层：该层提供TCP（传输控制协议）和UDP（User Datagram Protocol，用户数据报协议）两个协议，它们都建立在IP协议的基础上，其中TCP提供可靠的面向连接服务，UDP 提供简单的无连接服务。传输层提供端到端，即应用程序之间的通信，主要功能是数据格式化、数据确认和丢失重传等。
4) 应用层：TCP/IP协议的应用层相当于OSI模型的会话层、表示层和应用层，它向用户提供一组常用的应用层协议,其中包括：Telnet、SMTP、DNS等。此外，在应用层中还包含有用户应用程序，它们均是建立在TCP/IP协议组之上的专用程序
请写出float x 与“零值”比较的if 语句。（4 分）
标准答案示例：
const float EPSINON = 0.00001;
if ((x >= - EPSINON) && (x <= EPSINON)
不可将浮点变量用“==”或“！=”与数字
比较，应该设法转化成“>=”或“<=”此
类形式。
如下是错误的写法，不得分。
if (x == 0.0)
if (x != 0.0)
请写出char *p 与“零值”比较的if 语句。（3 分）标准答案：
if (p == NULL)
if (p != NULL)
如下写法均属不良风格，不得分。
if (p == 0)
if (p != 0)
if (p)
if (!)
四、有关内存的思考题（每小题5 分，共20 分）void GetMemory(char *p)
{
p = (char *)malloc(100);
}
void Test(void)
{
char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str);
}
请问运行Test 函数会有什么样的结果？
答：程序崩溃。
因为GetMemory 并不能传递动态内存，
Test 函数中的str 一直都是NULL。
strcpy(str, "hello world");将使程序崩
溃。
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
请问运行Test 函数会有什么样的结果？
答：可能是乱码。
因为GetMemory 返回的是指向“栈内存”
的指针，该指针的地址不是NULL，但其原
现的内容已经被清除，新内容不可知。
void GetMemory2(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
请问运行Test 函数会有什么样的结果？
答：（1）能够输出hello；（2）内存泄漏
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
}
请问运行Test 函数会有什么样的结果？
答：篡改动态内存区的内容，后果难以预
料，非常危险。
因为free(str);之后，str 成为野指针，
if(str != NULL)语句不起作用。
六、编写类String 的构造函数、析构函数和赋值函数（25 分）已知类String 的原型为：
class String
{
public:
String(const char *str = NULL); // 普通构造函数
String(const String &other); // 拷贝构造函数
~ String(void); // 析构函数
String & operate =(const String &other); // 赋值函数
private:
char *m_data; // 用于保存字符串
};
请编写String 的上述4 个函数。
标准答案：
// String 的析构函数
String::~String(void) // 3 分
{
delete [] m_data;
// 由于m_data 是内部数据类型，也可以写成delete m_data; }
// String 的普通构造函数
String::String(const char *str) // 6 分
{
if(str==NULL)
{
m_data = new char[1]; // 若能加NULL 判断则更好
*m_data = …\0?;
}
else
{
int length = strlen(str);
m_data = new char[length+1]; // 若能加NULL 判断则更好 strcpy(m_data, str);
}
}
// 拷贝构造函数
String::String(const String &other) // 3 分
{
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加NULL 判断则更好strcpy(m_data, other.m_data);
}
// 赋值函数
String & String::operate =(const String &other) // 13 分
{
// (1) 检查自赋值// 4 分
if(this == &other)
return *this;
// (2) 释放原有的内存资源// 3 分
delete [] m_data;
// （3）分配新的内存资源，并复制内容// 3 分
int length = strlen(other.m_data);
m_data = new char[length+1]; // 若能加NULL 判断则更好
strcpy(m_data, other.m_data);
// （4）返回本对象的引用// 3 分
return *this;
}
2 写出程序删除链表中的所有接点
void del_all(node *head)
{
node *p;
while(head!=NULL)
{
p=head->next;
free(head);
head=p;
}
cout<<"释放空间成功!"< } Josephu 问题为：设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。 数组实现： #include #include int Josephu(int n, int m) { int flag, i, j = 0; int *arr = (int *)malloc(n * sizeof(int)); for (i = 0; i < n; ++i) arr = 1; for (i = 1; i < n; ++i) { flag = 0; while (flag < m) { if (j == n) j = 0; if (arr[j]) ++flag; ++j; } arr[j - 1] = 0; printf("第%4d个出局的人是：%4d号\n", i, j); } free(arr); return j; } int main() { int n, m; scanf("%d%d", &n, &m); printf("最后胜利的是%d号！\n", Josephu(n, m)); system("pause"); return 0; } 链表实现： #include #include typedef struct Node { int index; struct Node *next; }JosephuNode; int Josephu(int n, int m) { int i, j; JosephuNode *head, *tail; head = tail = (JosephuNode *)malloc(sizeof(JosephuNode)); for (i = 1; i < n; ++i) { tail->index = i; tail->next = (JosephuNode *)malloc(sizeof(JosephuNode)); tail = tail->next; } tail->index = i; tail->next = head; for (i = 1; tail != head; ++i) { for (j = 1; j < m; ++j) { tail = head; head = head->next; } tail->next = head->next; printf("第%4d个出局的人是：%4d号\n", i, head->index); free(head); （一） 1什么是预编译，何时需要预编译： 答案： １、总是使用不经常改动的大型代码体。 ２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。 2 char * const p char const * p const char *p 上述三个有什么区别？ 答案： char * const p; //常量指针，p的值不可以修改 char const * p；//指向常量的指针，指向的常量值不可以改const char *p；//和char const *p 3 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; out < < ( str7 == str8 ) < < endl; 结果是：0 0 1 1 str1,str2,str3,str4是数组变量，它们有各自的存空间；而str5,str6,str7,str8是指针，它们指向相同的常量区域。 4以下代码中的两个sizeof用法有问题吗？ [C易] void UpperCase( char str[] ) // 将str 中的小写字母转换成大写字母 {for( size_t i=0; i （1）什么是预编译，何时需要预编译： 答案： １、总是使用不经常改动的大型代码体。 ２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。 （2）char * const p char const * p const char *p 上述三个有什么区别？ 答案： char * const p; //常量指针，p的值不可以修改 char const * p；//指向常量的指针，指向的常量值不可以改 const char *p； //和char const *p （3）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是指针，它们指向相同的常量区域。 （4）以下代码中的两个sizeof用法有问题吗？ [C易] void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母 { for( size_t i=0; i 1 读程序段，回答问题 (a) int main(int argc,char *argv[]) { int c=9,d=0; c=c++%5; d=c; printf("d=%d\n",d); return 0; } a) 写出程序输出 b) 在一个可移植的系统中这种表达式是否存在风险？why? 答案：5 存在风险，因为c=c++%5;这个表达式对c有两次修改，行为未定义，c的值不确定 (b) #include "stdio.h" int a=0; // data section int b; // data section static char c; // BSS int main(int argc,char *argv[]) { char d=4; // stack static short e; // BSS a++; b=100; c=(char)++a; e=(++d)++; printf("a=%d, b=%d, c=%d, d= %d, e=%d",a,b,c,d,e); return 0; } a) 写出程序输出 b) 编译器如果安排各个变量(a,b,c,d)在内存中的布局(eg. stack,heap,data section,bss section),最好用图形方式描述。 答案：a=2,b=100,c=2,d=6,e=5 2 中断是嵌入式系统中重要的组成部分，这导致了许多编译开发商提供一种扩展：让标准C支持中断，产生了一个新的关键字__interrupt。下面的代码就使用了__interrupt关键字去定义了一个中断服务子程序(ISR),请评论以下这段代码。 __interrupt double compute_area(double radius) { double area = PI * radius *radius; printf("nArea = %f", area); return area; } 答案 四川九洲电器集团有限责任公司成都技术中心 嵌入式软件开发人员笔试试题 本笔试试题分为C语言基础、算法、思维能力三部份。总分100分，描述思路和最后结果都很重要。 一、C语言基础 1. 语句实现x是否为2的若干次幂的判断。（5分） 2. 宏定义写出swap(x，y)。（5分） 3. 用变量a给出下面的定义。（16分，各两分） a) 一个整型数（An integer） b) 一个指向整型数的指针（A pointer to an integer） c) 一个指向指针的的指针，它指向的指针是指向一个整型数（A pointer to a pointer to an integer） d) 一个有10个整型数的数组（An array of 10 integers） e) 一个有10个指针的数组，该指针是指向一个整型数的（An array of 10 pointers to integers） f) 一个指向有10个整型数数组的指针（A pointer to an array of 10 integers） g) 一个指向函数的指针，该函数有一个整型参数并返回一个整型数（A pointer to a function that takes an integer as an argument and returns an integer） h) 一个有10个指针的数组，该指针指向一个函数，该函数有一个整型参数并返回一个整型数（An array of ten pointers to functions that take an integer argument and return an integer ） 软件笔试题（A） 姓名：___________________________________ 学校：_____________________________________ 专业：___________________________________ 电话：_____________________________________ （如无特殊说明，以下所有测试内容都是基于32位嵌入式系统） 1）程序的局部变量存在于 _______________ 中，全局变量存在于_________________ 中，动态申请数据存在于_________________ 中。 2）如何用if来做零值比较 int a : if（a==O） bool a : _________________________ float a : _________________________ void * a : 3) void func( char str[1OO]) { printf( “ ％d ,sizeof( str )); } 输出结果是：_____________________ 有下列定义： char str[] = “ Hello World ” ; char *p = str; int n = 10; void *ptr = malloc( 100 ); 请写出如下表达式的值: sizeof (str ) = _ sizeof ( p ) = _ sizeof ( n ) = _ sizeof ( ptr )= _ 4) un sig ned char *p1; un sig ned long *p2; p1=(unsigned char *)0x87000000; p2=(unsigned long *)0x80010000; 请问p1+5 = ____________ ; ___________ p2+5 = ________ ; _____________ 5) char str[10]; strcpy(str,"0123456789"); 产生什么结果？为什么？ 6）用C语句，让程序跳转到绝对地址0XFFFF0去执行 7) 已知一个数组array ,用一个宏定义，求出数组的元素个数 #define ARRAY_COUNT _____________________________________________________ 8) 简要说明，为什么标准头文件都有类似以下的结构。 #ifndef __INC_Ho neywell_Debug #defi ne __INC_Ho neywell_Debug #ifdef __cplusplus extern "C" { #en dif /*???*/ #ifdef __cplusplus } #en dif #e ndif /*__INC_Hon eywell_Debug */ 笔试题 1: 设 float a=2, b=4, c=3; ，以下 C 语言表达式与代数式 (a+b)+c 计算结果不一致的是 A.(a+b)*c/2 B.(1/2)*(a+b)*c C.(a+b)*c*1/2 D.c/2*(a+b) 参考答案： B，因为 a,b,c 三个变量都是浮点数，所以在 B 答案中其结果是 0，因为在计算 1/2 是就是 0，如果改成 1/2.0 就正确了。 2: 为了向二进制文件尾部增加数据，打开文件的方式应采用 A.″ab″ B.″rb+″ C.″wb″ D.″wb+″ 参考答案： D 3: 下述程序执行后的输出结果是 #include main() { int x= 'f'; printf( “%c n”, 'a'+(x - ‘a'+1)); } A.g B.h C.i D.j 参考答案： A 4:C 语言中，下列运算符优先级高的是 A.! B.% C.>> D.= = 参考答案： A 5:数组定义为“ int a [ 4 ] ; ”，表达式 ( ) 是错误的。 A.*a B. a [ 0 ] C. a D.a++ 参考答案： D 6: 执行语句“ k=7>>1; ”后，变量 k 的当前值是 A.15 B.31 C. 3 D. 1 参考答案： C 7: 定义函数时，缺省函数的类型声明，则函数类型取缺省类型 A.void B.char C.float D.int 参考答案： D 8: 若 main() 函数带参数，参数个数多是 A.0 B. 1 C. 2 D. 3 参考答案： C 只知道有定义形式 main(int argc,char* argv[])) 9: 若有宏定义： #define MOD(x ， y) x%y 则执行以下语句后的输出结果是 int a=13 ，b=94; printf( ″%d n″， MOD(b， a+4)); A. 5 B.7 C.9 D.11 参考答案： B 10: 下列各个错误中，哪一个不属于编译错误 A.改变 x 原值 3 为 5 ，写作“ x==5 ; ” B.花括号不配对 C.复合语句中的后一条语句后未加分号 D.变量有引用、无定义参考答案： A 11: 下列程序段运行后， x 的值是 ( ) a=1;b=2;x=0; if(!( — a))x — ; if(!b)x=7;else ++x; A.0 B. 3 C. 6 D.7 参考答案： A 嵌入式c语言经典笔试题目 1 .用预处理指令#define声明一个常数，用以表明1年中有多少秒（忽略闰年问题） #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 我在这想看到几件事情： 1) #define语法的基本知识（例如：不能以分号结束，括号的使用，等等） 2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。 3)意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。 4)如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。 2 .写一个"标准"宏MIN，这个宏输入两个参数并返回较小的一个。 #define MIN(A,B)（（A）<= (B) ? (A) : (B)) 这个测试是为下面的目的而设的： 1)标识#define在宏中应用的基本知识。这是很重要的。因为在嵌入(inline)操作符变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。 2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。 3)懂得在宏中小心地把参数用括号括起来 4)我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？ least = MIN(*p++, b); 3.预处理器标识#error的目的是什么？ 如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。 死循环（Infinite loops） 4.嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？ 这个问题用几个解决方案。我首选的方案是： while(1) { } 一些程序员更喜欢如下方案： for(;;) { } 这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案， 海康嵌入式笔试题 Revised as of 23 November 2020 海康嵌入式笔试题 1.请问TCP/IP协议分为哪几层FTP协议属于哪一层 答：可以分为物理层，数据链路层，网络层，传输层，应用层 应用层：应用程序间沟通的层，如简单电子邮件传输（SMTP）、 文件传输协议（FTP）、网络远程访问协议（Telnet）等。 传输层：在此层中，它提供了节点间的数据传送，应用程序之间的通信服务， 主要功能是数据格式化、数据确认和丢失重传等。 如传输控制协议（TCP）、用户数据报协议（UDP）等， TCP和UDP给数据包加入传输数据并把它传输到下一层中，这一层负责传送数据， 并且确定数据已被送达并接收。 互连网络层：负责提供基本的数据封包传送功能，让每一块数据包都能够到达目的主机（但不检查是否被正确接收），如网际协议（IP）。如ARP是地址解析协议，在这一层的时候吧IP地址转换为物理地址网络接口层（主机-网络层）：接收IP数据报并进行传输，从网络上接收物理帧，抽取IP数据报转交给下一层，对实际的网络媒体的管理，定义如何使用实际网络（如Ethernet、SerialLine等）来传送数据。 另外补充一下OSI的七层所对应的协议： 应用层（Application)： 应用程序网关（applicationgateway）Telnet:远程登录（在应用层连接两部分应用程序） FTP（FileTransferProtocol）：文件传输协议 HTTP（HyperTextTransferProtocol）：超文本传输协议 SMTP（SimpleMailTransterProtocol）：简单邮件传输协议 POP3（PostOfficePtotocol）：邮局协议 SNMP（SimpleNetworkMangementProtocol）简单网络管理协议 DNS（DomainNameSystem）：域名系统 传输层（Transport）： 传输网关（transportgateway） TCP（TransmissionControlPotocol)：传输控制协议 （在传输层连接两个网络） UDP（UserDataPotocol）：用户数据协议 网络层（Internet）： 多协议路由器（multiprotocolrouter） IP（InternetProtocol）：网络协议（在异构网络间转发分组） ARP（AddressResolutionProtocol）：地址解析协议 RARP（ReverseAddressResolutionProtocol)：逆地址解析协议 ICMP（InternetControlMessageProtocol）：因特网控制消息协议 嵌入式笔试题 国内普遍认同的嵌入式系统定义为:以应用为中心，以计算机技术为基础，软硬件可裁剪，适应应用系统对功能、可靠性、成本、体积、功耗等严格要求的专用计算机系统。 下面就由为大家介绍一下嵌入式笔试题的文章，欢迎阅读。 嵌入式笔试题篇11：用C语言实现大小端的测试Int CheckCpu(){union{int a;char b;}c;c.a=1;if(c.b==1)printf(“小端);else printf(“大端);}2：volatile的作用有哪些?Volatile第一变量相当于告诉编译器这个变量的值会随时发生变化，每次使用之前都要去内存里从新读取它的值，并不要随意针对它做优化，主要用在：1：一个中断子程序中会访问到的非自动变量;2：多线程应用中被几个线程共享的变量;3：并行设备的硬件寄存器。 3：C语言中static关键字的作用有哪些?1：在函数体中，一个被声明为静态的变量在这个变量在调用过程中维持其值不变;2：在模块内(但在函数体外)，一个被声明为静态的变量，可以被这个模块内的所用函数使用，但不能被模块外的函数使用，它是一个本地的全局变量;3：在模块内，一个被声明为静态变量的函数，智能被这个模块内的函数调用;4：static全局变量与局部变量的区别：static全局变量只能被初始化一次，防止其他单元文件中被引用;5：static局部变量与局部变量的区别：static局部变量只能被初始化一次，下一次依据上一次结果的值;6：static函数与普通函数的区别：static在内存中只用一份，普通函数在每 一次调用中维持一份拷贝。 4：请问下面三种变量的区别：Int const *p : 指向常整型的指针;Int *const p; 指向整型的常指针;Int *const *p：指向常整型的常指针;5：在ARM系统中，在函数调用的时候，参数是通过哪种方式传递的。 当参数小于等于4的时候是通过r0~r3来进行传递的，当参数大于4的时候是通过压栈的方式进行传递。 6：中断与异常有何区别.异常在处理的时候必须考虑与处理器的时钟同步，实际上异常也称为同步中断，在处理器执行到因编译错误而导致的错误指令时，或者在执行期间出现特殊错误，必须靠内核处理的时候，处理器就会产生一个异常;所谓中断是指外部硬件产生的一个电信号从CPU的中断引脚进入，打断CPU的运行。 所谓异常是指软件运行过程中发生了一些必须作出处理的事件，CPU自动产生一个陷入来打断CPU的运行。 7：用预处理指令#define表示一年中有多少秒#define SECONDS_PER_YEAR (60*60*24*365)UL注意后面必须加UL，表示计算的结构是常整型。 8:简述SPI,UART,I2C三种传输方式。 SPI：高速同步串行口，首发独立，可同步进行SPI接口主要应用在EEPROM，Flash，实时时钟，A/D转化器，数字信号处理，是一种全双工同步通讯总线，该接口一般使用四条线：串行时钟线(sck)，主出从入线，主入从出线，低电平有效地的从机选择线。 嵌入式软件工程师笔试 题华为 集团公司文件内部编码：（TTT-UUTT-MMYB-URTTY-ITTLTY- （一）1什么是预编译，何时需要预编译： 答案： １、总是使用不经常改动的大型代码体。 ２、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。 2char*constpcharconst*pconstchar*p上述三个有什么区别 答案： char*constp;//常量指针，p的值不可以修改 charconst*p；//指向常量的指针，指向的常量值不可以改 constchar*p；//和charconst*p 3 charstr1[]="abc"; charstr2[]="abc"; constcharstr3[]="abc"; constcharstr4[]="abc"; constchar*str5="abc"; constchar*str6="abc"; char*str7="abc"; char*str8="abc"; cout<<(str1==str2)< 经典嵌入式面试题 C语言测试就是招聘嵌入式系统程序员过程中必须而且有效的方法。这些年,我既参加也组织了许多这种测试,在这过程中我意识到这些测试能为带面试者与被面试者提供许多有用信息,此外,撇开面试的压力不谈,这种测试也就是相当有趣的。 从被面试者的角度来讲,您能了解许多关于出题者或监考者的情况。这个测试只就是出题者为显示其对ANSI标准细节的知识而不就是技术技巧而设计不？这个愚蠢的问题不？如要您答出某个字符的ASCII值。这些问题着重考察您的系统调用与内存分配策略方面的能力不？这标志着出题者也许花时间在微机上而不上在嵌入式系统上。如果上述任何问题的答案就是"就是"的话,那么我知道我得认真考虑我就是否应该去做这份工作。 从面试者的角度来讲,一个测试也许能从多方面揭示应试者的素质:最基本的,您能了解应试者C语言的水平。不管怎么样,瞧一下这人如何回答她不会的问题也就是满有趣。应试者就是以好的直觉做出明智的选择,还就是只就是瞎蒙呢？当应试者在某个问题上卡住时就是找借口呢,还就是表现出对问题的真正的好奇心,把这瞧成学习的机会呢？我发现这些信息与她们的测试成绩一样有用。 有了这些想法,我决定出一些真正针对嵌入式系统的考题,希望这些令人头痛的考题能给正在找工作的人一点帮住。这些问题都就是我这些 年实际碰到的。其中有些题很难,但它们应该都能给您一点启迪。 这个测试适于不同水平的应试者,大多数初级水平的应试者的成绩会很差,经验丰富的程序员应该有很好的成绩。为了让您能自己决定某些问题的偏好,每个问题没有分配分数,如果选择这些考题为您所用,请自行按您的意思分配分数。 预处理器(Preprocessor) 1 、用预处理指令#define 声明一个常数,用以表明1年中有多少秒(忽略闰年问题) #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 我在这想瞧到几件事情: ?; #define 语法的基本知识(例如:不能以分号结束,括号的使用,等等) ?; 懂得预处理器将为您计算常数表达式的值,因此,直接写出您就是如何计算一年中有多少秒而不就是计算出实际的值,就是更清晰而没有代价的。 ?; 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数就是的长整型数。 ?; 如果您在您的表达式中用到UL(表示无符号长整型),那么您有了一个好的起点。记住,第一印象很重要。 2 、写一个"标准"宏MIN ,这个宏输入两个参数并返回较小的一个。#define MIN(A,B) ( (A) <= (B) ? (A) : (B) ) 第三套嵌入式软件工程师 考试试题B卷 The document was prepared on January 2, 2021 嵌入式Linux软件工程师认证考试 B卷 20个小题，每小题1分，共20分） 1、在下列ARM处理器的各种模式中，（）模式有自己独立的R8-R14寄存器。 A、系统模式(System)、 B、终止模式(Abort) C、中断模式(IRQ) D、快中断模式(FIQ) 2、按照ARM过程调用标准（APCS），栈指针使用（）寄存器， A、R0 B、R13 C、R14 D、R15 3、在ARM体系结构中，（）寄存器作为连接寄存器，当进入子程序时或者处理器响应异常的时候，用来保存PC的返回值；（）寄存器作为处理器的程序计数器指针。 A、R0，R14 B、R13，R15 C、R14，R15 D、R14，R0 4、在ARM体系结构中，要从主动用户模式（User）切换到超级用户模式（Supervisor），应采用何种方法（） A、直接修改CPU状态寄存器（CPSR）对应的模式 B、先修改程序状态备份寄存器（SPSR）到对应的模式，再更新CPU状态 C、使用软件中断指令（SWI） D、让处理器执行未定义指令 5、下面关于MMU和Linux描述错误的是：（） A、MMU是内存管理单元Memory Management Unit的缩写 B、uClinux可以运行在有MMU的处理器上 C、Linux内核功能强大，内存管理功能丰富，即使在没有MMU的处理器上，也可 以通过软件实现地址映射。 D、Linux系统正是利用MMU，才能使得各个进程有独立的寻址空间 1将一个字符串逆序 2、将一个链表逆序 3、计算一个字节里（byte）里面有多少bit被置1 4、搜索给定的字节(byte) 5、在一个字符串中找到可能的最长的子字符串 6、字符串转换为整数 7、整数转换为字符串 答案： 1、方法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; } 2、 链表题：一个链表的结点结构 struct Node { int data ; Node *next ; }; typedef struct Node Node ; (1)已知链表的头结点head,写一个函数把这个链表逆序 ( Intel) Node * ReverseList(Node *head) //链表逆序 { if ( head == NULL || head->next == NULL ) return head; Node *p1 = head ; Node *p2 = p1->next ; Node *p3 = p2->next ; p1->next = NULL ; while ( p3 != NULL ) { p2->next = p1 ; p1 = p2 ; p2 = p3 ; p3 = p3->next ; } p2->next = p1 ; head = p2 ; return head ; } (2)已知两个链表head1 和head2 各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同） Node * Merge(Node *head1 , Node *head2) { if ( head1 == NULL) return head2 ; if ( head2 == NULL) return head1 ; Node *head = NULL ; Node *p1 = NULL; Node *p2 = NULL; if ( head1->data < head2->data ) { head = head1 ; p1 = head1->next; p2 = head2 ; } else { 上海某全球五百强面试题（嵌入式） 1.static变量和static 函数各有什么特点？ 3.描述一下嵌入式基于ROM的运行方式基于ram的运行方式有什么区别。 4.task 有几种状态？ 5.task 有几种通讯方式？ 6.C函数允许重入吗？ 7.嵌入式操作系统和通用操作系统有什么差别？ 嵌入式经典面试题 C语言测试是招聘嵌入式系统程序员过程中必须而且有效的方法。这些年，我既参加也组织了许多这种测试，在这过程中我意识到这些测试能为面试者和被面试者提供许多有用信息，此外，撇开面试的压力不谈，这种测试也是相当有趣的。 从被面试者的角度来讲，你能了解许多关于出题者或监考者的情况。这个测试只是出题者为显示其对ANSI标准细节的知识而不是技术技巧而设计吗？这是个愚蠢的问题吗？如要你答出某个字符的ASCII 值。这些问题着重考察你的系统调用和内存分配策略方面的能力吗？这标志着出题者也许花时间在微机上而不是在嵌入式系统上。如果上述任何问题的答案是"是"的话，那么我知道我得认真考虑我是否应该去做这份工作。 从面试者的角度来讲，一个测试也许能从多方面揭示应试者的素质：最基本的，你能了解应试者C语言的水平。不管怎么样，看一下这人如何回答他不会的问题也是满有趣。应试者是以好的直觉做出明智的选择，还是只是瞎蒙呢？当应试者在某个问题上卡住时是找借口呢，还是表现出对问题的真正的好奇心，把这看成学习的机会呢？我发现这些信息与他们的测试成绩一样有用。 有了这些想法，我决定出一些真正针对嵌入式系统的考题，希望这些令人头痛的考题能给正在找工作的人一点帮助。这些问题都是我这些年实际碰到的。其中有些题很难，但它们应该都能给你一点启迪。 这个测试适于不同水平的应试者，大多数初级水平的应试者的成绩会很差，经验丰富的程序员应该有很好的成绩。为了让你能自己决定某些问题的偏好，每个问题没有分配分数，如果选择这些考题为你所用，请自行按你的意思分配分数。 预处理器（Preprocessor） 1 . 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题） #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 我在这想看到几件事情： 1) #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等） 2)懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中有多少秒而不是计算出实际的值，是更清晰而没有代价的。 3) 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编译器这个常数是的长整型数。 4) 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。记住，第一印象很重要。 2 . 写一个"标准"宏MIN ，这个宏输入两个参数并返回较小的一个。 #define MIN(A,B) （（A）<= (B) ? (A) : (B)) 这个测试是为下面的目的而设的： 1) 标识#define在宏中应用的基本知识。这是很重要的。因为在嵌入(inline)操作符变为标准C的一部分之前，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。 2)三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。 3) 懂得在宏中小心地把参数用括号括起来 4) 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？ least = MIN(*p++, b); （一）1什么是预编译，何时需要预编译：答案：１、总是使用不经常改动的大型代码体。在这种所有模块都使用一组标准的包含文件和相同的编译选项。２、程序由多个模块 组成，情况下，可以将所有包含文件预编译为一个预编译头。 const char *p 上述三个有什么区别？2 char * const p char const * p 答案：p的值不可以修改char * const p; //常量指针，和char const *p const char *p ；//char const * p；//指向常量的指针，指向的常量值不可以改 3 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; out < < ( str7 == str8 ) < < endl; 0 0 1 1 结果是：是指针，它们指str5,str6,str7,str8str1,str2,str3,str4是数组变量，它们有各自的内 存空间；而向相同的常量区域。 以下代码中的两个sizeof用法有问题吗？4 ] [C易中的小写字母转换成大写字母// 将str void UpperCase( char str[] ) { for( size_t i=0; i 预处理器（Preprocessor） 1. 用预处理指令#define 声明一个常数，用以表明1年中有多少秒（忽略闰年问题） #define SECONDS_PER_YEAR (60 * 60 * 24 * 365)UL 我在这想看到几件事情： 1). #define 语法的基本知识（例如：不能以分号结束，括号的使用，等等） 2). 懂得预处理器将为你计算常数表达式的值，因此，直接写出你是如何计算一年中 有多少秒而不是计算出实际的值，是更清晰而没有代价的。 3). 意识到这个表达式将使一个16位机的整型数溢出-因此要用到长整型符号L,告诉编 译器这个常数是的长整型数。 4). 如果你在你的表达式中用到UL（表示无符号长整型），那么你有了一个好的起点。 记住，第一印象很重要。 2. 写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。 #define MIN(A,B) ((A) <= (B) (A) : (B)) 这个测试是为下面的目的而设的： 1). 标识#define在宏中应用的基本知识。这是很重要的，因为直到嵌入(inline)操作符变 为标准C的一部分，宏是方便产生嵌入代码的唯一方法，对于嵌入式系统来说，为了能达到 要求的性能，嵌入代码经常是必须的方法。 2). 三重条件操作符的知识。这个操作符存在C语言中的原因是它使得编译器能产生比if- then-else更优化的代码，了解这个用法是很重要的。 3). 懂得在宏中小心地把参数用括号括起来 4). 我也用这个问题开始讨论宏的副作用，例如：当你写下面的代码时会发生什么事？ least = MIN(*p++, b); 3. 预处理器标识#error的目的是什么？ 如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种 问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。 4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？ 这个问题用几个解决方案。我首选的方案是： while(1) { void e(int ); main(){ int a; a=3; e(a);}void e(int n){ if(n>0) { e(--n); printf("%d" , n); e(--n); }}这段程序的输出是: A.0 1 2 0 B.0 1 2 1 C.1 2 0 1 D.0 2 1 1 typedef int (*test) ( float * , float*)test tmp; tmp 的类型是【】 A.函数的指针，该函数以两个指向浮点数(float)的指针(pointer)作为参数(arguments) Pointer to function of having two arguments that is pointer to float B.整型 C.函数的指针，该函数以两个指向浮点数(float)的指针(pointer)作为参数(arguments),并且函数的返回值类型是整型Pointer to function having two argument that is pointer to float and return int D.以上都不是 第3 题 main(){ char p; char buf[10] ={ 1,2,3,4,5,6,9,8}; p = (buf+1)[5]; printf("%d" , p);}这段程序的输出是:【】 A.5 B.6 C.9 D.以上都不对 第4 题 Void f(char**);main(){ char * argv[] = { "ab" ,"cd" , "ef" ,"gh", "ij" ,"kl" }; f( argv );}void f( char **p ){ char* t; t= (p+= sizeof(int))[-1]; printf( "%s" , t);}这段程序的输出是:【】 A.ab B.cd C.ef D.gh 第5 题 #include嵌入式软件工程师笔试题
华为(嵌入式)笔试题
嵌入式笔试题汇总1
嵌入式软件开发人员笔试题
嵌入式软件工程师C语言笔试题
嵌入式软件工程师笔试题
嵌入式C语言经典笔试题目
海康嵌入式笔试题
嵌入式笔试题
嵌入式软件工程师笔试题华为优选稿
经典嵌入式面试题
第三套嵌入式软件工程师考试试题B卷
嵌入式经典笔试题目
嵌入式常见经典笔试题1
完整word版嵌入式软件工程师笔试题 华为
嵌入式软件工程师经典笔试题
嵌入式开发c语言经典笔试题-含答案
相关主题
文本预览