1)在函数体，一个被声明为静态的变量在这一函数被调用过程中维持其值不变。
2) 在模块内（但在函数体外），一个被声明为静态的变量可以被模块内所用函数访问，但不能被模块外其它函数访问。它是一个本地的全局变量。
3) 在模块内，一个被声明为静态的函数只可被这一模块内的其它函数调用。那就是，这个函数被限制在声明它的模块的本地范围内使用
2. 引用与指针有什么区别？
1) 引用必须被初始化，指针不必。
2) 引用初始化以后不能被改变，指针可以改变所指的对象。
3) 不存在指向空值的引用，但是存在指向空值的指针。
3. 描述实时系统的基本特性
在特定时间内完成特定的任务，实时性与可靠性。
4. 全局变量和局部变量在内存中是否有区别？如果有，是什么区别？
全局变量储存在静态数据库，局部变量在堆栈。
5. 什么是平衡二叉树？
左右子树都是平衡二叉树 且左右子树的深度差值的绝对值不大于1。
6. 堆栈溢出一般是由什么原因导致的？
没有回收垃圾资源。
7. 什么函数不能声明为虚函数？
constructor函数不能声明为虚函数。
8. 冒泡排序算法的时间复杂度是什么？
时间复杂度是O(n^2)。
9. 写出float x 与“零值”比较的if语句。
if(x>0.000001&&x<-0.000001)
10. Internet采用哪种网络协议？该协议的主要层次结构？
Tcp/Ip协议
主要层次结构为： 应用层/传输层/网络层/数据链路层/物理层。
11. Internet物理地址和IP地址转换采用什么协议？
ARP (Address Resolution Protocol)（地址解析协议 ）
12. IP地址的编码分为哪俩部分？
IP地址由两部分组成，网络号和主机号。不过是要和“子网掩码”按位与上之后才能区分哪些是网络位哪些是主机位。
13. 用户输入M,N值，从1至N开始顺序循环数数，每数到M输出该数值，直至全部输出。写出C程序。
循环链表，用取余操作做
14. 不能做switch()的参数类型是：
switch的参数不能为实型。
1. 某32位系统下, C++程序，请计算sizeof 的值
#include
#include
void Foo ( char str[100] )
{
printf("sizeof(str)=%d \n", sizeof(str) );
}
main()
{
char str[] = "www.ibegroup.com";
char *p1 = str ;
int n = 10;
void *p2 = malloc( 100 );
printf("sizeof(str)=%d \n", sizeof(str) );
printf("sizeof(p1)=%d \n", sizeof(p1) );
printf("sizeof(n)=%d \n", sizeof(n) );
printf("sizeof(p2)=%d \n", sizeof(p2) );
Foo(str);
}
答：(1)17 (2)4 (3) 4 (4)4 (5)4
2. 回答下面的问题
(1) 头文件中的 ifndef/define/endif干什么用? 预处理
答：防止头文件被重复引用
(2) #include
答：
对于#include
对于#include "filename.h" ，编译器从用户的工作路径开始搜索filename.h
(3) 在C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明?
答：函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern "C"修饰的变量和函数是按照C语言方式编译和连接的。由于编译后的名字不同，C++程序不能直接调用C 函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。
3. 回答下面的问题
(1) 请问运行Test 函数会有什么样的结果?
Void GetMemory(char **p, int num)
{
*p = (char *)malloc(num);
}
void Test(void)
{
char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str);
}
答：输出“hello”
(2) 请问运行Test 函数会有什么样的结果?
void Test(void)
{
char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{
strcpy(str, “world”);
printf(str);
}
}
答：输出“world”
(3) 请问运行Test 函数会有什么样的结果?
char *GetMemory(void)
{
char p[] = "hello world";
return p;
}
void Test(void)
{
char *str = NULL;
str = GetMemory();
printf(str);
}
答：无效的指针，输出不确定
4. 编写strcat函数
已知strcat函数的原型是char *strcat (char *strDest, const char *strSrc); 其中strDest 是目的字符串，strSrc 是源字符串。
(1)不调用C++/C 的字符串库函数，请编写函数 strcat
答：VC源码：
char * __cdecl strcat (char * dst, const char * src)
{
char * cp = dst;
while( *cp )
cp++; /* find end of dst */
while( *cp++ = *src++ ) ; /* Copy src to end of dst */
return( dst ); /* return dst */
}
(2)strcat能把strSrc 的内容连接到strDest，为什么还要char * 类型的返回值?
答：方便赋值给其他变量
5. 程序什么时候应该使用线程，什么时候单线程效率高
(1) 耗时的操作使用线程，提高应用程序响应
(2) 并行操作时使用线程，如C/S架构的服务器端并发线程响应用户的请求。
(3) 多CPU系统中，使用线程提高CPU利用率
(4) 改善程序结构。一个既长又复杂的进程可以考虑分为多个线程，成为几个独立或半独
立的运行部分，这样的程序会利于理解和修改。
其他情况都使用单线程。
6. C++中什么数据分配在栈或堆中，New分配数据是在近堆还是远堆中?
答：栈: 存放局部变量，函数调用参数，函数返回值，函数返回地址。由系统管理堆: 程序运行时动态申请，new 和malloc申请的内存就在堆上
7. 关于内存对齐的问题以及sizof()的输出
答：编译器自动对齐的原因：为了提高程序的性能，数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；然而，对齐的内存访问仅需要一次访问。
8. int i=10, j=10, k=3; k*=i+j; k最后的值是?
答：60，此题考察优先级，实际写成： k*=(i+j);，赋值运算符优先级最低
9. 动态连接库的两种方式?
答：调用一个DLL中的函数有两种方法：
1．载入时动态链接(load-time dynamic linking)，模块非常明确调用某个导出函数，使得他们就像本地函数一样。这需要链接时链接那些函数所在DLL的导入库，导入库向系统提供了载入DLL时所需的信息及DLL函数定位。
2．运行时动态链接(run-time dynamic linking)，运行时可以通过LoadLibrary或LoadLibraryEx函数载入DLL。DLL载入后，模块可以通过调用 GetProcAddress获取DLL函数的出口地址，然后就可以通过返回的函数指针调用DLL函数了。如此即可避免导入库文件了
10. 函数模板与类模板有什么区别?
答：函数模板的实例化是由编译程序在处理函数调用时自动完成的，而类模板的实例化必须由程序员在程序中显式地指定。
11.Windows是内核级线程么。
答：见下一题
12. Linux有内核级线程么。
答：线程通常被定义为一个进程中代码的不同执行路线。从实现方式上划分，线程有两种类型：“用户级线程”和“内核级线程”。 用户线程指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。 这种线程甚至在象 DOS 这样的操作系统中也可实现，但线程的调度需要用户程序完成，这有些类似 Windows 3.x 的协作式多任务。另外一种则需要内核的参与，由内核完成线程的调度。其依赖于操作系统核心，由内核的内部需求进行创建和撤销，这两种模型各有其好处和缺 点。用户线程不需要额外的内核开支，并且用户态线程的实现方式可以被定制或修改以适应特殊应用的要求，但是当一个线程因 I/O 而处于等待状态时，整个进程就会被调度程序切换为等待状态，其他线程得不到运行的机会；而内核线程则没有各个限制，有利于发挥多处理器的并发优势，但却占 用了更多的系统开支。
Windows NT和OS/2支持内核线程。Linux 支持内核级的多线程
13. 使用线程是如何防止出现大的波峰。
答：意思是如何防止同时产生大量的线程，方法是使用线程池，线程池具有可以同时提高调度效率和限制资源使用的好处，线程池中的线程达到最大数时，其他线程就会排队等候。
14. 写出判断ABCD四个表达式是否正确, 若正确, 写出经过表达式中a的值
int a = 4;
(A) a += (a++);
(B) a += (++a);
(C) (a++) += a;
(D) (++a) += (a++);
a = ?
答：C错误，左侧不是一个有效变量，不能赋值，可改为(++a) += a;
改后答案依次为9,10,10,11
15. MFC中CString是类型安全类么?
答：不是，其它数据类型转换到CString可以使用CString的成员函数Format来转换
16. C++中为什么用模板类。
答：
(1) 可用来创建动态增长和减小的数据结构
(2) 它是类型无关的，因此具有很高的可复用性。
(3) 它在编译时而不是运行时检查数据类型，保证了类型安全
(4) 它是平台无关的，可移植性
(5) 可用于基本数据类型
17. CSingleLock是干什么的。
答：同步多个线程对一个数据类的同时访问
18. 局部变量能否和全局变量重名？
答：能，局部会屏蔽全局。要用全局变量，需要使用"::"
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内。
19. 如何引用一个已经定义过的全局变量？
答：extern
可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间 会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错。
20. 全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？
答：可以，在不同的C文件中以static形式来声明同名全局变量。
可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错。
21. 语句for( ；1 ；)有什么问题？它是什么意思？
答：无限循环，和while(1)相同。
22. do……while和while……do有什么区别？
答：前一个循环一遍再判断，后一个判断以后再循环。
23. 请写出下列代码的输出内容
#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
1. 找错
#define MAX_SRM 256
DSN get_SRM_no()
{
static int SRM_no;
int I;
for(I=0;I
SRM_no %= MAX_SRM;
if(MY_SRM.state==IDLE)
{
break;
}
}
if(I>=MAX_SRM)
return (NULL_SRM);
else
return SRM_no;
}
答：
(1). SRM_no没有赋初值
(2). 由于static的声明，使该函数成为不可重入（即不可预测结果）函数，因为SRM_no变量放在程序的全局存储区中，每次调用的时候还可以保持原来的赋值。这里应该去掉static声明。
2. 写出程序运行结果
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));
}
}
答：8,10,12,14,16
该题比较简单。只要注意b声明为static静态全局变量，其值在下次调用时是可以保持住原来的赋值的就可以。
3.
int func(int a)
{
int b;
switch(a)
{
case 1: b=30;
case 2: b=20;
case 3: b=16;
default: b=0;
}
return b;
}
则func(1)=?
答：func(1)=0，因为没有break语句，switch中会一直计算到b=0。
4.
int a[3];
a[0]=0; a[1]=1; a[2]=2;
int *p, *q;
p=a;
q=&a[2];
则a[q-p]=?
答：a[q-p]=a[2]=2;这题是要告诉我们指针的运算特点
5. 定义 int **a[3][4], 则变量占有的内存空间为：_____
答：此处定义的是指向指针的指针数组，对于32位系统，指针占内存空间4字节，因此总空间为3×4×4＝48。
6. CObject类中的析构函数为什么是虚函数
面试SE时，很多公司喜欢问到虚函数相关。MFC类库中，CObject类的重要性不言自明的。在CObject的定义中，我们看到一个有趣的现象，即CObject的析构函数是虚拟的。
在AFX.H中，CObject的定义：
class CObject
{
public:
// Object model (types, destruction, allocation)
virtual CRuntimeClass* GetRuntimeClass() const;
virtual ~CObject(); //virtual destructors are necessary
};
为什么MFC的编写者认为virtual destructors are necessary (虚拟的析构函数是必要的)?
在著名的VC教程 "精通Visual C++ for Windows 95/NT"(电子工业版， 1997年5月版，胡俭，丘宗明等著)第99页中有这样一段话：
“如果CObject的析构函数不是虚拟的，派生类就不会自动地得到虚拟的 析构函数，当对象撤消时就会带来问题——只有当前类的析构函数得到调用而基类的析构函数就得不到调用...”
我认为这段解释是这本很不错的书中一个不应出现的严重错误。其意思是说：
若：
class CBase
{
public:
~CBase() {
};
class CChild : public CBase
{
public:
~CChild() {
};
main()
{
Child c;
return 0;
}
上段代码在运行时，当栈框中的自动对象 c 被撤消时，只调用~CChild()，而不调用~CBase()。
我想但凡对C++继承性理论有所了解的人都会立刻指出这是错误的。
由于在生成CChild对象c时，实际上在调用CChild类的构造函数之前必须首先 调用其基类CBase的构造函数，所以当撤消c时，也会在调用CChild类析构函数之后，调用CBase类的析构函数(析构函数调用顺序与构造函数相 反)。也就是说，无论析构函数是不是虚函数，派生类对象被撤消时，肯定会依次上调其基类的析构函数。
那么为什么CObject类要搞一个虚的析构函数呢？
仍以上面代码为例，如果main()中有如下代码：
...
CBase * pBase;
CChild c;
pBase = &c;
...
那么在、当pBase指针被撤消时，调用的是CBase的析构函数还是CChild的呢？ 显然是CBase的(静态联编)。但如果把CBase类的析构函数改成virtual型，当 pBase指针被撤消时，就会先调用CChild类构造函数，再调用CBase类构造函数。
在这个例子里，所有对象都存在于栈框中，当离开其所处的作用域时，该对象 会被自动撤消，似乎看不出什么大问题。但是试想，如果CChild类的的构造函数在堆中分配了内存，而其析构函数又不是virtual型的，那么撤消 pBase时，将不会 调用CChild::~CChild(), 从而不会释放CChild::CChild()占据的内存，造成内存泄露。
而将CObject的析构函数设为virtual型，则所有CObject类的派生类的析构函数都将 自动变为virtual型，这保证了在任何情况下，不会出现由于析构函数未被调用而导致 的内存泄露。这才是MFC将CObject::~CObject()设为virtual型的真正原因。
注意：析构函数可以为virtual型，构造函数则不能。
一、判断题
1、有数组定义int a[2][2]={{1},{2,3}};则a[0][1]的值为0。(正确)
2、int (*ptr) (),则ptr是一维数组的名字。(错误 int (*ptr) ();定义一个指向函数的指针变量 )
3、指针在任何情况下都可进行>,<,>=,<=,==运算。(错误)
4、switch(c) 语句中c可以是int ,long,char ,float ,unsigned int 类型。( 错，不能用实形)
二、填空题
1、在windows下，写出运行结果
char str[ ]= "Hello";
char *p=str;
int n=10;
sizeof(str)=( )
sizeof(p)=( )
sizeof(n)=( )
void func(char str[100]){ }
sizeof(str)=( )
答案：6，4，4，4
2、
void getmemory(char **p, int num)
{
*p=(char *) malloc(num);
}
void test(void)
{
char *str=NULL;
getmemory(&str,100);
strcpy(str,"hello");
printf(str);
}
运行test函数有什么结果？( )
答案：输出hello，但是发生内存泄漏。
3、
设int arr[]={6,7,8,9,10};
int *ptr=arr;
*(ptr++)+=123;
printf("%d,%d", *ptr, *(++ptr));
答案：8，8。这道题目的意义不大，因为在不同的编译器里printf的参数的方向是不一样的，在vc6.0下是从有到左，这里先*(++ptr) 后*pt，于是结果为8，8
二、编程题
1、不使用库函数，编写函数int strcmp(char *source, char *dest)
相等返回0，不等返回-1；
答案：一、
int strcmp(char *source, char *dest)
{
assert((source!=NULL)&&(dest!=NULL));
int i,j;
for(i=0; source[i]==dest[i]; i++)
{
if(source[i]=='\0' && dest[i]=='\0')
return 0;
else
return -1;
}
}
答案：二、
int strcmp(char *source, char *dest)
{
while ( (*source != '\0') && (*source == *dest))
{
source++;
dest++;
}
return ( (*source) - (*dest) ) ? -1 : 0;
}
2、 写一函数int fun(char *p)判断一字符串是否为回文，是返回1，不是返回0，出错返回-1
答案：一、
int fun(char *p)
{
if(p==NULL)
return -1;
else
{
int length = 0;
int i = 0;
int judge = 1;
length = strlen(p);
for(i=0; i
if(p[i]!=p[length-1-i])
judge = 0;
break;
}
if(judge == 0)
return 0;
else
return 1;
}
}
答案：二、
int fun(char *p)
{
int len = strlen(p) - 1;
char *q = p + len;
if (!p)
return -1;
while (p < q)
{
if ((*p++) != (*q--))
return 0;
}
return 1;
}
(一) 初级题
1. 什么是预编译，何时需要预编译：
答：
(1) 总是使用不经常改动的大型代码体
(2) 程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头
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用法有问题吗？
void UpperCase( char str[] ) // 将 str 中的小写字母转换成大写字母
{
for( size_t i=0; i
str[i] -= ('a'-'A' );
}
char str[] = "aBcDe";
cout << "str字符长度为: " << sizeof(str)/sizeof(str[0]) << endl;
UpperCase( str );
cout << str << endl;
答：函数内的sizeof有问题。根据语法，sizeof如用于数组，只能测出静态数组的大小，无法检测动态分配的或外部数组大小。函数外的str 是一个静态定义的数组，因此其大小为6，因为还有'\0'，函数内的str实际只是一个指向字符串的指针，没有任何额外的与数组相关的信息，因此 sizeof作用于上只将其当指针看，一个指针为4个字节，因此返回4。
5. 一个32位的机器,该机器的指针是多少位
答：指针是多少位只要看地址总线的位数就行了。80386以后的机子都是32的数据总线。所以指针的位数就是4个字节了。
6.
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]。
7. 请问以下代码有什么问题：
int main()
{
char a;
char *str=&a;
strcpy(str,"hello");
printf(str);
return 0;
}
答：没有为str分配内存空间，将会发生异常。问题出在将一个字符串复制进一个字符变量指针所指地址。虽然可以正确输出结果，但因为越界进行内在读写而导致程序崩溃。
8.
char* s="AAA";
printf("%s",s);
s[0]='B';
printf("%s",s);
有什么错？
答："AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。
cosnt char* s="AAA"; 然后又因为是常量，所以对是s[0]的赋值操作是不合法的。
9. 写一个“标准”宏，这个宏输入两个参数并返回较小的一个。
答：#define Min(X, Y) ((X)>(Y)?(Y):(X)) //结尾没有';'
10. 嵌入式系统中经常要用到无限循环，你怎么用C编写死循环。
答：while(1){}或者for(;;)
11. 关键字static的作用是什么？
答：定义静态变量
12. 关键字const有什么含意？
答：表示常量不可以修改的变量。
13. 关键字volatile有什么含意？并举出三个不同的例子？
答：提示编译器对象的值可能在编译器未监测到的情况下改变。
14. int (*s[10])(int) 表示的是什么啊？
答：int (*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。
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;
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. 列举几种进程的同步机制，并比较其优缺点。
答：原子操作、信号量机制、自旋锁、管程、会合、分布式系统
20. 进程之间通信的途径
答：共享存储系统、消息传递系统、管道：以文件系统为基础
21. 进程死锁的原因和4个必要条件
答：资源竞争及进程推进顺序非法；互斥、请求保持、不可剥夺、环路
22. 死锁的处理
答：鸵鸟策略、预防策略、避免策略、检测与解除死锁
23. 操作系统中进程调度策略有哪几种？
答：FCFS(先来先服务)，优先级，时间片轮转，多级反馈
24. 类的静态成员和非静态成员有何区别？
答：类的静态成员每个类只有一个，非静态成员每个对象一个
25. 纯虚函数如何定义？使用时应注意什么？
答：virtual void f()=0; 是接口，子类必须要实现
26. 数组和链表的区别
答：
数组：数据顺序存储，固定大小
链表：数据可以随机存储，大小可动态改变
27. ISO的七层模型是什么？tcp/udp是属于哪一层？tcp/udp有何优缺点？
答：应用层、表示层、会话层、运输层、网络层、物理链路层、物理层
tcp/udp属于运输层
TCP服务提供了数据流传输、可靠性、有效流控制、全双工操作和多路复用技术等。
与TCP 不同， UDP并不提供对IP协议的可靠机制、流控制以及错误恢复功能等。由于UDP比较简单，UDP头包含很少的字节，比TCP负载消耗少
tcp: 提供稳定的传输服务，有流量控制，缺点是包头大，冗余性不好
udp: 不提供稳定的服务，包头小，开销小
28. (void *)ptr 和 (*(void**))ptr的结果是否相同？其中ptr为同一个指针
答：(void *)ptr 和 (*(void**))ptr值是相同的
29.
int main()
{
int x=3;
printf("%d",x);
return 1;
}
问函数既然不会被其它函数调用，为什么要返回1？
答：main中，c标准认为0表示成功，非0表示错误。具体的值是某中具体出错信息
30. 要对绝对地址0x100000赋值，我们可以用(unsigned int*)0x100000 = 1234; 那么要是想让程序跳转到绝对地址是0x100000去执行，应该怎么做？
答：*((void (*)( ))0x100000 ) ( );
首先要将0x100000强制转换成函数指针,即: (void (*)())0x100000。然后再调用它: *((void (*)())0x100000)(); 用typedef可以看得更直观些:
typedef void(*)() voidFuncPtr;
*((voidFuncPtr)0x100000)();
31. 已知一个数组table，用一个宏定义，求出数据的元素个数
答：
#define NTBL
#define NTBL (sizeof(table)/sizeof(table[0]))
32. 线程与进程的区别和联系? 线程是否具有相同的堆栈? dll是否有独立的堆栈?
答：进程是死的，只是一些资源的集合，真正的程序执行都是线程来完成的，程序启动的时候操作系统就帮你创建了一个主线程。每个线程有自己的堆栈。DLL中 有没有独立的堆栈，这个问题不好回答，或者说这个问题本身是否有问题。因为DLL中的代码是被某些线程所执行，只有线程拥有堆栈，如果DLL中的代码是 EXE中的线程所调用，那么这个时候是不是说这个DLL没有自己独立的堆栈？如果DLL中的代码是由DLL自己创建的线程所执行，那么是不是说DLL有独 立的堆栈？
以上讲的是堆栈，如果对于堆来说，每个DLL有自己的堆，所以如果是从DLL中动态分配的内存，最好是从DLL中删除，如果你从DLL中分配内存，然后在EXE中，或者另外一个DLL中删除，很有可能导致程序崩溃
33.
unsigned short A = 10;
printf("~A = %u\n", ~A);
char c=128;
printf("c = %d\n",c);
输出多少？并分析过程
答：
第一题，~A ＝0xfffffff5, int值为-11，但输出的是uint。所以输出4294967285。
第二题，c＝0x10,输出的是int，最高位为1，是负数，所以它的值就是0x00的补码就是128，所以输出-128。
这两道题都是在考察二进制向int或uint转换时的最高位处理。
(二) 中级题
1. -1,2,7,28,,126请问28和126中间那个数是什么？为什么？
答：
第一题应该是4^3-1=63
规律是n^3-1(当n为偶数0，2，4)
n^3+1(当n为奇数1，3，5)
2. 用两个栈实现一个队列的功能？要求给出算法和思路！
答：设2个栈为A,B, 一开始均为空.
入队:
将新元素push入栈A;
出队:
(1)判断栈B是否为空；
(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B；
(3)将栈B的栈顶元素pop出；
这样实现的队列入队和出队的平摊复杂度都还是O(1), 比上面的几种方法要好。
3. 在c语言库函数中将一个字符转换成整型的函数是atol()吗，这个函数的原型是什么？
答：
函数名: 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);
}
4. 对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?
答：c用宏定义，c++用inline
5. 直接链接两个信令点的一组链路称作什么?
答：PPP点到点连接
7. 软件测试都有那些种类?
答：黑盒：针对系统功能的测试 白合：测试函数功能，各函数接口
8. 确定模块的功能和模块的接口是在软件设计的那个队段完成的?
答：概要设计阶段
9.
unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0x801000;
p2=(unsigned long *)0x810000;
请问
p1+5=______;
p2+5=______;
答案：801005；810014。不要忘记了这个是16进制的数字，p2要加20变为16进制就是14
选择题:
1. Ethternet链接到Internet用到以下那个协议?
A.HDLC; B.ARP; C.UDP; D.TCP; E.ID
2. 属于网络层协议的是:
A.TCP; B.IP; C.ICMP; D.X.25
3.Windows消息调度机制是:
A.指令队列; B.指令堆栈; C.消息队列; D.消息堆栈;
答：b，a，c
找错题:
1. 请问下面程序有什么错误?
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;
答：把循环语句内外换一下
2. 以下是求一个数的平方的程序,请找出错误:
#define SQUARE(a) ((a)*(a))
int a=5;
int b;
b=SQUARE(a++);
答案：这个没有问题，s(a＋＋)，就是((a＋＋)×(a＋＋))唯一要注意的就是计算后a＝7了
3. 找错误
typedef unsigned char BYTE
int examply_fun(BYTE gt_len; BYTE *gt_code)
{
BYTE *gt_buf;
gt_buf=(BYTE *)MALLOC(Max_GT_Length);
if(gt_len>Max_GT_Length)
{
return GT_Length_ERROR;
}
}
答：要释放内存
问答题:
1.IP Phone的原理是什么?
答：IPV6
2.TCP/IP通信建立的过程怎样，端口有什么作用？
答：三次握手，确定是哪个应用程序使用该协议
(三) 高级题
1、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？
答：全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。 这两者在存储方式上并无不同。这两者的区别虽在于非静态全局变量的作用域是整个源程序， 当一个源程序由多个源文件组成时，非静态的全局变量在各个源文件中都是有效的。
而静态全局变量则限制了其作用域， 即只在定义该变量的源文件内有效， 在同一源程序的其它源文件中不能使用它。由于静态全局变量的作用域局限于一个源文件内，只能为该源文件内的函数公用， 因此可以避免在其它源文件中引起错误。从以上分析可以看出， 把局部变量改变为静态变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态变量后是改变了它的作用域， 限制了它的使用范围。
static函数与普通函数作用域不同。仅在本文件。只在当前源文件中使用的函数应该说明为内部函数(static)，内部函数应该在当前源文件中说明和定义。对于可在当前源文件以外使用的函数，应该在一个头文件中说明，要使用这些函数的源文件要包含这个头文件
static全局变量与普通的全局变量有什么区别：static全局变量只初使化一次，防止在其他文件单元中被引用;
static局部变量和普通局部变量有什么区别：static局部变量只被初始化一次，下一次依据上一次结果值；
static函数与普通函数有什么区别：static函数在内存中只有一份，普通函数在每个被调用中维持一份拷贝
2、程序的局部变量存在于( )中，全局变量存在于( )中，动态申请数据存在于( )中。
答：栈；静态区；堆
3、设有以下说明和定义：
typedef union {long i; int k[5]; char c;} DATE;
struct data { int cat; DATE cow; double dog;} too;
DATE max;
则语句 printf("%d",sizeof(too)+sizeof(max));的执行结果是：______
答：DATE是一个union, 变量公用空间. 里面最大的变量类型是int[5], 占用20个字节. 所以它的大小是20
data是一个struct, 每个变量分开占用空间. 依次为int4 + DATE20 + double8 = 32.
所以结果是 20 + 32 = 52.
当然...在某些16位编辑器下, int可能是2字节,那么结果是 int2 + DATE10 + double8 = 20
4、队列和栈有什么区别？
答：队列先进先出，栈后进先出÷
5、已知一个单向链表的头，请写出删除其某一个结点的算法，要求，先找到此结点，然后删除。
答：
slnodetype *Delete(slnodetype *Head,int key)
{
if(Head->number==key)
{
Head=Pointer->next;
free(Pointer);
break;
}
Back = Pointer;
Pointer=Pointer->next;
if(Pointer->number==key)
{
Back->next=Pointer->next;
free(Pointer);
break;
}
void delete(Node* p)
{
if(Head = Node)
while(p)
}
}
7、请找出下面代码中的所以错误
说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”
#include "string.h"
main()
{
char*src="hello,world";
char* dest=NULL;
int len=strlen(src);
dest=(char*)malloc(len);
char* d=dest;
char* s=src[len];
while(len--!=0)
d++=s--;
printf("%s",dest);
return 0;
}
答：还要加上#include
int main()
{
char* src = "hello,world";
int len = strlen(src);
char* dest = (char*)malloc((len+1)*sizeof(char)); //要为\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;
}
下面是一份华为笔试题,主要是概念原理型的题目,我做了一份解答,其中有些地方可能答得不太准确,还有少数地方不清楚答案.
如果你知道答案,希望能替我补充下,谢谢!
华为笔试题
1．请你分别画出OSI的七层网络结构图和TCP/IP的五层结构图。
OSI 七层网络模型 应用层
表示层
会话层
传输层
网络层
数据链路层
物理层
TCP四层模型(一般都是四层,五层是不是加上物理层?) 应用层
传输层
网络层
链路层
2．请你详细地解释一下IP协议的定义，在哪个层上面？主要有什么作用？TCP与UDP呢？
IP协议(Internet Protocol)又称互联网协议，是支持网间互连的数据报协议，它与TCP协议（传输控制协议）一起构成了TCP/IP协议族的核心。它提供网间连接的完善功能， 包括IP数据报规定互连网络范围内的IP地址格式。
IP是网络层协议，工作在数据链路层的上面。
IP协议的作用就是向传输层（TCP层）提供统一的IP包，即将各种不同类型的MAC帧转换为统一的IP 包，并将MAC帧的物理地址变换为全网统一的逻辑地址（IP地址）。这样，这些不同物理网络MAC帧的差异对上层而言就不复存在了。正因为这一转换，才实 现了不同类型物理网络的互联。
TCP和UDP都是传输层协议.
TCP（Transmission Control Protocol，传输控制协议）是面向连接的协议,在收发数据前，必须和对方建立连接。
UDP（User Data Protocol，用户数据报协议）是与TCP相对应的协议。它是面向非连接的协议，它不与对方建立连接，而是直接就把数据包发送过去。
3．请问交换机和路由器各自的实现原理是什么？分别在哪个层次上面实现的？
原理太多了，略去！(哪位能给个简单的，请补充，谢谢！)
交换机是在数据链路层实现的
路由器在网络层实现。
4．请问C++的类和C里面的struct有什么区别？
C++中的类有构造函数，析构函数，继承等等。
C中的struct中，没有构造函数等C++类才有的元素。
然而，C++中的class和struct基本上是等同的，除了一点
它们数据成员的默认访问权限是不同的。
class的默认访问权限为private,而struct为public.
5．请讲一讲析构函数和虚函数的用法和作用。
假设有一个名为A的类，那么A的析构函数为如下形式
A::~A(){}, 没有参数也无返回值。
析构函数主要作用是在对象销毁前释放其占用的资源。
要将类的成员函数定义为虚函数，只需在函数声明前加上关键字virtual.
虚函数的作用是为了实现多态,可以在运行时决定具体调用哪个函数(动态绑定)。
6．全局变量和局部变量有什么区别？是怎么实现的？操作系统和编译器是怎么知道的？
全局变量和局部变量的区别主要在于它们的作用域和生存期不同。
全局变量对于整个程序均可见，而局部变量只对它所在的函数或者语句块可见。
全局变量的生存期与程序的生存期相同，而局部变量的生存期在退出函数或语句块后便结束。
通过将全局变量和局部变量置于内存中不同的段来实现的，全部变量存放与全局数据区，局部变量位于栈内。
操作系统和编译器识别变量的过程不清楚，麻烦哪位补充一下。
7．8086是多少位的系统？在数据总线上是怎么实现的？
8086是16位的系统。
8086地址总线有20位，CPU有1M的寻址空间，然而8086只有16位，为了能够寻址1M内存空间，必须通过分段来完成，即：物理地址=16位的段基址左移4位 + 16位的段内偏移量， 这样就可以寻址全部的地址空间了。
华为笔试网络题(1)
1.在OSI 7 层模型中,网络层的功能有( )
A.确保数据的传送正确无误 B.确定数据包如何转发与路由
C.在信道上传送比特流 D.纠错与流控
2.FDDI 使用的是___局域网技术。( )
A.以太网 B.快速以太网 C.令牌环 D.令牌总线
3.下面那种LAN 是应用CSMA/CD协议的 ( )
A.令牌环 B.FDDI C.ETHERNET D.NOVELL
4.TCP 和UDP 协议的相似之处是 ( )
A.面向连接的协议 B.面向非连接的协议 C.传输层协议 D.以上均不对
5.应用程序PING 发出的是___报文 ( )
A.TCP 请求报文 B.TCP 应答报文 C.ICMP 请求报文 D.ICMP 应答报文
6.以下说法错误的是(多) ( )
A.中继器是工作在物理层的设备 B.集线器和以太网交换机工作在数据连路层
C.路由器是工作在网络层的设备 D.桥能隔离网络层广播
7.当桥接收的分组的目的MAC地址在桥的映射表中没有对应的表项时,采取的策略是( )
A.丢掉该分组 B.将该分组分片 C.向其他端口广播该分组 D.以上答案均不对
8.LAN Switch 在网络层次模型中的地位( )
A.物理层 B.链路层 C.网络层 D.以上都不是
9.小于___的TCP/UDP端口号已保留与现有服务一一对应,此数字以上的端口号可自由分配。( )
A.199 B.100 C.1024 D.2048
10.当一台主机从一个网络移到另一个网络时,以下说法正确的是 ( )
A.必须改变它的IP地址和MAC 地址 B.必须改变它的IP 地址,但不需改动MAC 地址
C.必须改变它的MAC 地址,但不需改动IP 地址 D.MAC 地址、IP 地址都不需改动
答案：1.B; 2.C; 3.C; 4.C; 5.C; 6.BD; 7.C; 8.B; 9.C; 10.B.
笔试网络题
1、OSI模型7层结构
2、TCP/IP模型结构
3、CP/UDP区别
4、建立连接的步骤
5、TCP/IP 建立连接的过程?(3-way shake)
答：在TCP/IP协议中，TCP协议提供可靠的连接服务，采用三次握手建立一个连接。
第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；
第二次握手：服务器收到syn包，必须确认客户的SYN(ack=j+1)，同时自己也发送一个SYN包(syn=k)，即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
6、ICMP是什么协议,处于哪一层?
答：Internet控制报文协议，处于网络层(IP层)
7、IP组播有那些好处?
答：Internet上产生的许多新的应用，特别是高带宽的多媒体应用，带来了带宽的急剧
消耗和网络拥挤问题。组播是一种允许一个或多个发送者(组播源)发送单一的数据包
到多个接收者(一次的，同时的)的网络技术。组播可以大大的节省网络带宽，因为无
论有多少个目标地址，在整个网络的任何一条链路上只传送单一的数据包。所以说组播
技术的核心就是针对如何节约网络资源的前提下保证服务质量。
8、比特率和波特率的比较
9、邮件协议几层，介绍？
10、怎么样用命令行格式查看网络配置
11、Qos是什么，介绍下
1. 找错
试题1：
Void test1()
{
char string[10];
char* str1="0123456789";
strcpy(string, str1);
}
试题2：
Void test2()
{
char string[10], str1[10];
for(I=0; I<10;I++)
{
str1[i] ='a';
}
strcpy(string, str1);
}
试题3：
Void test3(char* str1)
{
char string[10];
if(strlen(str1) <= 10)
{
strcpy(string, str1);
}
}
解答：
test1: 字符串str1需要11个字节才能存放下(包括末尾的'\0')，而string只有10个字节的空间，strcpy会导致数组越界
test2: 如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10 分
test3: if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)，因为strlen的结果未统计'\0'所占用的1个字节
剖析：
考查对基本功的掌握：
(1)字符串以'\0'结尾；
(2)对数组越界把握的敏感度；
(3)库函数strcpy的工作方式，如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：
2分
void strcpy( char *strDest, char *strSrc )
{
while( (*strDest++ = * strSrc++) != '\0' );
}
4分
void strcpy( char *strDest, const char *strSrc )
//将源字符串加const，表明其为输入参数，加2分
{
while( (*strDest++ = * strSrc++) != '\0' );
}
7分
void strcpy(char *strDest, const char *strSrc)
{
//对源地址和目的地址加非0断言，加3分
assert( (strDest != NULL) && (strSrc != NULL) );
while( (*strDest++ = * strSrc++) != '\0' );
}
10分
//为了实现链式操作，将目的地址返回，加3分！
char * strcpy( char *strDest, const char *strSrc )
{
assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;
while( (*strDest++ = * strSrc++) != '\0' );
return address;
}
从2分到10分的几个答案我们可以清楚的看到，小小的strcpy竟然暗藏着这么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完美的strcpy啊！
(4)对strlen的掌握，它没有包括字符串末尾的'\0'。
读者看了不同分值的strcpy版本，应该也可以写出一个10分的strlen函数了，完美的版本为：
int strlen( const char *str ) //输入参数const
{
assert( strt != NULL ); //断言字符串地址非0
int len;
while( (*str++) != '\0' )
{
len++;
}
return len;
}
试题4：
void GetMemory( char *p )
{
p = (char *) malloc( 100 );
}
void Test( void )
{
char *str = NULL;
GetMemory( str );
strcpy( str, "hello world" );
printf( str );
}
试题5：
char *GetMemory( void )
{
char p[] = "hello world";
return p;
}
void Test( void )
{
char *str = NULL;
str = GetMemory();
printf( str );
}
试题6：
void GetMemory( char **p, int num )
{
*p = (char *) malloc( num );
}
void Test( void )
{
char *str = NULL;
GetMemory( &str, 100 );
strcpy( str, "hello" );
printf( str );
}
试题7：
void Test( void )
{
char *str = (char *) malloc( 100 );
strcpy( str, "hello" );
free( str );
}
解答：
试题4传入中GetMemory( char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完char *str = NULL; GetMemory( str ); 后的str仍然为NULL；
试题5中 char p[] = "hello world"; return p; 的p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。
试题6的GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，但是在GetMemory中执行申请内存及赋值语句
*p = (char *) malloc( num );后未判断内存是否申请成功，应加上：
if ( *p == NULL )
{
...//进行申请内存失败处理
}
试题7存在与试题6同样的问题，在执行char *str = (char *) malloc(100); 后未进行内存是否申请成功的判断；另外，在free(str)后未置str为空，导致可能变成一个“野”指针，应加上：str = NULL; 试题6的Test函数中也未对malloc的内存进行释放。
剖析：
试题4～7考查面试者对内存操作的理解程度，基本功扎实的面试者一般都能正确的回答其中50~60的错误。但是要完全解答正确，却也绝非易事。
对内存操作的考查主要集中在：
(1) 指针的理解；
(2) 变量的生存期及作用范围；
(3) 良好的动态内存申请和释放习惯。
再看看下面的一段程序有什么错误：
swap( int* p1,int* p2 )
{
int *p;
*p = *p1;
*p1 = *p2;
*p2 = *p;
}
在swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。该程序应该改为：
swap( int* p1,int* p2 )
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}
3. 内功题
试题1：分别给出BOOL，int，float，指针变量 与“零值”比较的 if 语句（假设变量名为var）
解答：
BOOL型变量：if(!var)
int型变量： if(var==0)
float型变量：const float EPSINON = 0.00001; if ((x >= - EPSINON) && (x <= EPSINON)
指针变量： if(var==NULL)
剖析：
考查对0值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)，而int型变量也可以写成if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。
一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断；如果用if判断一个数值 型变 量(short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)， 这是一种很好的编程习惯。
浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if (x == 0.0)，则判为错，得0分。
试题2：以下为Windows NT下的32位C++程序，请计算sizeof的值
void Func ( char str[100] )
{
sizeof( str ) = ?
}
void *p = malloc( 100 );
sizeof ( p ) = ?
解答：
sizeof( str ) = 4
sizeof ( p ) = 4
剖析：
Func ( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。
数组名的本质如下：
(1) 数组名指代一种数据结构，这种数据结构就是数组；
例如：
char str[10];
cout << sizeof(str) << endl;
输出结果为10，str指代数据结构char[10]。
(2) 数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；
char str[10];
str++; //编译出错，提示str不是左值
(3) 数组名作为函数形参时，沦为普通指针。
Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p ) 都为4。
试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？
least = MIN(*p++, b);
解答：
#define MIN(A,B) ((A) <= (B) ? (A) : (B))
MIN(*p++, b)会产生宏的副作用
剖析：
这个面试题主要考查面试者对宏定义的使用，宏定义可以实现类似于函数的功能，但是它终归不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替换。程序员对宏定义的使用要非常小心，特别要注意两个问题：
(1) 谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答：
#define MIN(A,B) (A) <= (B) ? (A) : (B)
#define MIN(A,B) (A <= B ? A : B ) 都应判0分；
(2) 防止宏的副作用。
宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：((*p++) <= (b) ? (*p++) : (*p++)) 这个表达式会产生副作用，指针p会作三次++自增操作。除此之外，另一个应该判0分的解答是：#define MIN(A,B) ((A) <= (B) ? (A) : (B));
这个解答在宏定义的后面加“;”，显示编写者对宏的概念模糊不清，只能被无情地判0分并被面试官淘汰。
试题4：为什么标准头文件都有类似以下的结构？
#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus
extern "C" {
#endif
/*
#ifdef __cplusplus
}
#endif
#endif /* __INCvxWorksh */
解答：
头文件中的编译宏
#ifndef __INCvxWorksh
#define __INCvxWorksh
#endif
的作用是防止被重复引用。
作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型为：
void foo(int x, int y);
该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。
为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题，函数声明前加上extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了。
试题5：编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果n=2，移位后应该是“hiabcdefgh”
函数头是这样的：
//pStr是指向以'\0'结尾的字符串的指针
//steps是要求移动的n
void LoopMove ( char * pStr, int steps )
{
//请填充...
}
解答：
正确解答1：
void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) - steps;
char tmp[MAX_LEN];
strcpy ( tmp, pStr + n );
strcpy ( tmp + steps, pStr);
*( tmp + strlen ( pStr ) ) = '\0';
strcpy( pStr, tmp );
}
正确解答2：
void LoopMove ( char *pStr, int steps )
{
int n = strlen( pStr ) - steps;
char tmp[MAX_LEN];
memcpy( tmp, pStr + n, steps );
memcpy(pStr + steps, pStr, n );
memcpy(pStr, tmp, steps );
}
剖析：
这个试题主要考查面试者对标准库函数的熟练程度，在需要的时候引用库函数可以很大程度上简化程序编写的工作量。
最频繁被使用的库函数包括：
(1) strcpy
(2) memcpy
(3) memset
试题6：已知WAV文件格式如下表，打开一个WAV文件，以适当的数据结构组织WAV文件头并解析WAV格式的各项信息。
WAVE文件格式说明表
偏移地址 字节数 数据类型 内 容
文件头
00H 4 Char "RIFF"标志
04H 4 int32 文件长度
08H 4 Char "WAVE"标志
0CH 4 Char "fmt"标志
10H 4 过渡字节（不定）
14H 2 int16 格式类别
16H 2 int16 通道数
18H 2 int16 采样率（每秒样本数），表示每个通道的播放速度
1CH 4 int32 波形音频数据传送速率
20H 2 int16 数据块的调整数（按字节算的）
22H 2 每样本的数据位数
24H 4 Char 数据标记符＂data＂
28H 4 int32 语音数据的长度
解答：
将WAV文件格式定义为结构体WAVEFORMAT：
typedef struct tagWaveFormat
{
char cRiffFlag[4];
UIN32 nFileLen;
char cWaveFlag[4];
char cFmtFlag[4];
char cTransition[4];
UIN16 nFormatTag ;
UIN16 nChannels;
UIN16 nSamplesPerSec;
UIN32 nAvgBytesperSec;
UIN16 nBlockAlign;
UIN16 nBitNumPerSample;
char cDataFlag[4];
UIN16 nAudioLength;
} WAVEFORMAT;
假设WAV文件内容读出后存放在指针buffer开始的内存单元内，则分析文件格式的代码很简单，为：
WAVEFORMAT waveFormat;
memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );
直接通过访问waveFormat的成员，就可以获得特定WAV文件的各项格式信息。
剖析：
试题6考查面试者组织数据结构的能力，有经验的程序设计者将属于一个整体的数据成员组织为一个结构体，利用指针类型转换，可以将memcpy、memset等函数直接用于结构体地址，进行结构体的整体操作。 透过这个题可以看出面试者的程序设计经验是否丰富。
试题7：编写类String的构造函数、析构函数和赋值函数，已知类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::String(const char *str)
{
if(str==NULL)
{
m_data = new char[1]; // 得分点：对空字符串自动申请存放结束标志'\0'的空
//加分点：对m_data加NULL 判断
*m_data = '\0';
}
else
{
int length = strlen(str);
m_data = new char[length+1]; // 若能加 NULL 判断则更好
strcpy(m_data, str);
}
}
// String的析构函数
String::~String(void)
{
delete [] m_data; // 或delete m_data;
}
//拷贝构造函数
String::String(const String &other) // 得分点：输入参数为const型
{
int length = strlen(other.m_data);
m_data = new char[length+1]; //加分点：对m_data加NULL 判断
strcpy(m_data, other.m_data);
}
//赋值函数
String & String::operate =(const String &other) // 得分点：输入参数为const型
{
if(this == &other) //得分点：检查自赋值
return *this;
delete [] m_data; //得分点：释放原有的内存资源
int length = strlen( other.m_data );
m_data = new char[length+1]; //加分点：对m_data加NULL 判断
strcpy( m_data, other.m_data );
return *this; //得分点：返回本对象的引用
}
剖析：
能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！
在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数，这既是对C++程序员的基本 要求，也是《Effective C++》中特别强调的条款。仔细学习这个类，特别注意加注释的得分点和加分点的意义，这样就具备了60%以上的C++基 本功！
试题8：请说出static和const关键字尽可能多的作用
解答：
static关键字至少有下列n个作用：
(1) 函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；
(2) 在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
(3) 在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
(4) 在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
(5) 在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。
const关键字至少有下列n个作用：
(1) 欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了(2) 对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
(3) 在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
(4) 对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
(5) 对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：
const classA operator*(const classA& a1,const classA& a2);
operator*的返回结果必须是一个const对象。如果不是，这样的变态代码也不会编译出错：
classA a, b, c;
(a * b) = c; // 对a*b的结果赋值
操作(a * b) = c显然不符合编程者的初衷，也没有任何意义。
剖析：
惊讶吗？小小的static和const居然有这么多功能，我们能回答几个？如果只能回答1~2个，那还真得闭关再好好修炼修炼。这个题可以考查面 试者对程序设计知识的掌握程度是初级、中级还是比较深入，没有一定的知识广度和深度，不可能对这个问题给出全面的解答。大多数人只能回答出static和 const关键字的部分功能。
4.技巧题
试题1：请写一个C函数，若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1
解答：
int checkCPU()
{
{
union w
{
int a;
char b;
} c;
c.a = 1;
return (c.b == 1);
}
}
剖析：
嵌入式系统开发者应该对Little-endian和Big-endian模式非常了解。采用Little-endian模式的CPU对操作数的存放方 式是从低字节到高字节，而Big-endian模式对操作数的存放方式是从高字节到低字节。例如，16bit宽的数0x1234在Little- endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址 存放内容
0x4000 0x34
0x4001 0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址 存放内容
0x4000 0x12
0x4001 0x34
32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为：
内存地址 存放内容
0x4000 0x78
0x4001 0x56
0x4002 0x34
0x4003 0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址 存放内容
0x4000 0x12
0x4001 0x34
0x4002 0x56
0x4003 0x78
联合体union的存放顺序是所有成员都从低地址开始存放，面试者的解答利用该特性，轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写。如果谁能当场给出这个解答，那简直就是一个天才的程序员。
试题2：写一个函数返回1+2+3+…+n的值（假定结果不会超过长整型变量的范围）
解答：
int Sum( int n )
{
return ( (long)1 + n) * n / 2; //或return (1l + n) * n / 2;
}
剖析：
对于这个题，只能说，也许最简单的答案就是最好的答案。下面的解答，或者基于下面的解答思路去优化，不管怎么“折腾”，其效率也不可能与直接return ( 1 l + n ) * n / 2相比！
int Sum( int n )
{
long sum = 0;
for( int i=1; i<=n; i++ )
{
sum += i;
}
return sum;
}
所以程序员们需要敏感地将数学等知识用在程序设计中。
编者按:
非常基本的C语言问题, 一个信息类(计算机,资讯工程,电子工程, 通信工程)专业的本科毕业生应该达到的水平。题目不难,全部都能快速地答完, 当然也需要一定的知识储备。对于大多数人, 我们预期你可能答错 3) 4) 15)题, 所以答错3道以内的, 我们认为你很棒。答错5道题以内, 我们认为你还不错(你还可能答错第9题)。如果你有6道以上的题目不能答对,基本上我们都不好说什么了....
约定:
1) 下面的测试题中, 认为所有必须的头文件都已经正确的包含了
2) 数据类型
char 一个字节 1 byte
int 两个字节 2 byte (16位系统, 认为整型是2个字节)
long int 四个字节 4 byte
float 四个字节4 byet
double 八个字节 8 byte
long double 十个字节 10 byte
pointer 两个字节 2 byte(注意, 16位系统, 地址总线只有16位)
第1题: 考查对volatile关键字的认识
#include
static jmp_buf buf;
main()
{
volatile int b;
b =3;
if(setjmp(buf)!=0)
{
printf("%d ", b);
exit(0);
}
b=5;
longjmp(buf , 1);
}
请问, 这段程序的输出是
(a) 3
(b) 5
(c) 0
(d) 以上均不是
第2题:考查类型转换
main()
{
struct node
{
int a;
int b;
int c;
};
struct node s= { 3, 5,6 };
struct node *pt = &s;
printf("%d" , *(int*)pt);
}
这段程序的输出是:
(a) 3
(b) 5
(c) 6
(d) 7
第3题:考查递归调用
int foo ( int x , int n)
{
int val;
val =1;
if (n>0)
{
if (n%2 == 1) val = val *x;
val = val * foo(x*x , n/2);
}
return val;
}
这段代码对x和n完成什么样的功能(操作)?
(a) x^n (x的n次幂)
(b) x*n(x与n的乘积)
(c) n^x(n的x次幂)
(d) 以上均不是
第4题:考查指针,这道题只适合于那些特别细心且对指针和数组有深入理解的人
main()
{
int a[5] = {1,2,3,4,5};
int *ptr = (int*)(&a+1);
printf("%d %d" , *(a+1), *(ptr-1));
}
这段程序的输出是:
(a) 2 2
(b) 2 1
(c) 2 5
(d) 以上均不是
第5题:考查多维数组与指针
void foo(int [][3]);
main()
{
int a [3][3]= { { 1,2,3} , { 4,5,6},{7,8,9}};
foo(a);
printf("%d" , a[2][1]);
}
void foo(int b[][3])
{
++ b;
b[1][1] =9;
}
这段程序的输出是:
(a) 8
(b) 9
(c) 7
(d)以上均不对
第6题:考查逗号表达式
main()
{
int a, b,c, d;
a=3;
b=5;
c=a,b;
d=(a,b);
printf("c=%d" ,c);
printf("d=%d" ,d);
}
这段程序的输出是:
(a) c=3 d=3
(b) c=5 d=3
(c) c=3 d=5
(d) c=5 d=5
第7题:考查指针数组
main()
{
int a[][3] = { 1,2,3 ,4,5,6};
int (*ptr)[3] = a;
printf("%d %d ", (*ptr)[1], (*ptr)[2]);
++ptr;
printf("%d %d" , (*ptr)[1], (*ptr)[2]);
}
这段程序的输出是:
(a) 2 3 5 6
(b) 2 3 4 5
(c) 4 5 0 0
(d) 以上均不对
第8题:考查函数指针
int *f1(void)
{
int x =10;
return(&x);
}
int *f2(void)
{
int*ptr;
*ptr =10;
return ptr;
}
int *f3(void)
{
int *ptr;
ptr=(int*) malloc(sizeof(int));
return ptr;
}
上面这3个函数哪一个最可能引起指针方面的问题
(a) 只有 f3
(b) 只有f1 and f3
(c) 只有f1 and f2
(d) f1 , f2 ,f3
第9题:考查自加操作(++)
main()
{
int i=3;
int j;
j = sizeof(++i+ ++i);
printf("i=%d j=%d", i ,j);
}
这段程序的输出是:
(a) i=4 j=2
(b) i=3 j=2
(c) i=3 j=4
(d) i=3 j=6
第10题:考查形式参数, 实际参数, 指针和数组
void f1(int *, int);
void f2(int *, int);
void(*p[2]) (int *, int);
main()
{
int a;
int b;
p[0] = f1;
p[1] = f2;
a=3;
b=5;
p[0](&a, b);
printf("%d\t %d\t", a, b);
p[1](&a, b);
printf("%d\t %d\t", a, b);
}
void f1(int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
}
void f2(int* p , int q)
{
int tmp;
tmp =*p;
*p = q;
q= tmp;
}
这段程序的输出是:
(a) 5 5 5 5
(b) 3 5 3 5
(c) 5 3 5 3
(d) 3 3 3 3
第11题:考查自减操作(--)
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
第12题:考查typedef类型定义,函数指针
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) 以上都不是
第13题:数组与指针的区别与联系
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) 以上都不对
第14题: 考查指针数组的指针
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
第15题:此题考查的是C的变长参数,就像标准函数库里printf()那样,这个话题一般国内大学课堂是不会讲到的,不会情有可原
#include
int ripple ( int ,
main()
{
int num;
num = ripple ( 3, 5,7);
printf( " %d" , num);
}
int ripple (int n,
{
int i , j;
int k;
va_list p;
k= 0;
j = 1;
va_start(p, n);
for (; j
i = va_arg(p , int);
for (; i; i &=i-1 )
++k;
}
return k;
}
这段程序的输出是:
(a) 7
(b) 6
(c) 5
(d) 3
第16题:考查静态变量的知识
int counter (int i)
{
static int count =0;
count = count +i;
return (count );
}
main()
{
int i , j;
for (i=0; i <=5; i++)
j = counter(i);
}
本程序执行到最后,j的值是:
(a) 10
(b) 15
(c) 6
(d) 7
详细参考答案
第1题: (b)
volatile字面意思是易于挥发的。这个关键字来描述一个变量时, 意味着 给该变量赋值(写入)之后, 马上再读取, 写入的值与读取的值可能不一样,所以说它"容易挥发"的。
这是因为这个变量可能一个寄存器, 直接与外部设备相连, 你写入之后, 该寄存器也有可能被外部设备的写操作所改变;或者, 该变量被一个中断程序, 或另一个进程
改变了.
volatile 不会被编译器优化影响, 在longjump 后,它的值 是后面假定的变量值,b最后的值是5,所以5被打印出来.
setjmp : 设置非局部跳转 /* setjmp.h*/
Stores context information such as register values so that the lomgjmp function can return control to the statement following the _disibledevent=> val =x;
while(n>0)
{
if (n%2 == 1)
product = product*val; /*如果是奇数次幂, x(val)要先乘上一次,;
偶数次幂, 最后返回时才会到这里乘以1*/
val = val* val;
n = n/2;
}
return product;
}
/* 用二元复乘策略 */
算法描述
(while n>0)
{
if next most significant binary digit of n( power) is _disibledevent=>b[1][0] = 7
第6题: (c)
考查逗号表达式,逗号表达式的优先级是很低的, 比 赋值(=)的优先级 低. 逗号表达式的值就是最后一个元素的值
逗号表达式的还有一个作用就是分割函数的参数列表..
E1, E2, ..., En
上面这个表示式的左右是,E1, E2,... En的值被分别计算出来, En计算出来的结构赋给整个逗号表达式
c=a,b; / *yields c=a* /
d=(a,b); /* d =b */
第7题: (a)
ptr是一个数组的指针, 该数组有3个int成员
第8题: (c)
f1显然有问题, 它返回一个局部变量的指针, 局部变量是保存在stack中的,退出函数后, 局部变量就销毁了, 保留其指针没有意义, 因为其指向的stack空间可能被其他变量覆盖了
f2也有问题, ptr是局部变量, 未初始化, 它的值是未知的, *ptr不知道指向哪里了, 直接给*ptr赋值可能会覆盖重要的系统变量, 这就是通常说的野指针的一种
第9题: (b)
sizeof 操作符给出其操作数需要占用的空间大小, 它是在编译时就可确定的, 所以其操作数即使是一个表达式, 也不需要在运行时进行计算.( ++i + ++ i )是不会执行的, 所以i的值还是3
第10题: (a)
很显然选a.
f1交换*p 和 q的值, f1执行完后, *p 和 q的值的确交换了, 但q的改变不会影响到b的改变, *p 实际上就是a
所以执行f1后, a=b=5
这道题考查的知识范围很广,包括typedef自定义类型,函数指针,指针数组void(*p[ 2 ]) ( int *, int);
定义了一个函数指针的数组p,p有两个指针元素. 元素是函数的指针, 函数指针指向的函数是一个带2个参数,返回void的函数, 所带的两个参数是指向整型的指针, 和整型
p[ 0 ] = f1; p[ 1 ] = f2 contain address of function .function name without parenthesis represent address of function Value and address of variable is passed to function _disibledevent=> (p+=sizeof(int))[-1] 指向 argv[1],能理解吗, 因为(p+=sizeof(int))[-1] 就相当于 (p+=2)[-1] ,也就是(p+2-1)
第15题: (c)
在C编译器通常提供了一系列处理可变参数的宏, 以屏蔽不同的硬件平台造成的差异, 增加程序的可移植性。这些宏包括va_start、va_arg和va_end等。
采用ANSI标准形式时, 参数个数可变的函数的原型声明是：type funcname(type para1, type para2, ...)
这种形式至少需要一个普通的形式参数, 后面的省略号不表示省略, 而是函数原型的一部分。type是函数返回值和形式参数的类型。
不同的编译器, 对这个可变长参数的实现不一样 , gcc4.x中是内置函数.
关于可变长参数,可参阅
http://www.upsdn.net/html/2004-11/26.html
http://www.upsdn.net/html/2004-11/24.html
程序分析
va_list p; /*定义一个变量 ,保存 函数参数列表 的指针*/
va_start( p , n); /*用va_start宏 初始化变量p, va_start宏的第2个参数n, 是一个固定的参数, 必须是我们自己定义的
变长函数的最后一个入栈的参数也就是调用的时候参数列表里的第1个参数*/
for (; j
i = va_arg( p , int); /*va_arg取出当前的参数,并认为取出的参数是一个整数(int) */
for (; i; i &=i-1 ) /*判断取出的i是否为0*/
++k; /* 如果i不为0, k自加, i与i-1进行与逻辑运算, 直到i 为0
这是一个技巧, 下面会谈到它的功能*/
}
当我们调用ripple函数时, 传递给ripple函数的 参数列表的第一个参数n的值是3. va_start 初始化p士气指向第一个未命名的参数(n是有名字的参数) ,也就是 is 5 (第一个). 每次对 va_arg的调用, 都将返回一个参数, 并且把 p 指向下一个参数. va_arg 用一个类型名来决定返回的参数是何种类型,以及在 var_arg的内部实现中决定移动多大的距离才到达下一个参数
(; i; i&=i-1) k++ /* 计算i有多少bit被置1 */
5用二进制表示是 (101) 2
7用二进制表示 (111) 3
所以 k 返回 5(2+3),也即本题应该选c
举个例子, 就很好理解了
令 i= 9 = 1001
i-1 = 1000
(i-1) +1 = i
1000
+1
1001
因为i与i-1的最右边的那位(最低位) 肯定是不同, 如果i1,i-1肯定是0, 反之亦然. i & i-1 这个运算, 在二相补的数字系统中, 将会消除最右边的1位
第16题: (b)
答案是 (b)
相传高斯小学一年级的时候就会做这类等比数列的题目了.这道题考查的是静态变量的知识,当每次调用完函数之后,静态变量的值不会丢失,这与栈中的临时局部变量明显不同的地方.
所以,第一次调用counter(0)之后,count =0
第二次调用 counter(1)后 count = 0+1;
第三次调用 counter(2) count = 1+2; /* count = count +i */
第四次调用 counter(3) count = 3+3;
第五次调用 counter(4) count = 6+4;
第六次调用 counter(5) count = 10+5;
命题人信息 Ashok K. Pathak a member ( Research Staff ) at Bharat Electronics Limited (CRL), Ghaziabad. He has been developing embedded application for the past five years .Ashok holds a M.E in computer science and engineering. Ashok recently completed a book about' "Advanced Test in C and Embedded System Programming", Published by BPB , ND.
选择题（每题5分，只有一个正确答案）
1．中国1号信令协议属于 的协议。
A. ccs B. cas C. ip D. atm
2．isdnpri协议全称是
A. 综合业务模拟网基速协议
B. 综合业务模拟网模拟协议
C. 综合业务数字网基率协议
D. 综合业务数字网基次协议
3．路由协议中， 协议是用距离作为向量的
A. ospf B. bgp C. is-is D. rip
4．中国智能网中，ssp与scp间最上层的ss7协议是
A. incs B. is41b C. is41c D. inap
5．dtmf全称是
A. 双音多频 B. 多音双频 C. 多音三频 D. 三音多频
6．计算机的基本组成部分中，不包含下面设备的是
A. cpu B. 输入设备 C. 存储器 D. 接口
7．脉冲编码调制的简称是
A. pcm B. pam C. (delta)M D. atm
8．普通电话线接口专业称呼是
A. rj11 B. rj45 C. rs232 D. bnc
9．现有的公共数据网都采用
A. 电路交换技术 B. 报文交换技术
C. 语音插空 D. 分组交换
10．ss7协议中的制止市忙消息简写为
A. stb B. slb C. sub D. spb
简答题（每题10分）
1．简述普通电话与IP电话的区别。
2．简述随路信令与公路信令的根本区别。
3．说明掩码的主要作用。
4．ss7协议中，有三大要素决定其具体定位，哪三大要素？
5．描述ss7的基本通话过程。
6．简述通信网的组成结构。
7．面向连接与面向非连接各有何利弊？
8．写出爱尔兰的基本计算公式。
9．数据网主要有哪些设备？
10．中国一号协议是如何在被叫号码中插入主叫号码的？
1. M是一个Byte，请计算M中bit为1的个数
#include
int main()
{
int i,count;
char M=0x11; /*00010001b*/
printf("%x\n",M);
for(i=0,count=0;i<8;i++)
{
if( ((1<
count++;
}
}
printf("%d\n",count);
}
2. 计算Num[100]中9的个数
#include
int main()
{
int i,count;
char Num[100]={0x1,0x2,0x3,0x4,0x9,0x12,0x3,0x9};
for(i=0,count=0;i<100;i++)
if( *(Num+i) == 9)
count++;
printf("%d",count);
}
3. 将整数M(4Bytes)转换成一个字符串
#include
int main()
{
int i=0;
int M=12345;
char str[12];
do
{
str[ i ]= (M%10)+0x30;
i++;
} while( (M=M/10)>0 );
printf("%s",str);
}
4. 将一个字符串倒置
#include
#include
int main()
{
int i,Len;
char str[12]="abcdef";
char temp;
Len=strlen(str);
for(i=0;i
temp = *(str+i);
*(str+i) = *(str-i+Len-1);
*(str-i+Len-1) = temp;
}
printf("%s",str);
}
5. 将一个单向链表 (linked list)逆序 (注：原题写成双向链表，是个陷阱)
q = h->next; /* h是头节点 */
h->next = NULL; /* h->next 充当临时变量 */
while( q!=NULL)
{
p = q;
q = q->next;
p->next = h->next;
h->next = p;
}
6. 在一个字符串查找一个最长子串，要求这个子串的每个字符相同
以下题目请在一个小时内完成
1、完成字符串拷贝可以使用 sprintf、strcpy 及 memcpy 函数，请问这些函数有什么区别，你喜欢使用哪个，为什么？
2、变量的声明和定义有什么区别？
3、请写出下面代码在 32 位平台上的运行结果，并说明 sizeof 的性质：
#include
#include
int main(void)
{
char a[30];
char *b = (char *)malloc(20 * sizeof(char));
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(b));
printf("%d\n", sizeof(a[3]));
printf("%d\n", sizeof(b+3));
printf("%d\n", sizeof(*(b+4)));
return 0 ;
}
4、请完成以下题目。注意，请勿直接调用 ANSI C 函数库中的函数实现。
a)请编写一个 C 函数，该函数给出一个字节中被置1的位的个数，并请给出该题的至少一个不同解法。
b)请编写一个 C 函数，该函数将给定的一个字符串转换成整数。
c)请编写一个 C 函数，该函数将给定的一个整数转换成字符串。
d)请编写一个 C 函数，该函数将一个字符串逆序。
e)请编写一个 C 函数，该函数在给定的内存区域搜索给定的字符，并返回该字符所在位置索引值。
f)请编写一个 C 函数，该函数在一个字符串中找到可能的最长的子字符串，该字符串是由同一字符组成的。
5、给出演示上述函数功能的一个简单程序，并请编写对应的Makefile文件。
若应聘嵌入式软件高级工程师，请作答以下题目：
6、我们需要编写一个图形相关的应用程序，需要处理大量图形(Shape)信息，图形有矩形(Rectangle)，正方形(Square)，圆形 (Circle)等种类，应用需要计算这些图形的面积，并且可能需要在某个设备上进行显示(使用在标准输出上打印信息的方式做为示意)。
a)请用面向对象的方法对以上应用进行设计，编写可能需要的类
b)请给出实现以上应用功能的示例性代码，从某处获取图形信息，并且进行计算和绘制
c)如果你的Square继承自Rectangle，请给出理由，如果不是，请给出理由，并且请比较两种方式的优劣
d)请问你所编写的类，在如下代码中会有何表现，请解释
void test_rectangle_area(Rectangle& r)
{
r.set_width(10);
r.set_height(15);
assert(r.area() == 150);
}
朗讯(青岛)笔试题，共7页，2小时
1.Quick caculation(10分)
I.
a 8月1日是星期三，问到9月的第一个星期六有多少天？(包括8月1日和那个星期六)
b 一月有5个星期一5个星期二5个星期三，2月1日是星期几？
II.6只猫6分钟捉6只老鼠，问10分钟抓10只老鼠需要几只猫？
2. Basic Algorithm(10)
Given an arbitrary binary tree,propose a method to determine the first common ancestor of 2 randomly selected nodes in the tree.
3. Basic computer knowledge (10)
1) 把16进制译成8bit的2进制字符FF,7F,F0
2) web browser与search engine的区别
3) osi的七层网络模型，以及网关工作在哪一层？
4. 操作系统(10)
请解释死锁deadlock，以及防止死锁的方法。
5. 数据库(10)
a tabel called "performance" contain ：name and score，please 用SQL语言表述如何选出score最high的一个(仅有一个)
6. 编程题(50分)
I the program that tranlate high level program into low_level program to be execute in computer 叫做什么？
II c和java都是可移植的，但是是在不同的level，请指出它们分别在那个level上可以移植。
III static char S[]="I come not to bury caesar."
请给出结果：
a) printf("%s",s)
b) printf("%s",&s[0])
c) printf("%s",s+11)
IV 有个程序让改错，好像是有一句memcpy(buffer,pMsg->content+7,msglen)错了，我觉得中间的参数应该是&(pMsg->content+7)。
V 写一个递归程序求n!，语言可以自选，最好用C/c++或java、delphi、pascal。
VI 写一个实现多项式乘法的c程序。
---------------------------------------
1、一个类的多个实例如何共享一个数据？
2、什么叫多态，举个多态的例子。
3、继承有几种？
4、内存泄漏？
5、c++比c有什么优势？给你一个100,000行的工作量，你选什么做编程语言？
---------------------------------------------------------
朗讯面试经历
英语出题，主要包括智力题、基本算法题、数据库、操作系统、程序填充、程序改错、小程序
智力题: 很简单不说了，注意点就行
基本算法题: 就是给出两个字符串相加的表达式，推测每个字母代表的数字
数据库: 从表中选出成绩最高的学生的名字的sql语句
操作系统: 解释deadlock，只考了一道题
程序提填空: 完善一个链表的操作，很简单，但是不小心就只能得个六七分
程序改错: 就是一段程序，看错在哪里，老实说我现在还不知道那个题是什么意思
完善小程序:
1、不使用第三个变量交换两个变量
void swap(int a,int b)
{
a=a^b;
b=b^a;
a=a^b;
}
或者
void swap(int a, int b)
{
a=a+b;
b=a-b;
a=a-b;
}
不过这两种方法只是修改了函数的形参，如果要修改实参，可以采用如下的方法:
void swap(int* a,int *b)
{
*a=*a^*b;
*b=*b^*a;
*a=*a^*b;
printf("In %s:a=%d,b=%d\n",__FUNCTION__,*a,*b);
}
2、计算一个大数的阶乘
//计算100!
unsigned int result[10000];
int main(int argc,char* argv[])
{
int i,j,k=1;
result[0]=1;
for(i=1;i<10000;i++)
result[i]=0;
for(i=0;i<101;i++){
for(j=0;j
for(j=0;j
result[j+1]+=result[j]/10000;
result[j]%=10000;
if(j==k-1){
k++;
break;
}
}
}
}
printf("%d",result[k-1]);
for(i=k-2;i>=0;i--)
printf("%04d",result[i]);
return 0;
}
这个周一参加了lucent(青岛)研发中心的笔试，感想很多
1，对笔试既然去了就要足够的重视，至少在考试的时候要集中精力。我对lucent的印象蛮好的，但是我觉得自己不可能会去青岛的，所以去笔试的时候态度 就有问题，能过则过，不过也就拉倒，以至于考试的两个小时里面无法集中注意力，当然这个可能不仅与心态不好有关，还有就是好久没有接触过试卷了，看到试卷 非常的烦躁，结果一些非常弱质的测试题，居然一分没有得到，结果面试官的表情让我看出来他觉得我的ET-6是由水分的或者之上低，不然怎么可能6只猫6分 钟抓6只老鼠，几只猫10分钟能抓10只老鼠都算错了呢。^_^结论就是去了就要认真对待试题上的每一分；
2，就是一个认识问题，以前总觉得笔试是为了剔除不合适的人，比如招聘软件的会看你的基本的软件能力如何，所以我就尽量打好编程相关的题，结果也导致了简 单的智力题一分没有得到这么惨痛的事情(自己都觉得不好意思:))。其实笔试是为了选择最优秀的top20~top30的人，不可能每个人都有面试机会 的，否则目前这种一个职位应者云集的情况下，还不把招聘人员累死了。所以还是得到和1相同的结论:笔试就要全力争取每一分。
3，其实3和1、2的结论都一样，就是全力争取每一分，不要说这样的题只会在考试中才会出现这样幼稚的，人家题出来了，就只看分的，况且每道题的分都根据 他们的测试重点给出了不同的分值。结论就是:全力争取每一道题，每一分，就像高考一样，否则过不了笔试哪里有面试，面试都没有，你再优秀HR们是看不到的
微软亚洲技术支持中心
1. 进程(Process)和线程(Thread)的差别
2. 堆(Heap)与栈(stack)的差别
3. Windows是如何管理内存的
4. 介绍.Net和.Net的安全性
5. 客户端如何访问.Net组件实现Web Service
6. C/C++编译器中虚表是如何完成的
7. 谈谈COM的线程模型， 然后讨论进程内/外组件的差别
8. 谈谈IA32下的分页机制
9. 给两个变量，如何找出一个带环单链表中是什么地方出现环的
10. 在IA32中一共有多少种办法从用户态跳到内核态
11. 如果只想让程序有一个实例运行，不能运行两个，像winamp一样，只能开一个窗口，怎样实现
12. 如何截取键盘的响应,让所有的'a'变成'b'
13. Apartment在COM中有什么用，为什么要引入
14. 存储过程是什么，有什么用，有什么优点
15. Template有什么特点，什么时候用
16. 谈谈Windows DNA结构的特点和优点
微软亚洲工程院
基础题
1. regular expression不能描述的是?
a)两个连续偶数 b)两个连续奇数
2. 程序分析
int s(int v)
{
int count=0;
int x=v;
while (x)
{
count++;
x=x&(x-1)
}
return count;
}
s(9999)=?
3. 关于堆排序的东西，插入新的元素以后的结果
4. 关于C语言中，.h文件和.c文件之间的关系
5. 如果数据扩大两倍，是向左，还是向右移动几位的问题
6. 对二叉排序数，以什么输出(前序，中序，还是后续)输出，是排列
7. 一个顺序为 1，2，3，4，5，6 的栈，依次进入一个队列，然后再进栈， 顺序是什么？
8. 关于数组指针的的题目
9. 在编写代码是查找错误好还是用testing找好？
10. 好像是说编译器可以修改type error的好处或不好。
程序设计部分
1 Translate MIPS assembly code into a function in C/C++
* your code should be concise
* no any GOTOs/pointers
MIPS code:
func:
li v0,0
li t0,0
l1:
add t1,a0,a0
lb t2,0(t1)
beq t2,zero,l3
bne t2,a1,l2
add v0,v0,1
l2:
add t0,t0,1
j l1
l3:
jr ra
(caller register: t0~t9,a0~a3,v0~v1; callee s0~s7,ra)
然后列出了指令表,li是赋值,lb是将字段后第一个寄存器内容个字节的内容复制到第二个寄存器,beq是等值转移ben是不等值转移,j是无条件转移,jr转移至寄存器标示的内容.
2. 实现数组的插入、查找、删除操作
arr为指向数组的指针
len为数组长度
count表示数组元素数目
出错返回-1
int insert(int* arr, size_t len, size_t count, int val)
返回插入的数组索引
插入后要求对数组排序
出错处理
int search(int* arr, size_t len, size_t count, int val)
要求返回所找到的元素
出错处理
int remove(int* arr, size_t len, size_t count, int val)
要求返回删除的元素值
出错处理
测试部分
1. 你被分配到Internet Explorer研发部,(从核心到界面什么都可以).你如何设计,开发和测试它?
2. 给你个DVD,你应当如何测试它,如果你的时间极其有限,你会测试什么?为什么?
3. 给你一个字符比较函数strCmp(const char* string1，const char* string2)以及其返回值表明的意义,(>0，==0，<0),设计测试case
4. 一段字符串复制程序,指出其存在的错误和潜在缺陷
最后是个论述题目,只有这个题目是要用英文作答的，上面的都可以用Chinese
1) 问的是你在过去一年里做出过什么样的重要决定,你为什么做出这样的决定,这个决定对你的影响,你达到你作决定时期望的目标了没.有什么收获.
2) 问的是你在过去一年里遇到什么样的问题，你如何解决的，是和别人解决的还是自己解决的？你达到你作决定时期望的目标了没，有什么收获。
微软亚洲工程院笔试题
1. 找Bug
int CopyStringCount(const char* Str)
{
int nCount = 0;
char* pBuffer;
pBuffer = new char[_MAX_PATH];
strcpy(pBuffer,Str);
while(;pBuffer ;pBuffer++)
if(pBuffer == '\\') nCount ++;
return nCount;
}
2. 写输出
void foo(int p1[])
{
*p1 += 5;
}
void bar(int p2[])
{
p2[1] = 15;
}
void main()
{
int a[]={3,4,5};
int b[]={3,4,5};
int *p2;
p2=&a[1];
bar(p2);
printf("%i %i %i\n",a[0],a[1],a[2]);
p2=&b[0];
p2++;
foo(p2);
bar(p2);
printf("%i %i %i\n",b[0],b[1],b[2]);
}
微软亚洲工程院2004年第二轮笔试题
1. 找错
struct S
{
int i;
int * p;
};
void main()
{
S s;
int * p = &s.i;
p[0] = 4;
p[1] = 3;
s.p = p;
s.p[1] = 1;
s.p[0] = 2;
}
程序会在哪一行死掉
2.
int CalcMean(int i)
{
static int s, c;
s+=i; c++;
return s/c;
}
求CalcMeas( CalcMeas(3) )＝？
3.
int calc(int a，int b)
{
if(a >= b)
return (a==b)?a:b;
else
return a+b+calc(++a，--b);
}
求calc(1，5)等于？
Mircosoft面试题
1.2.4 IQ题(是填空的最后两题)：
1、三个盒子，有一个有宝石，让你先选一个。然后主持人在剩下的盒子中打开一个空盒子(主持人知道宝石在哪个盒子里)。现在你有一次改变选择的机会。你改不改？
2、
abcdef*2=cdefab
cdefab*2=efabcd
每个字母代表一个数字
abcdef＝？
2 编程题
(1) 写一个CircularQueue()
(2) 写一个Merge函数。把两个已排序的链表合并。两个链表一个是升序，一个是降序。
3 设计(可用中文)
设计一个密码对话框，用来保护用户的文件。
(1) 写出设计文档
(2) 写出各种功能的priority，以及为什么这样设定。
(3) 如果开发人员根据你的要求实现了这个对话框，你准备如何测试它？写出测试的各点。
4 测试(可用中文)
(1) 已知有一个函数，它的功能是将字符串转换成数字，你如何测试它？假设函数是这样的形式：atoi(char *，int*) 。请列出所有可能的测试案例。
(2) 现在有一个Web搜索引擎，它说它拥有了搜索的功能。你怎样测试它？请写出你想要测试的各个方面以及方法。
5 要用英文做答opening question
(1) 你曾经有过什么非常有创意的想法？最好是软件方面。
(2) 你想让开发者添加一个他认为不重要的功能，你会怎么做？英文是：
How would you convince a developer to add a featurethat the developer does not view as importart?
Microsoft程序员常用面试题
1.链表和数组的区别在哪里？
2.编写实现链表排序的一种算法。说明为什么你会选择用这样的方法？
3.编写实现数组排序的一种算法。说明为什么你会选择用这样的方法？
4.请编写能直接实现strstr()函数功能的代码。
5.编写反转字符串的程序，要求优化速度、优化空间。
6.在链表里如何发现循环链接？
7.给出洗牌的一个算法，并将洗好的牌存储在一个整形数组里。
8.写一个函数，检查字符是否是整数，如果是，返回其整数值。(或者：怎样只用4行代码编写出一个从字符串到长整形的函数？)
9.给出一个函数来输出一个字符串的所有排列。
10.请编写实现malloc()内存分配函数功能一样的代码。
11.给出一个函数来复制两个字符串A和B。字符串A的后几个字节和字符串B的前几个字节重叠。
12.怎样编写一个程序，把一个有序整数数组放到二叉树中？
13.怎样从顶部开始逐层打印二叉树结点数据？请编程。
14.怎样把一个链表掉个顺序(也就是反序，注意链表的边界条件并考虑空链表)？
Mircosoft经典面试题智力题
1. 为什么下水道的井盖是圆的？
答：因为圆井盖不会掉进下水道去，因为方井盖对角线明显长于边长，稍微角度不对就掉进去了，其他非圆形井盖也有这个问题。
2. 美国有多少辆车？(一个常见的类似问题是：美国有多少家加油站？)
答：大约一亿辆车，算上公司的车，差不多平均每个家庭一辆车。
3. 美国有多少个下水道井盖？
答：缺少数据，比如美国公路总长度之类的数据
4. 你让某些人为你工作了七天，你要用一根金条作为报酬。这根金条要被分成七块。你必须在每天的活干完后交给他们一块。如果你只能将这根金条切割两次，你怎样给这些工人分？
答：1/7，2/7，4/7，第一天给1/7，第二天拿2/7换1/7
5. 一列火车以每小时15英里的速度离开洛杉矶，朝纽约进发。另外一列火车以每小时20英里的速度离开纽约，朝洛杉矶进发。如果一只每小时飞行25英里的鸟同时离开洛杉矶，在两列火车之间往返飞行，请问当两列火车相遇时，鸟飞了多远？
答：用相对速度，距离是5L/7，L是两城市之间的距离
6. 假设一张圆盘像唱机上的唱盘那样转动。这张盘一半是黑色，一半是白色。假设你有数量不限的一些颜色传感器。要想确定圆盘转动的方向，你需要在它周围摆多少个颜色传感器？它们应该被摆放在什么位置？
答：两个就可以了，挨着放。有一个探测器测到变色，紧跟着另一个测到，过一段时间才有下一次。转盘从第一个测到变色的转向第二个。
7. 假设时钟到了12点。注意时针和分针重叠在一起。在一天之中，时针和分针共重叠多少次？你知道它们重叠时的具体时间吗？
8. 你有两个罐子，分别装着50个红色的玻璃球和50个蓝色的玻璃球。随意拿起一个罐子，然后从里面拿出一个玻璃球。怎样最大程度地增加让自己拿到红球的机会？利用这种方法，拿到红球的几率有多大？
答：一个瓶子里装一个红球，其他都装到另一个瓶子里，取到红球的概率是149/198
9. 中间只隔一个数字的两个奇数被称为奇数对，比如17和19。证明奇数对之间的数字总能被6整除(假设这两个奇数都大于6)。现在证明没有由三个奇数组成的奇数对。
答：题目有问题，应该把所有的“奇数”改为“质数”。原因是，质数对必然全是奇数，中间数字为偶数。指数对都不能被三整数，所以中间的数可以被三整除。得证连续三个奇数必有一个可以被三整除，大于6的质数全不能被三整数。所以不存在。
10. 一个屋子有一个门(门是关闭的)和3盏电灯。屋外有3个开关，分别与这3盏灯相连。你可以随意操纵这些开关，可一旦你将门打开，就不能变换开关了。确定每个开关具体管哪盏灯。
答：开两个开关，过一段时间关一个，进去，一个灯亮，两个灯灭，灭的灯有一个是热的。
11. 假设你有8个球，其中一个略微重一些，但是找出这个球的惟一方法是将两个球放在天平上对比。最少要称多少次才能找出这个较重的球？
答：拿出六个球比，两次可解决
12. 假设你站在镜子前，抬起左手，抬起右手，看看镜中的自己。当你抬起左手时，镜中的自己抬起的似乎是右手。可是当你仰头时，镜中的自己也在仰头，而不是低头。为什么镜子中的影像似乎颠倒了左右，却没有颠倒上下？
答：上下和左右的定义不同，上下是面对称的，左右是旋转对称的 (如果两只眼睛是长成一上一下就好了)
13. 你有4瓶药。每粒药丸的重量是固定的，不过其中有一瓶药受到了污染，药丸的重量发生了变化，每个药丸增加了一点重量。你怎样一下子测出哪瓶药是遭到污染的呢？
答：如果确切知道那一点重量是多少，可以采取一种方法：第二个瓶取一粒，第三个瓶去两粒第四个瓶取三粒。称重之后可以计算出。
如果不确切的知道，可以考虑使用三根绳子和三个滑轮。
14. 下面玩一个拆字游戏，所有字母的顺序都被打乱。你要判断这个字是什么。假设这个被拆开的字由5个字母组成：
答：
1) 共有多少种可能的组合方式？ 26^5(可重复)，26*25*25*24*23*22(不可重复)
2) 如果我们知道是哪5个字母，那会怎么样？ 5!
3) 找出一种解决这个问题的方法。 穷举试探法，把五个字母按权重排序，逐步变大序列权重，可保证完却探索。
15. 有4个女人要过一座桥。她们都站在桥的某一边，要让她们在17分钟内全部通过这座桥。这时是晚上。她们只有一个手电筒。最多只能让两个人同时过桥。不管是 谁过桥，不管是一个人还是两个人，必须要带着手电筒。手电筒必须要传来传去，不能扔过去。每个女人过桥的速度不同，两个人的速度必须以较慢的那个人的速度 过桥。
答：
第一个女人：过桥需要1分钟；
第二个女人：过桥需要2分钟；
第三个女人：过桥需要5分钟；
第四个女人：过桥需要10分钟。
比如，如果第一个女人与第4个女人首先过桥，等她们过去时，已经过去了10分钟。如果让第4个女人将手电筒送回去，那么等她到达桥的另一端时，总共用去了20分钟，行动也就失败了。怎样让这4个女人在17分钟内过桥？还有别的什么方法？
第一次1和2过桥，共用2分钟
1回来，共用3分钟
3和4过桥，共用13分钟
2回来，共用15分钟
1和2过桥，共用17分钟
1和2返回的次序可以相反 ,效果不变
16. 如果你有一个5夸脱的水桶和一个3夸脱的水桶，如何准确量出4夸脱的水？
答：装满3，3倒入5，装满3，3倒满5，3中剩1夸脱。倒空5，将一夸脱倒入5，装满3，倒入 5即可。
17. 你有一袋糖，有红色的，蓝色的，绿色的。闭上眼睛，拿出两块颜色一样的糖，你需要拿多少次才能确保有两块颜色相同的？
答：四次 (鸽笼原理)
18. 如果你有两个桶，一个装的是红色的颜料，另一个装的是蓝色的颜料。你从蓝色颜料桶里舀一杯，倒入红色颜料桶，再从红色颜料桶里舀一杯倒入蓝颜料桶。两个桶中红蓝颜料的比例哪个更高？通过算术的方式来证明这一点。
答：算术的方式来证明这一点。 设桶是杯子容量的k倍。蓝倒入红一杯，红中蓝的比例是1/(k+1)。倒回一杯，红中蓝色比例不变。蓝中红色比例是(k/(k+1))/k=1/(k+1)。比例一样大
Microsoft Interview Questions
The following are actual questions from actual interviews conducted by Microsoft employees _disibledevent=> Riddles
- Why is a manhole cover round?
- How many cars are there in the USA? (A popular variant is "How many gas stations are there in the USA?")
- How many manhole covers are there in the USA?
- You've got someone working for you for seven days and a gold bar to pay them. The gold bar is segmented into seven connected pieces. You must give them a piece of gold at the end of every day. If you are _disibledevent=> Algorithms
- What's the difference between a linked list and an array?
- Implement a linked list. Why did you pick the method you did?
- Implement an algorithm to sort a linked list. Why did you pick the method you did? Now do it in O(n) time.
- Describe advantages and disadvantages of the various stock sorting algorithms.
- Implement an algorithm to reverse a linked list. Now do it without recursion.
- Implement an algorithm to insert a node into a circular linked list without traversing it.
- Implement an algorithm to sort an array. Why did you pick the method you did?
- Implement an algorithm to do wild card string matching.
- Implement strstr() (or some other string library function).
- Reverse a string. Optimize for speed. Optimize for space.
- Reverse the words in a sentence, i.e. "My name is Chris" becomes "Chris is name My." Optimize for speed. Optimize for space.
- Find a substring. Optimize for speed. Optimize for space.
- Compare two strings using O(n) time with constant space.
- Suppose you have an array of 1001 integers. The integers are in random order, but you know each of the integers is between 1 and 1000 (inclusive). In addition, each number appears _disibledevent=> Applications
- How can computer technology be integrated in an elevator system for a hundred story office building? How do you optimize for availability? How would variation of traffic over a typical work week or floor or time of day affect this?
- How would you implement copy-protection _disibledevent=> Thinkers
- How are M&Ms made?
- If you had a clock with lots of moving mechanical parts, you took it apart piece by piece without keeping track of the method of how it was disassembled, then you put it back together and discovered that 3 important parts were not included; how would you go about reassembling the clock?
- If you had to learn a new computer language, how would you go about doing it?
- You have been assigned to design Bill Gates bathroom. Naturally, cost is not a consideration. You may not speak to Bill.
- What was the hardest question asked of you so far today?
- If MS told you we were willing to invest $5 million in a start up of your choice, what business would you start? Why?
- If you could gather all of the computer manufacturers in the world together into _disibledevent=> 10．三篇写作，均为书信形式。
(1)一片中文的祝贺信，祝贺某男当了某公司xx
(2)两篇英文的，一是说有事不能应邀，派别人去；另一篇是讨债的，7天不给钱就走人(主要考business letter格式)。
大唐移动测试工程师笔经
B卷
第一部分:选择题
1.相同码元速率下,那种传输方式信息传输速率最高
A.QPSK B.16QAM C.BPSK D.GMSK
2.下面哪些属于差错控制编码
3.自由空间传播环境下信号衰减与距离( )次方成比例
4.下列哪些功能属于网络管理的功能域
故障管理、配置管理、计费管理、性能管理、安全管理、传输管理、路由管理
5.采用CDMA技术通信系统,扰码的主要作用
信道估计、信道区分、信号白化、同步
6.交织的主要作用
7.数据链路层的协议是
A.HDLC B.ARQ C.PPP D.ICMP E.RTP
8.那种ATM协议最适合应用话音业务
A.AAL5 B.AAL4 C.AAL3 D.AAL2
第二部分:填空问答
1.香农公式表达式
2.爱尔兰含义
最大话务量和BHCA分别取决于什么
3.中继器,网桥.路由器,网关各是两个网络的哪层连接;路由器的功能是( )和( )
4.解释QPSK调制的原理
5.简述dB,dBm的概念
6.画出数字通信系统的模型,简述信源编码和信道编码的区别,及其它们在无线通信系统中的作用
7.C语言中能否在头文件中定义变量,并说明原因
8.在Windows系统,能否动态链接库中定义变量,如果可以定义说明有效范围
9.结构化程序设计中 程序=
面向对象程序设计中 程序=
10.解释return和exit的区别
11.ATM网络信元长度是( ),所有信息在最底层以( )的方式传送,以保持电路交换适合于传送实时性很强的业务特点.
12.什么是TDD,什么是FDD,多址方式又指什么?列出你所了解的多址方式
13.谈谈对OSI或计算机网络中'协议''实体''服务'的理解以及什么是SDU PDU和Primitive?
14.GSM逻辑信道及分类
15.谈谈你对移动通信系统组成的理解.
判断题:
1.大字节序是高位放在低地址处
2.MOTOROLA的XX系统是高字节序(记不清型号了)
选择题:
1.那个不要硬件支持
A.进程调度 B.地址映射 C系统终端 D时钟...
填空题:
1. strncpy的结果
2. 4字节对齐的系统,给出一个struct问占几字节.
编程题：
1.把32位的unsigned int按位倒过来:
unsigned int func(unsigned int nVar);
2.写函数把链表倒过来,
typedef struct link
{
int a;
struct link *next;
}
struct link *revers(struct link* plink);
3.写两个函数分别分配内存和释放内存: GetMem , FreeMem
参数和返回类型自己定，要求GetMem输入参数含大小多少char (感觉记不太清)
大唐电信面试试题
1．什么是中断？中断发生时CPU做什么工作？
2．CPU在上电后，进入操作系统的main()之前必须做什么工作？
3．简述ISO OSI的物理层Layer1，链路层Layer2，网络层Layer3的任务。
4．有线电话和无线电话有何区别？无线电话特别需要注意的是什么？
5．软件开发五个主要step是什么？
6．你在开发软件的时候，这5个step分别占用的时间百分比是多少？
7．makefile文件的作用是什么？
8．UNIX显示文件夹中，文件名的命令是什么？能使文件内容显示在屏幕的命令是什么？
9．(选做)手机用户在从一个基站漫游到另一个基站的过程中，都会发生什么?
1. 给你10台机器，每个机器2个cpu，2g内存，现在已知在10亿条记录的数据库里执行一次查询需要5秒，问用什么方法能让90%的查询能在100毫秒以内返回结果。
2. 一个长度为10000的字符串，写一个算法，找出最长的重复子串，如abczzacbca，结果是bc。
3. 一个保存有10000个URL的文本文件，删除其中相同的URL。
4. 连接两个单向链表，返回排序后的结果。
5. 将9个石子放在9x9的方格中，要求同行、同列、45度上无两个石子。
6. 有一幢100层高的大楼，给你两个完全相同的玻璃围棋子。假设从某一层开始，丢下玻璃棋子就会破碎。那么怎么利用手中的两颗棋子，用一种什么样的最优策略，知道这个临界的层高呢？
7. 用c++写一个函数，如Foo(const char *str)，打印出str的全排列，如abc的全排列：abc, acb, bca, dac, cab,cba
8. 求出一字符串中最长的数字串。比如as123cdf1234f，返回1234，char* FindNumber(char * out,char *in)。
笔试题目
1．设计一个重采样系统，说明如何anti-alias
2．y1(n)=x(2n)，y2(n)=x(n/2)，问：
如果y1为周期函数，那么x是否为周期函数？
如果x为周期函数，那么y1是否为周期函数？
如果y2为周期函数，那么x是否为周期函数？
如果x为周期函数，那么y2是否为周期函数？
3．如果模拟信号的带宽为5kHz，要用8k的采样率，怎么办
4．某个程序在一个嵌入式系统(200M的CPU，50M的SDRAM)中已经最优化了，换到另一个系统(300M的CPU，50M的SDRAM)中运行，还需要优化吗？
5．x^4+a*x^3+x^2+c*x+d最少需要做几次乘法
6．三个float:a,b,c
问值：
(a+b)+c == (b+a)+c
(a+b)+c == (a+c)+b
7．把一个链表反向填空
8．下面哪种排序法对12354最快？
A. quick sort
B. buble sort
C. merge sort
9．哪种结构平均来讲获取一个值最快？
A. binary tree
B. hash table
C. stack
10．
#include
#include
struct bit
{
int a:3;
int b:2;
int c:3;
};
int main(int argc, char* argv[])
{
bit s;
char *c = (char*)&s;
*c = 0x99;
cout << s.a << s.b << s.c;
return 0;
}
Output: ?
11．挑bug，在linux下运行：
#include
char *reverse(char* str)
{
int len=0, i=0;
char *pstr=str, *ptemp,*pd;
while(*++pstr)
len++;
pstr--;
//ptemp=(char*)malloc(len+1);
ptemp=(char*)malloc(len+1);
pd=ptemp;
while(len--)
{
*ptemp=*pstr;
ptemp++;
pstr--;
i++;
}
*ptemp=*pstr;
ptemp++;
*ptemp='\0';
return pd;
}
main()
{
char string[40]= "Hello World!";
char *pstr=string;
printf("%s", pstr);
printf("%s", reverse(pstr));
}
实验室笔试题
1．写出下列信号的奈亏斯特频率
(1) f(t) = 1+cos(2000pait) + sin(4000pait)
(2) f(t) = sin(4000pait)/pait
(3) f(t) =(sin(4000pait)的平方)/pait
2．有两个线程
void producer()
{
while(1)
{
GeneratePacket();
PutPacketIntoBuffer();
Signal(customer);
}
}
void customer()
{
while(1)
{
WaitForSignal();
if(PacketInBuffer>10)
{
ReadAllPackets();
ProcessPackets();
}
}
}
(1)有没有其他方法可以提高程序的性能
(2)可不可以不使用信号之类的机制来实现上述的功能
3．优化下面的程序
(0)sum=0
(1)I=1
(2)T1=4*I
(3)T2=address(A)-4
(4)T3=T2[T1]
(5)T4=address(B)-4
(6)T5=4*I
(7)T6=T4[T5]
(8)T7=T3*T5
(9)sum=sum+T6
(10)I=I+1
(11)IF I<20 GOTO (2)
Intel校园招聘
第一部分：
6道智力+1道简答+1个编程(走迷宫)+两个百字短文(一个是根据试卷上对Intel一个产品
的介绍来写一个summary，还有一个是写自己对IT发展趋势的见解)
第二部分：
5道简答：
1.叙述内存泄漏的原理和常用解决方法
2.UNIX中的Zombie Process是怎么形成的，为啥用kill杀不掉，应该怎样避免
3.叙述滑动窗口的原理
4.实模式和保护模式的区别
5.实现strcpy代码
6.已经实现了一个TCP，怎么测试它
2005Intel面试题
1. 编译中的问题：全局变量如int i=5; int*(pf)()=foo; 分别在何时被初始化？设计时候如何具体的实现。
2. OS相关的问题，内存访问，cache等(包括cache在整个系统中的位置，画出来，并解释)
3. 解释例如mov ax,100H 这样一条指令的cpu, os, memory等都完成了什么样的工作。
4. Strlen()的C语言实现，不能使用任何变量。
5. 编译中display表的一些问题
6. 一个hash函数，输入随机，现发生冲突，如数据集中在某几条中，问怎样处理hash函数保证高效的访问，怎样实现？
7. 把Switch()case…语句翻译成三元组。
8. 一个byte(用C语言实现计数其中1的个数)，给出最高效的实现方法。(位域)或者查表最快的；
9. C语言参数的入栈顺序？为什么这么实现？
10. C语言中字符串的翻转，最高效率(时间和空间)的实现
1．设计函数 int atoi(char *s)
int atoi(char *s)
{
char sign;
char sign_val = 1;
int val = 0;
int n = 0;
/* skip spaces */
while (isspace(*s))
++s;
if (*s == '-' || *s == '+')
/* skip '-' and '+' sign */
{
sign = *s;
if (sign == '-')
sign_val = -1;
++s;
}
/* when goes here, it is not space or sign */
while ((*s != '\0') && isdigit(*s))
{
val = 10 * n + (*s - '0');
n = val;
s++;
}
if (*s != '\0')
{
printf("non digit in your input!!\n");
exit(-1);
}
/* non error occured */
return (sign_val * val);
}
2．int i=(j=4,k=8,l=16,m=32); printf("%d", i); 输出是多少？结果为: 32.
3．解释局部变量、全局变量和静态变量的含义。
局部变量包括函数的形参,包含在函数体或者语句块内的变量,局部变量的生存期
在退出函数或语句块后结束。
全局变量是指在所有函数和语句块之外的变量,它对于整个程序均可见,全局变量
的生存期与程序的生存期相同.
静态变量指由关键字static声明的变量,它的作用域和其他变量一样,由它所在的
位置决定,如在函数体或语句块中声明,则只在函数体或语句块可见,其他地方均不
可见.它的生存期与程序相同.
4．解释堆和栈的区别。
简述如下:
栈上分配的内存，由系统自动分配,系统会自动收回.
如果需要动态分配内存,则只能通过malloc/new在堆上分配的内存，
使用完毕后,通过free/delete来释放内存。
5．论述含参数的宏与函数的优缺点。
含参数的宏优点:
省去了函数调用的开销,运行效率高.
含参数的缺点:
由于宏本质上是字符串的替换,所有可能会由于一些参数的副作用导致得出
错误的结果.
如:
#define max(a, b) ( ((a) > (b)) ? (a) : (b) )
如果程序中出现这样的调用: max(a++, b);
将导致a被计算2次,从而可能得到错误的结果,而函数调用不会出现这种问题.
另外,如果程序中有多次宏替换的话,可能导致代码体积变大.
函数的优点是:
没有带参数宏可能导致的副作用,计算的正确性较宏更有保证.
函数调用的缺点:
函数调用需要一些参数,返回地址等入栈,出栈的开销,效率没有宏函数高.
SECTION Ⅰ
Instruction: You are not allowed to use any library or API calls. Your answer will be evaluated from the following aspects: correctness, algorithm efficiency, error handing. API interface, and boundary case handing. You may use any language to code the answer.
Given two arrays which are sorted ascendingly, write a function to get the N th number from the merged and sorted array of them.
For example :
INPUT
A : 1,4,6,7,9
B : 2,4,5,8,9
N : 3
MERGED : 1,2,(4),4,5,6,7,8,9
OUTPUT : 4
However, due to the performance requirement, the spatial complexity of the solution should be O(1) and temporal complexity of it should be O(N).
对于这道题，
我的思路如下：
因为数组a和b都是升序排列的，要想确定第N个数是什么，可以逐个比较两数组中的各元素，a[i]和b[j]。其中下标i,j分别指向数组a,b。
每次确定一个数在合并后数组中的位置。以index来记录我们当前在合并数组中所处的位置，确定一个数的位置后就将index的值增加1，当index值为N时候，我们也就找到了所需的数(下标i,j正好记录了该数的位置)
程序中没有利用辅助数组，所以空间复杂度为O(1),时间复杂度为O(n),满足要求。
程序如下：
#include
#include
int get_nth_val(int a[], int b[], int sa, int sb, int n)
{
int i, j;
int index;
if (n < 0 || (n > sa+sb))
{
printf("invalid value!!!\n");
exit(-1);
}
i = j = 0;
index = 0; /* count nth number we now at */
while (i < sa && j < sb)
{
if (a[i] < b[j])
{
index++;
if (index == n)
return a[i];
i++;
}
else
{
index++;
if (index == n)
return b[j];
j++;
}
}
if (i == sa)
return b[n-index-1+j];
else
return a[n-index-1+i];
}
int main()
{
int a[] = {1, 4, 6, 7, 9, 11, 15, 17, 39, 45};
int b[] = {2, 4, 5, 8, 9, /*12, 16, 20, 33, 56*/};
int sa = sizeof(a) / sizeof(a[0]);
int sb = sizeof(b) / sizeof(b[0]);
int n;
int c;
n = 3;
c = get_nth_val(a, b, sa, sb, n);
printf("the %dth number is %d\n", n, c);
return 0;
}
SECTION Ⅱ
Instruction: Choose _disibledevent=>return 1;
if ((a+b > c) && (a+c > b) && (b+c) > a
&& (ABS(a-b) < c) && (ABS(a-c) < b) && (ABS(b-c) < a))
{
if (a == b || b == c || a == c)
return 2;
else
return 3;
}
/* can't construct a triangle */
return -1;
}
int main()
{
int flag;
flag = triangle(3, 4, 1);
switch(flag)
{
case 1:
printf("three edges are all equal\n"); break;
case 2:
printf("two edges are equal\n"); break;
case 3:
printf("no equal edges\n"); break;
default:
printf("can't construct triangle\n");
}
return 0;
}
1．实现双向链表删除一个节点P，在节点P后插入一个节点，写出这两个函数。
编写了一个完整的可运行程序,其中del_node和insert两个函数分别为题目中要求的两个函数,其余部分是用来测试这两个函数的
#include
#include
#include
struct tag_Node {
struct tag_Node *prev;
struct tag_Node *next;
int value;
};
typedef struct tag_Node Node;
typedef Node DList;
DList *head = NULL;
DList *old_head = NULL; /* 保存头结点的指针 */
Node *append_node(int n)
{
Node *p = (Node *)malloc(sizeof(Node));
if (!p) {
printf("memory alloc failure!\n");
exit(1);
}
p->value = n;
if (!head) {
/* now q contain the address of head */
old_head = head = p;
head->prev = 0;
head->next = 0;
}
head->next = p;
p->prev = head;
p->next = NULL;
head = p;
return p;
}
/* delete a node from double linked list */
void del_node(Node *p)
{
p->prev->next = p->next;
p->next->prev = p->prev;
printf("Node %d has been deleted!\n", p->value);
free(p);
}
/* insert a new node after Node p */
Node* insert(Node *p, int n)
{
Node *new_node = (Node*)malloc(sizeof(Node));
if (!new_node) {
printf("memory alloc failure!\n");
exit(1);
}
new_node->value = n;
new_node->next = p->next;
p->next->prev = new_node;
new_node->prev = p;
p->next = new_node;
printf("Node %d has been inserted\n", new_node->value);
return new_node;
}
void print()
{
Node *p = old_head;
printf("( ");
while (p)
{
printf("%d, ", p->value);
p = p->next;
}
printf(")\n");
}
void free_all()
{
Node *p = old_head;
Node *q;
while (p)
{
q = p;
p = p->next;
free(q);
}
printf("memory has been freed!\n");
}
int main()
{
Node *p, *q;
append_node(3);
append_node(4);
p = append_node(5);
append_node(0);
q = append_node(1);
append_node(2);
print(old_head);
insert(p, 6);
print(old_head);
del_node(q);
print(old_head);
free_all();
return 0;
}
2．写一个函数，将其中的\t都转换成4个空格
/* 此程序将源程序文件中所有的'\t'转换成4个空格 ,并另存为expanded.c*/
#include
#include
int expand_tab()
{
FILE *fp, *fp2;
int c;
char *r_name = "expanded.c";
if ((fp = fopen(__FILE__, "r")) == NULL)
{
perror("file open error");
exit(1);
}
if ((fp2 = fopen(r_name, "w")) == NULL)
{
perror("output file open error");
exit(2);
}
while ((c = fgetc(fp)) != EOF)
{
if (c == '\t')
{
/* '\t' is replaced with 4 spaces */
fputs(" ", fp2);
continue;
}
fputc(c, fp2);
}
fclose(fp);
fclose(fp2);
return 0;
}
int main()
{
int rval = expand_tab();
if (!rval)
printf("expand successfully!\n");
else if (rval == 1)
printf("error occured in %s!\n", __FILE__);
else if (rval == 2)
printf("error occured in tempfile\n");
else
printf("unknown error!\n");
return 0;
}
3．Windows程序的入口是哪里？写出Windows消息机制的流程。
入口点是WinMain函数
4．如何定义和实现一个类的成员函数为回调函数？
5．C++里面是不是所有的动作都是main()引起的？如果不是，请举例。
不是的。有些跟线程操作相关的操作是由操作系统引起的,如sleep是由时钟中断控制。
6．C++里面如何声明const void f(void)函数为C程序中的库函数？
使用extern "C"连接指令, extern "C" const void f(void)。
7．下列哪两个是等同的
int b;
A const int* a = &b;
B const* int a = &b;
C const int* const a = &b;
D int const* const a = &b;
C和D是等同的,将b的地址赋给一个指向const int对象的常指针。A的=号左边为一个指向const int对象的指针。 B的=号左边为一个指向int型对象的常指针。
8．内联函数在编译时是否做参数类型检查？
void g(base & b)
{
b.play;
}
void main()
{
son s;
g(s);
return;
}
会做类型检查的，只不过内联函数是在调用点处展开代码，省去了函数调用时候的开销，但是也可能会带来代码体积变大的问题。上面这段代码不知是何意思，可能是题目不完全。应该考察虚函数和动态绑定。
公共部分(50分)
1：作业调度程序从处于(B)状态的队列中选择适当的作业的作业投入运行。(3分)
A 运行 B 提交 C 完成 D后备
2：SQL语言中，删除一个表的命令是(B) (3分)
A CLEAR TABLE B DROP TABLE
C DELETE TABLE D REMOVE TABLE
3：ATM采用的线路复用方式为(C) (3分)
A 频分多路复用
B 同步时分多路复用
C 异步时分多路复用
D 独占信道
4：数据库中只存放视图的(C) (3分)
A操作
B 对应的数据
C 定义
D 限制
5：什么是虚拟设备？为什么在操作系统中引入虚拟设备？(10分)
SPOOLing是Simultaneous Peripheral Operation _disibledevent=> 2：要使引用pr代表变量“char *p”，则pr的初始化语句为char * &pr = p;(3分)
3：“零值”可以是0，0.0，FALSE或者“空指针”。例如int变量n与“零值”比较的if语句为：if(n==0)，则BOOL flag与“零值”比较的if语句为 if(!a) ；float x与“零值”比较的if语句为：const float EPSINON = 0.00001; if ((x >= - EPSINON) && (x <= EPSINON)。(6分)
4：设有如下语句：(C)(3分)
Int x;
*px=0;
则选择以下哪条语句可将x值置为0。
A int *px； B int const *px=&x；
C int *const px=&x； D const int *px=&x；
5：设void f1(int *m，long &n)；int a；long b；则以下调用合法的是(B)(3分)
A f1(a，b) B f1(&a，b)
C f1(a，&b) D f1(&a，&b)
6：请写出如下代码的运行结果(6分)6
int main()
{
int a,b,c,d;
a=0;
b=1;
c=2;
d=3;
printf(“%d”,a+++b+c+++d++);
}
7：写出下面函数的功能(12分)将数组a中的元素(如果为类类型，调用拷贝赋值算符)逆序放置到数组b中
Template
void WE(Type a[],Type b[],int n)
{
for(int i=0;i
}
8：写一段代码判断一个单向链表中是否有环。(14分)
给出如下结构
struct node
{
struct *next;
};
typedef stuct node Node；
答：
#include
struct listtype
{
int data;
struct listtype * next;
};
typedef struct listtype * list;
/* Check that whether there is loop in the singly linked list sll or not. */
int find_circle(list sll)
{
list fast = sll;
list slow = sll;
if (NULL == fast)
{
return -1;
}
while (fast && fast->next)
{
fast = fast->next->next;
slow = slow->next;
if (fast == slow)
{
return 1;
}
}
return 0;
}
JAVA部分(50分)
1：判断下列对的是哪个(B)(3分)
A short s1=1;s1=s1+1
B short s1=1;s1+=1
C short s1=1;s1=s1-1
D short s1=1;s1=s1*1
2:main方法是Java Application程序执行的入口点，关于main方法的方法头以下哪项是合法的(C)(3分)
A public static void main ()
B public static void main (String args)
C public static int main (String []arg)
D public void main (String args)
3：设float x=1，y=2，z=3，则表达式y+=z--/++x的值是(A)(3分)
A 3.5 B 3
C 4 D 5
4：Math.round(11.5)=12
Math.round(-11.5)=－11(4分)
5：假设x=10，y=20，z=30；计算下列表达式的值(6分)
A x<10||x>10_________false
B !(x<=20)___________false
C z-y==x&&Math.abs(y-z)!=x_____________false
6：方法重建Overload和方法的重写Overriding的区别。Overload的方法是否可以改变返回值的类型？(10分)
方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现， 重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被“屏蔽”了。如果在一个类中定义了多个同名的方 法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。 Overloaded的方法是可以改变返回值的类型。
7：谈谈HashMap和Hashtable的区别(6分)
答：
1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使 用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解 决：
Map Collections.synchronizedMap(Map m)
这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。
3. 在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示 HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键， 而应该用containsKey()方法来判断。
4.其底层的实现机制不同，hashmap的访问速度要快于hashtable，因为它不需要进行同步检验，建议在非多线程环境中使用hashmap代替hashtable .
8：构造一个类来描述屏幕上的一个点，该类的构成包括点x和y两个坐标，以及一些对点进行的操作，包括：取得点的坐标值，对点的坐标进行赋值，编写应用程序生成该类的对象并对其进行操作。(15分)
class Point
{
private int x;
private int y;
public int getX() {
return x;
}
public int getY() {
return y;
}
public void setX(int x) {
this.x = x;
}
public void setY(int y) {
this.y = y;
}
}
数据结构和算法
1. 假设执行语句S的时间为O(1)，则执行下列程序短的时间为(B)
for(i=1;i<=n;i++)
for(j=i;j<=n;j++)
S;
A. O(n)
B. O(n2)
C. O(n*i)
D. O(n+1)
2. 二位数组A[10…20，5…10]采用行序为主序方式存储，每个数据元素占4个存储单元，且A[10][5]的存储地址是1000，则A[18][9]的地址是(A)
A. 1208
B. 1212
C. 1368
D. 1364
3. 设栈最大长度为3，入栈序列为1，2，3，4，5，6，则不可能得出栈序列是(D)
A. 1，2，3，4，5，6
B. 2，1，3，4，5，6
C. 3，4，2，1，5，6
D. 4，3，2，1，5，6
4. 设有98个已排序列元素，采用二分法查找时，最大比较次数是(D)
A. 49
B. 15
C. 20
D. 7
5. Hash表示用于数据存储的一种有效的数据结构，Hash表等查找复杂度依赖于Hash值算法的有效性，在最好的情况下，Hash表的查找复杂度为(A)
A. O(1)
B. O(logn)
C. O(n)
D. O(nlogn)
第二部分 软件工程
1. 软件能力成熟度模型CMM共分为(C)成熟度等级
A. 3
B. 4
C. 5
D. 6
2. 按照是否了解软件的内部构造，可以将测试分为黑盒测试和白盒测试。考虑以下算法的PDL语句，如果要对其进行完全路径覆盖的白盒测试，则需要()条路径。
do ehile records remain
read record;
if record field 1 = 0
then process record;
store in buffer;
increment counter;
elseif record field 2 = 0
then reset counter;
else process record;
store in file;
endif
endif
enddo
A. 4
B. 5
C. 6
D. 7
3. 按照瀑布模型的阶段划分，软件测试可以分为单元测试，集成测试，系统测试。请问以下那项测试不属于系统测试的内容()
A. 压力测试
B. 接口测试
C. 功能测试
D. 安全测试
E. 性能测试
4. 测试用例的设计是测试的重要阶段。系统测试用例设计应该从什么时候开始()
A. 需求完成
B. 详细设计完成
C. 编码完成
D. 系统集成完毕，提交系统测试
5. 在UML方法中，使用多种类型的图形来帮助进行设计，请问一下那些图形不是UML的图形类型(B)
A. 类图
B. 实体关系图
C. 序列图
D. 活动图
第三部分 Java语言及其他
1. 下面哪个是short型的取值范围：(C)
A. -27--- 27-1
B. 0 --- 216-1
C. -215--- 215-1
D. -231---231-1
2. 下面哪项是不合法的标识符：(C)
A. $persons
B. TwoUsers
C. *point
D. _endline
3. 设 float x = 1,y = 2,z = 3，则表达式 y+=z--/++x 的值是(A)
A. 3.5
B. 3
C. 4
D. 5
4. 下列哪些关键字即能够被用于局部变量的修饰，也可以用做类变量的修饰()
A. public
B. transient
C. static
D. finally
5. 以下的语句构造了几个JAVA对象？(B)
String S = new String(“aaa”);
A. 1
B. 2
C. 3
6. 下面的哪些叙述为真(C)
A. equals()方法判定引用值是否指向同一对象
B. == 操作符判定两个不同的对象的内容和类型是否一致
C. equal() 方法只有在两个对象的内容一致时返回ture
D. 类File重写方法equals()在两个不同的对象的内容和类型一致时返回ture
7. 如果一个对象仅仅声明实现了cloneable接口，但是不声明clone方法，外部能够调用其clone方法吗？(A)
A. 能
B. 不能
C. 不确定
8. 考虑在C/S结构下，服务器接受并处理请求，那么关于服务器处理请求的模式，哪些描述是错误的()
A. 单线程模式下，服务器使用一个线程顺序的处理所有的请求，可能导致阻塞
B. 服务器可以为每一个请求创建一个线程来处理该请求，这样做比单线程模式更加稳定
C. 线程池模式下，当线程使用达到最大数量限制之后，线程池中没用可用线程的时候，服务器将阻塞或者拒绝某个请求的处理
9. 使用Swing做界面的时候，如果把一个JButton放在一个JFrame中，在JFrame改变时只影响JButton的高度而宽度不受影响，应该使用哪个布局管理器？(D)
A. FlowLayout
B. CardLayout
C. North and South of BorderLayout
D. East and West of BorderLayout
E. GridLayout
10. 以下的那个状态是SessionBean所具有，而StatelessBean不具有的(D)
A. 池态
B. 就绪态
C. 不存在态
D. 钝化态
11. 以下关于数据库范式的描述，哪些是错误的(B)
A. 如果把多个数据项用一个大的String表示为一个字段，则不满足第一范式
B. 满足数据库范式使得数据库的效率更高
C. 如果满足更高的范式，则必须首先满足低级别的范式
D. 数据库第二范式要求把表中与所有键没有直接关系的数据全部拆分到其他表中
12. 考虑一下需求：包括学生、课程和教师的信息。其中学生的信息包括学生姓名、年龄地址等；课程信息包括课程号、课程名、课程学分等；教师信息包括教师的姓 名、教师的地址等。一个学生可以选修多门课，而每门课也能有多个学生选修；一位教师可以教多门课，每门课也可以由多个教师讲授。请问如果使用关系数据库， 并且达到第二范式的要求，需要设计(C)张表
A. 3
B. 4
C. 5
D. 6
13. 为了加快数据库查找的速度，需要对数据表添加索引，请问以下关于索引的描述，哪些是错误的(D)
A. 聚类索引中，表中行的物理次序与索引键值的逻辑顺序相同
B. 使用索引会使得数据更新的效率降低
C. 在大多数数据库系统中，每张表只能够有一个聚类索引
D. 考虑这个SQL语句：Select S.name，S.age from Student S where S.address=”成都”，如果我们对表Student建一个复合索引(age，address)，可以改善上述查询的效率。
第四部分 问答题
1. 简述一个Linux驱动程序的主要流程与功能。
2. 请列举一个软件中时间换空间或者空间换时间的例子。
数组成倍增长(空间换时间)。
3. 简述进程与线程的区别。
多线程共存于应用程序中是现代操作系统中的基本特征和重要标志。用过UNIX操作系统的读者知道进程，在UNIX操作系统中，每个应用程序的执行都在操作 系统内核中登记一个进程标志，操作系统根据分配的标志对应用程序的执行进行调度和系统资源分配，但进程和线程有什么区别呢？
进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：
线程的划分尺度小于进程，使得多线程程序的并发性搞。
另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。
线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。
从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。
进程(Process)是最初定义在Unix等多用户、多任务操作系统环境下用于表示应用程序在内存环境中基本执行单元的概念。以Unix操作系统 为例，进程是Unix操作系统环境中的基本成分、是系统资源分配的基本单位。Unix操作系统中完成的几乎所有用户管理和资源分配等工作都是通过操作系统 对应用程序进程的控制来实现的。
C、C++、Java等语言编写的源程序经相应的编译器编译成可执行文件后，提交给计算机处理器运行。这时，处在可执行状态中的应用程序称为进程。 从用户角度来看，进程是应用程序的一个执行过程。从操作系统核心角度来看，进程代表的是操作系统分配的内存、CPU 时间片等资源的基本单位，是为正在运行的程序提供的运行环境。进程与应用程序的区别在于应用程序作为一个静态文件存储在计算机系统的硬盘等存储空间中，而 进程则是处于动态条件下由操作系统维护的系统资源管理实体。多任务环境下应用程序进程的主要特点包括：
●进程在执行过程中有内存单元的初始入口点，并且进程存活过程中始终拥有独立的内存地址空间；
●进程的生存期状态包括创建、就绪、运行、阻塞和死亡等类型；
●从应用程序进程在执行过程中向CPU发出的运行指令形式不同，可以将进程的状态分为用户态和核心态。处于用户态下的进程执行的是应用程序指令、处于核心态下的应用程序进程执行的是操作系统指令。
在Unix操作系统启动过程中，系统自动创建swapper、init等系统进程，用于管理内存资源以及对用户进程进行调度等。在Unix环境下无论是由操作系统创建的进程还要由应用程序执行创建的进程，均拥有唯一的进程标识(PID)。
4. static有什么用途？(请至少说明两种)
static关键字是C, C++中都存在的关键字, 它主要有三种使用方式, 其中前两种只指在C语言中使用, 第三种在C++中使用(C,C++中具体细微操作不尽相同, 本文以C++为准).
(1)局部静态变量
(2)外部静态变量/函数
(3)静态数据成员/成员函数
5. 头文件中的ifndef/define/endif做什么用？条件编译
6. 请问一下程序将输出什么结果？乱码
char *RetMenory(void)
{
char p[] = “hellow world”;
return p;
}
void Test(void)
{
char *str = NULL;
str = RetMemory();
printf(str);
}
7. 引用与指针有什么区别？
8. 描述实时系统的基本特性
9. 全局变量和局部变量在内存中是否有区别？如果有，是什么区别？
10. 什么是平衡二叉树？
11. 堆栈溢出一般是由什么原因导致的？
递归调用深度过深(栈)
12. 什么函数不能声明为虚函数？
一个类中将所有的成员函数都尽可能地设置为虚函数总是有益的。
设置虚函数须注意：
1：只有类的成员函数才能说明为虚函数；
2：静态成员函数不能是虚函数；
3：内联函数不能为虚函数；
4：构造函数不能是虚函数；
5：析构函数可以是虚函数，而且通常声明为虚函数。
13. 冒泡排序算法的时间复杂度是什么？n*n
14. #include和 #include “filename.h” 有什么区别？
用 #include格式来引用标准库的头文件(编译器将从标准库目录开始搜索)。
用 #include “filename.h” 格式来引用非标准库的头文件(编译器将从用户的工作目录开始搜索)。
15. 写出float x 与“零值”比较的if语句。
const float EPSINON = 0.00001;
if ((x >= - EPSINON) && (x <= EPSINON)
16. 操作系统中进程调度策略有哪几种？
先来先服务 短作业优先 高优先权优先 时间片轮转
17. Internet采用哪种网络协议？该协议的主要层次结构？TCP/IP
18. Internet物理地址和IP地址转换采用什么协议？ARP RARP
19. IP地址的编码分为哪俩部分？网络号 主机号
C Language Programmer Interview
● What does static variable mean?
● What is a pointer?
● What is a structure?
● What are the differences between structures and arrays?
● In header files whether functions are declared or defined?
● What are the differences between malloc() and calloc()?
● What are macros? What are the advantages and disadvantages?
● Difference between pass by reference and pass by value?
● What is static identifier?
● Where are the auto variables stored?
● Where does global, static, local, register variables, free memory and C Program instructions get stored?
● Difference between arrays and linked list?
● What are enumerations?
● Describe about storage allocation and scope of global, extern, static, local and register variables?
● What are register variables? What are the advantage of using register variables?
● What is the use of typedef?
● Can we specify variable field width in a scanf() format string? If possible how?
● Out of fgets() and gets() which function is safe to use and why?
● Difference between strdup and strcpy?
● What is recursion?
● Differentiate between a for loop and a while loop? What are it uses?
● What are the different storage classes in C?
● Write down the equivalent pointer expression for referring the same element a[i][j][k][l]?
● What is difference between Structure and Unions?
● What the advantages of using Unions?
● What are the advantages of using pointers in a program?
● What is the difference between Strings and Arrays?
● In a header file whether functions are declared or defined?
● What is a far pointer? where we use it?
● How will you declare an array of three function pointers where each function receives two ints and returns a float?
● What is a NULL Pointer? Whether it is same as an uninitialized pointer?
● What is a NULL Macro? What is the difference between a NULL Pointer and a NULL Macro?
● What does the error 'Null Pointer Assignment' mean and what causes this error?
● What is near, far and huge pointers? How many bytes are occupied by them?
● How would you obtain segment and offset addresses from a far address of a memory location?
● Are the expressions arr and *arr same for an array of integers?
● Does mentioning the array name gives the base address in all the contexts?
● Explain _disibledevent=>● How do I initialize a pointer to a function?
Q & A
Q. What is pure virtual function?
A class is made abstract by declaring _disibledevent=> Q. Write a Struct Time where integer m, h, s are its members
struct Time
{
int m;
int h;
int s;
};
how do you traverse a Btree in Backward in-order?
Process the node in the right subtree
Process the root
Process the node in the left subtree
Q. What is the two main roles of Operating System?
As a resource manager
As a virtual machine
Q. In the derived class, which data member of the base class are visible?
In the public and protected sections.
What is a modifier? A modifier, also called a modifying function is a member function that changes the value of at least _disibledevent=> }
void mod()
{
x=10;
y=15;
}
};
Q. What is an accessor? An accessor is a class operation that does not modify the state of an object. The accessor functions need to be declared as const operations
Q. Differentiate between a template class and class template.
Template class: A generic definition or a parameterized class not instantiated until the client provides the needed information. It's jargon for plain templates. Class template: A class template specifies how individual classes can be constructed much like the way a class specifies how individual objects can be constructed. It's jargon for plain classes.
Q. When does a name clash occur?
A name clash occurs when a name is defined in more than _disibledevent=>*i=0; //set the value of memory location pointed by i.
Incomplete types are otherwise called uninitialized pointers.
Q. What is a dangling pointer?
A dangling pointer arises when you use the address of an object after its lifetime is over. This may occur in situations like returning addresses of the automatic variables from a function or using the address of the memory block after it is freed. The following code snippet shows this:
class Sample
{
public:
int *ptr;
Sample(int i)
{
ptr = new int(i);
}
~Sample()
{
delete ptr;
}
void PrintVal()
{
cout << "The value is " << *ptr;
}
};
void SomeFunc(Sample x)
{
cout << "Say i am in someFunc " << endl;
}
int main()
{
Sample s1 = 10;
SomeFunc(s1);
s1.PrintVal();
}
In the above example when PrintVal() function is called it is called by the pointer that has been freed by the destructor in SomeFunc.
Q. Differentiate between the message and method.
Message: Objects communicate by sending messages to each other. A message is sent to invoke a method.
Method: Provides response to a message. It is an implementation of an operation.
Q. What is an adaptor class or Wrapper class?
A class that has no functionality of its own. Its member functions hide the use of a third party software component or an object with the non-compatible interface or a non-object-oriented implementation.
Q. What is a Null object?
It is an object of some class whose purpose is to indicate that a real object of that class does not exist. _disibledevent=>
class Array2D
{
public:
class Array1D
{
public:
T& operator[] (int index);
const T& operator[] (int index)const;
};
Array1D operator[] (int index);
const Array1D operator[] (int index) const;
};
The following then becomes legal:
Array2Ddata(10,20);
cout<
Objects of this latter class stand for one-dimensional array objects that, conceptually, do not exist for clients of Array2D. Such clients program as if they were using real, live, two-dimensional arrays. Each Array1D object stands for a one-dimensional array that is absent from a conceptual model used by the clients of Array2D. In the above example, Array1D is a proxy class. Its instances stand for one-dimensional arrays that, conceptually, do not exist.
Name some pure object oriented languages. Smalltalk, Java, Eiffel, Sather.
Name the operators that cannot be overloaded. sizeof, ., .*, .->, ::, ?: Salam in the comments notes that -> can be overloaded.
Q. What is a node class?
A node class is a class that, relies on the base class for services and implementation, provides a wider interface to the users than its base class, relies primarily on virtual functions in its public interface depends on all its direct and indirect base class can be understood only in the context of the base class can be used as base for further derivation
can be used to create objects. A node class is a class that has added new services or functionality beyond the services inherited from its base class.
Q. What is an orthogonal base class?
If two base classes have no overlapping methods or data they are said to be independent of, or orthogonal to each other. Orthogonal in the sense means that two classes operate in different dimensions and do not interfere with each other in any way. The same derived class may inherit such classes with no difficulty.
Q. What is a container class? What are the types of container classes?
A container class is a class that is used to hold objects in memory or external storage. A container class acts as a generic holder. A container class has a predefined behavior and a well-known interface. A container class is a supporting class whose purpose is to hide the topology used for maintaining the list of objects in memory. When a container class contains a group of mixed objects, the container is called a heterogeneous container; when the container is holding a group
of objects that are all the same, the container is called a homogeneous container.
Embedded System Engineer Interview
● Can structures be passed to the functions by value?
● Why cannot arrays be passed by values to functions?
● Advantages and disadvantages of using macro and inline functions?
● What happens when recursion functions are declared inline?
● Scope of static variables?
● Difference between object oriented and object based languages?
● Multiple inheritance - objects contain howmany multiply inherited ancestor?
● What are the 4 different types of inheritance relationship?
● How would you find out the no of instance of a class?
● Is java a pure object oriented language? Why?
● Order of constructor and destructor call in case of multiple inheritance?
● Can u have inline virtual functions in a class?
● When you inherit a class using private keyword which members of base class are visible to the derived class? ● What is the output of printf("\nab\bcd\ref"); -> ef
● #define cat(x,y) x##y concatenates x to y. But cat(cat(1,2),3) does not expand but gives preprocessor warning. Why?
● Can you have constant volatile variable? Yes, you can have a volatile pointer?
● ++*ip increments what? it increments what ip points to
● Operations involving unsigned and signed – unsigned will be converted to signed
● a+++b -> (a++)+b
● malloc(sizeof(0)) will return – valid pointer
● main() {fork();fork();fork();printf("hello world"); } – will print 8 times.
● Array of pts to functions – void (*fptr[10])()
● Which way of writing infinite loops is more efficient than others? there are 3ways.
● # error – what it does?
● How is function itoa() written?
● Who to know wether systemuses big endian or little endian format and how to convert among them?
● What is interrupt latency?
● What is forward reference w.r.t. pointers in c?
● How is generic list manipulation function written which accepts elements of any kind?
● What is the difference between hard real-time and soft real-time OS?
● What is interrupt latency? How can you recuce it?
● What is the differnce between embedded systems and the system in which rtos is running?
● How can you define a structure with bit field members?
● What are the features different in pSOS and vxWorks?
● How do you write a function which takes 2 arguments - a byte and a field in the byte and returns the value of the field in that byte?
● What are the different storage classes in C?
● What are the different qualifiers in C?
● What are the different BSD and SVR4 communication mechanisms
延伸阅读
最新评论