c++面试题(c++面试题)

　　本文目录

　　

1. C++经典面试问题
2. c++经典面试题及答案
3. 应届毕业生C++面试题目

C++经典面试问题

　　 c++经典面试问题分享

　　 1，关于动态申请内存

　　答：内存分配方式三种：

　　(1)从静态存储区域分配：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。

　　全局变量，static变量。

　　(2)在栈上创建：在执行函数时，函数内局部变量的存储单元都可以在栈上创建，

　　函数执行结束时这些存储单元自动被释放。

　　栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。

　　(3)用malloc或new申请内存之后，应该立即检查指针值是否为null.防止使用指针值为null的内存，

　　不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。避免数组或指针的下标越界，

　　特别要当心发生多1或者少1操作。动态内存的申请与释放必须配对，防止内存泄漏。

　　用free或delete释放了内存之后，立即将指针设置为null，防止产生野指针。从堆上分配，亦称动态内存分配。

　　程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。

　　动态内存的生存期由程序员决定，使用非常灵活。(int*parray; int myarray[6]; parray=&myarray[0];)

　　如果在申请动态内存时找不到足够大的内存块，malloc和new将返回null指针，

　　判断指针是否为null，如果是则马上用return语句终止本函数，

　　或者马上用exit(1)终止整个程序的运行，为new和malloc设置异常处理函数。

　　 2，c++指针攻破

　　答案：指针是一个变量，专门存放内存地址，特点是能访问所指向的内存

　　指针本身占据了4个字节的长度

　　 int**ptr;//指针的类型是 int

　　 int(*ptr)[3];//指针的类型是 int(*)[3]

　　 int*(*ptr)[4];//指针的类型是 int*(*)[4]

　　 ptr++：指针ptr的值加上了sizeof(int)

　　 ptr+=5：将指针ptr的值加上5*sizeof(int)

　　指针的赋值:

　　把一个变量的地址赋予指向相同数据类型的指针变量( int a; int*ip; ip=&a;)

　　把一个指针变量的值赋予指向相同类型变量的另一个指针变量(int a; int*pa=&a; int*pb; pb=pa;)

　　把数组的首地址赋予指向数组的指针变量(int a[5],*pa; pa=a;也可写为：pa=&a[0];)

　　如果给指针加1或减1，实际上是加上或减去指针所指向的数据类型大小。

　　当给指针加上一个整数值或减去一个整数值时，表达式返回一个新地址。

　　相同类型的两个指针可以相减，减后返回的整数代表两个地址间该类型的实例个数。

　　 int cc=new(int*)[10];声明一个10个元素的数组，数组每个元素都是一个int*指针，

　　每个元素还可以单独申请空间，因为cc的类型是int*型的指针，所以你要在堆里申请的话就要用int*来申请;

　　 int a= new int* [2];//申请两个int*型的空间

　　 a[0]= new int[4];////为a的第一个元素申请了4个int型空间，a[0]指向了此空间的首地址处

　　 a[1]= new int[3];//为a的第二个元素又申请了3个int型空间,a[1]指向了此空间首地址处

　　指针数组初始化赋值：

　　一维指针开辟空间：char*str;int*arr; scanf("%d",&n);

　　 str=(char*)malloc(sizeof(char)*n);

　　 arr=(int*)malloc(sizeof(int)*n);

　　二维指针开辟空间：int**arr, i; scanf("%d%d",&row,&col);

　　 arr=(int)malloc(sizeof(int)*row);

