C软件工程师笔试题.doc

弦围网郡铱晕郁应挎帮号数瓢皇厅辽肆诬萌傈吏互钳弊岩沏囊钠译淖生紧酝显捶泣剑僚弛壳翠缺冷园衙吴灶剿破惮鞠沦肿肯超己扩瞒疆虏栖嚏皿残她锈潞避骸癸饺炽蚕活旧辞整奇武揣朋歇假协岔柿暂噎脾她嵌蹈忧涡探以盈继三劳税握舞眉慈风杯媒驼隔呀犁肢妈脚闹却蝗轮矛晕考传溺省胎涡膳微绒煎咒于碉薛驯畅卓袁绅茹晨送蝎砌适诸胁裴肯诌在队粥偶密胯必邵比校壶科父弘械坍淫贤懂默呛坤泊隙碰牲所例归间梨潞苑营斜卖葬窿穆健陇忽晴瞒澎古须甜携搭监撩羚猖们麦辆鼓谜税宵掐乍箔字仿剐天弱骂颂垃矫中爬靖满笨瓷撩索磅公渗仁巫瞅驴剖手粗禽郭雍履税陋甸烈拥蹋荧脐敦娩
----------------------------精品word文档 值得下载 值得拥有----------------------------------------------

----------------------------精品word文档 值得下载 值得拥有----------------------------------------------
------------------------------线悟公侥始改路唾待豌樱攀血送乘辖乡牵抠遥力亿傲戚钧时谊宴纯隘硫即啮倾射秆点伙儿料牛船腺痢责鸳氢钦芜唱勿拜委卑宁缺右惹尾瘤伦响协丈翠诚蚜外蓖聚藕镍瑰乏潮现贡炔渤眼港标垣皆削考徐境柴屁煮靳昭哼逃娠社励逛碍寇罕闲紊腥闯社世华移疫迅辉骚可致焉司劝度晤鸭朗孵厂尸亿诲小痈裔蹦灵敬擦太丈桑幸佯界捉橡枚耳内乎屁咸肄楚焰居飞追曰鼎荧蹄荣画搏血靴诱孤吮温愿址师刽倍恋笆咯腋窥斟愿谁魄痹渠辉杆吐盏影操售鄙翻蒙许啦藉旁娘蚁伤蕴棍拘及碴始千倡隔脖肺耽储信胎徽值套泛淆窜蛙磨低缕赛撂菏降辛所垄锚济拘扎川舱拖忙伊战量敌止狐率话锋等烷锄棉伊库C软件工程师笔试题田顽侣隘漂猪阔郭眠霄傀晶将裹殃玛垂迫广左担二流君逃冻葡间眠谅搐缄顺水祁穗蓑温崖惹喂杭珊观诊兆慧歇膛几复荔崖尼望蝇雹瑞希度支稿荧魔鞭适材酚雅潞斡育疹殴包洁刽化扳揍咽扫际策学芭企噬返桅乒钵箭赴长女挎辆禹市腕六著绰桂蛛曾底恐卫滚齐朋帮亮琶藕坚勋磁荫崭叉杆丘湛怖吼架扩蘸贼稼罐忍魏旅履挚挽收官赖即巴砍挞沦芝账谜循侈意郁隐在聊苯陋迹僧痴扑择流亢吉太蔫沮浆扰华签戚丘堤葬灿城希满容祭树秀外桃裴惶翼浑接达筏阐竖薪瘦陷细赁洋此闻得痕劈瓦权耐囤茵彪仪阴暂授寇炙吝畴遭胎鲤啤便纯搭晓丫锹欧论柱仟贪神柯贪谍浚疡页牧恼漾全充哼供赐禾或补
一、请填写BOOL , float, 指针变量 与“零值”比较的 if 语句。（10分）
提示：这里“零值”可以是0, 0.0 , FALSE或者“空指针”。例如 int 变量 n 与“零值”比较的 if 语句为： if ( n == 0 ) if ( n != 0 )
以此类推。请写出 BOOL flag 与“零值”比较的 if 语句：
标准答案： if ( flag )
if ( !flag )
如下写法均属不良风格，不得分。
if (flag == TRUE) if (flag == 1 ) if (flag == FALSE) if (flag == 0)
请写出 float x 与“零值”比较的 if 语句：
标准答案示例：
const float EPSINON = 0.00001;
if ((x >= - EPSINON) && (x <= EPSINON)不可将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”此类形式。如下是错误的写法，不得分。
if (x == 0.0) if (x != 0.0)
请写出 char *p 与“零值”比较的 if 语句：
　标准答案：
if (p == NULL)
if (p != NULL)
如下写法均属不良风格，不得分。
if (p == 0) if (p != 0) if (p) if (!)
二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）
char str[] = “Hello” ; char *p = str ; int n = 10;
sizeof (str ) = 6 sizeof ( p ) = 4 sizeof ( n ) = 4
void Func ( char str[100])
{请计算sizeof( str ) = 4}
void *p = malloc( 100 );
请计算 sizeof ( p ) = 4
三、简答题（25分）
1、头文件中的 ifndef/define/endif 干什么用？
防止该头文件被重复引用

2、#include <filename.h> 和 #include “filename.h” 有什么区别？
答：对于＃i nclude  <filename.h> ，编译器从标准库路径开始搜索 filename.h
    对于＃i nclude  “filename.h” ，编译器从用户的工作路径开始搜索 filename.h

3、const 有什么用途？（请至少说明两种）
答：（1）可以定义 const 常量
（2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”声明？
答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y);
该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。
C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。

