C++笔试面试题.docx

上传人:b****1 文档编号:1420352 上传时间:2023-04-30 格式:DOCX 页数:88 大小:120.22KB
下载 相关 举报
C++笔试面试题.docx_第1页
第1页 / 共88页
C++笔试面试题.docx_第2页
第2页 / 共88页
C++笔试面试题.docx_第3页
第3页 / 共88页
C++笔试面试题.docx_第4页
第4页 / 共88页
C++笔试面试题.docx_第5页
第5页 / 共88页
C++笔试面试题.docx_第6页
第6页 / 共88页
C++笔试面试题.docx_第7页
第7页 / 共88页
C++笔试面试题.docx_第8页
第8页 / 共88页
C++笔试面试题.docx_第9页
第9页 / 共88页
C++笔试面试题.docx_第10页
第10页 / 共88页
C++笔试面试题.docx_第11页
第11页 / 共88页
C++笔试面试题.docx_第12页
第12页 / 共88页
C++笔试面试题.docx_第13页
第13页 / 共88页
C++笔试面试题.docx_第14页
第14页 / 共88页
C++笔试面试题.docx_第15页
第15页 / 共88页
C++笔试面试题.docx_第16页
第16页 / 共88页
C++笔试面试题.docx_第17页
第17页 / 共88页
C++笔试面试题.docx_第18页
第18页 / 共88页
C++笔试面试题.docx_第19页
第19页 / 共88页
C++笔试面试题.docx_第20页
第20页 / 共88页
亲,该文档总共88页,到这儿已超出免费预览范围,如果喜欢就下载吧!
下载资源
资源描述

C++笔试面试题.docx

《C++笔试面试题.docx》由会员分享,可在线阅读,更多相关《C++笔试面试题.docx(88页珍藏版)》请在冰点文库上搜索。

C++笔试面试题.docx

C++笔试面试题

1.以下三条输出语句分别输出什么?

charstr1[]="abc";

charstr2[]="abc";

constcharstr3[]="abc";

constcharstr4[]="abc";

constchar*str5="abc";

constchar*str6="abc";

cout<

cout<

cout<

答:

分别输出false,false,true。

str1和str2都是字符数组,每个都有其自己的存储区,它们的值则是各存储区首地址,不等;str3和str4同上,只是按const语义,它们所指向的数据区不能修改。

str5和str6并非数组而是字符指针,并不分配存储区,其后的“abc”以常量形式存于静态数据区,而它们自己仅是指向该区首地址的指针,相等。

2.以下代码中的两个sizeof用法有问题吗?

voidUpperCase(charstr[])//将str中的小写字母转换成大写字母

