C++/C程序员面试的一份试题(附标答)

最新推荐文章于 2024-04-13 11:14:15 发布

bingdian37

最新推荐文章于 2024-04-13 11:14:15 发布

阅读量1.7k

点赞数

分类专栏： c++/SDK 文章标签： c++ 面试 string null 编译器 delete

c++/SDK 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

用于测试C++/C程序员的基本编程技能、编程质量以及对C++/C的理解程度的一份考卷试题

本试题仅用于考查C++/C程序员的基本编程技能。内容限于C++/C常用语法，不涉及数据结构、算法以及深奥的语法。考试成绩能反映出考生的编程质量以及对C++/C的理解程度，但不能反映考生的智力和软件开发能力。

笔试时间90分钟。

一、请填写BOOL , float, 指针变量与“零值”比较的 if 语句。（10分）

提示：这里“零值”可以是0, 0.0 , FALSE或者“空指针”。例如 int 变量 n 与“零值”比较的 if 语句为：

if ( n == 0 )

if ( n != 0 )

以此类推。

请写出 BOOL flag 与“零值”比较的 if 语句：

请写出 float x 与“零值”比较的 if 语句：

请写出 char *p 与“零值”比较的 if 语句：

二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）

char str[] = “Hello” ;

char *p = str ;

int n = 10;

请计算

sizeof (str ) =

sizeof ( p ) =

sizeof ( n ) =

void Func ( char str[100])

{

请计算

sizeof( str ) =

}

void *p = malloc( 100 );

请计算

sizeof ( p ) =

三、简答题（25分）

1、头文件中的 ifndef/define/endif 干什么用？

2、#include <filename.h> 和 #include “filename.h” 有什么区别？

3、const 有什么用途？（请至少说明两种）

4、在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();

}

优点：

缺点：

优点：

缺点：

四、有关内存的思考题（20分）

void GetMemory(char *p)

{

p = (char *)malloc(100);

}

void Test(void)

{

char *str = NULL;

GetMemory(str);

strcpy(str, "hello world");

printf(str);

}

请问运行Test函数会有什么样的结果？

答：

char *GetMemory(void)

{

char p[] = "hello world";

return p;

}

void Test(void)

{

char *str = NULL;

str = GetMemory();

printf(str);

}

请问运行Test函数会有什么样的结果？

答：

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函数会有什么样的结果？

答：

void Test(void)

