面试的技巧

一、请填写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   分）
void   Func   (   char   str[100])
{
请计算
sizeof(   str   )   =   4   （2   分）
}
char   str[]   =   “Hello”   ;
char   *p   =   str   ;
int   n   =   10;
请计算
sizeof   (str   )   =   6   （2   分）
sizeof   (   p   )   =   4   （2   分）
sizeof   (   n   )   =   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++)   !=   ‘\0’   )   //   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   =   ‘\0’;
}
else
{
int   length   =   strlen(str);
m_data   =   new   char[length+1];   //   若能加NULL   判断则更好
strcpy(m_data,   str);
}
}
//   拷贝构造函数
String::String(const   String   &other)   //   3   分
{
int   length   =   strlen(other.m_data);
m_data   =   new   char[length+1];   //   若能加NULL   判断则更好
strcpy(m_data,   other.m_data);
}
//   赋值函数
String   &   String::operate   =(const   String   &other)   //   13   分
{
//   (1)   检查自赋值//   4   分
if(this   ==   &other)
return   *this;
//   (2)   释放原有的内存资源//   3   分
delete   []   m_data;
//   （3）分配新的内存资源，并复制内容//   3   分
int   length   =   strlen(other.m_data);
m_data   =   new   char[length+1];   //   若能加NULL   判断则更好
strcpy(m_data,   other.m_data);
//   （4）返回本对象的引用//   3   分
return   *this;
}