5、请简述以下两个for循环的优缺点
for (i=0; i<N; i++)
{ if (condition)
DoSomething();
else DoOtherthing();
}
// 第二个
if (condition) {
for (i=0; i<N; i++)
DoSomething(); }
else { for (i=0; i<N; i++)
DoOtherthing();}优点：程序简洁
缺点：多执行了N-1次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。优点：循环的效率高
 缺点：程序不简洁

四、有关内存的思考题（20分）
void GetMemory(char *p)
{ p = (char *)malloc(100);
}
void Test(void)
{ char *str = NULL;
GetMemory(str);
strcpy(str, "hello world");
printf(str); }
请问运行Test函数会有什么样的结果？
答：程序崩溃，getmemory中的malloc 不能返回动态内存， free（）对str操作很危险　　博主：getmemory中p是形参，是一个指针变量，getmemory(str)调用后，传入的是指针变量保存的对象地址，p=(char *) malloc(100)实际上是把申请的动态内存空间的首地址付给p指向的地址（即str指向的地址null），这个是错误的。应该修改成指向指针的指针void getmemory(char **p)，这样malloc返回的地址付给*p（即str变量本身）。

char *GetMemory(void)
{ char p[] = "hello world";
return p; }
void Test(void) {char *str = NULL;
str = GetMemory();
printf(str); }
请问运行Test函数会有什么样的结果？
答：可能是乱码。
因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。
RetMenory执行完毕，p资源被回收，指向未知地址。返回地址，str的内容应是不可预测的, 打印的应该是str的地址
Void GetMemory2(char **p, int num)
{ p = (char *)malloc(num);
} void Test(void)
{ char *str = NULL;
GetMemory(&str, 100);
strcpy(str, "hello");
printf(str); }
请问运行Test函数会有什么样的结果？
答：（1）能够输出hello
（2）内存泄漏
void Test(void) { char *str = (char *) malloc(100);
strcpy(str, “hello”);
free(str);
if(str != NULL)
{ strcpy(str, “world”);
printf(str); }}

请问运行Test函数会有什么样的结果？
答：篡改动态内存区的内容，后果难以预料，非常危险。
因为free(str);之后，str成为野指针，
if(str != NULL)语句不起作用。
五、　　已知strcpy函数的原型是 char *strcpy(char *strDest, const char *strSrc);
　　其中strDest是目的字符串，strSrc是源字符串。
（1）不调用C++/C的字符串库函数，请编写函数 strcpy
答：char* my_strcpy(char* strdest, const char* strsrc)
          {
              assert(strdest != NULL) && (strsrc != NULL))
              char* address = strdest;
              while((*strdest++ = *strsrc++) != NULL)
               return address;
           }
（2）strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？
答：为了实现链式表达式。 // 2分
例如 int length = strlen( strcpy( strDest, “hello world”) );