{

char *str = (char *) malloc(100);

strcpy(str, “hello”);

free(str);

if(str != NULL)

{

strcpy(str, “world”);

printf(str);

}

请问运行Test函数会有什么样的结果？

答：

五、编写strcpy函数（10分）

已知strcpy函数的原型是

char *strcpy(char *strDest, const char *strSrc);

其中strDest是目的字符串，strSrc是源字符串。

（1）不调用C++/C的字符串库函数，请编写函数 strcpy

（2）strcpy能把strSrc的内容复制到strDest，为什么还要char * 类型的返回值？

六、编写类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个函数。

试题的答案与评分标准

一、请填写BOOL , float, 指针变量与“零值”比较的 if 语句。（10分）

请写出 BOOL flag 与“零值”比较的 if 语句。（3分）

标准答案：

if ( flag )

if ( !flag )

如下写法均属不良风格，不得分。

if (flag == TRUE)

if (flag == 1 )

if (flag == FALSE)

if (flag == 0)

请写出 float x 与“零值”比较的 if 语句。（4分）

标准答案示例：

const float EPSINON = 0.00001;

if ((x >= - EPSINON) && (x <= EPSINON)

不可将浮点变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”此类形式。

如下是错误的写法，不得分。

if (x == 0.0)

if (x != 0.0)

请写出 char *p 与“零值”比较的 if 语句。（3分）

标准答案：

if (p == NULL)

if (p != NULL)

如下写法均属不良风格，不得分。

if (p == 0)

if (p != 0)

if (p)

if (!)

二、以下为Windows NT下的32位C++程序，请计算sizeof的值（10分）

char str[] = “Hello” ;

char *p = str ;

int n = 10;

请计算

sizeof (str ) = 6 （2分）

sizeof ( p ) = 4 （2分）

sizeof ( n ) = 4 （2分）

void Func ( char str[100])

{

请计算

sizeof( str ) = 4 （2分）

}

void *p = malloc( 100 );

请计算

sizeof ( p ) = 4 （2分）

三、简答题（25分）
1、头文件中的 ifndef/define/endif 干什么用？（5分）

答：防止该头文件被重复引用。

2、#include <filename.h> 和 #include “filename.h” 有什么区别？（5分）

答：对于#include <filename.h> ，编译器从标准库路径开始搜索 filename.h

对于#include “filename.h” ，编译器从用户的工作路径开始搜索 filename.h

3、const 有什么用途？（请至少说明两种）（5分）

答：（1）可以定义 const 常量

（2）const可以修饰函数的参数、返回值，甚至函数的定义体。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

4、在C++ 程序中调用被 C编译器编译后的函数，为什么要加 extern “C”？（5分）

答：C++语言支持函数重载，C语言不支持函数重载。函数被C++编译后在库中的名字与C语言的不同。假设某个函数的原型为： void foo(int x, int y);

该函数被C编译器编译后在库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。

C++提供了C连接交换指定符号extern“C”来解决名字匹配问题。

5、请简述以下两个for循环的优缺点（5分）

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次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。

优点：循环的效率高

缺点：程序不简洁

四、有关内存的思考题（每小题5分，共20分）

void GetMemory(char *p)

{

p = (char *)malloc(100);

}

void Test(void)

{

char *str = NULL;

GetMemory(str);

strcpy(str, "hello world");

printf(str);

}

请问运行Test函数会有什么样的结果？

答：程序崩溃。

因为GetMemory并不能传递动态内存，

Test函数中的 str一直都是 NULL。

strcpy(str, "hello world");将使程序崩溃。

char *GetMemory(void)

{

char p[] = "hello world";

return p;

}

void Test(void)

{

char *str = NULL;

str = GetMemory();

printf(str);

}

请问运行Test函数会有什么样的结果？

答：可能是乱码。

因为GetMemory返回的是指向“栈内存”的指针，该指针的地址不是 NULL，但其原现的内容已经被清除，新内容不可知。

void GetMemory2(char **p, int num)

{

*p = (char *)malloc(num);

}

void Test(void)

{

char *str = NULL;

GetMemory(&str, 100);

strcpy(str, "hello");

printf(str);

}

请问运行Test函数会有什么样的结果？

答：

（1）能够输出hello

（2）内存泄漏

void Test(void)

{

char *str = (char *) malloc(100);

strcpy(str, “hello”);

free(str);

if(str != NULL)

{

strcpy(str, “world”);

printf(str);

}

请问运行Test函数会有什么样的结果？

答：篡改动态内存区的内容，后果难以预料，非常危险。

因为free(str);之后，str成为野指针，

if(str != NULL)语句不起作用。

五、编写strcpy函数（10分）

已知strcpy函数的原型是

char *strcpy(char *strDest, const char *strSrc);

其中strDest是目的字符串，strSrc是源字符串。

（1）不调用C++/C的字符串库函数，请编写函数 strcpy

char *strcpy(char *strDest, const char *strSrc);

{

assert((strDest!=NULL) && (strSrc !=NULL)); // 2分

char *address = strDest; // 2分

while( (*strDest++ = * strSrc++) != ‘’ ) // 2分

NULL ;

return address ; // 2分

}

（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::~String(void) // 3分

{

delete [] m_data;

// 由于m_data是内部数据类型，也可以写成 delete m_data;

}

// String的普通构造函数

String::String(const char *str) // 6分

{

if(str==NULL)

{

m_data = new char[1]; // 若能加 NULL 判断则更好

*m_data = ‘’;

}

else

{

int length = strlen(str);

m_data = new char[length+1]; // 若能加 NULL 判断则更好

strcpy(m_data, str);

}

// 拷贝构造函数

String::String(const String &other) // 3分

{

int length = strlen(other.m_data);

m_data = new char[length+1]; // 若能加 NULL 判断则更好

strcpy(m_data, other.m_data);

}

// 赋值函数

String & String::operate =(const String &other) // 13分

{

// (1) 检查自赋值 // 4分

if(this == &other)

return *this;

// (2) 释放原有的内存资源 // 3分

delete [] m_data;

// （3）分配新的内存资源，并复制内容 // 3分

m_data = new char[length+1]; // 若能加 NULL 判断则更好

strcpy(m_data, other.m_data);

// （4）返回本对象的引用 // 3分

return *this;

}

冰点自己的一点见解:

关于strcpy函数
测试了一下,改为for循环,会稍微快一点
测试数据使用1000000字符,循环复制1000次

char *strcpy(char *strDest, const char *strSrc);

{

assert((strDest!=NULL) && (strSrc !=NULL));

char *address = strDest;

for(;*strDest=strSrc;strDest++,strSrc++);

return address ;
}

但是更快的方法(使用了库函数)却是:
char *strcpy(char *strDest, const char *strSrc);

{

assert((strDest!=NULL) && (strSrc !=NULL)); // 2分
memmove(strDest,strSrc,strlen(strSrc)+1); // 2分
return strDest ; // 2分
}

原因是memmove和strlen的实现都针对处理器的32位运算能力做了充分的优化
memmove的复制是一次四个字节
strlen判断'/0'也是一次四个字节
虽然多了几次函数调用,但是这两个函数的性能优化所带来的好处远比函数调用带来的开销要少
所以这个方法的速度是一般方法的三倍左右
到了这里,我们发现,还不如使用strcpy来得直接呢......速度.....

由此我们想到,可以将memmove和strlen中使用到的优化方法
直接引入我们的strcpy函数(参考微软库函数strlen的实现)

同时写了一个完整的测试小程序:

#include "stdafx.h"

using namespace std;

char * mystrcpy1( char *,const char *);

char * mystrcpy2( char *,const char *);

char * mystrcpy3( char *,const char *);

int _tmain(int argc, _TCHAR* argv[])

{

clock_t start,finish;

start=clock();

char *onem = new char[1000000];

char *twom = new char[1000000];

/*本来想直接使用char onem[1000000];char twom[1000000];的,可是用VS2005编译时堆栈溢出了(超过了默认堆栈的大小),所以直接使用堆内存了,不过原先用DEV C++编译的时候就没有问题,奇怪。*/

for(int i=0;i<999998;i++)onem[i]='a';

onem[999999]='/0';

finish=clock();

cout<<"初始化耗时:"<<(double)(finish-start)/CLOCKS_PER_SEC<<endl;

start=clock();

for(int i=0;i<1000;i++)mystrcpy1(twom,onem);

finish=clock();

cout<<"mystrcpy1执行次字符串复制耗时:"<<(double)(finish-start)/CLOCKS_PER_SEC<<endl;

start=clock();

for(int i=0;i<1000;i++)mystrcpy2(twom,onem);

finish=clock();

cout<<"mystrcpy2执行次字符串复制耗时:"<<(double)(finish-start)/CLOCKS_PER_SEC<<endl;

start=clock();

for(int i=0;i<1000;i++)mystrcpy3(twom,onem);

finish=clock();

cout<<"mystrcpy3执行次字符串复制耗时:"<<(double)(finish-start)/CLOCKS_PER_SEC<<endl;

start=clock();

for(int i=0;i<1000;i++)strcpy(twom,onem);

finish=clock();

cout<<"---strcpy执行次字符串复制耗时:"<<(double)(finish-start)/CLOCKS_PER_SEC<<endl;

system("pause");

delete [] onem;

delete [] twom;

return 0;

}

char * mystrcpy1(char *strDest,const char *strSrc )

{

assert(strDest!=NULL&&strSrc!=NULL);

//算法算法

char * temp=strDest;

while(*(temp++)=*(strSrc++));

return strDest;

}

char * mystrcpy2(char *strDest,const char *strSrc)

{

assert(strDest!=NULL&&strSrc!=NULL);

char * temp=strDest;

for(;*temp=*strSrc;temp++,strSrc++);

return strDest;

}

char * mystrcpy3( char *strDest,const char *strSrc)

{

assert(strDest!=NULL&&strSrc!=NULL);

char * strDestTemp=strDest;

for(;((unsigned long int)strSrc&(sizeof(unsigned long int)-1))!=0;)

{

*(strDestTemp++)=*(strSrc++);

if('/0'==*strSrc)return strDest;

}

for(;;strSrc+=sizeof(unsigned long int),strDestTemp+=sizeof(unsigned long int))

{

if(((*(unsigned long int*)strSrc-0x 01010101L )&0x 80808080L )!=0)

{

const char * tail = strSrc;

if('/0'==tail[0])

*strDestTemp++='/0';

else

{

*strDestTemp++=tail[0];

if('/0'==tail[1])

*strDestTemp++='/0';

else

{

*strDestTemp++=tail[1];

if('/0'==tail[2])

*strDestTemp++='/0';

else

{

*strDestTemp++=tail[2];

if('/0'==tail[3])

*strDestTemp++='/0';

else

*strDestTemp++=tail[3];

}

break;

}

else

{

*(unsigned long int*)strDestTemp=*(unsigned long int*)strSrc;

}

return strDest;

}

以下是stdafx.h的内容

#pragma once

#define WIN32_LEAN_AND_MEAN // 从Windows 头中排除极少使用的资料

#include <tchar.h>

#include <cstdlib>

#include <iostream>

#include <assert.h>

#include <time.h>

执行结果:

初始化耗时:0

mystrcpy1执行1000次字符串复制耗时:5.36

mystrcpy2执行1000次字符串复制耗时:4.875

mystrcpy3执行1000次字符串复制耗时:1.25

---strcpy执行1000次字符串复制耗时:0.937

请按任意键继续. . .

mystrcpy3就是我们最终优化的版本,虽然速度比原先的函数提高了近4倍,但是仍然比标准库函数strcpy慢三分之一。标准库函数的编写人员真是不容易啊。

感兴趣的可以看看MFC中strcpy的asm实现,很有参考价值的

bingdian37

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录