第一篇：2017年知名软件科技公司笔试题总结
2017年知名软件科技公司笔试题总结 写出十种开源框架，用一句话说明他们的作用。2 什么是SOP。3 什么是工作流。多少种设计模式，三种分类。5 找错，都很简单 有一道题认真就行 Class MyServlet extends HttpServlet {
Private map myMap;Public void doPost(req,res)throws Exception { } } 以上有哪些错误，还会问到用hashTable和hashMap，和线程安全的问题。设计简单的权限控制的表和结构(user,role,menu,function)。（写汽车租赁的就行，然后他问的时候给他讲解一下）myMap.put(req.getParamater(“name”));7 你认为在“部门管理”中有哪些功能 jUnit相关（谈的时候会问到一些，使用的版本，怎么用，什么时候用，居然连标签首字母大小写都问了，哈哈）剩下的都是一些简单的东西，忘记了
单独问的时候，问到了关于js构建对象有几种方式，是什么，json
用得是什么格式的
这家感觉考得比较基础，技术部人问的时候相关的比较多。
总结
名词解释：Ajax和AOB 描述什么环境下用一下三种模式
单例模式：确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。代理模式：
工厂模式：有时候需要单例或者创建时隐藏过程细节或者加一些扩展，比如日志记录等，需要用工厂模式.你经常去的有关IT技术的网站有哪些，它们各有什么特点？ 改错 A.public class Mylist extends list{
......} 设计一个JUnit单元测试
（这题用简单的Helloword实现就行了判断字符串中是否包含空字符）6.tomcat的缺省端口号是什么？修改端口号在那个目录下的那个文件
中？
总结：
车源找货源，或是货源找车源，以一放为用户设计需求分析，用文字或是图。
总结：
找错,多处错误
public class MyFile1 implements Runnable {
public void run(){
while(true){//死循环不知道算不算错
try { FileReaderfr = new FileReader(new File(“a.txt”));//这具体的文件路径记不清了,可能有错
String line = fr.readLine();//FileReader没有readLine()System.out.println(line);} catch(FileNotFoundException e){
} sleep(1000);//该处应为Thread.sleep(1000);
e.printStackTrace();
} } }
第二篇：IT公司笔试题总结
1.引用与指针有什么区别？
1.引用必须被初始化，指针不必。
2.引用初始化以后不能被改变，指针可以改变所指的对象。3.不存在指向空值的引用，但是存在指向空值的指针。
2.堆栈溢出一般是由什么原因导致的？
没有回收垃圾资源。3.什么函数不能声明为虚函数？ constructor函数不能声明为虚函数。4.写出float x 与“零值”比较的if语句。if(x>0.000001&&x<-0.000001)
5.不能做switch()的参数类型是：
switch的参数不能为实型
6.头文件中的 ifndef/define/endif干什么用? 预处理
答：防止头文件被重复引用
7.#include
答：
对于#include
对于#include “filename.h”，编译器从用户的工作路径开始搜索filename.h
8.在C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明?
答：函数和变量被C++编译后在符号库中的名字与C语言的不同，被extern “C”修饰的变量和函数是按照C语言方式编译和连接的。由于编译后的名字不同，C++程序不能直接调用C 函数。C++提供了一个C 连接交换指定符号extern“C”来解决这个问题。
9.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是指针，它们指向相同的常量区域。
10.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]。
11.交换两个变量的值，不使用第三个变量。即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;
12.列举几种进程的同步机制，并比较其优缺点。
答：原子操作、信号量机制、自旋锁、管程、会合、分布式系统
13.进程死锁的原因和4个必要条件
答：资源竞争及进程推进顺序非法；互斥、请求保持、不可剥夺、环路
14.要对绝对地址0×100000赋值，我们可以用(unsigned int*)0×100000 = 1234;那么要是想让程序跳转到绝对地址是0×100000去执行，应该怎么做？
答：*((void(*)())0×100000)();
首先要将0×100000强制转换成函数指针,即:(void(*)())0×100000。然后再调用它: *((void(*)())0×100000)();用typedef可以看得更直观些:
typedef void(*)()voidFuncPtr;
*((voidFuncPtr)0×100000)();
15.unsigned char *p1;
unsigned long *p2;
p1=(unsigned char *)0×801000;
p2=(unsigned long *)0×810000;
请问
p1+5=______;
p2+5=______;
答案：801005；810014。不要忘记了这个是16进制的数字，p2要加20变为16进制就是14
16、设有以下说明和定义：
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 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);
}
}
在swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。该程序应该改为：
解答：
test1: 字符串str1需要11个字节才能存放下(包括末尾的' ')，而string只有10个字节的空间，strcpy会导致数组越界
test2: 如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10 分
test3: if(strlen(str1)<= 10)应改为if(strlen(str1)< 10)，因为strlen的结果未统计' '所占用的1个字节
剖析：
考查对基本功的掌握：
(1)字符串以' '结尾；
(2)对数组越界把握的敏感度；
(3)库函数strcpy的工作方式，如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：
2分
void strcpy(char *strDest, char *strSrc)
{
while((*strDest++ = * strSrc++)!= ' ');
}
4分
void strcpy(char *strDest, const char *strSrc)
//将源字符串加const，表明其为输入参数，加2分
{
while((*strDest++ = * strSrc++)!= ' ');
}
7分
void strcpy(char *strDest, const char *strSrc)
{
//对源地址和目的地址加非0断言，加3分
assert((strDest!= NULL)&&(strSrc!= NULL));
while((*strDest++ = * strSrc++)!= ' ');
}
10分
//为了实现链式操作，将目的地址返回，加3分！
char * strcpy(char *strDest, const char *strSrc)
{
assert((strDest!= NULL)&&(strSrc!= NULL));
char *address = strDest;
while((*strDest++ = * strSrc++)!= ' ');
return address;
}
(4)对strlen的掌握，它没有包括字符串末尾的' '。
读者看了不同分值的strcpy版本，应该也可以写出一个10分的strlen函数了，完美的版本为
int strlen(const char *str)//输入参数const
{
assert(strt!= NULL);//断言字符串地址非0
int len;
while((*str++)!= ' ')
{
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(int* p1,int* p2)
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}
2.内功题
试题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是指向以' '结尾的字符串的指针
//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))= ' ';
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];// 得分点：对空字符串自动申请存放结束标志' '的空
//加分点：对m_data加NULL 判断
*m_data = ' ';
}
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;
//得分点：返回本对象的引用
}
试题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关键字 的部分功能。3.技巧题 试题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宽的数0×1234在Little-endian模式CPU内存中的存放方式（假设从地址0×4000开始存放）为： 内存地址 存放内容 0×4000 0×34 0×4001 0×12
而在Big-endian模式CPU内存中的存放方式则为： 内存地址 存放内容 0×4000 0×12 0×4001 0×34
32bit宽的数0×12345678在Little-endian模式CPU内存中的存放方式（假设从地址0×4000开始存放）为： 内存地址 存放内容 0×4000 0×78 0×4001 0×56 0×4002 0×34 0×4003 0×12
而在Big-endian模式CPU内存中的存放方式则为： 内存地址 存放内容 0×4000 0×12 0×4001 0×34 0×4002 0×56 0×4003 0×78
联合体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相比！3.不用第三变量交换两个数 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=%dn”,__FUNCTION__,*a,*b);} 4.求大数的阶乘例如100！，使用通常的做法会溢出，这里要使用数组的方法。例如：123*20 相当于 100*20 + 20*20+3*20 #include
i)–
第三篇：北京鼎普科技公司软件测试工程师QTP笔试题
北京鼎普科技公司软件测试工程师QTP笔试题
1.QTP中RO与TO的区别？
TO是Test Object的简称，RO是Runtime Object简称，既用来区分仓库对象和实际对象，又用来区分对象的封装接口和自身接口。
从实际作用上来看，应该说TO就是是仓库文件里定义的仓库对象，RO是被测试软件的实际对象。
QTP为用户提供了两种操作对象的接口，一种就是对象的封装接口，另一种是对象的自身接口。对象的自身接口是对象控件本身的接口，对象的封装接口是QTP 为对象封装的另一层接口，它是QTP通过调用对象的自身接口来实现的。两种接口的脚本书写格式的差别在于：自身接口需要在对象名后面加object再加属 性名或方法名，封装接口就不用在对象名后面加object.2.QTP中OBJECT SPY的作用？
查看对象，在查看窗口里有列出这些接口，包括属性和方法。
窗口中间有选择栏让你选择Run-time Object或者Test Object，当你选择Runtime Object时，它显示的就是对象的自身接口（自身的属性和方法）
当你选择Test Object时，它显示的就是对象的封装接口（封装的属性和方法）
3.编写在QTP脚本，实现向记事本中输入 “0123456789ABCDEFG”后，按ENTER？ SystemUtil.Run “C:WINDOWSsystem32notepad.exe”
Window(“Notepad”).Activate
Window(“Notepad”).WinEditor(“Edit”).Type “0123456789ABCDEFG”
第四篇：MTK深圳公司嵌入式软件工程师笔试题+
MTK深圳公司嵌入式软件工程师笔试题
//MTK深圳嵌入式软件工程师笔试题(B卷)
//1***************************************** #define pi 3.14
#define Area(R)pi*R*R
main()
{
int r1=5,r2=2;
double s=0;
s=Area(r1-r2);
printf(“The area is %f”,s);
}
//求结果
//2********************************************* //函数 int compare(int a,int b),定义为该函数的函数指针P:为_______________
//3********************************************* #include
void sub(char*s,int num)
{
int i ,j=num;
char t;
while(j-->1)
{
for(i=0;i { if(s[i] { t=s[i]; s[i]=s[i+1]; s[i+1]=t; } } } } main() { char*s=“CEAeded”; sub(s,6); printf(“%sn”,s) } //求结果 //4********************************************** //交换两个变量的值,不使用第三个变量,即a=3,b=5交换 //后b=3,a=5 unsigned char a=3,b=5; //5************************************************** #define N 100 void GetMemory1(char*p) { p=(char*)malloc(sizeof(char)*N); strcpy(p,“Have a good day!”); } char*GetMemory2(void) { char p[]=“Have a good day!”; return p; void main(void) { char*str1=NULL,*str2=NULL; GetMemory1(str1); GetMemory2(str2); printf(“nstr1:%s”,str1); printf(“nstr2:%s”,str2); //6****************************************************** //构造N个结点的单链表返回链表头指针,要求链表中各结点顺序 //与结点数据输入顺序相反,例如输入1,2,3,4,5,形成的链表为 //head->5 4 3 2 1 ,补充程序 #define N 10 typedef struct Node { int data; struct Node*next; }NODE; int Get_Data(int i);//定义省略 Node*Create_u() { int i; NODE*p,*Head=NULL; for(i=0;i { VP=New NODE; P->Data=Get_Data(i); ________________; ________________; return Head; } //7********************************************** //N个结点链表,每个结点中存放一个字符,判断链表存放的字符是否 //中心对称,即a b c c b a或a b c b a,补充程序 typedef struct Node { int data; struct Node*next; }NODE; bool Is_symmeic(NODE*head,*int n) { char D[N]; int i,d; __________; for(i=0;i { D[i]=head->data; head=head->next; } if(__________) { head=head->next; } while(head) { _______________; if(D[i]!=head->data) { return false; } head=head->next; } return true; } //8************************************* //str中只含有大写和小写字母函数change_move(char*str)将字符串中大写改成*并 //移到前面小写后返回*的个数 //如AabBdcYY改为*****abd,返回5 int chang_move(char*str) { int len,i,curstr=-1; len=strlen(str); for(i=len-1;i>=0;i--) { if(str[i]>='A'&&str[i]<='Z') { str[i]='*'; if(cursor==-1) { cursor=i; } else if(cursor>i) { _____________; str[i]='*'; _____________; } } return____________; } //9*********************************************** //求两个字符串的第一个公共子串,并返回该子串 //如:“a b c d e f g e h i” “a a c d e f * * g e h i” //第一个为“c d e f”;不许用strcmp() char*Maxf(char*str1,char*str2) { } 软件工程师－笔试试题 说明：不需要全部完成，做你懂的就可以。 Java基础 １．Set、Map、List有什么异同？ ２．Abstract class和interface有什么区别？什么是基于接口编程？ ３．类C有４个方法m1、m2、m3、m4,其中m1、m2、m3使用synchronized声明，m3还有static声明，m4没有特殊的声明。当一个线程T1进入C的一个实例的m1方法后，另一线程T2能立刻进入另一个实例的m1、m2、m3、m4方法吗？为什么？［高分］ ４．String和StringBuffer区别，什么时候应该使用StringBuffer？ ５．RuntimeException与一般异常（非RuntimeException的Exception）有何异同？ Web（HTML, DOM, JavaScript, CSS） ６．你平时有注意浏览器的兼容性吗？简述你知道的浏览器兼容性的例子。７．简述iframe的特点、使用模式 ８．你用过些什么javascript的框架？ ９．你了解什么是SEO吗？ １０． 怎样的网页适合做缓存？一个网页怎样才会被缓存？网页缓存为什么重要？ １１． 使用Cookie应注意什么问题，什么时候适合用Cookie，什么时候不适合？ JavaEE １２。说出Servlet的生命周期 １３。Forward和redirect的区别 １４。Jsp中动态include和静态include的区别？ １５。不能往Session里面存储太多太大的对象，为什么？ １６。Servlet里面，什么情况下会调用doGet()和doPost()？有什么区别 数据库 １７。写一段数据库查询的JDBC或hibernate程序(select * from employee where empid=?”)（只要主要的代码，把你认为“不可缺少”的语句写上，但要完整）１８。在SQL里面怎样过滤重复的记录？ １９。What is a “transaction”？Why are they necessary? ２０。Trigger 有什么作用？ ２１。What are stored procedures?How is it useful? ２２。What is the advantage of using PreparedStatement? XML和WebService ２３。Xml文档定义有几种形式？它们之间有何本质区别？ ２４。What is the difference between SAX parser and DOM parser? OOAD和UML ２５。What is an usecase? 架构与框架 26.说说你对ＭＣＶ的认识第五篇：某公司软件工程师笔试题
点击咨询 