求面试题...

[shrinerain]

老大让我参与面试一个学生...

他简历写的"熟悉C/C++",老大说考察下是不是水货...

郁闷的是,我自己都不能算"熟悉C/C++"...

我平时主要用Shell/Java/C#干活...很少接触C/C++....

主要考察基础牢固程度,各位有比较好的面试题,砸死我吧!

[jixingzhong]

C/C++笔试、面试题目大汇总
http://www.linuxmine.com/6096.html

[jixingzhong]

c/c++ 笔试、面试题目大汇总
http://tag.csdn.net/tag/c/c++%20%E7%AC%94%E8%AF%95%E3%80%81%E9%9D%A2%E8%AF%95%E9%A2%98%E7%9B%AE%E5%A4%A7%E6%B1%87%E6%80%BB/1.html

[discory]

你们公司在招c++新手吗?

[freshui]

hehe 面试题我觉得基本都是从题库里抽的 很少有自己写的

[shelok]

1 回文数的判定
2 基本排序查找算法
3 用递归实现数组求和
4 数组或者链表的合并

回溯对新手要求太高了 没必要出

[shrinerain]

不是算法类的...这些第一关已经考过了...

C/C++基础!=算法基础

[shelok]

考考基础就行了``要想精通C/C++谈何容易啊，别说刚毕业的,就算是工作几年的又有谁敢拍胸脯说精通C/C++,这学生够谦虚的,在简历上还写的是熟练,其实``我如果现在去跳槽,我只敢在简历上写了解C/C++，甚至都还会脸红....越学越觉得自己只是站在c的门槛上

[limaolinghu]

我怎么觉得C++基础指的是，类，指针，魔板啊

[thinkinnight]

基础的话，考些指针的东西吧。
还有就是static, const,函数指针，类成员变量访问控制，继承，RTTI之类的
模板就算了，实在要考，就考考他对STL的熟悉情况吧。

[thinkinnight]

其实我觉得算法过了，就过了一大半了。
算法都很厉害的话，这些应该问题不大

[王集鹄]

算法是程序的灵魂，又不是在学校里考试
基础问题自己搜吧，

C++程序设计试题（A卷）
（共九题，满分：100分）
一、用简短语言回答下列问题（共20分，每题2分）
1．如果表达式中出现a::b的形式，则a可能是什么样的语言成分。
2．已知A是某种类型，且有定义：A * p；则表达式p+1中1所表示的字节数是多少？请用表达式给出。
3．静态数据成员应该在程序的什么位置进行初始化？
4．类的protected访问权限下的成员和private访问权限下的成员的不同点是什么？
5．C++程序中抽象类的标志是什么？
6．如何定义的函数可以将其调用结果作为赋值运算的左值？
7．new运算和malloc函数都可以申请空间，它们的主要区别是什么？
8．解决多重继承中名称冲突的问题的主要手段是什么？
9．基类的哪些成员是不可以被子类继承的？
10．静态成员函数不可以访问所在类的非静态成员的主要原因是什么？
二、判断对错（共20分，每题10分）
1．在C++中，允许从一个类派生出任意多个类，但不允许某个类同时从多个类派生。
2．抽象类不会产生实例，所以不需要有构造函数。
3．从一个模板类可以派生新的模板类，也可以派生非模板类。
4．一个类产生的所有对象共享同一个该类的静态数据的拷贝。
5．任何类都要有不必提供参数的构造函数（默认缺省构造函数）。
6．构造函数和析构函数都不能重载。
7．基类类型的指针可以指向其派生类对象。
8．设有说明int * const p=new int；则表明指针p是常量，即p只能指向固定的存储单元。
9．行为多态是指不同类的对象可以实现同一行为，但实现方法不同，利用函数和运算的重载(overloading)及继承中的覆写(overriding)可以实现行为多态。
10．设有函数说明void f(const int&)；则在调用该函数时，提供的参数既可以是变量，又可以是常量。
三、设计一个类，使得该类任何形式的派生类无论怎么定义和实现，都无法产生任何对象实例。（5分）