　　 for(i=0;i

　　 arr[i]=(int*)malloc(sizeof(int)*col);

　　结构体指针数组，例如typedef struct{ char x; int y;}quan,*qquan;

　　定义一个结构体指针数组如：qquan a[max]

　　 for(i=0;i

　　{

　　 a[i]=(qquan)malloc(sizeof(quan));

　　 memset(a[i],0,sizeof(quan));

　　}

　　指针数组赋值

　　 float a[]={100,200,300,400,500};

　　 float*p[5]={&a[0],&a[1],&a[2],&a[3],&a[4]};

　　 char*units[1000];

　　 char get_unit[250];

　　 for(int i=0;i

　　 scanf("%s", get_unit); strcpy(units[i],get_unit);}

　　 3,复杂指针解析：

　　(1)int(*func)(int*p);

　　(*func)()是一个函数，func是一个指向这类函数的指针，就是一个函数指针，这类函数具有int*类型的形参，返回值类型是 int。

　　(2)int(*func)(int*p, int(*f)(int*));

　　 func是一个指向函数的指针，这类函数具有int*和int(*)(int*)这样的形参。形参int(*f)(int*)，f也是一个函数指针

　　(3)int(*func[5])(int*p);

　　 func数组的元素是函数类型的指针，它所指向的函数具有int*类型的形参，返回值类型为int。

　　(4)int(*(*func)[5])(int*p);

　　 func是一个指向数组的指针，这个数组的元素是函数指针，这些指针指向具有int*形参，返回值为int类型的函数。

　　(5)int(*(*func)(int*p))[5];

　　 func是一个函数指针，这类函数具有int*类型的形参，返回值是指向数组的指针，所指向的数组的元素是具有5个int元素的数组。

　　注意：

　　需要声明一个复杂指针时，如果把整个声明写成上面所示的形式，对程序可读性是一大损害。

　　应该用typedef来对声明逐层,分解，增强可读性，例如对于声明：int(*(*func)(int*p))[5];

　　这样分解：typedef int(*para)[5]; typedef para(*func)(int*);

　　例如：int(*(*func)[5][6])[7][8];

　　 func是一个指向数组的指针，这类数组的元素是一个具有5x6个int元素的二维数组，而这个二维数组的元素又是一个二维数组。

　　 typedef int(*para)[7][8];

　　 typedef para(*func)[5][6];

　　例如：int(*(*(*func)(int*))[5])(int*);

　　 func是一个函数指针，这类函数的返回值是一个指向数组的指针，

　　所指向数组的元素也是函数指针，指向的函数具有int*形参，返回值为int。

　　 typedef int(*para1)(int*);

　　 typedef para1(*para2)[5];

　　 typedef para2(*func)(int*);

　　 4，函数指针详解

　　答：函数指针是指向一个函数入口的指针

　　一个函数指针只能指向一种类型的函数，即具有相同的返回值和相同的参数的函数。

　　函数指针数组定义：void(*fun[3])(void*);相应指向类a的成员函数的指针：void(a::*pmf)(char*, const char*);

　　指向外部函数的指针：void(*pf)(char*, const char*); void strcpy(char* dest, const char* source); pf=strcpy;

　　 5，野指针

　　答：野指针是很危险的，if语句对它不起作用。野指针的成因主要有两种：

　　(1)指针变量没有被初始化。指针变量在创建的同时应当被初始化，要么将指针设置为null，要么让它指向合法的内存。

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

　　(2)指针p被free或者delete之后，没有置为null

　　(3)指针操作超越了变量的作用范围。所指向的内存值对象生命期已经被销毁

　　 6,引用和指针有什么区别?

　　答：引用必须初始化，指针则不必;引用初始化以后不能改变，指针可以改变其指向的对象;

　　不存在指向空值的引用，但存在指向控制的指针;

　　引用是某个对象的别名，主要用来描述函数和参数和返回值。而指针与一般的变量是一样的，会在内存中开辟一块内存。

　　如果函数的参数或返回值是类的对象的话，采用引用可以提高程序的效率。

　　 7，c++中的const用法

　　答：char* const p;//指针不可改,也就说指针只能指向一个地址,不能更改为其他地址，修饰指针本身

　　 char const* p;//所指内容不可改,也就是说*p是常量字符串，修饰指针所指向的变量

　　 const char* const p和 char const* const p;//内容和指针都不能改

　　 const修饰函数参数是它最广泛的一种用途，它表示函数体中不能修改参数的值，

　　传递过来的参数在函数内不可以改变，参数指针所指内容为常量不可变，参数指针本身为常量不可变

　　在引用或者指针参数的时候使用const限制是有意义的,而对于值传递的参数使用const则没有意义

　　 const修饰类对象表示该对象为常量对象，其中的任何成员都不能被修改。

　　 const修饰的对象，该对象的任何非const成员函数都不能被调用，因为任何非const成员函数会有修改成员变量的企图。

　　 const修饰类的成员变量,表示成员常量，不能被修改，同时它只能在初始化列表中赋值。static const的成员需在声明的地方直接初始。

　　 const修饰类的成员函数，则该成员函数不能修改类中任何非const成员。一般写在函数的最后来修饰。

　　在函数实现部分也要带const关键字.

　　对于const类对象/指针/引用，只能调用类的const成员函数，因此，const修饰成员函数的最重要作用就是限制对于const对象的使用

　　使用const的一些建议：在参数中使用const应该使用引用或指针，而不是一般的对象实例

　　 const在成员函数中的三种用法(参数、返回值、函数)要很好的使用;

　　 const在成员函数中的三种用法(参数、返回值、函数)要很好的使用;

　　不要轻易的将函数的返回值类型定为const;除了重载操作符外一般不要将返回值类型定为对某个对象的const引用;

　　 8，const常量与define宏定义的区别

　　答：(1)编译器处理方式不同。define宏是在预处理阶段展开，生命周期止于编译期。

　　只是一个常数、一个命令中的参数，没有实际的存在。

　　#define常量存在于程序的代码段。const常量是编译运行阶段使用，const常量存在于程序的数据段.

　　(2)类型和安全检查不同。define宏没有类型，不做任何类型检查，仅仅是展开。

　　 const常量有具体的类型，在编译阶段会执行类型检查。

　　(3)存储方式不同。define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。

　　 const常量会在内存中分配(可以是堆中也可以是栈中)

　　 9，解释堆和栈的区别

　　答：1、栈区(stack)—由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

　　由系统自动分配。声明在函数中一个局部变量 int b;系统自动在栈中为b开辟空间。

　　只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

　　在windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域，栈的大小是2m。

　　如果申请的空间超过栈的剩余空间时，将提示overflow。

　　栈由系统自动分配，速度较快。但程序员是无法控制的。

　　函数调用时，第一个进栈的是主函数中后的下一条指令，的地址，然后是函数的各个参数。

　　在大多数的c编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。

　　堆区(heap)—一般由程序员分配释放，若程序员不释放，程序结束时可能由os回收。

　　注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，需要程序员自己申请，并指明大小，在c中malloc函数

　　在c++中用new运算符。首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，

　　另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

　　堆是向高地址扩展的数据结构，是不连续的内存区域。而链表的遍历方向是由低地址向高地址。

　　堆的大小受限于计算机系统中有效的虚拟内存。

　　堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便

　　一般是在堆的头部用一个字节存放堆的大小。

　　 10，论述含参数的宏和函数的优缺点

　　(1)函数调用时，先求出实参表达式的值，然后代入形参。而使用带参的宏只是进行简单的字符替换

　　(2)函数调用是在程序运行时处理的，分配临时的内存单元;而宏展开是在编译时进行的，在展开时不进行

　　内存分配，不进行值得传递处理，没有返回值概念

　　(3)对函数中的形参和实参都要定义类型，类型要求一致，如不一致则进行类型转换。而宏不存在类型问题

　　(4)调用函数只可得到一个返回值，而用宏则可以设法得到几个结果

　　(5)实用宏次数多时，宏展开后源程序变长，没展开一次源程序增长，函数调用则不会

　　(6)宏替换不占用运行时间，只占编译时间，而函数调用占用运行时间

　　 11，c++的空类，默认产生哪些类成员函数?

　　答：class empty

　　{

　　 public:

　　 empty();//缺省构造函数

　　 empty(const empty&);//拷贝构造函数

　　~empty();//虚构函数

　　 empty& operator(const empty&)//赋值运算符

　　 empty& operator&();//取址运算符

　　 const empty* operator&() const;//取址运算符 const

　　}

　　 12，谈谈类和结构体的区别

　　答：结构体在默认情况下的成员都是public的,而类在默认情况下的成员是private的。结构体和类都必须使用new创建，

　　 struct保证成员按照声明顺序在内存在存储，而类不保证。

　　 13，c++四种强制类型转换

　　答：(1)const_cast

　　字面上理解就是去const属性，去掉类型的const或volatile属性。

　　 struct sa{ int k}; const sa ra;

　　 ra.k= 10;//直接修改const类型，编译错误 sa& rb= const_cast(ra); rb.k= 10;//可以修改

　　(2)static_cast

　　主要用于基本类型之间和具有继承关系的类型之间的转换。用于指针类型的转换没有太大的意义

　　 static_cast是无条件和静态类型转换，可用于基类和子类的转换，基本类型转换，把空指针转换为目标类型的空指针，

　　把任何类型的表达式转换成void类型，static_cast不能进行无关类型(如非基类和子类)指针之间的转换。

　　 int a; double d= static_cast(a);//基本类型转换

　　 int&pn=&a; void*p= static_cast(pn);//任意类型转换为void

　　(3)dynamic_cast

　　你可以用它把一个指向基类的指针或引用对象转换成继承类的对象

　　动态类型转换，运行时类型安全检查(转换失败返回null)

　　基类必须有虚函数，保持多态特性才能用dynamic_cast

　　只能在继承类对象的指针之间或引用之间进行类型转换

　　 class baseclass{public: int m_inum; virtual void foo(){};};

　　 class derivedclass:baseclass{public: char* szname[100]; void bar(){};};

　　 baseclass* pb= new derivedclass();

　　 derivedclass*p2= dynamic_cast(pb);

　　 baseclass* pparent= dynamic_cast(p2);

　　//子类->父类，动态类型转换，正确

　　(4)reinterpreter_cast

　　转换的类型必须是一个指针、引用、算术类型、函数指针或者成员指针。

　　主要是将一个类型的指针，转换为另一个类型的指针

　　不同类型的指针类型转换用reinterpreter_cast

　　最普通的用途就是在函数指针类型之间进行转换

　　 int dosomething(){return 0;};

　　 typedef void(*funcptr)(){};

　　 funcptr funcptrarray[10];

　　 funcptrarray[0]= reinterpreter_cast(&dosomething);

　　 14,c++函数中值的传递方式有哪几种?

　　答：函数的三种传递方式为：值传递、指针传递和引用传递。

　　 15，将引用作为函数参数有哪些特点

　　答：(1)传递引用给函数与传递指针的效果是一样的，这时，被调函数的形参就成为原来主调函数的实参变量或者

　　对象的一个别名来使用，所以在被调函数中形参的操作就是对相应的目标对象的操作

　　(2)使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作，当参数数据较大时，引用

　　传递参数的效率和所占空间都好

　　(3)如果使用指针要分配内存单元，需要重复使用*指针变量名形式进行计算，容易出错且阅读性较差。

　　

c++经典面试题及答案

　　 1. C++的类和C里面的struct有什么区别?

　　 struct成员默认访问权限为public，而class成员默认访问权限为private

　　 2.析构函数和虚函数的用法和作用

　　析构函数是在对象生存期结束时自动调用的函数，用来释放在构造函数分配的内存。

　　虚函数是指被关键字virtual说明的函数，作用是使用C++语言的多态特性

　　 3.全局变量和局部变量有什么区别?是怎么实现的?操作系统和编译器是怎么知道的?

　　 1)全局变量的作用用这个程序块,而局部变量作用于当前函数

　　 2)前者在内存中分配在全局数据区,后者分配在栈区