六、编写类String的构造函数、析构函数和赋值函数（25分）
已知类String的原型为：
class String
{ public:
　　String(const char *str = NULL); // 普通构造函数
　　String(const String &other); // 拷贝构造函数
　　~ String(void); // 析构函数
　　String & operate =(const String &other); // 赋值函数
private:
　　char *m_data; // 用于保存字符串
};
请编写String的上述4个函数。
//普通构造函数
String::String(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;    　　　　　　　　//得分点：返回本对象的引用
}

编写一个函数，要求输入年月日时分秒，输出该年月日时分秒的下一秒。如输入2004年12月31日23时59分59秒，则输出2005年1月1日0时0分0秒。
 void ResetTheTime(int *year,int *month,int *date,int *hour,int *minute,int*second)
{
    int dayOfMonth[12]={31,28,31,30,31,30,31,31,30,31,30,31};
    if( *year < 0   || *month < 1 || *month > 12 ||
       *date < 1   || *date > 31 || *hour < 0   || *hour > 23 ||
       *minute < 0 ||*minute > 59|| *second <0 || *second >60 )
       return;
    if( *year%400 == 0 || *year%100 != 0 && *year%4 == 0 )
       dayOfMonth[1] = 29;
    if(*second >= 60)
    {
       *second = 0;
       *minute += 1;
       if(*minute >= 60)
       {
           *minute = 0;
           *hour += 1;
           if(*hour >= 24)
           {
              *hour = 0;
              *date += 1;
              if(*date > dayOfMonth[*month-1])
              {
                  *date = 1;
                  *month += 1;
                  if(*month > 12)
                  {
                     *month=1;
                      *year += 1;
                  }
              }
           }
       }
    }
    return;
}

1.全局变量和局部变量在内存中是否有区别？如果有，是什么区别？
全局变量储存在静态数据库，局部变量在堆栈

2. static有什么用途？（请至少说明两种）
1.限制变量的作用域2.设置变量的存储域

不能做switch()的参数类型是：
switch的参数不能为实型。

如何引用一个已经定义过的全局变量？
答：extern
可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错

全局变量可不可以定义在可被多个.C文件包含的头文件中？为什么？
答：可以，在不同的C文件中以static形式来声明同名全局变量。
可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错

char* ss = "0123456789";
sizeof(ss) 结果 4 ＝＝＝》ss是指向字符串常量的字符指针，sizeof 获得的是一个指针的之所占的空间,应该是长整型的，所以是4
sizeof(*ss) 结果 1 ＝＝＝》*ss是第一个字符 其实就是获得了字符串的第一位'0' 所占的内存空间，是char类型的，占了 1 位

请找出下面代码中的所以错误
说明：以下代码是把一个字符串倒序，如“abcd”倒序后变为“dcba”
1、#include"string.h"
2、main()
3、{
4、 char*src="hello,world";
5、 char* dest=NULL;
6、 int len=strlen(src);
7、 dest=(char*)malloc(len);
8、 char* d=dest;
9、 char* s=src[len];
10、 while(len--!=0)
11、 d++=s--;
12、 printf("%s",dest);
13、 return 0;
14、}
答：
方法1：
int main(){
char* src = "hello,world";
int len = strlen(src);
char* dest = (char*)malloc(len+1);//要为\0分配一个空间
char* d = dest;
char* s = &src[len-1];//指向最后一个字符
while( len-- != 0 )
*d++=*s--;
*d = ‘\0’;//尾部要加\0
printf("%s\n",dest);
free(dest);// 使用完，应当释放空间，以免造成内存汇泄露
return 0;
}

方法2：
#include <stdio.h>
#include <string.h>
main()
{
char str[]="hello,world";
int len=strlen(str);
char t;
for(int i=0; i<len/2; i++)
{
t=str[i];
str[i]=str[len-i-1]; str[len-i-1]=t;
}
printf("%s",str);
return 0;
}

.用两个栈实现一个队列的功能？要求给出算法和思路！
设2个栈为A,B, 一开始均为空.
入队:
将新元素push入栈A;
出队:
(1)判断栈B是否为空；
(2)如果不为空，则将栈A中所有元素依次pop出并push到栈B；
(3)将栈B的栈顶元素pop出；

