C C++面试问题分类大汇总.docx

C C++面试问题分类大汇总.docx

《C C++面试问题分类大汇总.docx》由会员分享，可在线阅读，更多相关《C C++面试问题分类大汇总.docx（44页珍藏版）》请在冰豆网上搜索。

CC++面试问题分类大汇总

1.指针和引用的区别

指针指向一块内存，它的内容是指向内存的地址；引用是某内存的别名

引用使用是无需解引用，指针需解引用

引用不能为空，指针可以为空

引用在定义是被初始化一次，之后不可变；指针可变

程序为指针变量分配内存区域，而引用不需要分配内存区域

1.memcpy和strcpy的区别

memcpy用来内存拷贝的，它有指定的拷贝数据长度，他可以拷贝任何数据类型的对象

Strcpy它只能去拷贝字符串，它遇到’\0′结束拷贝

1.new和malloc的区别，free和delete的区别

malloc与free是C++/C语言的标准库函数，new/delete是C++的运算符。

它们都可用于申请动态内存和释放内存。

对于非内部数据类型的对象而言，光用maloc/free无法满足动态对象的要求。

对象在创建的同时要自动执行构造函数，对象在消亡之前要自动执行析构函数。

由于malloc/free是库函数而不是运算符，不在编译器控制权限之内，不能够把执行构造函数和析构函数的任务强加于malloc/free。

因此C++语言需要一个能完成动态内存分配和初始化工作的运算符new，以及一个能完成清理与释放内存工作的运算符delete。

注意new/delete不是库函数。

1.struct和class的区别

1.成员变量

结构在默认情况下的成员是公共（public）的,

而类在默认情况下的成员是私有（private）的。

2.存储

struct保证成员按照声明顺序在内存中存储。

class不保证等等

3.继承

structA{}；

classB:

A{};//private继承

structC:

B{}；//public继承

这是由于class默认是private，struct默认是public。

2.struct与union的区别.（一般假定在32位机器上）

1．一个union类型的变量，所有成员变量共享一块内存，该内存的大小有这些成员变量中长度最大的一个来决定，struct中成员变量内存都是独立的

2．union分配的内存是连续的，而struct不能保证分配的内存是连续的

1.队列和栈有什么区别？

队列先进先出，栈后进先出

2.指针在16位机、32位机、64位机分别占用多少个字节

16位机        2字节

32位机        4字节

64位机        8字节

3.如何引用一个已经定义过的全局变量？

extern

可以用引用头文件的方式，也可以用extern关键字，如果用引用头文件方式来引用某个在头文件中声明的全局变理，假定你将那个变写错了，那么在编译期间会报错，如果你用extern方式引用时，假定你犯了同样的错误，那么在编译期间不会报错，而在连接期间报错

4.全局变量可不可以定义在可被多个.C文件包含的头文件中？

为什么？

可以，在不同的C文件中以static形式来声明同名全局变量。

可以在不同的C文件中声明同名的全局变量，前提是其中只能有一个C文件中对此变量赋初值，此时连接不会出错

5.语句for（；1；）有什么问题？

它是什么意思？

for（；1；）和while

（1）相同。

6.do……while和while……do有什么区别？

前一个循环一遍再判断，后一个判断以后再循环

7.请写出下列代码的输出内容

#include

main（）

{

inta,b,c,d;

a=10;

b=a++;

c=++a;

d=10*a++;

printf（“b，c，d：

%d，%d，%d”，b，c，d）;

return0;

}

10，12，120

8.对于一个频繁使用的短小函数,在C语言中应用什么实现,在C++中应用什么实现?

c用宏定义，c++用inline

9.main函数执行以前，还会执行什么代码？

全局对象的构造函数会在main函数之前执行。

10.main主函数执行完毕后，是否可能会再执行一段代码，给出说明？

可以，可以用on_exit注册一个函数，它会在main之后执行intfn1（void）,fn2（void）,fn3（void）,fn4（void）;

