C/C++ 笔试、面试题目大汇总

最新推荐文章于 2022-04-16 14:25:41 发布

iteye_17686

最新推荐文章于 2022-04-16 14:25:41 发布

阅读量173

点赞数

文章标签：面试 c/c++ 数据结构与算法

转自：http://www.cnblogs.com/fangyukuan

零、先来一些常见题目

1.求下面函数的返回值（微软）

intfunc(x)
{
intcountx=0;
while(x)
{
countx++;
x=x&(x-1);
}
returncountx;
}

假定x = 9999。答案：8

思路：将x转化为2进制，看含有的1的个数。
每取一次&会消去1个1；

2.什么是“引用”？申明和使用“引用”要注意哪些问题？

1引用就是某个目标变量的“别名”(alias)，对应用的操作与对变量直接操作效果完全相同。
2申明一个引用的时候，切记要对其进行初始化。引用声明完毕后，相当于目标变量名有两个名称，即该目标原名称和引用名，不能再把该引用名作为其他变量名的别名。
3声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。
4不能建立数组的引用。

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

（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

（2）使用引用传递函数的参数，在内存中并没有产生实参的副本，它是直接对实参操作；而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递的是对象，还将调用拷贝构造函数。因此，当参数传递的数据较大时，用引用比用一般变量传递参数的效率和所占空间都好。

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

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

如果既要利用引用提高程序的效率，又要保护传递给函数的数据不在函数中被改变，就应使用常引用。
常引用声明方式：const类型标识符 &引用名=目标变量名；

例1

inta;
constint&ra=a;
ra=1;//错误
a=1;//正确

例2

stringfoo( );
voidbar(string&s)
//下面的表达式都是非法的
bar(foo( ));
bar("hello world");

原因在于foo( )和"hello world"串都是产生一个临时对象，而在C++中，这些临时对象都是const类型的。因此上面的表达式就是试图将一个const类型的对象转换为非const类型，这是非法的。

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

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

格式：

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

好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的。因为随着该局部变量生存期的结束，相应的引用也会失效，产生runtime error!

注意：

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

（2）不能返回函数内部new分配的内存的引用。可对于这种情况，又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。

（3）可以返回类成员的引用，但最好是const。

（4）流操作符重载返回值申明为“引用”的作用：

流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout <<"hello" << endl;　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因吧。赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

＃include<iostream.h>
int&put(intn);
intvals[10];
interror= -1;

voidmain()
{
　　put(0)=10;//以put(0)函数值作为左值，等价于vals[0]=10;
　　put(9)=20;//以put(9)函数值作为左值，等价于vals[9]=20;
　　cout<<vals[0];
　　cout<<vals[9];
}