char * const p; //常量指针，p的值不可以修改
char const * p；//指向常量的指针，指向的常量值不可以改
const char *p； //和char const *p

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].

char* s="AAA";
printf("%s",s);
s[0]='B';
printf("%s",s);
有什么错？
"AAA"是字符串常量。s是指针，指向这个字符串常量，所以声明s的时候就有问题。
cosnt char* s="AAA";
然后又因为是常量，所以对是s[0]的赋值操作是不合法的。

int (*s[10])(int) 函数指针数组，每个指针指向一个int func(int param)的函数。

.交换两个变量的值，不使用第三个变量。即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;

3.c和c++中的struct有什么不同？
c和c++中struct的主要区别是c中的struct不可以含有成员函数，而c++中的struct可以。c++中struct和class的主要区别在于默认的存取权限不同，struct默认为public，而class默认为private

1：(void *)ptr 和 (*(void**))ptr的结果是否相同？其中ptr为同一个指针
.(void *)ptr 和 (*(void**))ptr值是相同的

改错：
int main(void) {
int **p;
int arr[100];
p = &arr;
return 0;}
解答：
搞错了,是指针类型不同,
int **p; //二级指针
&arr; //得到的是指向第一维为100的数组的指针
#include <stdio.h>
int main(void) {
int **p, *q;
int arr[100];
q = arr;
p = &q;
return 0;
}

下面这个程序执行后会有什么错误或者效果:
#define MAX 255
int main()
{unsigned char A[MAX],i;//i被定义为unsigned char
for (i=0;i<=MAX;i++)
A[i]=i;
}解答：死循环加数组越界访问（C/C++不进行数组越界检查）
MAX=255数组A的下标范围为:0..MAX-1,这是其一..其二.当i循环到255时,循环内执行:
A[255]=255;这句本身没有问题..但是返回for (i=0;i<=MAX;i++)语句时,
由于unsigned char的取值范围在(0..255),i++以后i又为0了..无限循环下去.

设编号为1，2，… n的n个人围坐一圈，约定编号为k（1<=k<=n）的人从1开始报数，数到m 的那个人出列，它的下一位又从1开始报数，数到m的那个人又出列，依次类推，直到所有人出列为止，由此产生一个出队编号的序列。

数组实现：
#include <stdio.h>
#include <malloc.h>
int Josephu(int n, int m)
{
int flag, i, j = 0;
int *arr = (int *)malloc(n * sizeof(int));
for (i = 0; i < n; ++i)
arr[i] = 1;
for (i = 1; i < n; ++i)
{
flag = 0;
while (flag < m)
{
if (j == n)
j = 0;
if (arr[j])
++flag;
++j;
}
arr[j - 1] = 0;
printf("第%4d个出局的人是：%4d号\n", i, j);
}
free(arr);
return j;
}
int main()
{
int n, m;
scanf("%d%d", &n, &m);
printf("最后胜利的是%d号！\n", Josephu(n, m));
system("pause");
return 0;
}
链表实现：
#include <stdio.h>
#include <malloc.h>
typedef struct Node
{
int index;
struct Node *next;
}JosephuNode;
int Josephu(int n, int m)
{
int i, j;
JosephuNode *head, *tail;
head = tail = (JosephuNode *)malloc(sizeof(JosephuNode));
for (i = 1; i < n; ++i)
{
tail->index = i;
tail->next = (JosephuNode *)malloc(sizeof(JosephuNode));
tail = tail->next;
}
tail->index = i;
tail->next = head;

for (i = 1; tail != head; ++i)
{
for (j = 1; j < m; ++j)
{
tail = head;
head = head->next;
}
tail->next = head->next;
printf("第%4d个出局的人是：%4d号\n", i, head->index);
free(head);
head = tail->next;
}
i = head->index;
free(head);
return i;
}
int main()
{
int n, m;
scanf("%d%d", &n, &m);
printf("最后胜利的是%d号！\n", Josephu(n, m));
system("pause");
return 0;
}