四、阅读Time类的定义及实现，写出main函数的运行结果。（10分）
#include <iostream.h>
class Time
{
public:
Time(int =0, int = 0, int = 0);
Time(const Time&);
Time& setTime(int, int, int);
Time& setHour(int);Time& setMinute(int);
Time& setSecond(int);
void printTime( ) const;
static int count;
private:
int hour;
int minute;
int second;
};
int Time::count = 0;
Time::Time(int h,int m, int s)
{
hour = (h>=0&&h<=24) ? h : 0;
minute=(m>=0&&m<=60) ? m : 0;
second=(s>=0&&s<=60) ? s : 0;count++;
}
Time::Time(const Time& t)
{
hour = 12;
minute = t.minute;
second = t.second+1;
count++;
}
Time& Time::setHour(int h)
{
hour = (h>=0&&h<=24) ? h : 0;
return *this;
}
Time& Time::setMinute(int m)
{
minute = (m>=0&&m<=60) ? m : 0;
return *this;
}
Time& Time::setSecond(int s)
{
second = ( s>=0&&s<=30) ? s : 30;
return *this;
}
void Time::printTime( ) const
{
cout << “The current Time is: “<< hour << “:” <<minute << “:” <<second << endl;
}
void main( )
{
Time time1, time2 = time1, time3(9,21,32), time4(38,53,61);
cout << “The courrent number of the timers is:” << Time::count<< endl;
time1.printTime( );
time2.printTime( );
time3.printTime( );
time4.printTime( );
time1.setHour(12).setMinute(32).setSecond(32);
time1.printTime( );
}


五、阅读下列类的定义，写出main函数的运行结果。（10分）
#include <iostream.h>
struct B1
{
B1() { cout << "Construct B1" << endl; }
~B1() { cout << "Destruct B1" << endl; }
};
struct B2
{
B2() { cout << "Construct B2" << endl; }
~B2() { cout << "Destruct B2" << endl; }
};
struct D : public B2, public B1
{
D( ) : B2( ), B1( ) { cout << "Construct D" << endl; }
~D( ) { cout << "Destruct D" << endl; }
private:
B2 b2;
B1 b1;
};
void main( )
{
D d;
}
六、在如下定义和实现的两个类A 和类B中，各自存在着指向对方对象的指针成员。且在运行时刻，对于任意Male类对象m,若m.m.pWife的值不空，则有m.pWife->getHusband( )==&m；同时，对任何Felmale类对象f，若f.pHusband的值不空，有f.pHusband->getWife( ) == &f。这种情况称为双向依赖。现请你在不改变这两个类已有的各成员函数的原型及功能的条件下，重新实现这两个类，使得A和B两个类之间不存在双向依赖。允许增加类，也允许增加方法。（10分）
class Femal;
class Male
{
public:
Female* getWife( ) const {return pWife;}
//其它方法及实现，略。
private:
Female* pWife;
};
class Female
{
public:
Male* getHusband( ) const { return pHusband; } //其它方法及实现，略。
private:
Male* pHusband;
};
七、不使用任何自定义数据类型，设计一个函数，其功能是把一个float型数据分解为它的整数和小数部分。要求：待分解的float型数据是它的一个参数，通过调用该函数，可得到该数据的整数和小数部分。（5分）

八、设有如下定义的几个类，其中，Graphic是个抽象类，它定义了平面封闭图形应该具有的运算（接口）求面积getArea，它可以有任意多子类，如代码段中的Circle和Rectangle便是它的两个子类。GraphicContainer是一个与Graphic相关的类，该类有两个数据成员，其中：m_buffer是个数组，m_sum用来表示该数组中实际存放元素的个数。现在要求你完成该类的拷贝构造函数GraphicContainer(const GraphicContainer& )的实现代码。为了完成该函数，允许你在其它相关类中增加方法及其实现。（10分）

class Point
{public:float getX( ) const { return m_x;}
float getY( ) const { return m_y;}
private:float m_x; float m_y; //横纵坐标
};

class Graphic
{public:virtual float getArea( ) const = 0; //求面积
//其它成员定义，略。
};

Class Circle: public Graphic
{ public:float getArea( ) const {//实现略}
//其它成员定义，略。
private:float m_radius;//半径
Point m_centrePoint;//圆心
};

class Rectangle : pubic Graphic
{public:float getArea( ) const { //实现略}
//其它成员定义，略。
private:Point m_upLeftPoint;//左上点
Point m_bottomRightPoint;//右下点
};


class GraphicContainer
{public:GraphicContainer( ) {m_sum =0; }
GraphicContainer(const GraphicContainer& );
//其它方法的函数原型。
private: Graphic * m_buffer[100];
int m_sum; //m_buffer中存放有效数据的个数。
};

九、从列表构造相应二叉树。这里的列表是一个三元组：其第一项是字符；后两项既可以是字符又可以是列表。如：
q：(1,2,3)
p：(A,(1,(B,A,4),C),(4,3,1))
就是两个列表。每个列表按如下规则确定相应的树：
a)每个列表对应一棵树；
b)树根结点数据为列表第一项的字符；
c)树的左子树是三元组的第二项，右子树是第三项；
d)单个字符是树的叶结点
列表放在一个字符数组text中。本题要求编函数，函数的一个参数是该字符数组，该函数返回指向所建树形的跟节点的指针。(10分)

[shrinerain]

算法是程序的灵魂，又不是在学校里考试
--------------------------------------

对于算法,我自己还是没有问题的...
.Net板块我的id你可能见过...

---------------------------------------