int&put(intn)
{
　　if(n>=0&&n<=9)

　　{

　　　　returnvals[n];

　　}

　　else

　　{

　　　　cout<<"subscript error";

　　　　returnerror;

　　}

（5）在另外的一些操作符中，却千万不能返回引用：+-*/ 四则运算符。它们不能返回引用，Effective C++[1]的Item23详细的讨论了这个问题。主要原因是这四个操作符没有side effect，因此，它们必须构造一个对象作为返回值，可选的方案包括：返回一个对象、返回一个局部变量的引用，返回一个new分配的对象的引用、返回一个静态对象引用。根据前面提到的引用作为返回值的三个规则，第2、3两个方案都被否决了。静态对象的引用又因为((a+b) == (c+d))会永远为true而导致错误。所以可选的只剩下返回一个对象了。

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

引用是除指针外另一个可以产生多态效果的手段。这意味着，一个基类的引用可以指向它的派生类实例

Class A;
Class B : Class A
{
　　//...
};

B b;
A&ref=b;

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

指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；

而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作,可读性强。

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

流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数。

9.结构与联合有和区别？
1. 结构和联合都是由多个不同的数据类型成员组成, 但在任何同一时刻, 联合中只存放了一个被选中的成员（所有成员共用一块地址空间）, 而结构的所有成员都存在（不同成员的存放地址不同）。
2. 对于联合的不同成员赋值, 将会对其它成员重写,原来成员的值就不存在了, 而对于结构的不同成员赋值是互不影响的。

10.下面关于“联合”的题目的输出？

＃include<stdio.h>
union
{
　　inti;
　　charx[2];
}a;

voidmain()
{
　　a.x[0]=10;
　　a.x[1]=1;
　　printf("%d",a.i);
}

答案：266

union这种类型，就是内部的变量共同使用一块空间，按照size大的分配
int i 占4个字节  char x[2] 占2个，所以一共分配了4个字节
可以使用sizeof(a) 来看下它的总大小
一共4个字节的内存，对应x来说相当于占用了低2个字节，低位低地址，高位高地址,而给x赋值的1，和10，就存在个位和十位上

按照内存分布，x 改之后内存为 0x010a
也就是说，i的内存时0x10a

union{
inti;

struct{
charfirst;
charsecond;
}half;

}number;

number.i=0x4241;
printf("%c%c\n", number.half.first, mumber.half.second);
number.half.first='a';
number.half.second='b';
printf("%x\n",number.i);

答案： AB (0x41对应'A',是低位；Ox42对应'B',是高位）

6261 (number.i和number.half共用一块地址空间）

11.已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串，strSrc 是源字符串。不调用C++/C 的字符串库函数，请编写函数 strcpy。

答案：

#include<assert.h>
#include<stdio.h>
char*strcpy(char*strDest,constchar*strSrc)
{
assert((strDest!=NULL)&&(strSrc!=NULL));//2分
char*address=strDest; 　　//2分
while( (*strDest++=*strSrc++)!='\0')　　　　　　　//2分
NULL;
returnaddress ; 　　　//2分
}

另外strlen函数如下：

#include<stdio.h>
#include<assert.h>
intstrlen(constchar*str )//输入参数const
{
assert( str!=NULL );//断言字符串地址非0
intlen = 0;
while( (*str++)!='\0')
{
len++;
}
returnlen;
}

12. 已知String类定义如下：

classString
{
public:
　　String(const char*str=NULL);//通用构造函数
　　String(const String&another);//拷贝构造函数
　　~String();//析构函数
　　String&operater=(constString&rhs);//赋值函数
private:
　　char*m_data;//用于保存字符串
};

尝试写出类的成员函数实现。

答案：

String::String(constchar*str)
{
if( str==NULL )//strlen在参数为NULL时会抛异常才会有这步判断
{
m_data=newchar[1] ;
m_data[0]='\0';
}
else
{
m_data=newchar[strlen(str)+1];
strcpy(m_data,str);
}
}
String::String(constString&another)
{
m_data=newchar[strlen(another.m_data)+1];
strcpy(m_data,other.m_data);
}

String&String::operator=(constString&rhs)
{
if(this==&rhs)
return*this;
delete []m_data;//删除原来的数据，新开一块内存
m_data=newchar[strlen(rhs.m_data)+1];
strcpy(m_data,rhs.m_data);
return*this;
}

String::~String()
{
delete []m_data ;
}

13. .h头文件中的ifndef/define/endif 的作用？

答：防止该头文件被重复引用。

14.＃include<file.h> 与＃include "file.h"的区别？

答：前者是从Standard Library的路径寻找和引用file.h，而后者是从当前工作路径搜寻并引用file.h。

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

首先，作为extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。

通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数

extern "C"是连接申明(linkage declaration),被extern "C"修饰的变量和函数是按照C语言方式编译和连接的,来看看C++中对类似。

C的函数是怎样编译的：

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

void foo( int x, int y );

该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。

_foo_int_int 这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

未加extern "C"声明时的连接方式

假设在C++中，模块A的头文件如下：

//模块A头文件　moduleA.h
#ifndef MODULE_A_H
#defineMODULE_A_H
intfoo(intx,inty );
#endif　　

在模块B中引用该函数：

//模块B实现文件　moduleB.cpp
＃include"moduleA.h"
foo(2,3);

实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

加extern "C"声明后的编译和连接方式

加extern "C"声明后，模块A的头文件变为：

//模块A头文件　moduleA.h
#ifndef MODULE_A_H
#defineMODULE_A_H
extern"C"intfoo(intx,inty );
#endif　

在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：
（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：实现C++与C及其它语言的混合编程。

明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧：

extern "C"的惯用法

（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：

extern"C"
{
　　＃include"cExample.h"
}

而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern"C"时会出现编译语法错误。

C++引用C函数例子工程中包含的三个文件的源代码如下：

#ifndef C_EXAMPLE_H
#defineC_EXAMPLE_H
externintadd(intx,inty);
#endif

#include"cExample.h"
intadd(intx,inty )
{
　　returnx+y;
}

//c++实现文件，调用add：cppFile.cpp
extern"C"
{
　　＃include"cExample.h"
}
intmain(intargc,char*argv[])
{
　　add(2,3);
　　return0;
}

如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。

（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern"C"函数声明为extern类型。

C引用C++函数例子工程中包含的三个文件的源代码如下：

//C++头文件cppExample.h
#ifndef CPP_EXAMPLE_H
#defineCPP_EXAMPLE_H
extern"C"intadd(intx,inty );
#endif

//C++实现文件 cppExample.cpp
＃include"cppExample.h"
intadd(intx,inty )
{
　　returnx+y;
}

externintadd(intx,inty );
intmain(intargc,char*argv[] )
{
　　add(2,3);
　　return0;
}

16.关联、聚合(Aggregation)以及组合(Composition)的区别？

涉及到UML中的一些概念：

关联是表示两个类的一般性联系，比如“学生”和“老师”就是一种关联关系；

聚合表示has-a的关系，是一种相对松散的关系，聚合类不需要对被聚合类负责，如下图所示，用空的菱形表示聚合关系：

从实现的角度讲，聚合可以表示为:

class A {...} class B { A* a; .....}

组合表示contains-a的关系，关联性强于聚合：组合类与被组合类有相同的生命周期，组合类要对被组合类负责，采用实心的菱形表示组合关系：

实现的形式是:

class A{...} class B{ A a; ...}

17.面向对象的三个基本特征，并简单叙述之？

1.封装：将客观事物抽象成类，每个类对自身的数据和方法实行protection(private, protected,public)

2.继承：广义的继承有三种实现形式：实现继承（指使用基类的属性和方法而无需额外编码的能力）、可视继承（子窗体使用父窗体的外观和实现代码）、接口继承（仅使用属性和方法，实现滞后到子类实现）。前两种（类继承）和后一种（对象组合=>接口继承以及纯虚函数）构成了功能复用的两种方式。

3.多态：系统能够在运行时，能够根据其类型确定调用哪个重载的成员函数的能力，称为多态性。（见：C++中类的多态与虚函数的使用）

18.重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？

常考的题目。

从定义上来说：

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

重写：是指子类重新定义父类虚函数的方法。

从实现原理上来说：

重载：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！

重写：和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚绑定）。

19.多态的作用？

主要是两个：

1. 隐藏实现细节，使得代码能够模块化；扩展代码模块，实现代码重用；

2. 接口重用：为了类在继承和派生的时候，保证使用家族中任一类的实例的某一属性时的正确调用。

20. Ado与Ado.net的相同与不同？

除了“能够让应用程序处理存储于DBMS 中的数据“这一基本相似点外，两者没有太多共同之处。但是Ado使用OLE DB 接口并基于微软的COM 技术，而ADO.NET 拥有自己的ADO.NET 接口并且基于微软的.NET 体系架构。众所周知.NET 体系不同于COM 体系，ADO.NET 接口也就完全不同于ADO和OLE DB 接口，这也就是说ADO.NET 和ADO是两种数据访问方式。ADO.net 提供对XML 的支持。

21.New delete与mallocfree的联系与区别?
答案：都是在堆(heap)上进行动态的内存操作。用malloc函数需要指定内存分配的字节数并且不能初始化对象，new 会自动调用对象的构造函数。delete 会调用对象的destructor，而free 不会调用对象的destructor.

（可以看看：显式调用构造函数和析构函数）

22.#define DOUBLE(x) x+x，i = 5*DOUBLE(5)；i是多少？
答案：i 为30。（注意直接展开就是了） 5 * 5 + 5

23.有哪几种情况只能用intializationlist而不能用assignment?

答案：当类中含有const、reference 成员变量；基类的构造函数都需要初始化表。

24.C++是不是类型安全的？
答案：不是。两个不同类型的指针之间可以强制转换（用reinterpret cast)。C#是类型安全的。

25.main函数执行以前，还会执行什么代码？
答案：全局对象的构造函数会在main 函数之前执行，为malloc分配必要的资源，等等。

26.描述内存分配方式以及它们的区别?
1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
2）在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。
3）从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由程序员决定，使用非常灵活，但问题也最多。

4) 代码区。

27.struct和class的区别

答案：struct 的成员默认是公有的，而类的成员默认是私有的。struct 和 class 在其他方面是功能相当的。

从感情上讲，大多数的开发者感到类和结构有很大的差别。感觉上结构仅仅象一堆缺乏封装和功能的开放的内存位，而类就象活的并且可靠的社会成员，它有智能服务，有牢固的封装屏障和一个良好定义的接口。既然大多数人都这么认为，那么只有在你的类有很少的方法并且有公有数据（这种事情在良好设计的系统中是存在的!）时，你也许应该使用 struct 关键字，否则，你应该使用 class 关键字。

28.当一个类A中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。（Autodesk）
答案：肯定不是零。举个反例，如果是零的话，声明一个class A[10]对象数组，而每一个对象占用的空间是零，这时就没办法区分A[0],A[1]…了。

29.在8086汇编下，逻辑地址和物理地址是怎样转换的？（Intel）
答案：通用寄存器给出的地址，是段内偏移地址，相应段寄存器地址*10H+通用寄存器内地址，就得到了真正要访问的地址。

30.比较C++中的4种类型转换方式？

重点是static_cast, dynamic_cast和reinterpret_cast的区别和应用。(以后再补上吧）

31.分别写出BOOL,int,float,指针类型的变量a与“零”的比较语句。
答案：

BOOL : 　if(!a ) orif(a)
int: 　　if( a==0)
float:constEXPRESSION EXP=0.000001
　　if( a<EXP&&a>-EXP)
pointer :　if( a!=NULL) orif(a==NULL)

32.请说出const与#define相比，有何优点？
1）const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查。而对后者只进行字符替换，没有类型安全检查，并且在字符替换可能会产生意料不到的错误。
2）有些集成化的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

33.简述数组与指针的区别？
数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。指针可以随时指向任意类型的内存块。
(1)修改内容上的差别
char a[] = “hello”;
a[0] = ‘X’;
char *p = “world”; // 注意p 指向常量字符串
p[0] = ‘X’; // 编译器不能发现该错误，运行时错误
(2) 用运算符sizeof 可以计算出数组的容量（字节数）。sizeof(p),p为指针得到的是一个指针变量的字节数，而不是p所指的内存容量。C++/C 语言没有办法知道指针所指的内存容量，除非在申请内存时记住它。注意当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针。

chara[]="hello world";
char*p=a;
cout<<sizeof(a)<<endl;//12 字节
cout<<sizeof(p)<<endl;//4 字节

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

voidFunc(chara[100])
{
　　cout<<sizeof(a)<<endl;//4 字节而不是100 字节
}

34.类成员函数的重载、覆盖和隐藏区别？
答案：
a.成员函数被重载的特征：
（1）相同的范围（在同一个类中）；
（2）函数名字相同；
（3）参数不同；
（4）virtual 关键字可有可无。
b.覆盖是指派生类函数覆盖基类函数，特征是：
（1）不同的范围（分别位于派生类与基类）；
（2）函数名字相同；
（3）参数相同；
（4）基类函数必须有virtual 关键字。
c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

35. There are twoint variables: a and b, don’t use “if”, “? :”, “switch”or other judgementstatements, find out the biggest one of the two numbers.
答案：( ( a + b ) + abs( a- b ) ) / 2

36.如何打印出当前源文件的文件名以及源文件的当前行号？
答案：
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系统预定义宏，这种宏并不是在某个文件中定义的，而是由编译器定义的

。

37. main主函数执行完毕后，是否可能会再执行一段代码，给出说明？
答案：可以，可以用atexit()函数;注它会在main 之后执行int fn1(void), fn2(void), fn3(void),fn4 (void);

voidmain(void)
{
　　String str("zhanglin");
　　atexit( fn1 );
　　atexit( fn2 );
　　atexit( fn3 );
　　atexit( fn4 );
　　printf("This is executed first.\n");
}
intfn1()
{
　　printf("next.\n");
　　return0;
}
intfn2()
{
　　printf("executed");
　　return0;
}
intfn3()
{
　　printf("is");
　　return0;
}
intfn4()
{
　　printf("This");
　　return0;
}

38.如何判断一段程序是由C编译程序还是由C++编译程序编译的？
答案：

#ifdef __cplusplus
　　cout<<"c++";
#else
　　cout<<"c";
#endif

注意，后面很多代码啊。代码不看也罢。

39.文件中有一组整数，要求排序后输出到另一个文件中（面试官，超级喜欢考排序的。你要去面试，数据结构的那几个排序一定要非常熟悉，用笔也可以写出代码来，用笔写代码，就是这样变态啊，其实感觉没有必要这样笔试）
答案：

＃include<iostream>
＃include<fstream>
usingnamespacestd;

voidOrder(vector<int>&data)//bubble sort
{
intcount=data.size() ;
inttag=false;//设置是否需要继续冒泡的标志位
for(inti=0; i<count ; i++)
{
for(intj=0; j<count-i-1; j++)
{
if( data[j]>data[j+1])
{
tag=true;
inttemp=data[j] ;
data[j]=data[j+1] ;
data[j+1]=temp ;
}
}
if(!tag )
break;
}
}

voidmain(void)
{
vector<int>data;
ifstreamin("c:\\data.txt");
if(!in)
{
cout<<"file error!";
exit(1);
}
inttemp;
while(!in.eof())
{
in>>temp;
data.push_back(temp);
}
in.close();//关闭输入文件流
Order(data);
ofstreamout("c:\\result.txt");
if(!out)
{
cout<<"file error!";
exit(1);
}
for( i=0; i<data.size() ; i++)
out<<data[i]<<"";
out.close();//关闭输出文件流
}

40. 链表题：一个链表的结点结构

structNode
{
intdata ;
Node*next ;
};
typedefstructNode Node ;

(1)已知链表的头结点head,写一个函数把这个链表逆序( Intel)

Node*ReverseList(Node*head)//链表逆序
{
if( head==NULL||head->next==NULL )
returnhead;
Node*p1=head ;
Node*p2=p1->next ;
Node*p3=p2->next ;
p1->next=NULL ;
while( p3!=NULL )
{
p2->next=p1 ;
p1=p2 ;
p2=p3 ;
p3=p3->next ;
}
p2->next=p1 ;
head=p2 ;
returnhead ;
}

(2)已知两个链表head1和head2各自有序，请把它们合并成一个链表依然有序。(保留所有结点，即便大小相同）

Node*Merge(Node*head1 , Node*head2)
{
if( head1==NULL)
returnhead2 ;
if( head2==NULL)
returnhead1 ;
Node*head=NULL ;
Node*p1=NULL;
Node*p2=NULL;
if( head1->data<head2->data )
{
head=head1 ;
p1=head1->next;
p2=head2 ;
}
else
{
head=head2 ;
p2=head2->next ;
p1=head1 ;
}
Node*pcurrent=head ;
while( p1!=NULL&&p2!=NULL)
{
if( p1->data<=p2->data )
{
pcurrent->next=p1 ;
pcurrent=p1 ;
p1=p1->next ;
}
else
{
pcurrent->next=p2 ;
pcurrent=p2 ;
p2=p2->next ;
}
}
if( p1!=NULL )
pcurrent->next=p1 ;
if( p2!=NULL )
pcurrent->next=p2 ;
returnhead ;
}

(3)已知两个链表head1和head2各自有序，请把它们合并成一个链表依然有序，这次要求用递归方法进行。(Autodesk)
答案：

Node*MergeRecursive(Node*head1 , Node*head2)
{
if( head1==NULL )
returnhead2 ;
if( head2==NULL)
returnhead1 ;
Node*head=NULL ;
if( head1->data<head2->data )
{
head=head1 ;
head->next=MergeRecursive(head1->next,head2);
}
else
{
head=head2 ;
head->next=MergeRecursive(head1,head2->next);
}
returnhead ;
}

41.分析一下这段程序的输出(Autodesk)

classB
{
public:
B()
{
cout<<"default constructor"<<endl;
}
~B()
{
cout<<"destructed"<<endl;
}
B(inti):data(i)//B(int) works as a converter ( int ->instance of B)
{
cout<<"constructed by parameter"<<data<<endl;
}
private:
intdata;
};

B Play( B b)
{
returnb ;
}
(1) results:
intmain(intargc,char*argv[]) constructedby parameter5
{ destructed B(5)形参析构
B t1=Play(5); B t2=Play(t1); 　 destructed t1形参析构
return0;　　　　　　　　　　　　　　 destructed t2　注意顺序！
} destructed t1
(2) results:
intmain(intargc,char*argv[]) constructedby parameter5
{ destructed B(5)形参析构
B t1=Play(5); B t2=Play(10); 　 constructed by parameter10
return0;　　　　　　　　　　　　　　 destructed B(10)形参析构
} destructed t2　注意顺序！
destructed t1

42. 写一个函数找出一个整数数组中，第二大的数（microsoft）
答案：

constintMINNUMBER=-32767;
intfind_sec_max(intdata[] ,intcount)
{
intmaxnumber=data[0] ;
intsec_max=MINNUMBER ;
for(inti=1; i<count ; i++)
{
if( data[i]>maxnumber )
{
sec_max=maxnumber ;
maxnumber=data[i] ;
}
else
{
if( data[i]>sec_max )
sec_max=data[i] ;
}
}
returnsec_max ;
}

43.写一个在一个字符串(n)中寻找一个子串(m)第一个位置的函数。

KMP算法效率最好，时间复杂度是Ｏ(n+m)。

44.多重继承的内存分配问题：
比如有class A : public class B, public classC {}
那么A的内存结构大致是怎么样的？

这个是compiler-dependent的, 不同的实现其细节可能不同。
如果不考虑有虚函数、虚继承的话就相当简单；否则的话，相当复杂。
可以参考《深入探索C++对象模型》

45.如何判断一个单链表是有环的？（注意不能用标志位，最多只能用两个额外指针）

structnode {charval; node*next;}
boolcheck(constnode*head) {}//return false : 无环；true: 有环一种O（n）的办法就是（搞两个指针，一个每次递增一步，一个每次递增两步，如果有环的话两者必然重合，反之亦然）：
boolcheck(constnode*head)
{
if(head==NULL)returnfalse;
node*low=head,*fast=head->next;
while(fast!=NULL&&fast->next!=NULL)
{
low=low->next;
fast=fast->next->next;
if(low==fast)returntrue;
}
returnfalse;
}

一.找错题

试题1：

voidtest1()
{
　charstring[10];
　char*str1="0123456789";
　strcpy(string, str1 );
}

试题2：

voidtest2()
{
　charstring[10],str1[10];
　inti;
　for(i=0; i<10; i++)
　{
　　str1='a';
　}
　strcpy(string, str1 );
}

试题3：

voidtest3(char*str1)
{
　charstring[10];
　if( strlen( str1 )<=10)
　{
　　strcpy(string, str1 );
　}
}

解答：

　　试题1字符串str1需要11个字节才能存放下（包括末尾的’\0’），而string只有10个字节的空间，strcpy会导致数组越界；

　　对试题2，问题很严重,对string[10]数组的赋值本身没有错误,但很明显程序期望对string按字符串操作,这就需要额外的赋给一个'\0'结束符;另外如果没有'\0'结束标志,调用strcpy将不会结束,造成程序的不确定性,很危险.如果面试者指出字符数组str1不能在数组内结束可以给3分；如果面试者指出strcpy(string,str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分，在此基础上指出库函数strcpy工作方式的给10分；

　　对试题3，if(strlen(str1)<= 10)应改为if(strlen(str1) < 10)，因为strlen的结果未统计’\0’所占用的1个字节

剖析：
　　考查对基本功的掌握：
　　(1)字符串以’\0’结尾；
　　(2)对数组越界把握的敏感度；
　　(3)库函数strcpy的工作方式，如果编写一个标准strcpy函数的总分值为10，下面给出几个不同得分的答案：

　2分

void strcpy( char *strDest, char *strSrc )
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}

　　4分

void strcpy( char *strDest, const char *strSrc )
//将源字符串加const，表明其为输入参数，加2分
{
　 while( (*strDest++ = * strSrc++) != ‘\0’ );
}

　　7分

void strcpy(char *strDest, const char *strSrc)
{
　//对源地址和目的地址加非0断言，加3分
　assert( (strDest != NULL) && (strSrc != NULL) );
　while( (*strDest++ = * strSrc++) != ‘\0’ );
}

　　10分

//为了实现链式操作，将目的地址返回，加3分！

char * strcpy( char *strDest, const char *strSrc )
{
　assert( (strDest != NULL) && (strSrc != NULL) );
　char *address = strDest;
　while( (*strDest++ = * strSrc++) != ‘\0’ );
　　return address;
}

　　从2分到10分的几个答案我们可以清楚的看到，小小的strcpy竟然暗藏着这么多玄机，真不是盖的！需要多么扎实的基本功才能写一个完美的strcpy啊！
　　(4)对strlen的掌握，它没有包括字符串末尾的'\0'。
　　读者看了不同分值的strcpy版本，应该也可以写出一个10分的strlen函数了，完美的版本为：

int strlen( const char *str ) //输入参数const
{
assert( strt != NULL ); //断言字符串地址非0
　int len = 0;
　while( (*str++) != '\0' )
　{
　　len++;
　}
　return len;
}

试题4：

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

试题5：

char*GetMemory(void)
{
　charp[]="hello world";
　returnp;
}
voidTest(void)
{
　char*str=NULL;
　str=GetMemory();
　printf( str );
}

试题6：

voidGetMemory(char**p,intnum )
{
　*p=(char*) malloc( num );
}
voidTest(void)
{
　char*str=NULL;
　GetMemory(&str,100);
　strcpy( str,"hello");
　printf( str );
}

试题7：

voidTest(void)
{
　char*str=(char*) malloc(100);
　strcpy( str,"hello");
　free( str );
　...//省略的其它语句
}

解答：
试题4
GetMemory(char *p )函数的形参为字符串指针，在函数内部修改形参并不能真正的改变传入形参的值，执行完

char *str = NULL;
GetMemory( str );
str仍然为NULL

试题5
char p[] = "hello world";
return p;

实际上相当于：
char p[12];
strcpy(p, "Hello world");
p[]是在栈里临时分配的。虽然p指向的内容是"Hello world", 但是这是复制品，不是原件。当函数结束，char p[]就被程序回收了，所以p[]的内容就不再是"Hello world"了。
但如果以char *p="Hello world"的方式使用，p指向的是静态字符串存储的位置，也就是说指向"Hello world"的原件，当然没有问题了。
如果想坚持用char p[]而不使用char *p, 有效方法必须是：
{
static char p[]="Hello world";
return p;
}

试题6的GetMemory避免了试题4的问题，传入GetMemory的参数为字符串指针的指针，但是在GetMemory中执行申请内存及赋值语句

*p = (char *) malloc( num );
后未判断内存是否申请成功，应加上：

if ( *p == NULL )
{
　...//进行申请内存失败处理
}

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运行时提示错误“AccessViolation”。该程序应该改为：

swap(int*p1,int*p2 )
{
　intp;
　p=*p1;
　*p1=*p2;
　*p2=p;
}

二.内功题

试题1：分别给出BOOL，int，float，指针变量与“零值”比较的 if 语句（假设变量名为var）

解答：

　　　BOOL型变量：if(!var)

　　　int型变量：if(var==0)

　　　float型变量：

　　　const float EPSINON = 0.00001;

　　　if ((x >= - EPSINON) && (x <=EPSINON)

　　　指针变量：　　if(var==NULL)

剖析：

　　考查对0值判断的“内功”，BOOL型变量的0判断完全可以写成if(var==0)，而int型变量也可以写成if(!var)，指针变量的判断也可以写成if(!var)，上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。
　一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if(var)、if(!var)，表明其为“逻辑”判断；如果用if判断一个数值型变量(short、int、long等)，应该用if(var==0)，表明是与0进行“数值”上的比较；而判断指针则适宜用if(var==NULL)，这是一种很好的编程习惯。

　　浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if(x == 0.0)，则判为错，得0分。

试题2：以下为WindowsNT下的32位C++程序，请计算sizeof的值

voidFunc (charstr[100] )
{
　sizeof( str )=?
}
void*p=malloc(100);
sizeof( p )=?

解答：

sizeof( str ) = 4
sizeof ( p ) = 4
剖析：

　　Func ( char str[100] )函数中数组名作为函数形参时，数组名失去了本身的内涵，仅仅只是一个指针；在失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

数组名的本质如下：
（1）数组名指代一种数据结构，这种数据结构就是数组；

char str[10];
cout << sizeof(str) << endl;

输出结果为10，str指代数据结构char[10]。

（2）数组名可以转换为指向其指代实体的指针，而且是一个指针常量，不能作自增、自减等操作，不能被修改；

char str[10];
str++; //编译出错，提示str不是左值　

（3）数组名作为函数形参时，沦为普通指针。

Windows NT 32位平台下，指针的长度（占用内存的大小）为4字节，故sizeof( str ) 、sizeof ( p) 都为4。

试题3：写一个“标准”宏MIN，这个宏输入两个参数并返回较小的一个。另外，当你写下面的代码时会发生什么事？

least = MIN(*p++, b);

解答：
#define MIN(A,B) ((A) <= (B) ? (A) : (B)) //应注意不能在宏定义的后面加“;”
MIN(*p++, b)会产生宏的副作用

剖析：

（1）谨慎地将宏定义中的“参数”和整个宏用用括弧括起来。所以，严格地讲，下述解答：

#define MIN(A,B) (A) <= (B) ? (A) : (B)
#define MIN(A,B) (A <= B ? A : B )都应判0分；

（2）防止宏的副作用。

宏定义#define MIN(A,B) ((A) <= (B) ? (A) : (B))对MIN(*p++, b)的作用结果是：

((*p++) <= (b) ? (*p++) : (*p++))

这个表达式会产生副作用，指针p会作三次++自增操作。
　　试题4：为什么标准头文件都有类似以下的结构？

#ifndef __INCvxWorksh
#define __INCvxWorksh
#ifdef __cplusplus

extern "C" {
#endif

#ifdef __cplusplus
}

#endif
#endif /* __INCvxWorksh *

　　解答：
　　头文件中的编译宏

#ifndef　__INCvxWorksh
#define　__INCvxWorksh
#endif

的作用是防止被重复引用。
　　作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在symbol库中的名字与C语言的不同。例如，假设某个函数的原型为：

void foo(int x, int y);

　　该函数被C编译器编译后在symbol库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字。_foo_int_int这样的名字包含了函数名和函数参数数量及类型信息，C++就是考这种机制来实现函数重载的。为了实现C和C++的混合编程，C++提供了C连接交换指定符号extern "C"来解决名字匹配问题，函数声明前加extern "C"后，则编译器就会按照C语言的方式将该函数编译为_foo，这样C语言中就可以调用C++的函数了

试题5：编写一个函数，作用是把一个char组成的字符串循环右移n个。比如原来是“abcdefghi”如果steps=2，移位后应该是“hiabcdefgh”
函数头是这样的：

//pStr是指向以'\0'结尾的字符串的指针
//steps是要求移动的n
voidLoopMove (char*pStr,intsteps )
{
　//请填充...
}

解答：

voidLoopMove (char*pStr,intsteps )
{
intn=strlen( pStr )-steps;
　chartmp[MAX_LEN];
memcpy(tmp, pStr+n, steps); //从第7个开始复制最后的”hi“

　memcpy(pStr+steps, pStr, n); //从最前面开始复制连续7个字节到pStr的第3个字节起
　memcpy(pStr, tmp, steps); //将”hi“复制进pStr的起始两位置
}

剖析：
这个试题主要考查面试者对标准库函数的熟练程度，在需要的时候引用库函数可以很大程度上简化程序编写的工作量

最频繁被使用的库函数包括：

（1） strcpy

（2） memcpy
（3） memset

试题6：已知WAV文件格式如下表，打开一个WAV文件，以适当的数据结构组织WAV文件头并解析WAV格式的各项信息。

　　WAVE文件格式说明表

	偏移地址	字节数	数据类型	内容
文件头	00H	4	Char	"RIFF"标志
	04H	4	int32	文件长度
	08H	4	Char	"WAVE"标志
	0CH	4	Char	"fmt"标志
	10H	4		过渡字节（不定）
	14H	2	int16	格式类别
	16H	2	int16	通道数
	18H	2	int16	采样率（每秒样本数），表示每个通道的播放速度
	1CH	4	int32	波形音频数据传送速率
	20H	2	int16	数据块的调整数（按字节算的）
	22H	2		每样本的数据位数
	24H	4	Char	数据标记符＂data＂
	28H	4	int32	语音数据的长度

解答：
将WAV文件格式定义为结构体WAVEFORMAT：

typedefstructtagWaveFormat
{
　charcRiffFlag[4];
　UIN32 nFileLen;
　charcWaveFlag[4];
　charcFmtFlag[4];
　charcTransition[4];
　UIN16 nFormatTag ;
　UIN16 nChannels;
　UIN16 nSamplesPerSec;
　UIN32 nAvgBytesperSec;
　UIN16 nBlockAlign;
　UIN16 nBitNumPerSample;
　charcDataFlag[4];
　UIN32 nAudioLength;
} WAVEFORMAT;

假设WAV文件内容读出后存放在指针buffer开始的内存单元内，则分析文件格式的代码很简单，为：

WAVEFORMAT waveFormat;
memcpy( &waveFormat, buffer,sizeof( WAVEFORMAT ) );
直接通过访问waveFormat的成员，就可以获得特定WAV文件的各项格式信息。

试题7：编写类String的构造函数、析构函数和赋值函数，已知类String的原型为：

classString
{
　public:
　　String(constchar*str=NULL);//普通构造函数
　　String(constString&other);//拷贝构造函数
　　~String(void);//析构函数
　　String&operate=(constString&other);//赋值函数
　private:
　　char*m_data;//用于保存字符串
};
　
解答：
//普通构造函数
String::String(constchar*str)
{
　if(str==NULL)
　{
　　m_data=newchar[1];//得分点：对空字符串自动申请存放结束标志'\0'的空
　　*m_data='\0';//加分点：对m_data加NULL判断
　}
　else
　{
　　intlength=strlen(str);
　　m_data=newchar[length+1];//若能加NULL 判断则更好
　　strcpy(m_data, str);
　}
}
//String的析构函数
String::~String(void)
{
　delete [] m_data;//或deletem_data;
}
//拷贝构造函数
String::String(constString&other)//得分点：输入参数为const型
{
　intlength=strlen(other.m_data);
　m_data=newchar[length+1]; 　　　　//加分点：对m_data加NULL 判断
　strcpy(m_data, other.m_data);
}
//赋值函数
String&String::operate=(constString&other)//得分点：输入参数为const型
{
　if(this==&other) 　　return*this;//得分点：检查自赋值
　delete [] m_data; 　　　　//得分点：释放原有的内存资源
　intlength=strlen( other.m_data );
　m_data=newchar[length+1]; 　//加分点：对m_data加NULL 判断
　strcpy( m_data, other.m_data );
　return*this; 　　　　　　　　//得分点：返回本对象的引用
}

剖析：
　　能够准确无误地编写出String类的构造函数、拷贝构造函数、赋值函数和析构函数的面试者至少已经具备了C++基本功的60%以上！
　　在这个类中包括了指针类成员变量m_data，当类中包括指针类成员变量时，一定要重载其拷贝构造函数、赋值函数和析构函数。

试题8：请说出static和const关键字尽可能多的作用

解答：
　　static关键字至少有下列n个作用：
　　（1）函数体内static变量的作用范围为该函数体，其值在下次调用时仍维持上次的值；
　　（2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；
　　（3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；
　　（4）在类中的static成员变量属于整个类所拥有，对类的所有对象只有一份拷贝；
　　（5）在类中的static成员函数属于整个类所拥有，这个函数不接收this指针，因而只能访问类的static成员变量。

　　const关键字至少有下列n个作用：
　　（1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；
　　（2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；
　　（3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；
　　（4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
　　（5）对于类的成员函数，有时候必须指定其返回值为const类型，以使得其返回值不为“左值”。例如：
const classA operator*(const classA& a1,const classA& a2);
　　operator*的返回结果必须是一个const对象。

返回值为const的函数例如const int test();会返回一个const int 型的返回值，如重载运算符“=”，const T &operator=(T &t),T d=(a=b+c);d的值也等于b+c，不会等于a的原值。

三.技巧题

试题1：写一个函数返回1+2+3+…+n的值（假定结果不会超过长整型变量的范围）

解答：

intSum(intn )
{
　return( (long)1+n)*n/2;　　
}

剖析：
　　对于这个题，只能说，也许最简单的答案就是最好的答案。下面的解答，或者基于下面的解答思路去优化，不管怎么“折腾”，其效率也不可能与直接return( 1 l + n ) * n / 2相比！

intSum(intn )
{
　longsum=0;
　for(inti=1; i<=n; i++)
　{
　　sum+=i;
　}
　returnsum;
}

所以程序员们需要敏感地将数学等知识用在程序设计中。

iteye_17686

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C/C++ 笔试、面试题目大汇总

转自：http://www.cnblogs.com/fangyukuan零、先来一些常见题目1.求下面函数的返回值（微软）intfunc(x){intcountx=0;while(x){countx++;x=x&amp;(x-1);}returncountx;}假定x = 9999。答案：8思路：将x转化为2进制，看含有的1的个数。每...
复制链接

扫一扫