C/C++基础面试题集锦

1.#include<>与#include""的区别

当用#include“file.h”时，先搜索当前工作目录，如果没有，再去搜索库，库没有再搜索资源库；

当用#include<file.h>时，编译器先从标准库路径开始搜索，如果没再搜索资源库目录，最好搜索当前工作目录。

2.在C++ 程序中调用被 C 编译器编译后的函数，为什么要加 extern “C”声明？

C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：该函数被C编译器编译后在符号库中的名字为_foo，而

C++编译器则会产生像_foo_int_int之类的名字，foo_int_int 这样的名字包含了函 数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数

void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者 为_foo_int_float。

3.虚函数的实现机制

4.什么函数不能声明为虚函数：

一个类中将所有的成员函数都尽可能地设置为虚函数总是有益的。 
设置虚函数须注意： 
1：只有类的成员函数才能说明为虚函数； 
2：静态成员函数不能是虚函数； 
3：内联函数不能为虚函数； 
4：构造函数不能是虚函数； 
5：析构函数可以是虚函数，而且通常声明为虚函数。

5.float与0值比较

const float EPSINON = 0.00001; 
if ((x >= - EPSINON) && (x <= EPSINON)

6.头文件中的 ifndef/define/endif 干什么用

7.虚函数

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。 在这个表中，主是要一个
类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了 这个实例的
内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。
这里我们着重看一下这张虚函数表。在C++的标准规格说明书中说到，编译器必需要保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证
正确取到虚函数的偏移量）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

纯 虚函数 是一种特殊的虚函数，它的一般格式如下：

class <类名>

{

virtual <类型><函数名>(<参数表>)=0;

…

};

在许多情况下，在 基类 中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的 派生类 去做。这就是纯虚函数的作用。

纯虚函数可以让类先具有一个操作名称，而没有操作内容，让派生类在继承时再去具体地给出定义。凡是含有纯虚函数的类叫做 抽象类 。这种类不能声明对象，只是作

为基类为派生类服务。除非在派生类中完全实现基类中所有的的纯虚函数，否则，派生类也变成了抽象类，不能实例化对象。

8.c++ private protected public

当private,public,protected单纯的作为一个类中的成员权限设置时：
private: 只能由该类中的函数、其友元函数访问,不能被任何其他访问，该类的对象也不能访问. 
protected: 可以被该类中的函数、子类的函数、以及其友元函数访问,但不能被该类的对象访问 
public: 可以被该类中的函数、子类的函数、其友元函数访问,也可以由该类的对象访问
注：友元函数包括两种：设为友元的全局函数，设为友元类中的成员函数

当private,public,protected作为继承方式时：
对于公有继承方式： 
(1)父类的public成员成为子类的public成员，允许类以外的代码访问这些成员；
(2)父类的private成员仍旧是父类的private成员，子类成员不可以访问这些成员；
(3)父类的protected成员成为子类的protected成员，只允许子类成员访问；

9.友元函数

include <iostream>
using namespace std;

class Car
{
    friend void display(Car); //类"Car"的朋友display() //友元函数的声明
private:
    int speed;
    char color[20];
public:
    void input( )
    {
        cout<<"Enter the color : ";
        cin>>color;
        cout<<"Enter the speed : ";
        cin>>speed;
    }
};

void display(Car x) //友元函数的定义
{
    cout<<"The color of the car is : "<<x.color<<endl;
    cout<<"The speed of the car is : "<<x.speed<<endl;
}

int main( )
{
    Car mine;
    mine.input( ); //访问成员函数
    display(mine); //友元函数的使用 //将对象"mine"传给友元函数
    return 0;
}

10.int* pInt = new int(5);和int* pInt = new int[5]; 
int *p = new int(5); 
这句是从堆上分配一个int型变量所占的字节内存，这个内存单元存放的整数值为5，然后让一个整形的指针变量p指向它的地址。
释放方式：delete p;
int *p = new int[5]; 
这句相当于从堆上分配一个含有5个元素的整形数组所占的字节内存，然后让一个整形的指针变量p指向它的首址。
释放方式：delete []p;(注意这个[]不能掉了，如果掉了就会只释放P[0]所占的空间，p[1]到p[4]不会被释放，产生内存泄露。)

 

GetMemory函数详解

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

char *GetMemory(char *&p, int num)
{
p = (char *)malloc(sizeof(char)*num);

//p = new char[num];
return p;

}
int main(void)
{
char *str ;
GetMemory(str, 100);
strcpy(str, "hello");
cout << str << endl;
return 0;
}

//上面是一个正确的程序，下面是转载的一些相关的知识

GetMemory错误讲解（指针练习） 错误程序：

void GetMemory( char *p )
{
　p = (char *) malloc( 100 );
}
void Test( void ) 
{
　char *str = NULL;
　GetMemory( str ); 
　strcpy( str, "hello world" );
　printf( “%s”，str );
}

这个一个考验对指针理解的题目，上面程序在运行之后：

1，调用GetMemory( str )后， str并未产生变化，依然是NULL.只是改变的str的一个拷贝的内存的变化   

2，strcpy( str, "hello world" );程序运行到这将产生错误。

3，new的时候有可能内存出错，应该在*p = (char *) malloc( num ); 后判断内存是否申请成功，应加上：
     if ( *p == NULL )
   {
　    ...//进行申请内存失败处理
   }

4，动态创建的内存没释放。

错误分析：

       错认为 GetMemory(char   *p)中的 p “就是” GetMemory(str)中的str。但p“不是”str，它只是“等于”str 。 
就象：   int   a   =   100；   
            int   b   =   a；       //   现在b等于a   
            b   =   500；         //   现在能认为a   =   500 ?      
显然不能认为a   =   500，因为b只是等于a，但不是a！ 当b改变的时候，a并不会改变，b就不等于a了。    因此，虽然p已经有new的内存，但str仍然是null  

GetMemory(str);             //把str传进去，str是一个指针，而他实际上是一个int      
void   GetMemory(char   *p)     //   p是str的一个副本   
{   
p=(char   *)new   char[100];         //   p的值改变，但是str的值并没有改变。   
}   
而双重指针为什么就可以了呢：   
GetMemory(&str);             //把str的地址传进去       
void   GetMemory(char   **   p)     //   p是str地址的一个副本   
{  

    *p   =   (char   *)new   char[100];         //   p指向的值改变，也就是str的值改变。   
}

修改方法1：(推荐使用这种方法)

void GetMemory2(char **p)变为二级指针. 
void GetMemory2(char **p, int num) 
{ 
*p = (char *)malloc(sizeof(char) * num); 
} 
void Test(void)
{ 
char *str=NULL; 
GetMemory=(&str); 
strcpy(str,"hello world"); 
printf(str); 
}

修改方法2：

char *GetMemory()
{ 
char *p=(char *)malloc(100); 
return p; 
} 
void Test(void){ 
char *str=NULL; 
str=GetMemory()；
strcpy(str,"hello world"); 
printf(str); 
}

附录A（相关资料）

试题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 ); 
　... //省略的其它语句
}

解答：

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

试题6中
1、GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，但是在GetMemory中执行申请内存及赋值语句
*p = (char *) malloc( num ); 
后未判断内存是否申请成功，应加上：
if ( *p == NULL )
{
　...//进行申请内存失败处理
} 
2、试题6的Test函数中也未对malloc的内存进行释放。

试题7中
    存在与试题6同样的问题，在执行
char *str = (char *) malloc(100); 后未进行内存是否申请成功的判断；另外，在free(str)后未置str为空，导致可能变成一个“野”指针，应加上： str = NULL; 

　　剖析：

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