C++常见面试题Word文档下载推荐.docx
《C++常见面试题Word文档下载推荐.docx》由会员分享，可在线阅读，更多相关《C++常见面试题Word文档下载推荐.docx（49页珍藏版）》请在冰豆网上搜索。
union
V
{
struct
X
{
unsigned
char
s1:
s2:
s3:
}
x;
unsigned
c;
}
v;
v.c
=
100;
printf（"
%d"
v.x.s3）;
结果：
3。
100的2进制是1100100，去掉后面5位余11放入x.s3中，所以结果是3。
（4）对于空的类进行评测。
classA{};
sizeof（A）=1;
默认空类是有一个占位符的。
对于虚函数，下面的代码中，sizeof（A）=4;
sizeof（B）=4;
任何含有虚函数的类都拥有一个vptr指针，用来指向虚函数表vtable。
sizeof（vptr）=4。
classA
virtualtest（）{};
classB:
publicA{};
classA{staticinta;
};
对于静态成员变量是分配在全局存储区的，所以A还是相当于空类。
classC:
publicvirtualA{};
sizeof（C）=4;
对于虚拟继承的类拥有虚函数表，所以空类C含有vptr.
（5）设有以下说明和定义：
typedefunion{longi;
intk[5];
charc;
}DATE;
//sizeof（int）*5=20
structdata{intcat;
DATEcow;
doubledog;
}too;
//4+20+8=32
DATEmax;
则语句printf（"
sizeof（structdate）+sizeof（max））;
的执行结果是：
52
对于union联合来说，取其中最大元素长度来做为联合大小。
（6）使用malloc或者new分配内存，void*pp
malloc（10）;
sizeof（p）=4;
跟指针一样，sizeof只能测出静态数组的长度，无法检测动态分配的或外部数组大小
（7）下面函数输出结果：
对于charstr[100]或者charstr[]
参数都退化为char*str,这样的函数即使传入chars[10]也是可以的
voidFunc（charstr[100]）
printf（"
%d\n"
sizeof（str））;
}
chars[10];
//函数对数组长度并没有检验
Func（s）;
sizeof（char*）=4;
如何强制str为100位数组？
可以如此声明char（&
str）[100];
理解顺序：
第一、str声明为一个引用；
第二、引用一个100元素数组；
第三、
数组元素每个为int大小。
voidFunc（char（&
str）[100]）
chars[100];
//这里必须给定100位长度char数组
100*sizeof（char）=100
CONST常见题目
（1）const与#define有什么不同？
第一、const常量有数据类型，而宏没有数据类型。
编译器可以对const常量进行类型检查，而对宏只进行字符替换没有类型检查；
第二、有些编译器可以对const常量进行调试，但不能对宏常量进行调试；
第三、const可以用来修饰函数参数、函数返回值；
在C++里还可以用来修饰函数，定义内中某个成员函数为常量函数。
（2）写一个标准宏MIN，这个宏输入两个参数并返回较小的一个
#defineMIN（A,B）（（A）<
=（B）?
（A）:
（B））
第一、宏是方便的产生嵌入代码的唯一方法；
第二、三重条件操作符对编译器来说可以产生比if-then-else更优化的代码；
第三、必须把宏中的参数用括号括起来。
（3）内联函数和宏的差别是什么?
内联函数和普通函数相比可以加快程序运行的速度，因为不需要中断调用。
编译时内联函数代码直接嵌入到目标代码中；
而宏只是字符替换。
内联函数要做类型检查，相对于宏更安全可靠。
inline只用于如下情况：
第一、一个函数被不断调用；
第二、函数只有简单的几行，且函数内不包含for、while、switch等语句。
（4）对于const
符号常量，说明上面三种描述的区别：
const
*p
char
const
*
p
1和2相同，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量，不能修改指针指向对象的内容；
如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量，不能修改指针的指向。
写出二分查找的代码
intbfind（int*a,intlen,intval）
intm=len/2;
intl=0;
intr=len;
while（（l!
=m）&
&
（r!
=m））
if（a[m]>
val）
{
r=m;
m=（m+l）/2;
}
elseif（a[m]<
val）
l=m;
m=（m+r）/2;
else
returnm;
}
return-1;
//没有找到
2常见字符串面试题
写出在母串中查找子串出现次数的代码
/*在母串中查找子串出现次数的代码。
*str：
母字符串；
*s：
子字符串*/
intcount（char*str,char*s）
char*s1;
char*s2;
intcount=0;
while（*str!
='
\0'
）
{
s1=str;
s2=s;
while（（*s2==*s1）&
（*s2!
）&
（*s1!
））
s2++;
s1++;
if（*s2=='
count++;
str++;
}
returncount;
}
查找第一个匹配子串位置，如果返回的是s1长度len1表示没有找到。
size_tfind（char*s1,char*s2）
size_tlen1=strlen（s1）;
size_tlen2=strlen（s2）;
if（len1-len2<
0）
returnlen1;
for（size_ti=0;
i<
len1-len2;
i++）
size_tm=i;
for（size_tj=0;
j<
len2;
j++）
if（s1[m]!
=s2[j]）
break;
m++;
if（j==len2）
break;
return（i<
len1-len2）?
i:
len1;
实现strcpy函数（出现次数相当频繁的一道题）
char*strcpy（char*strDest,constchar*strSrc）
{
assert（（strDest!
=NULL）&
（strSrc!
=NULL））;
char*address=strDest;
while（（*strDest++=*strSrc++）!
NULL;
returnaddress;
注：
《VisualC++与面向对象程序设计教程》第101页对关于此函数的调用有精彩分析。
实现strcmp函数
intstrcmp（char*strFir,char*strSec）
assert（（strFir!
=0）&
（strSec!
=0））;
while（（*strFir==*strSec）&
（*strFir!
strFir++,strSec++;
if（*strFir>
*strSec）//找到第一个不等的字符，strFir的靠后
return1;
elseif（*strFir==*strSec）//两个字符串相等
return0;
return-1;
//找到第一个不等的字符，strFir的靠前
实现字符串翻转
voidmyreverse（char*str）
assert（str!
=NULL）;
char*p1=str;
char*p2=str-1;
while（*++p2）
//一般要求不能使用strlen
p2-=1;
while（p1<
p2）
charc=*p1;
*p1++=*p2;
*p2--=c;
用指针的方法，将字符串“ABCD1234efgh”前后对调显示
//不能用strlen求字符串长度，否则就没分了
charstrSrc[]="
ABCD1234efgh"
char*p1=strSrc;
char*p2=strSrc-1;
while（*++p2）
NULL;
p2-=1;
while（p1<
p2）
charc=*p1;
*p1++=*p2;
*p2--=c;
给定字符串A和B,输出A和B中的最大公共子串。
比如A="
aocdfe"
B="
pmcdfa"
则输出"
cdf"
#include"
stdafx.h"
#include<
string.h>
#include<
iostream>
usingnamespacestd;
char*commanstring（charshortstring[],charlongstring[]）
inti,j;
char*substring=（char*）malloc（256）;
if（strstr（longstring,shortstring）!
=NULL）//如果……，那么返回shortstring
returnshortstring;
for（i=strlen（shortstring）-1;
i>
0;
i--）//否则，开始循环计算
for（j=0;
=strlen（shortstring）-i;
memcpy（substring,&
shortstring[j],i）;
//memcpy:
从&
shortstring[j]里//拷贝i字节到substring里
substring[i]='
if（strstr（longstring,substring）!
=NULL）
returnsubstring;
returnNULL;
intmain（）
char*str1=（char*）malloc（256）;
char*str2=（char*）malloc（256）;
char*comman=NULL;
gets（str1）;
gets（str2）;
if（strlen（str1）>
strlen（str2））//将短的字符串放前面
comman=commanstring（str2,str1）;
else
comman=commanstring（str1,str2）;
printf（"
thelongestcommanstringis:
%s\n"
comman）;
return0;
判断一个字符串是不是回文
intIsReverseStr（char*str）
intfound=1;
if（str==NULL）
return-1;
//空字串，返回-1
char*p=str-1;
while（*++p!
）
p-=1;
while（（*str==*p）&
（str<
p））
str++,p--;
//可以写while语句里：
while（（*str++==*p--）&
p））;
if（str<
p）
found=0;
//非回文字串，返回0
returnfound;
//回文字串，返回1
写函数完成内存的拷贝
/*dst:
Destination;
src:
Source*/
void*memcpy（void*dst,constvoid*src,unsignedintlen）
registerchar*d;
registerchar*s;
if（len==0）
returndst;
if（dst>
src）//考虑覆盖情况
d=（char*）dst+len-1;
s=（char*）src+len-1;
while（len>
=4）//循环展开，提高执行效率
*d--=*s--;
len-=4;
while（len--）
}
elseif（dst<
src）
d=（char*）dst;
s=（char*）src;
=4）
*d++=*s++;
while（len--）
returndst;
写一个函数,它的原形是intcontinumax（char*outputstr,char*intputstr）。
功能：
在字符串中找出连续最长的数字串，把这个串的长度返回，并把这个最长数字串付给其中一个函数参数outputstr所指内存。
例如：
"
abcd12345ed125ss123456789"
的首地址传给intputstr后，函数将返回9，outputstr所指的值为123456789
intcontinumax（char*outputstr,char*inputstr）
char*in=inputstr,*out=outputstr,*temp,*final;
intcount=0,maxlen=0;
while（*in!
if（*in>
47&
*in<
58）
for（temp=in;
*in>
58;
in++）
count++;
else
in++;
if（maxlen<
count）
maxlen=count;
count=0;
final=temp;
for（inti=0;
i<
maxlen;
i++）
*out=*final;
out++;
final++;
*out='
returnmaxlen;
/*我自己的函数，只能满足部分要求*/
intcontinumax（char*inputstr）
assert（inputstr!
=NULL）;
char*p=inputstr;
intcnt=0;
while（*inputstr++!
inti=0;
for（p=inputstr;
*p!
*p++）
if（（*p>
0'
（*p<
9'
i++;
else
cnt=（cnt>
i?
cnt:
i）;
returncnt;
编写一个C函数，该函数在一个字符串中找到可能的最长的子字符串，且该字符串是由同一字符组成的。
char*search（char*cpSource,charch）
char*cpTemp=NULL,*cpDest=NULL;
intiTemp,iCount=0;
while（*cpSource）
if（*cpSource==ch）
iTemp=0;
cpTemp=cpSource;
while（*cpSource==ch）
++iTemp,++cpSource;
if（iTemp>
iCount）
iCount=iTemp,cpDest=cpTemp;
if（!
*cpSource）
break;
++cpSource;
returncpDest;
3排序算法
写出快速排序或者某种排序算法代码
（1）快速排序
intpartition（int*a,intl,intr）
inti=l-1,j=r,v=a[r];
while
（1）
while（a[++i]<
v）;
while（a[--j]>
v）if（j<
=i）break;
if（i>
=j）
swap（a[i],a[j]）;
swap（a[i],a[r]）;
returni;
voidqsort（int*a,intl,intr）
if（r>
l）
inti=partition（a,l,r）;
qsort（a,l,i-1）;
qsort（a,i+1,r）;
有兴趣可以看看下面2个。
一般面试不会要求的
改进1:
while（l<
r）
//防止过多递归
l=i+1;
改进2：
if（r-l<
32）
//防止分割恶化
insertsort（a+l,r-l+1）;
//后面的插入排序
return;
inti=partition（a,l
升级会员 