因为平时很少用C/C++,对于面试新人我不好把握...
要说面UNIX/C#/Java等肯定没有任何问题...

当然"过于基础"的题我都知道,林锐的"高质量C/C++编程"这种书上一大把...
"语法题"之类的也不需要,能到面试的人不会连语法都搞不懂...

举个例子,比如"虚函数内部怎么实现的"之类的问题,能够判断一个人基础只是扎实程度,而不是只会用虚函数而已...

毕竟这是C/C++版...所以想请教一下这方面好的问题...

[王集鹄]

:) 我现在在C\C++专家分是99，今天混1分成两个裤衩就发车 //正在拉火车

面试题得结合你们的业务需要注重什么技术来出

[thinkinnight]

写个程序，让他解释一下由生到死的过程好了。
或者，位操作？

[Jofee]

你就考考他对多态的理解，对模板的理解，
对重载的理解。
如果都答的差不多，
就再问一下他编译器是怎么实现这些特性的。

[thinkinnight]

ls说的那些，我估计组织不起来表达明确的描述

[x360995630]

公司招聘最常考的 :
1、冒泡排序；
2、树的基本概念相关；
3、操作系统相关知识；
4、网络相关知识； 但是都不是好难你只要知道最基本的旧一切OK了；

[pass86]

JF

[shrinerain]

:) 我现在在C\C++专家分是99，今天混1分成两个裤衩就发车 //正在拉火车

面试题得结合你们的业务需要注重什么技术来出
-------------------------------------------------

似乎你什么版都混...而且很热心...

呵呵,我不行了...不太有闲心再去回答技术问题...除非很有趣的~~

[yuanchengjun]

一
1，类名class 或 名字空间(namespace)。
2，sizeof(A)
3，整个程序最开始的时候。
4，private只能类自己访问，protected子类也可以访问。
5，有纯虚函数，即由定义没有实现的函数。
6，不知道。
7，new会调用构造函数。
8，namespace
9，private私有的，static当前类拥有的，
10，static，当前类的东西；no static，对象的东西；对象不存在的时候，类已经存在了。

二，
1，错，允许的。
2，错，可以有，也可以没有。
3，对
4，错，静态数据就一份。
5，错，可以没有。
6，错，析构函数可以的。
7，对。
8，对。但是可以通过p修改p所指内容。
9，错。利用虚函数。
10，对。

三，
class abc
{
private:
abc(){}
}

四，
The courrent number of the timers is:4
The current Time is: 0:0:0
The current Time is: 0:0:0
The current Time is: 9:21:32
The current Time is: 0:53:0
The current Time is: 12:32:32

五，
Construct B2
Construct B1
Construct B2
Construct B1
Construct D
Destruct D
Destruct B1
Destruct B2
Destruct B1
Destruct B2

六，
friend用友元？不知道。

七，
void f(float src, float *a, int *b)
{
*b = (int)src;
*a = src - *b;
}

八，

class Point
{
public:
float getX() const
{
return m_x;
}

float getY() const
{
return m_y;
}

private:
float m_x;
float m_y;
};

class Graphic
{
public:
virtual float getArea( ) const = 0;

//from java
virtual Graphic * Clone() = 0;
};


class Circle : public Graphic
{
public:
float getArea() const {}

virtual Graphic * Clone()
{
Circle * circle = new Circle;

//这里程序是逐个类成员复制的...
*circle = *this;

return circle;
}

private:
float m_radius;
Point m_centrePoint;
};

class Rectangle : public Graphic
{
public:
float getArea() const {}


virtual Graphic * Clone()
{
Rectangle * ra = new Rectangle;

//这里程序是逐个类成员复制的...
*ra = *this;

return ra;
}

private:
Point m_upLeftPoint;
Point m_bottomRightPoint;
};


class GraphicContainer
{
public:
GraphicContainer( ) {m_sum =0; }

//我不喜欢gc的这个const
GraphicContainer(const GraphicContainer& gc)
{
// " *this = gc; "是错误的，应该复制一份m_buffer
m_sum = gc.getSum();

Graphic * pg;
for(int i = 0; i < 100; i ++)
{
pg = gc.getGraphicConst(i);
if (0 != pg)
{
m_buffer[i] = pg->Clone();
}
else
{
m_buffer[i] = 0;
}
}

}

//
int getSum() const
{
return m_sum;
}

//
Graphic * getGraphicConst(int idx) const
{
if ((idx > 99) || (idx < 0))
return 0;

return m_buffer[idx];
}

private:
Graphic * m_buffer[100];
int m_sum;
};

最后一题，二叉树，字符处理还是有一点点麻烦的，大致如下：
class node
{
private:
node * _left;
node * _right;
char _value;

//这里会递归的，
node * load(const char * str)
{
_value = ...

_left->load ...

_right->load ...

return this;
}
}