C/C++措施员应聘常晤口试题深入分解
当前位置：以往代写 > C/C++ 教程 >C/C++措施员应聘常晤口试题深入分解

C/C++措施员应聘常晤口试题深入分解

2019-06-13

C/C++措施员应聘常晤口试题深入分解

C/C++措施员应聘常晤口试题深入分解

副标题#e#

1.引言

本文的写作目标并不在于提供C/C++措施员求职口试指导，而旨在从技能上阐明口试题的内在。文中的大大都口试题来自各大论坛，部门试题解答也参考了网友的意见。

很多口试题看似简朴，却需要深厚的根基功才气给出完美的解答。企业要求口试者写一个最简朴的strcpy函数都可看出头试者在技能上毕竟到达了奈何的水平，我们能真正写好一个strcpy函数吗？我们都以为本身能，但是我们写出的strcpy很大概只能拿到10分中的2分。读者可从本文看到strcpy函数从2分到10解析答的例子，看看本身属于什么样的条理。另外，尚有一些口试题观察口试者火速的思维本领。

阐明这些口试题，自己包括很强的趣味性；而作为一名研发人员，通过对这些口试题的深入分解则可进一步加强自身的内功。

2.找错题

试题1：

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

试题2：

void test2()
{
　char string[10], str1[10];
　int i;
　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 );
　}
}

解答：

试题1字符串str1需要11个字节才气存放下（包罗末端的’\0’），而string只有10个字节的空间，strcpy会导致数组越界；

对试题2，假如口试者指出字符数组str1不能在数组内竣事可以给3分；假如口试者指出strcpy(string, str1)挪用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基本上指出库函数strcpy事情方法的给10分；

对试题3，if(strlen(str1) <= 10)应改为if(strlen(str1) < 10)，因为strlen的功效未统计’\0’所占用的1个字节。

分解：

稽核对根基功的把握：

(1)字符串以’\0’末了；

(2)对数组越界掌握的敏感度；

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

从2分到10分的几个谜底我们可以清楚的看到，小小的strcpy竟然潜伏着这么多玄机，真不是盖的！需要何等扎实的根基功才气写一个完美的strcpy啊！

(4)对strlen的把握，它没有包罗字符串末端的’\0’。

读者看了差异分值的strcpy版本，应该也可以写出一个10分的strlen函数了，完美的版本为： int strlen( const char *str ) //输入参数const

{
　assert( strt != NULL ); //断言字符串地点非0
　int len;
　while( (*str++) != '\0' )
　{
　　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;
}

#p#分页标题#e#

在swap函数中，p是一个“野”指针，有大概指向系统区，导致措施运行的瓦解。在VC++中DEBUG运行时提示错误“Access Violation”。该措施应该改为：

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

3.内功题

试题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)会发生宏的副浸染

分解：

#p#分页标题#e#

这个口试题主要观察口试者对宏界说的利用，宏界说可以实现雷同于函数的成果，可是它终归不是函数，而宏界说中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”举办的是一对一的替换。

措施员对宏界说的利用要很是小心，出格要留意两个问题：

（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

的浸染是防备被反复引用。


#p#副标题#e#

作为一种面向工具的语言，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是指向以'\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 );
}

分解：

这个试题主要观察口试者对尺度库函数的纯熟水平，在需要的时候引用库函数可以很洪流平上简化措施编写的事情量。

最频繁被利用的库函数包罗：

（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：

#p#分页标题#e#

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]; // 得分点：对空字符串自动申请存放竣事符号'\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; 　　　　　　　　//得分点：返回本工具的引用
}

分解：

可以或许精确无误地编写出String类的结构函数、拷贝结构函数、赋值函数和析构函数的口试者至少已经具备了C++根基功的60%以上！

在这个类中包罗了指针类成员变量m_data，当类中包罗指针类成员变量时，必然要重载其拷贝结构函数、赋值函数和析构函数，这既是对C++措施员的根基要求，也是《Effective　C++》中出格强调的条款。

仔细进修这个类，出格留意加注释的得分点和加分点的意义，这样就具备了60%以上的C++根基功！

试题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个，那还真得闭关再好好修炼修炼。

#p#分页标题#e#

这个题可以观察口试者对措施设计常识的把握水平是低级、中级照旧较量深入，没有必然的常识广度和深度，不行能对这个问题给出全面的解答。大大都人只能答复出static和const要害字的部门成果。

4.能力题

试题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宽的数0x1234在Little-endian模式CPU内存中的存放方法（假设从地点0x4000开始存放）为：

内存地点 存放内容
0x4000 0x34
0x4001 0x12

而在Big-endian模式CPU内存中的存放方法则为：

内存地点 存放内容
0x4000 0x12
0x4001 0x34

32bit宽的数0x12345678在Little-endian模式CPU内存中的存放方法（假设从地点0x4000开始存放）为：

内存地点 存放内容
0x4000 0x78
0x4001 0x56
0x4002 0x34
0x4003 0x12

而在Big-endian模式CPU内存中的存放方法则为：

内存地点 存放内容
0x4000 0x12
0x4001 0x34
0x4002 0x56
0x4003 0x78

#p#分页标题#e#

连系体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对比！

int Sum( int n )
{
　long sum = 0;
　for( int i=1; i<=n; i++ )
　{
　　sum += i;
　}
　return sum;
}

所以措施员们需要敏感地将数学等常识用在措施设计中。

    关键字：

在线提交作业