voidmain（void）

{

Stringstr（“zhanglin”）;

on_exit（fn1）;

on_exit（fn2）;

on_exit（fn3）;

on_exit（fn4）;

printf（“Thisisexecutedfirst.\n”）;

}

intfn1（）

{

printf（“next.\n”）;

return0;

}

intfn2（）

{

printf（“executed”）;

return0;

}

intfn3（）

{

printf（“is”）;

return0;

}

intfn4（）

{

printf（“This”）;

return0;

}

Theon_exitfunctionispassedtheaddressofafunction（func）tobecalledwhentheprogramterminatesnormally.Successivecallstoon_exitcreatearegisteroffunctionsthatareexecutedinLIFO（last-in-first-out）order.Thefunctionspassedtoon_exitcannottakeparameters.

Thisisexecutednext.

1.局部变量能否和全局变量重名？

能，局部会屏蔽全局。

要用全局变量，需要使用”:

:

”

局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。

对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那个循环体内

2.描述内存分配方式以及它们的区别?

1．从静态存储区域分配。

内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。

例如全局变量，static变量。

2．在栈上创建。

在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。

栈内存分配运算内置于处理器的指令集。

3．从堆上分配，亦称动态内存分配。

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

动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

3.类成员函数的重载、覆盖和隐藏区别？

1.成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual关键字可有可无。

2.覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual关键字。

3.”隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。

此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。

此时，基类的函数被隐藏（注意别与覆盖混淆）

4.static有什么用途？

（请至少说明两种）

1.限制变量的作用域

2.设置变量的存储域

5.请说出const与#define相比，有何优点？

1．const常量有数据类型，而宏常量没有数据类型。

编译器可以对前者进行类型安全检查。

而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。

2．有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

堆栈溢出一般是由什么原因导致的？

没有回收垃圾资源

6.简述数组与指针的区别？

数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。

指针可以随时指向任意类型的内存块。

（1）修改内容上的差别

chara[]=“hello”;

a[0]=‘X’;

char*p=“world”;//注意p指向常量字符串

p[0]=‘X’;//编译器不能发现该错误，运行时错误

（2）用运算符sizeof可以计算出数组的容量（字节数）。

sizeof（p）,p为指针得到的是一个指针变量的字节数，而不是p所指的内存容量。

C++/C语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。

注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

chara[]=“helloworld”;

char*p=a;

cout<

cout<

计算数组和指针的内存容量

voidFunc（chara[100]）

{

cout<

}

7.Therearetwointvariables:

aandb,don’tuse“if”,“?

:

”,“switch”orotherjudgementstatements,findoutthebiggestoneofthetwonumbers.

（（a+b）+abs（a–b））/2

8.冒泡排序算法的时间复杂度是什么？

O（n^2）

9.什么函数不能声明为虚函数？

构造函数（Constructor）

10.变量在内存中存放的位置

全局变量                    全局静态区

全局静态变量                全局静态区

全局常量

        有初始化            代码区

        无初始化            全局静态区

局部变量                    堆栈区

局部静态变量                静态区

局部常量                    堆栈区

    new和malloc分配空间    堆区

1.进程间通信方式

管道（有名管道，无名管道），共享内存，消息队列，信号量，socket通信

1.线程同步方式

临界区：

通过对多线程的串行化来访问公共资源或一段代码，速度快，适合控制数据访问

互斥量：

为协调共同对一个共享资源的单独访问而设计

信号量（PV操作）：

为控制一个具有有限数量用户资源而设计

事件：

用来通知线程有一些事件已

1.进程和线程的区别

资源：

进程是拥有资源的一个独立单位，线程是不拥有资源。

调度：

线程作为调度和分配的基本单位，进程是作为资源的基本单位

并发性：

进程之间可以有并发性进行，同一个进程中的多个线程是可以并发执行

系统开销：

进程在创建和撤销的时候，由于系统要分配和回收资源，导致系统的开销明显大于线程