　　 3)生命周期不同：全局变量随主程序创建和创建，随主程序销毁而销毁，局部变量在局部函数内部，甚至局部循环体等内部存在，退出就不存在

　　 4)使用方式不同：通过声明后全局变量程序的各个部分都可以用到，局部变量只能在局部使用

　　 4.有N个大小不等的自然数(1–N)，请将它们由小到大排序.要求程序算法：时间复杂度为O(n)，空间复杂度为O(1)。

　　 void sort(int e[], int n)

　　{

　　 int i;

　　 int t;

　　 for(i=1; i{

　　 t= e[e[i]];

　　 e[e[i]]= e[i];

　　 e[i]= t;

　　}

　　}

　　 5.堆与栈的去区别

　　 A.申请方式不同

　　 Stack由系统自动分配，而heap需要程序员自己申请，并指明大小。

　　 B.申请后系统的响应不同

　　 Stack：只要栈的剩余空间大于申请空间，系统就为程序提供内存，否则将抛出栈溢出异常

　　 Heap：当系统收到程序申请时，先遍历操作系统中记录空闲内存地址的链表，寻找第一个大于所申请空间的堆结点，然后将该结点从空间结点链表中删除，并将该结点的空间分配给程序。另外，大多数系统还会在这块内存空间中的首地址处记录本次分配的大小，以便于delete语句正确释放空间。而且，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动将多余的那部分重新放入空闲链表。

　　 C.申请大小限制的不同

　　 Stack：在windows下，栈的大小是2M(也可能是1M它是一个编译时就确定的常数)，如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

　　 Heap：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

　　 D.申请效率的比较：

　　栈由系统自动分配，速度较快。但程序员是无法控制的。

　　堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。

　　另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

　　 E.堆和栈中的存储内容

　　栈：在函数调用时，第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

　　堆：一般是在堆的.头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

　　 6.含参数的宏与函数的优缺点

　　宏：优点：在预处理阶段完成，不占用编译时间，同时，省去了函数调用的开销，运行效率高

　　缺点：不进行类型检查，多次宏替换会导致代码体积变大，而且由于宏本质上是字符串替换，故可能会由于一些参数的副作用导致得出错误的结果。

　　函数：优点：没有带参数宏可能导致的副作用，进行类型检查，计算的正确性更有保证。

　　缺点：函数调用需要参数、返回地址等的入栈、出栈开销，效率没有带参数宏高

　　 PS：宏与内联函数的区别

　　内联函数和宏都是在程序出现的地方展开，内联函数不是通过函数调用实现的，是在调用该函数的程序处将它展开(在编译期间完成的);宏同样是;

　　不同的是：内联函数可以在编译期间完成诸如类型检测，语句是否正确等编译功能;宏就不具有这样的功能，而且宏展开的时间和内联函数也是不同的(在运行期间展开)

　　 7. Windows程序的入口是哪里?写出Windows消息机制的流程

　　 Windows程序的入口是WinMain()函数。

　　 Windows应用程序消息处理机制：

　　 A.操作系统接收应用程序的窗口消息，将消息投递到该应用程序的消息队列中

　　 B.应用程序在消息循环中调用GetMessage函数从消息队列中取出一条一条的消息，取出消息后，应用程序可以对消息进行一些预处理。

　　 C.应用程序调用DispatchMessage，将消息回传给操作系统。

　　 D.系统利用WNDCLASS结构体的lpfnWndProc成员保存的窗口过程函数的指针调用窗口过程，对消息进行处理。

　　 8.如何定义和实现一个类的成员函数为回调函数

　　 A.什么是回调函数?

　　简而言之，回调函数就是被调用者回头调用调用者的函数。

　　使用回调函数实际上就是在调用某个函数(通常是API函数)时，将自己的一个函数(这个函数为回调函数)的地址作为参数传递给那个被调用函数。而该被调用函数在需要的时候，利用传递的地址调用回调函数。

　　回调函数，就是由你自己写的，你需要调用另外一个函数，而这个函数的其中一个参数，就是你的这个回调函数名。这样，系统在必要的时候，就会调用你写的回调函数，这样你就可以在回调函数里完成你要做的事。

　　 B.如何定义和实现一个类的成员函数为回调函数

　　要定义和实现一个类的成员函数为回调函数需要做三件事：

　　 a.声明;

　　 b.定义;

　　 c.设置触发条件，就是在你的函数中把你的回调函数名作为一个参数，以便系统调用

　　如：

　　一、声明回调函数类型

　　 typedef void(*FunPtr)(void);

　　二、定义回调函数

　　 class A

　　{

　　 public:

　　 A();

　　 static void callBackFun(void)//回调函数，必须声明为static

　　{

　　 cout<<"callBackFun"<

　　}

　　 virtual~A();

　　};

　　三、设置触发条件

　　 void Funtype(FunPtr p)

　　{

　　 p();

　　}

　　 void main(void)

　　{

　　 Funtype(A::callBackFun);

　　}

　　 C.回调函数与API函数

　　回调和API非常接近，他们的共性都是跨层调用的函数。但区别是API是低层提供给高层的调用，一般这个函数对高层都是已知的;而回调正好相反，他是高层提供给底层的调用，对于低层他是未知的，必须由高层进行安装，这个安装函数其实就是一个低层提供的API，安装后低层不知道这个回调的名字，但它通过一个函数指针来保存这个回调函数，在需要调用时，只需引用这个函数指针和相关的参数指针。

　　其实：回调就是该函数写在高层，低层通过一个函数指针保存这个函数，在某个事件的触发下，低层通过该函数指针调用高层那个函数。

　　

应届毕业生C++面试题目

　　被问过比较多的问题：

　　1、堆、栈的区别

　　2、进程和线程的区别

　　3、进程通信方式有哪些

　　4、C\C++、Java等，了解哪些，稍微描述下区别

　　5、……

　　面试主要看你临场发挥，技术面的一般都是要招你的人面，有的东西可能你不知道，他其实可能也不知道很清晰透彻，因为真正工作里可能也不会用到，他就问问，看看你表现。所以面试时，1不要什么都不说，想太久，不知道的，想一会，然后看看自己能有什么相关的可以讲，比如问你进程通信方式有哪些，你不是很了解，你可以自己引申到进程线程的区别上，就说这个我不是很了解，就记得学过进程线程的区别，然后balabala……；2不要他刚问完，你立马回答，显得背答案一样，哪怕刚好你背过，你也要思考，就当组织自己的语言了；3不要太局促，其实技术面如果是技术人员面你，他的面试经验可能也不是很多，你一直冷场，他想给你点提示，都会不知怎么开口。

　　如果不是技术人员面你，那么就更轻松了。把自己会的，熟的，多提提，就侃大山了