{

for(size_ti=0;i

if('a'<=str[i]&&str[i]<='z')

str[i]-=('a'-'A');

}

charstr[]="aBcDe";

cout<<"str字符长度为:

"<

UpperCase(str);

cout<

答:

函数内的sizeof有问题。

根据语法,sizeof如用于数组,只能测出静态数组的大小,无法检测动态分配的或外部数组大小。

函数外的str是一个静态定义的数组,因此其大小为6,函数内的str实际只是一个指向字符串的指针,没有任何额外的与数组相关的信息,因此sizeof作用于上只将其当指针看,一个指针为4个字节,因此返回4。

3.非C++内建型别A和B,在哪几种情况下B能隐式转化为A?

答:

a.classB:

publicA{……}//B公有继承自A,可以是间接继承的

b.classB{operatorA();}//B实现了隐式转化为A的转化

c.classA{A(constB&);}//A实现了non-explicit的参数为B(可以有其他带默认值的参数)构造函数

d.A&operator=(constA&);//赋值操作,虽不是正宗的隐式类型转换,但也可以勉强算一个

4.以下代码有什么问题?

structTest

{

Test(int){}

Test(){}

voidfun(){}

};

voidmain(void)

{

Testa

(1);

a.fun();

Testb();

b.fun();

}

答:

变量b定义出错。

按默认构造函数定义对象,不需要加括号。

5.以下代码有什么问题?

cout<<(true?

1:

"1")<

答:

三元表达式“?

:

”问号后面的两个操作数必须为同一类型。

6.以下代码能够编译通过吗,为什么?

unsignedintconstsize1=2;

charstr1[size1];

unsignedinttemp=0;

cin>>temp;

unsignedintconstsize2=temp;

charstr2[size2];

答:

str2定义出错,size2非编译器期间常量,而数组定义要求长度必须为编译期常量。

7.以下反向遍历array数组的方法有什么错误?

vectorarray;

array.push_back

(1);

array.push_back

(2);

array.push_back(3);

for(vector:

:

size_typei=array.size()-1;i>=0;--i)//反向遍历array数组

{

cout<

}

答:

首先数组定义有误,应加上类型参数:

vectorarray。

其次vector:

:

size_type被定义为unsignedint,即无符号数,这样做为循环变量的i为0时再减1就会变成最大的整数,导致循环失去控制。

8.以下代码中的输出语句输出0吗,为什么?

structCLS

{

intm_i;

CLS(inti):

m_i(i){}

CLS(){CLS(0);}

};

CLSobj;

cout<

答:

不能。

在默认构造函数内部再调用带参的构造函数属用户行为而非编译器行为,亦即仅执行函数调用,而不会执行其后的初始化表达式。

只有在生成对象时,初始化表达式才会随相应的构造函数一起调用。

9.C++中的空类,默认产生哪些类成员函数?

答:

classEmpty

{

public:

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

Empty(constEmpty&);//拷贝构造函数

~Empty();//析构函数

Empty&operator=(constEmpty&);//赋值运算符

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

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

};

10.以下两条输出语句分别输出什么?

floata=1.0f;

cout<<(int)a<

cout<<(int&)a<

cout<

floatb=0.0f;

cout<<(int)b<

cout<<(int&)b<

cout<

答:

分别输出false和true。

注意转换的应用。

(int)a实际上是以浮点数a为参数构造了一个整型数,该整数的值是1,(int&)a则是告诉编译器将a当作整数看(并没有做任何实质上的转换)。

因为1以整数形式存放和以浮点形式存放其内存数据是不一样的,因此两者不等。

对b的两种转换意义同上,但是0的整数形式和浮点形式其内存数据是一样的,因此在这种特殊情形下,两者相等(仅仅在数值意义上)。

注意,程序的输出会显示(int&)a=1065353216,这个值是怎么来的呢?

前面已经说了,1以浮点数形式存放在内存中,按ieee754规定,其内容为0x0000803F(已考虑字节反序)。

这也就是a这个变量所占据的内存单元的值。

当(int&)a出现时,它相当于告诉它的上下文:

“把这块地址当做整数看待!

不要管它原来是什么。

”这样,内容0x0000803F按整数解释,其值正好就是1065353216(十进制数)。

通过查看汇编代码可以证实“(int)a相当于重新构造了一个值等于a的整型数”之说,而(int&)的作用则仅仅是表达了一个类型信息,意义在于为cout<<及==选择正确的重载版本。

11.以下代码有什么问题?

#include

#include

usingstd:

:

vector;usingstd:

:

cout;usingstd:

:

endl;

typedefvectorIntArray;

voidtest()

{

IntArrayarray;

array.push_back

(1);

array.push_back

(2);

array.push_back

(2);

array.push_back(3);

//删除array数组中所有的2

for(IntArray:

:

iteratoritor=array.begin();itor!

=array.end();++itor)

{

if(2==*itor)

{

array.erase(itor);

}

}

for(IntArray:

:

iteratoritor=array.begin();itor!

=array.end();++itor)

cout<<*itor;

}

intmain()

{

test();

}

答:

同样有缺少类型参数的问题。

另外,每次调用“array.erase(itor);”,迭代器每次删除后回自动指向下一个元素,导致迭代漏项,应在删除一项后使itor--,使之从已经前移的下一个元素起继续遍历。

12.写一个函数,完成内存之间的拷贝。

[考虑问题是否全面]

答:

void*mymemcpy(void*dest,constvoid*src,size_tcount)

{

char*pdest=static_cast(dest);

constchar*psrc=static_cast(src);

if(pdest>psrc&&pdest

{

for(size_ti=count-1;i!

=-1;--i)

pdest[i]=psrc[i];

}

else

{

for(size_ti=0;i

pdest[i]=psrc[i];

}

returndest;

}

注意内存块覆盖,向前与向后拷贝的问题。

1.求下面函数的返回值(微软)

intfunc(x)

{

intcountx=0;

while(x)

{

countx++;

x=x&(x-1);

}

returncountx;

}

假定x=9999。

答案:

8

思路:

将x转化为2进制,看含有的1的个数。

2.什么是“引用”?

申明和使用“引用”要注意哪些问题?

答:

引用就是某个目标变量的“别名”(alias),对应用的操作与对变量直接操作效果完全相同。

申明一个引用的时候,切记要对其进行初始化。

引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,不能再把该引用名作为其他变量名的别名。

声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。

不能建立数组的引用。

3.将“引用”作为函数参数有哪些特点?

(1)传递引用给函数与传递指针的效果是一样的。

这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。

(2)使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。

因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占空间都好。

(3)使用指针作为函数的参数虽然也能达到与使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用"*指针变量名"的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。

而引用更容易使用,更清晰。

4.在什么时候需要使用“常引用”?

 

如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。

常引用声明方式:

const类型标识符&引用名=目标变量名;

例1

inta;

constint&ra=a;

ra=1;//错误

a=1;//正确

例2

stringfoo();

voidbar(string&s);

那么下面的表达式将是非法的:

bar(foo());

bar("helloworld");

原因在于foo()和"helloworld"串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。

因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。

引用型参数应该在能被定义为const的情况下,尽量定义为const。

5.将“引用”作为函数返回值类型的格式、好处和需要遵守的规则?

格式:

类型标识符&函数名(形参列表及类型说明){//函数体}

好处:

在内存中不产生被返回值的副本;(注意:

正是因为这点原因,所以返回一个局部变量的引用是不可取的。

因为随着该局部变量生存期的结束,相应的引用也会失效,产生runtimeerror!

注意事项:

(1)不能返回局部变量的引用。

这条可以参照EffectiveC++[1]的Item31。

主要原因是局部变量会在函数返回后被销毁,因此被返回的引用就成为了"无所指"的引用,程序会进入未知状态。

(2)不能返回函数内部new分配的内存的引用。

这条可以参照EffectiveC++[1]的Item31。

虽然不存在局部变量的被动销毁问题,可对于这种情况(返回函数内部new分配内存的引用),又面临其它尴尬局面。

例如,被函数返回的引用只是作为一个临时变量出现,而没有被赋予一个实际的变量,那么这个引用所指向的空间(由new分配)就无法释放,造成memoryleak。

(3)可以返回类成员的引用,但最好是const。

这条原则可以参照EffectiveC++[1]的Item30。

主要原因是当对象的属性是与某种业务规则(businessrule)相关联的时候,其赋值常常与某些其它属性或者对象的状态有关,因此有必要将赋值操作封装在一个业务规则当中。

如果其它对象可以获得该属性的非常量引用(或指针),那么对该属性的单纯赋值就会破坏业务规则的完整性。

(4)流操作符重载返回值申明为“引用”的作用:

流操作符<<和>>,这两个操作符常常希望被连续使用,例如:

cout<<"hello"<

可选的其它方案包括:

返回一个流对象和返回一个流对象指针。

但是对于返回一个流对象,程序必须重新(拷贝)构造一个新的流对象,也就是说,连续的两个<<操作符实际上是针对不同对象的!

这无法让人接受。

对于返回一个流指针则不能连续使用<<操作符。

因此,返回一个流对象引用是惟一选择。

这个唯一选择很关键,它说明了引用的重要性以及无可替代性,也许这就是C++语言中引入引用这个概念的原因吧。

赋值操作符=。

这个操作符象流操作符一样,是可以连续使用的,例如:

x=j=10;或者(x=10)=100;赋值操作符的返回值必须是一个左值,以便可以被继续赋值。

因此引用成了这个操作符的惟一返回值选择。

例3

#include

int&put(intn);

intvals[10];

interror=-1;

intmain()

{

put(0)=10;//以put(0)函数值作为左值,等价于vals[0]=10;

put(9)=20;//以put(9)函数值作为左值,等价于vals[9]=20;

cout<

cout<

}

int&put(intn)

{

if(n>=0&&n<=9)returnvals[n];

else{cout<<"subscripterror";returnerror;}

}

(5)在另外的一些操作符中,却千万不能返回引用:

+-*/四则运算符。

它们不能返回引用,EffectiveC++[1]的Item23详细的讨论了这个问题。

主要原因是这四个操作符没有sideeffect,因此,它们必须构造一个对象作为返回值,可选的方案包括:

返回一个对象、返回一个局部变量的引用,返回一个new分配的对象的引用、返回一个静态对象引用。

根据前面提到的引用作为返回值的三个规则,第2、3两个方案都被否决了。

静态对象的引用又因为((a+b)==(c+d))会永远为true而导致错误。

所以可选的只剩下返回一个对象了。

6.“引用”与多态的关系?

引用是除指针外另一个可以产生多态效果的手段。

这意味着,一个基类的引用可以指向它的派生类实例。

例4

ClassA;

ClassB:

ClassA{...};

Bb;

A&ref=b;

7.“引用”与指针的区别是什么?

指针通过某个指针变量指向一个对象后,对它所指向的变量间接操作。

程序中使用指针,程序的可读性差;而引用本身就是目标变量的别名,对引用的操作就是对目标变量的操作。

此外,就是上面提到的对函数传ref和pointer的区别。

8.什么时候需要“引用”?

流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

以上2-8参考:

深入讨论C++中的引用

引用是C++引入的新语言特性,是C++常用的一个重要内容之一,正确、灵活地使用引用,可以使程序简洁、高效。

我在工作中发现,许多人使用它仅仅是想当然,在某些微妙的场合,很容易出错,究其原由,大多因为没有搞清本源。

故在本篇中我将对引用进行详细讨论,希望对大家更好地理解和使用引用起到抛砖引玉的作用。

  一、引用简介

  引用就是某一变量(目标)的一个别名,对引用的操作与对变量直接操作完全一样。

  引用的声明方法:

类型标识符&引用名=目标变量名;

  【例1】:

inta;int&ra=a;//定义引用ra,它是变量a的引用,即别名

  说明:

  

(1)&在此不是求地址运算,而是起标识作用。

  

(2)类型标识符是指目标变量的类型。

  (3)声明引用时,必须同时对其进行初始化。

  (4)引用声明完毕后,相当于目标变量名有两个名称,即该目标原名称和引用名,且不能再把该引用名作为其他变量名的别名。

  ra=1;等价于a=1;

  (5)声明一个引用,不是新定义了一个变量,它只表示该引用名是目标变量名的一个别名,它本身不是一种数据类型,因此引用本身不占存储单元,系统也不给引用分配存储单元。

故:

对引用求地址,就是对目标变量求地址。

&ra与&a相等。

  (6)不能建立数组的引用。

因为数组是一个由若干个元素所组成的集合,所以无法建立一个数组的别名。

  二、引用应用

  1、引用作为参数

  引用的一个重要作用就是作为函数的参数。

以前的C语言中函数参数传递是值传递,如果有大块数据作为参数传递的时候,采用的方案往往是指针,因为这样可以避免将整块数据全部压栈,可以提高程序的效率。

但是现在(C++中)又增加了一种同样有效率的选择(在某些特殊情况下又是必须的选择),就是引用。

  【例2】:

voidswap(int&p1,int&p2)//此处函数的形参p1,p2都是引用

{intp;p=p1;p1=p2;p2=p;}

  为在程序中调用该函数,则相应的主调函数的调用点处,直接以变量作为实参进行调用即可,而不需要实参变量有任何的特殊要求。

如:

对应上面定义的swap函数,相应的主调函数可写为:

main()

{

 inta,b;

 cin>>a>>b;//输入a,b两变量的值

 swap(a,b);//直接以变量a和b作为实参调用swap函数

 cout<

}

  上述程序运行时,如果输入数据1020并回车后,则输出结果为2010。

  由【例2】可看出:

  

(1)传递引用给函数与传递指针的效果是一样的。

这时,被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用,所以在被调函数中对形参变量的操作就是对其相应的目标对象(在主调函数中)的操作。

  

(2)使用引用传递函数的参数,在内存中并没有产生实参的副本,它是直接对实参操作;而使用一般变量传递函数的参数,当发生函数调用时,需要给形参分配存储单元,形参变量是实参变量的副本;如果传递的是对象,还将调用拷贝构造函数。

因此,当参数传递的数据较大时,用引用比用一般变量传递参数的效率和所占空间都好。

  (3)使用指针作为函数的参数虽然也能达到与使用引用的效果,但是,在被调函数中同样要给形参分配存储单元,且需要重复使用"*指针变量名"的形式进行运算,这很容易产生错误且程序的阅读性较差;另一方面,在主调函数的调用点处,必须用变量的地址作为实参。

而引用更容易使用,更清晰。

  如果既要利用引用提高程序的效率,又要保护传递给函数的数据不在函数中被改变,就应使用常引用。

  2、常引用

  常引用声明方式:

const类型标识符&引用名=目标变量名;

  用这种方式声明的引用,不能通过引用对目标变量的值进行修改,从而使引用的目标成为const,达到了引用的安全性。

  【例3】:

inta;

constint&ra=a;

ra=1;//错误

a=1;//正确

  这不光是让代码更健壮,也有些其它方面的需要。

  【例4】:

假设有如下函数声明:

stringfoo();

voidbar(string&s);

  那么下面的表达式将是非法的:

bar(foo());

bar("helloworld");

  原因在于foo()和"helloworld"串都会产生一个临时对象,而在C++中,这些临时对象都是const类型的。

因此上面的表达式就是试图将一个const类型的对象转换为非const类型,这是非法的。

  引用型参数应该在能被定义为const的情况下,尽量定义为const。

  3、引用作为返回值

  要以引用返回函数值,则函数定义时要按以下格式:

类型标识符&函数名(形参列表及类型说明)

{函数体}

  说明:

  

(1)以引用返回函数值,定义函数时需要在函数名前加&

  

(2)用引用返回一个函数值的最大好处是,在内存中不产生被返回值的副本。

  【例5】以下程序中定义了一个普通的函数fn1(它用返回值的方法返回函数值),另外一个函数fn2,它以引用的方法返回函数值。

#include

floattemp;//定义全局变量temp

floatfn1(floatr);//声明函数fn1

float&fn2(floatr);//声明函数fn2

floatfn1(floatr)//定义函数fn1,它以返

展开阅读全文
相关资源
猜你喜欢
相关搜索
资源标签

当前位置:首页 > 人文社科 > 法律资料

copyright@ 2008-2023 冰点文库 网站版权所有

经营许可证编号:鄂ICP备19020893号-2