一个进程可以拥有多个线程。

1.局部变量和全局变量能否重名

能，局部屏蔽全局。

在C++里使用全局，需要使用”：

：

”。

在C语言里，extern

1.虚函数和纯虚函数的区别

虚函数必须实现，纯虚函数没有实现

虚函数在子类里可以不重载，但是纯虚函数必须在每一个子类里去实现

在动态内存分配的时候，析构函数必须是虚函数，但没有必要是纯虚函数

1.面向对象的三大特性（四大特性）

封装、继承、多态（抽象）

封装：

把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏

继承：

子类可以拥有父类的属性和方法，但父类没有子类的属性和方法

多态：

允许将子类类型的指针赋值给父类类型的指针

实现多态，有二种方式，覆盖，重载

覆盖，是指子类重新定义父类的虚函数的做法

重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）

1.vi编辑器打开时跳到指定的行

vi+5000filename

1.int型在ToubleC里占多少个字节

2个字节

1.判断一个单链表是否有环

两个指针指向链表头，一个指针每次走一步，另一个指针每次走两步，若有一个指针先指向为NULL表示这个链表无环。

若两个指针重合表示链表有环

1.刷新缓冲区方式?

换行刷新缓冲区

printf（“\n”）;

使用函数刷新缓冲区

fflush（stdout）;

程序结束刷新缓冲区

return0;

1.类和对象的两个基本概念什么？

对象就是对客观事物在计算机中的抽象描述。

类就是对具体相似属性和行为的一组对象的统一描述。

类的包括：

类说明和类实现两大部分：

类说明提供了对该类所有数据成员和成员函数的描述。

类实现提供了所有成员函数的实现代码。

1.数据库三范式

第一范式：

没有重复的列

第二范式：

非主属的部分依赖于主属部分

第三范式：

属性部分不依赖于其他非主属部分

1.ASSERT（）是干什么用的

是在调试程序使用的一个宏，括号里面要满足，如果不满足，程序将报告错误，并将终止执行。

1.如果只想让程序有一个实例运行，不能运行两个。

像winamp一样，只能开一个窗口，怎样实现？

用内存映射或全局原子（互斥变量）、查找窗口句柄

FindWindow，互斥，写标志到文件或注册表,共享内存

1.如何截取键盘的响应，让所有的’a’变成’b’？

键盘钩子SetWindowsHookEx

1.网络编程中设计并发服务器，使用多进程与多线程，请问有什么区别？

1．进程：

子进程是父进程的复制品。

子进程获得父进程数据空间、堆和栈的复制品。

2．线程：

相对与进程而言，线程是一个更加接近与执行体的概念，它可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。

两者都可以提高程序的并发度，提高程序运行效率和响应时间。

线程和进程在使用上各有优缺点：

线程执行开销小，但不利于资源管理和保护；而进程正相反。

同时，线程适合于在SMP机器上运行，而进程则可以跨机器迁移。

编程

字符串实现

strcat

char*strcat（char*strDes,constchar*strSrc）

{

assert（（strDes!

=NULL）&&（strSrc!

=NULL））;

char*address=strDes;

while（*strDes!

=‘\0′）

++strDes;

while（（*strDes++=*strSrc++）!

=‘\0′）

NULL;

returnaddress;

}

strncat

char*strncat（char*strDes,constchar*strSrc,intcount）

{

assert（（strDes!

=NULL）&&（strSrc!

=NULL））;

char*address=strDes;

while（*strDes!

=‘\0′）

++strDes;

while（count—&&*strSrc!

=‘\0′）

*strDes++=*strSrc++;

*strDes=‘\0′;

returnaddress;

}

strcmp

intstrcmp（constchar*s,constchar*t）

{

assert（s!

=NULL&&t!

=NULL）;

while（*s&&*t&&*s==*t）

{

++s;

++t;

}

return（*s–*t）;

}

strncmp

intstrncmp（constchar*s,constchar*t,intcount）

