C++ 笔记（33）— C/C++ 程序员常见面试试题深入剖析

wohu007

于 2021-07-07 20:16:23 发布

阅读量607

点赞数 1

分类专栏： C++ 文章标签：笔试面试 C++

本文链接：https://blog.csdn.net/wohu1104/article/details/118548980

版权

C++ 专栏收录该内容

40 篇文章 20 订阅

订阅专栏

1. 找错题

试题1：

void test1()
{
　char string[10];
　char* str1 = "0123456789";
　strcpy(string, str1);
}

错误原因：字符串 str1 需要 11 个字节才能存放下（包括末尾的 \0），而 string只有 10 个字节的空间，strcpy会导致数组越界；

试题2：

void test2()
{
　char string[10], str1[10];
　int i;
　for(i=0; i<10; i++)
　{
　　str1[i] = 'a';
　}
　strcpy(string, str1);
}

如果面试者指出字符数组 str1不能在数组内结束可以给3分；
如果面试者指出 strcpy(string, str1)调用使得从 str1内存起复制到 string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分；

试题3：

void test3(char* str1)
{
　char string[10];
　if(strlen(str1) <= 10 )
　{
　　strcpy(string, str1);
　}
}

if(strlen(str1) <= 10)应改为 if(strlen(str1) < 10)，因为 strlen的结果未统计 \0所占用的 1 个字节。

试题4：

void GetMemory( char *p )
{
　p = (char *) malloc( 100 );
}

void Test( void ) 
{
　char *str = NULL;
　GetMemory( str ); 
　strcpy( str, "hello world" );
　printf( str );
}

GetMemory( char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完

char *str = NULL;
GetMemory( str );

后的 str仍然为 NULL；

试题5：

char *GetMemory( void )
{ 
　char p[] = "hello world"; 
　return p; 
}

void Test( void )
{ 
　char *str = NULL; 
　str = GetMemory(); 
　printf( str ); 
}

p[]数组为函数内的局部自动变量，在函数返回后，内存已经被释放。这是许多程序员常犯的错误，其根源在于不理解变量的生存期。

试题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 ); 
}

Test函数中也未对 malloc的内存进行释放。

GetMemory避免了试题4的问题，传入 GetMemory的参数为字符串指针的指针，但是在GetMemory中执行申请内存及赋值语句

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

后未判断内存是否申请成功，应加上：

if (*p == NULL)
{
　...//进行申请内存失败处理
}

试题7：

void Test( void )
{
　char *str = (char *) malloc( 100 );
　strcpy( str, "hello" );
　free( str ); 
　... //省略的其它语句
}

存在与试题6同样的问题，在执行

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

后未进行内存是否申请成功的判断；另外，在 free(str)后未置 str为空，导致可能变成一个“野”指针，应加上：

str = NULL;

试题8：

swap( int* p1,int* p2 )
{
　int *p;
　*p = *p1;
　*p1 = *p2;
　*p2 = *p;
}

在 swap函数中，p是一个“野”指针，有可能指向系统区，导致程序运行的崩溃。运行报错：

main.cpp:7:13: warning: ‘p’ is used uninitialized in this function [-Wuninitialized]
     *p = *p1;
             ^
Segmentation fault (core dumped)

该程序应该改为：

swap( int* p1,int* p2 )
{
　int p;
　p = *p1;
　*p1 = *p2;
　*p2 = p;
}

2. 编写一个标准strcpy函数

库函数 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;
}

3. 编写一个标准strlen函数

切记 strlen它没有包括字符串末尾的 \0。

int strlen(const char *str) 
{
　assert(strt != NULL); //断言字符串地址非0
　int len;
　while( (*str++) != '\0' ) 
　{ 
　　len++; 
　} 
　return len;
}

4. 分别给出 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)

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分。

5. 计算sizeof的值

请计算 sizeof的值

void Func(char str[100])
{
　sizeof(str) = ?
}

void *p = malloc(100);
sizeof(p) = ?

答案

sizeof(str) = 4
sizeof(p) = 4

Func( char str[100] )函数中数组名作为函数形参时，在函数体内，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

数组名的本质如下：

数组名指代一种数据结构，这种数据结构就是数组；

char str[10];
cout << sizeof(str) << endl;

输出结果为 10，str指代数据结构 char[10]。

数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；

char str[10]; 
str++; //编译出错，提示str不是左值

数组名作为函数形参时，沦为普通指针；

在一般的平台上指针的长度（占用内存的大小）为 4 字节，故 sizeof(str) 、sizeof(p) 都为 4。

6. 写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个

#define MIN(A,B) ((A) <= (B) ? (A) : (B))

对宏定义的使用要非常小心，特别要注意两个问题：

谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答都应判0分；

#define MIN(A,B) (A) <= (B) ? (A) : (B)
#define MIN(A,B) (A <= B ? A : B )

防止宏的副作用；

宏定义

#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 分并被面试官淘汰。

7. 编写一个函数，作用是把一个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); 
}

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);

9. 编写类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(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; 　　　　　　　　//得分点：返回本对象的引用
}