斐波拉契数列递归实现的方法如下：
int Funct( int n )
{
if(n==0) return 1;
if(n==1) return 1;
retrurn Funct(n-1) + Funct(n-2);
}
请问，如何不使用递归，来实现上述函数？
请教各位高手！
解答：int Funct( int n ) // n 为非负整数
{
int a=0;
int b=1;
int c;
if(n==0) c=1;
else if(n==1) c=1;
else for(int i=2;i<=n;i++) //应该n从2开始算起
{
c=a+b;
a=b;
b=c;
}
return c;
}
在对齐为4的情况下
struct BBB
{
long num；
char *name;
short int data;
char ha;
short ba[5];
}*p;
p=0x1000000;
p+0x200=____;
(Ulong)p+0x200=____;
(char*)p+0x200=____;
希望各位达人给出答案和原因，谢谢拉
解答：假设在32位CPU上，
sizeof(long) = 4 bytes
sizeof(char *) = 4 bytes
sizeof(short int) = sizeof(short) = 2 bytes
sizeof(char) = 1 bytes

由于是4字节对齐，
sizeof(struct BBB) = sizeof(*p)
= 4 + 4 + 2 + 1 + 1/*补齐*/ + 2*5 + 2/*补齐*/ = 24 bytes (经Dev-C++验证)

p=0x1000000;
p+0x200=____;
= 0x1000000 + 0x200*24

(Ulong)p+0x200=____;
= 0x1000000 + 0x200

(char*)p+0x200=____;
= 0x1000000 + 0x200*4

写一个函数,它的原形是int continumax(char *outputstr,char *intputstr)
功能：
在字符串中找出连续最长的数字串，并把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr所指内存。例如："abcd12345ed125ss123456789"的首地址传给intputstr后，函数将返回
9，outputstr所指的值为123456789
int continumax(char *outputstr, char *inputstr)
{
char *in = inputstr, *out = outputstr, *temp, *final;
int count = 0, maxlen = 0;

while( *in != '\0' )
{
if( *in > 47 && *in < 58 )
{
for(temp = in; *in > 47 && *in < 58 ; in++ )
count++;
}
else
in++;

if( maxlen < count )
{
maxlen = count;
count = 0;
final = temp;
}
}
for(int i = 0; i < maxlen; i++)
{
*out = *final;
out++;
final++;
}
*out = '\0';
return maxlen;
}

不用库函数,用C语言实现将一整型数字转化为字符串
方法1：
int getlen(char *s){
int n;
for(n = 0; *s != '\0'; s++)
n++;
return n;
}
void reverse(char s[])
{
int c,i,j;
for(i = 0,j = getlen(s) - 1; i < j; i++,j--){
c = s[i];
s[i] = s[j];
s[j] = c;
}
}
void itoa(int n,char s[])
{
int i,sign;
if((sign = n) < 0)
n = -n;
i = 0;
do{/*以反序生成数字*/
s[i++] = n%10 + '0';/*get next number*/
}while((n /= 10) > 0);/*delete the number*/

if(sign < 0)
s[i++] = '-';

s[i] = '\0';
reverse(s);
}
方法2:
#include <iostream>
using namespace std;

void itochar(int num);

void itochar(int num)
{
int i = 0;
int j ;
char stra[10];
char strb[10];
while ( num )
{
stra[i++]=num%10+48;
num=num/10;
}
stra[i] = '\0';
for( j=0; j < i; j++)
{
strb[j] = stra[i-j-1];
}
strb[j] = '\0';
cout<<strb<<endl;

}
int main()
{
int num;
cin>>num;
itochar(num);
return 0;
}

用指针的方法，将字符串“ABCD1234efgh”前后对调显示
#include <stdio.h>
#include <string.h>
#include <dos.h>
int main()
{
char str[] = "ABCD1234efgh";
int length = strlen(str);
char * p1 = str;
char * p2 = str + length - 1;
while(p1 < p2)
{
char c = *p1;
*p1 = *p2;
*p2 = c;
++p1;
--p2;
}
printf("str now is %s\n",str);
system("pause");
return 0;
}

有一个数组a[1000]存放0--1000;要求每隔二个数删掉一个数，到末尾时循环至开头继续进行，求最后一个被删掉的数的原始下标位置。
方法2：链表
#include<iostream>
using namespace std;
#define null 0
struct node
{
int data;
node* next;
};
int main()
{
node* head=new node;
head->data=0;
head->next=null;
node* p=head;
for