2024年c语言面试常问题.doc

已经n次倒在c语言面试的问题上，总结了一下，是因为基础知识不扎实。痛定思痛，决定好好努力！

1.引言

　　本文的写作目标并不在于提供C/C++程序员求职面试指引，而意在从技术上分析面试题的内涵。文中的大多数面试题来自各大论坛，部分试题解答也参考了网友的意见。

　　许多面试题看似简单，却需要深厚的基本功才能给出完美的解答。企业要求面试者写一个最简单的strcpy函数都可看出面试者在技术上到底达成了怎样的程度，我们能真正写好一个strcpy函数吗？我们都以为自己能，可是我们写出的strcpy很也许只能拿到10分中的2分。读者可从本文看到strcpy 函数从2分到10分解答的例子，看看自己属于什么样的层次。另外，尚有某些面试题考查面试者灵敏的思维能力。

　　分析这些面试题，自身包括很强的趣味性；而作为一名研发人员，通过对这些面试题的深入剖析则可深入增强自身的内功。

2.找错题

　　试题1：

void test1()
{
　char string[10];
　char* str1 = "";
　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 )函数的形参为字符串指针，在函数内部修改形参并不能真正的变化传入形参的值（这个说法不准确，看高质量C一书），执行完

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

　　在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)会产生宏的副作用

　　剖析：

　　这个面试题重要考查面试者对宏定义的使用，宏定义能够实现类似于函数的功效，不过它终究不是函数，而宏定义中括弧中的“参数”也不是真的参数，在宏展开的时候对“参数”进行的是一对一的替代。

　　程序员对宏定义的使用要非常小心，尤其要注意两个问题：

　　（1）谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。因此，严格地讲，下述解答：

#define MIN(A,B) (A) ＜= (B) ? (A) : (B)
#define MIN(AB) (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

　　的作用是预防被重复引用。

　　作为一个面对对象的语言，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

Pre-interview Questions

These are questions to ask in a phone interview. The idea is to qualify a person before bringing them in for a face-to-face session.

What is a virtual method? A pure virtual method? When would you use/not use a virtual destructor?

What is the difference between a pointer and a reference?

A reference must always refer to some object and, therefore, must always be initialized; pointers do not have such restrictions. A pointer can be reassigned to point to different objects while a reference always refers to an object with which it was initialized.

What is the difference between new/delete and malloc/free?

Malloc/free do not know about constructors and destructors. New and delete create and destroy objects, while malloc and free allocate and deallocate memory.

What does const mean?

What methods should every c++ class define and why?

What does main return?

Explain what the header for a simple class looks like.

How do you handle failure in a constructor?

According to Bjarne Stroustup, designer of the C++ language, you handle failures in a constructor by throwing an exception. See here for more details, including a link to his document on exception safety and the standard library:

--------------------------------------------------------------------------------

Junior Questions

What is the difference between C and C++? Would you prefer to use one over the other?

C is based on structured programming whereas C++ supports the object-oriented programming paradigm. Due to the advantages inherent in object-oriented programs such as modularity and reuse, C++ is preferred. However almost anything that can be built using C++ can also be built using C.

Explain operator precendence.

Operator precedence is the order in which operators are evaluated in a compound expression. For example, what is the result of the following expression?

6 + 3 * 4 / 2 + 2

Here is a compound expression with an insidious error.
while ( ch = nextChar() != '\0' )

The programmer's intention is to assign ch to the next character then test that character to see whether it is null. Since the inequality operator has higher precendence than the assignment operator, the real result is that the next character is compared to null and ch is assigned the boolean result of the test (i.e. 0 or 1).

What are the access privileges in C++? What is the default access level?

The access privileges in C++ are private, public and protected. The default access level assigned to members of a class is private. Private members of a class are accessible only within the class and by friends of the class. Protected members are accessible by the class itself and it's sub-classes. Public members of a class can be accessed by anyone.

What is data encapsulation?

Data Encapsulation is also known as data hiding. The most important advantage of encapsulation is that it lets the programmer create an object and then provide an interface to the object that other objects can use to call the methods provided by the object. The programmer can change the internal workings of an object but this transparent to other interfacing programs as long as the interface remains unchanged.

What is inheritance?

Inheritance is a mechanism through which a subclass inherits the properties and behavior of its superclass; the subclass has a ISA relationship with the superclass. For example Vehicle can be a superclass and Car can be a subclass derived from Vehicle. In this case a Car ISA Vehicle. The superclass 'is not a' subclass as the subclass is more specialized and may contain additional members as compared to the superclass. The greatest advantage of inheritance is that it promotes generic design and code reuse.

What is multiple inheritance? What are its advantages and disadvantages?

Multiple Inheritance is the process whereby a sub-class can be derived from more than one super class. The advantage of multiple inheritance is that it allows a class to inherit the functionality of more than one base class thus allowing for modeling of complex relationships. The disadvantage of multiple inheritance is that it can lead to a lot of confusion when two base classes implement a method with the same name.

What is polymorphism?

Polymorphism refers to the ability to have more than one method with the same signature in an inheritance hierarchy. The correct method is invoked at run-time based on the context (object) on which the method is invoked. Polymorphism allows for a generic use of method names while providing specialized implementations for them.

What do the keyword static and const signify?

When a class member is declared to be of a static type, it means that the member is not an instance variable but a class variable. Such a member is accessed using Classname.Membername (as opposed to Object.Membername). Const is a keyword used in C++ to specify that an object's value cannot be changed.

What is a static member of a class?

Static data members exist once for the entire class, as opposed to non-static data members, which exist individually in each instance of a class.

How do you access the static member of a class?

::.

What feature of C+ would you use if you wanted to design a member function that guarantees to leave this object unchanged?

It is const as in: int MyFunc? (int test) const;

What is the difference between const char *myPointer; and char *const myPointer;?

const char *myPointer; is a non-constant pointer to constant data; while char *const myPointer; is a constant pointer to non-constant data.

How is memory allocated/deallocated in C? How about C++?

Memory is allocated in C using malloc() and freed using free(). In C++ the new() operator is used to allocate memory to an object and the delete() operator is used to free the memory taken up by an object.

What is the difference between public, protected, and private members of a class?

Private members are accessible only by members and friends of the class. Protected members are accessible by members and friends of the class and by members and friends of derived classes. Public members are accessible by everyone.

How do you link a C++ program to C functions?

By using the extern "C" linkage specification around the C function declarations.

The candidate should know about mangled function names and type-safe linkages. They should explain how the extern "C" linkage specification statement turns that feature off during compilation so that the linker properly links function calls to C functions.

What does extern "C" int func(int *, Foo) accomplish?

It will turn off "name mangling" for func so that one can link to code compiled by a C compiler.

Why do C++ compilers need name mangling?

Name mangling is the rule according to which C++ changes function names into function signatures before invoking the linker. Mangled names are used by the linker to differentiate between different functions with the same name.

What is function's signature?

function's signature is its name plus the number and types of the parameters it accepts.

What are the differences between a C++ struct and C++ class?

The default member and base class access specifiers