{

assert（（s!

=NULL）&&（t!

=NULL））;

while（*s&&*t&&*s==*t&&count–）

{

++s;

++t;

}

return（*s–*t）;

}

strcpy

char*strcpy（char*strDes,constchar*strSrc）

{

assert（（strDes!

=NULL）&&（strSrc!

=NULL））;

char*address=strDes;

while（（*strDes++=*strSrc++）!

=‘\0′）

NULL;

returnaddress;

}

strncpy

char*strncpy（char*strDes,constchar*strSrc,intcount）

{

assert（strDes!

=NULL&&strSrc!

=NULL）;

char*address=strDes;

while（count—&&*strSrc!

=‘\0′）

*strDes++=*strSrc++;

returnaddress;

}

strlen

intstrlen（constchar*str）

{

assert（str!

=NULL）;

intlen=0;

while（*str++!

=‘\0′）

++len;

returnlen;

}

strpbrk

char*strpbrk（constchar*strSrc,constchar*str）

{

assert（（strSrc!

=NULL）&&（str!

=NULL））;

constchar*s;

while（*strSrc!

=‘\0′）

{

s=str;

while（*s!

=‘\0′）

{

if（*strSrc==*s）

return（char*）strSrc;

++s;

}

++strSrc;

}

returnNULL;

}

strstr

char*strstr（constchar*strSrc,constchar*str）

{

assert（strSrc!

=NULL&&str!

=NULL）;

constchar*s=strSrc;

constchar*t=str;

for（;*t!

=‘\0′;++strSrc）

{

for（s=strSrc,t=str;*t!

=‘\0′&&*s==*t;++s,++t）

NULL;

if（*t==‘\0′）

return（char*）strSrc;

}

returnNULL;

}

strcspn

intstrcspn（constchar*strSrc,constchar*str）

{

assert（（strSrc!

=NULL）&&（str!

=NULL））;

constchar*s;

constchar*t=strSrc;

while（*t!

=‘\0′）

{

s=str;

while（*s!

=‘\0′）

{

if（*t==*s）

returnt–strSrc;

++s;

}

++t;

}

return0;

}

strspn

intstrspn（constchar*strSrc,constchar*str）

{

assert（（strSrc!

=NULL）&&（str!

=NULL））;

constchar*s;

constchar*t=strSrc;

while（*t!

=‘\0′）

{

s=str;

while（*s!

=‘\0′）

{

if（*t==*s）

break;

++s;

}

if（*s==‘\0′）

returnt–strSrc;

++t;

}

return0;

}

strrchr

char*strrchr（constchar*str,intc）

{

assert（str!

=NULL）;

constchar*s=str;

while（*s!

=‘\0′）

++s;

for（–s;*s!

=（char）c;—s）

if（s==str）

returnNULL;

return（char*）s;

}

strrev

char*strrev（char*str）

{

assert（str!

=NULL）;

char*s=str,*t=str,c;

while（*t!

=‘\0′）

++t;

for（–t;s

{

c=*s;

*s=*t;

*t=c;

}

returnstr;

}

strnset

char*strnset（char*str,intc,intcount）

{

assert（str!

=NULL）;

char*s=str;

for（;*s!

=‘\0′&&s–str

*s=（char）c;

returnstr;

}

strset

char*strset（char*str,intc）

{

assert（str!

=NULL）;

char*s=str;

for（;*s!

=‘\0′;++s）

*s=（char）c;

returnstr;

}

strtok

char*strtok（char*strToken,constchar*str）

{

assert（strToken!

=NULL&&str!

=NULL）;

char*s=strToken;

constchar*t=str;

while（*s!

=‘\0′）

{

t=str;

while（*t!

=‘\0′）

{

if（*s==*t）

{

*（strToken+（s–strToken））=‘\0′;

returnstrToken;

}

++t;

}

++s;

}

returnNULL;

}

strupr

char*strupr（char*str）

{

assert（str!

=NULL）;

char*s=str;

while（*s!

=‘\