1.实现双向链表删除一个节点P,在节点P后插入一个节点,写出这两个函数;
答:
//假设线性表的双向链表存储结构
typedef struct DulNode{
struct DulNode *prior; //前驱指针
ElemType data; //数据
struct DulNode *next; //后继指针
}DulNode,*DuLinkList;
//删除操作
Status ListDelete_DuL(DuLinkList &L,int i,ElemType &e)
{
if(!(p=GetElemP_DuL(L,i))) //此处得到i位置的节点指针,如果有需要也得写出具体函数实现
return ERROR;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->pror;
free(p);
return OK;
}
//插入操作
Status ListInsert_DuL(DuLinkList &L,int i,ElemType &e)
{
if(!(p=GetElemP_DuL(L,i)))
return ERROR;
if(!(s=(DuLinkList)malloc(sizeof(DuLNode))))
return ERROR;
s->data=e;
s->prior=p->prior;
p->prior->next=s;
s->next=p;
p->prior=s;
return OK;
}
2.写一个函数,将其中的t都转换成4个空格。
答:
该函数命名为convert,参数的意义为:
*strDest目的字符串,*strSrc源字符串,length源字符串的长度
函数实现为:
char* convert(char *strDest, const char *strSrc,int length)
{
char * cp = strDest;
int i=0;
while(*strSrc && i{
if (*strSrc==’t’) //将t转换成4个空格
{
for(int j=0;j<4;j++)
*cp++=' ';
}
else //否则直接拷贝
*cp++=*strSrc;
strSrc++;
i++;
}
return strDest;
}
3.Windows程序的入口是哪里?写出Windows消息机制的流程。
答:
Windows程序的入口是WinMain函数
消息机制:系统将会维护一个或多个消息队列,所有产生的消息都会被放入或是插入队列中。系统会在队列中取出每一条消息,根据消息的接收句柄而将该消息发送给拥有该窗口的程序的消息循环。每一个运行的程序都有自己的消息循环,在循环中得到属于自己的消息并根据接收窗口的句柄调用相应的窗口过程。而在没有消息时消息循环就将控制权交给系统。
4.如何定义和实现一个类的成员函数为回调函数?
答:
所谓的回调函数,就是预先在系统的对函数进行注册,让系统知道这个函数的存在,以后,当某个事件发生时,再调用这个函数对事件进行响应。
定义一个类的成员函数时在该函数前加CALLBACK即将其定义为回调函数,函数的实现和普通成员函数没有区别
5.C++里面是不是所有的动作都是main()引起的?如果不是,请举例。
答:不是,比如中断引起的中断处理不是直接由main()引起的,而是由外部事件引起的。
6.C++里面如何声明const void f(void)函数为C程序中的库函数?
答:在该函数前添加extern “C”声明
7.下列哪两个是等同的
int b;
A const int* a = &b
B const* int a = &b
C const int* const a = &b
D int const* const a = &b
答:
各式表示的意思分别为:
A const int* a = &b //*a是const,但指针a可变
B const* int a = &b //a是const,但*a可变
C const int* const a = &b //a和*a都是const,常量和指针的值都不能改变
D int const* const a = &b //a和*a都是const,常量和指针的值都不能改变
因此C,D两者是相同的。
总结个技巧:如果const位于星号的左侧,则const就是用来修饰指针所指向的变量,即指针指向为常量;如果const位于星号的右侧,const就是修饰指针本身,即指针本身是常量。
8. 内联函数在编译时是否做参数类型检查?
答:做类型检查,因为内联函数就是在程序编译时,编译器将程序中出现的内联函数的调用表达式用内联函数的函数体来代替
1. C++中如何阻止一个类被实例化?
纯虚函数;构造函数私有化(友元)
2. 一般在什么时候构造函数被声明成private呢?
singleton模式; 阻止某些操作(如阻止拷贝构造)
3. 什么时候编译器会生成默认的copy constructor呢?
用户没有自定义copy constructor;在代码中使用到了copy constructor;
4. 如果你已经写了一个构造函数,编译器还会生成copy constructor吗?
5. struct和class有什么区别?
答:默认的访问级别不同,struct是public,class是private
6. 没有别的不同了吗?
7. 为什么说如果一个类作为基类,则它的析构函数要声明成virtual的?
因为,如果delete一个基类的指针时, 如果它指向的是一个子类的对象,那么析构函数不为虚就会导致无法调用子类析构函数,从而导致资源泄露。 当然,另一种做法是将基类析构函数设为protected.
8. inline的函数和#define有什么区别?
1) 宏是在预编译阶段简单文本替代, inline在编译阶段实现展开
2)宏肯定会被替代,而复杂的inline函数不会被展开
3)宏容易出错(运算顺序),且难以被调试,inline不会
4)宏不是类型安全,而inline是类型安全的,会提供参数与返回值的类型检查
当出现以下情况时inline失败
9. inline是什么意思?
10. 那你说说什么时候会真的被inline,什么时候不会呢?
当出现以下情况时inline失败:函数size太大;inline虚函数函数中存在循环或递归函数;调用其他inline函数
11. 如果把一个类的成员函数写在类的声明中是什么意思?
inline此函数 (inline与template类似, 必须在.h中实现)
12. public继承和private继承有什么架构上的区别?
public是is-a的关系,继承接口与实现;private是has-a的关系 ,只继承实现
13. 在多继承的时候,如果一个类继承同时继承自class A和class B,而class A和
B中都有一个函数叫foo(),如何明确的在子类中指出override哪个父类的foo()?
14. 虚拟继承的语法是什么?
A
/
B C
/
D
class A{};
class B: virtual public A{};
class C: virtual public A{};
class D: public B, public C{};
.
找错
试题1:
Code
Void test1()
{
char string[10];
char* str1="0123456789";
strcpy(string, str1);
}
试题2:
Code
Void test2()
{
char string[10], str1[10];
for(I=0; I<10;I++)
{
str1[i] ='a';
}
strcpy(string, str1);
}
试题3:
Code
Void test3(char* str1)
{
char string[10];
if(strlen(str1) <= 10)
{
strcpy(string, str1);
}
}
解答:
test1: 字符串str1需要11个字节才能存放下(包括末尾的' '),而string只有10个字节的空间,strcpy会导致数组越界
test2: 如果面试者指出字符数组str1不能在数组内结束可以给3分;如果面试者指出strcpy(string, str1)调用使得从str1内存起复制到string内存起所复制的字节数具有不确定性可以给7分,在此基础上指出库函数strcpy工作方式的给10分
test3: if(strlen(str1) <= 10)应改为if(strlen(str1) < 10),因为strlen的结果未统计' '所占用的1个字节
剖析:
考查对基本功的掌握:
(1)字符串以' '结尾;
(2)对数组越界把握的敏感度;
(3)库函数strcpy的工作方式,如果编写一个标准strcpy函数的总分值为10,下面给出几个不同得分的答案:
2分
void strcpy( char *strDest, char *strSrc )
{
while( (*strDest++ = * strSrc++) != ' ' );
}
4分
void strcpy( char *strDest, const char *strSrc )
//将源字符串加const,表明其为输入参数,加2分
{
while( (*strDest++ = * strSrc++) != ' ' );
}
7分
void strcpy(char *strDest, const char *strSrc)
{
//对源地址和目的地址加非0断言,加3分
assert( (strDest != NULL) && (strSrc != NULL) );
while( (*strDest++ = * strSrc++) != ' ' );
}
10分
//为了实现链式操作,将目的地址返回,加3分!
Code
char * strcpy( char *strDest, const char *strSrc )
{
assert( (strDest != NULL) && (strSrc != NULL) );
char *address = strDest;
while( (*strDest++ = * strSrc++) != ' ' );
return address;
}
从2分到10分的几个答案我们可以清楚的看到,小小的strcpy竟然暗藏着这么多玄机,真不是盖的!需要多么扎实的基本功才能写一个完美的strcpy啊!
(4)对strlen的掌握,它没有包括字符串末尾的' '。
读者看了不同分值的strcpy版本,应该也可以写出一个10分的strlen函数了,完美的版本为:
Code
int strlen( const char *str ) //输入参数const
{
assert( strt != NULL ); //断言字符串地址非0
int len;
while( (*str++) != ' ' )
{
len++;
}
return len;
}
试题4:
Code
void GetMemory( char *p )
{
p = (char *) malloc( 100 );
}
void Test( void )
{
char *str = NULL;
GetMemory( str );
strcpy( str, "hello world" );
printf( str );
}
试题5:
Code
char *GetMemory( void )
{
char p[] = "hello world";
return p;
}
void Test( void )
{
char *str = NULL;
str = GetMemory();
printf( str );
}
试题6:
Code
void GetMemory( char **p, int num )
{
*p = (char *) malloc( num );
}
void Test( void )
{
char *str = NULL;
GetMemory( &str, 100 );
strcpy( str, "hello" );
printf( str );
}
试题7:
Code
void Test( 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; 的p[]数组为函数内的局部自动变量,在函数返回后,内存已经被释放。这是许多程序员常犯的错误,其根源在于不理解变量的生存期。
试题6的GetMemory避免了试题4的问题,传入GetMemory的参数为字符串指针的指针,但是在GetMemory中执行申请内存及赋值语句
*p = (char *) malloc( num );后未判断内存是否申请成功,应加上:
if ( *p == NULL )
{
...//进行申请内存失败处理
}
试题7存在与试题6同样的问题,在执行char *str = (char *) malloc(100); 后未进行内存是否申请成功的判断;另外,在free(str)后未置str为空,导致可能变成一个“野”指针,应加上:str = NULL; 试题6的Test函数中也未对malloc的内存进行释放。
剖析:
试题4~7考查面试者对内存操作的理解程度,基本功扎实的面试者一般都能正确的回答其中50~60的错误。但是要完全解答正确,却也绝非易事。
对内存操作的考查主要集中在:
(1) 指针的理解;
(2) 变量的生存期及作用范围;
(3) 良好的动态内存申请和释放习惯。
再看看下面的一段程序有什么错误:
Code
swap( int* p1,int* p2 )
{
int *p;
*p = *p1;
*p1 = *p2;
*p2 = *p;
}
在swap函数中,p是一个“野”指针,有可能指向系统区,导致程序运行的崩溃。在VC++中DEBUG运行时提示错误“Access Violation”。
野指针,也就是指向不可用内存区域的指针。通常对这种指针进行操作的话,将会使程序发生不可预知的错误。
“野指针”不是NULL指针,是指向“垃圾”内存的指针。人们一般不会错用NULL指针,因为用if语句很容易判断。但是“野指针”是很危险的,if语句对它不起作用。野指针的成因主要有两种:
一、指针变量没有被初始化。任何指针变量刚被创建时不会自动成为NULL指针,它的缺省值是随机的,它会乱指一气。所以,指针变量在创建的同时应当被初始化,要么将指针设置为NULL,要么让它指向合法的内存。
二、指针p被free或者delete之后,没有置为NULL,让人误以为p是个合法的指针。别看free和delete的名字恶狠狠的(尤其是delete),它们只是把指针所指的内存给释放掉,但并没有把指针本身干掉。通常会用语句if (p != NULL)进行防错处理。很遗憾,此时if语句起不到防错作用,因为即便p不是NULL指针,它也不指向合法的内存块。例:
char *p = (char *) malloc(100);
strcpy(p, “hello”);
free(p); // p 所指的内存被释放,但是p所指的地址仍然不变
if(p != NULL) // 没有起到防错作用
strcpy(p, “world”); // 出错
另外一个要注意的问题:不要返回指向栈内存的指针或引用,因为栈内存在函数结束时会被释放。
该程序应该改为:
Code
swap( int* p1,int* p2 )
{
int p;
p = *p1;
*p1 = *p2;
*p2 = p;
}
3. 内功题
试题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:以下为Windows NT下的32位C++程序,请计算sizeof的值
void Func ( char str[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会作三次++自增操作。除此之外,另一个应该判0分的解答是:#define MIN(A,B) ((A) <= (B) ? (A) : (B));
这个解答在宏定义的后面加“;”,显示编写者对宏的概念模糊不清,只能被无情地判0分并被面试官淘汰。
宏的一些副作用
1、优先级问题
1) 传入变量优先级
#define MULTI(a,b) a * b
MULTI(1+2,3) => 1 + 2 * 3 其实是想要(1 + 2) * 3
2) 作为值返回时,类似1)
#define ADD(a,b) (a) + (b)
int c = ADD(a,b) * 3; => (a) + (b) * 3 其实是想要(a + b) * 3
所以,一般的规则是:宏里面参数全部用括号括起来;如果作为值返回,整个表达式也用括号括起来。
所以,上面最好这么写:
#define MULTI(a,b) ((a) * (b))
#define ADD(a,b) ((a) + (b))
2、实际使用参数和宏内部变量同名
#define HASH(str,sz,rst) do{unsigned int n = 0; n = xxx; rst = n % sz;}while(0)
这是一个hash的宏实现,其中定义了一个临时变量n,根据str计算n,然后对sz求模并把返回值赋给传进来的rst.
这么调用:
int n;
HASH(“hello”,7,n);
不会达到改变n的效果,因为实际使用参数n和宏内部的变量n同名。宏扩展中最后一条语句是:n = n % sz;因为宏内部n有更小作 用域,实际赋值的是宏内部的那个临时变量n。外面调用的n不会有任何改变。
这个副作用有些隐蔽,一般的规则是:宏内部变量使用一种不同风格的命名方式。
比如:
#define HASH(str,sz,rst) do{unsigned int __n = 0; __n = …
3、++,–
#define MAX(a,b) ((a) > (b) ? (a) : (b))
int a = 3,b = 2;
int c = MAX(a++,b);
执行看看,不但a的值不是和想要的一致,返回值c也会让你大吃一惊,哈哈。(a = 5,c = 4)
在宏内部一个变量”执行”多少次,它就自增或自减了多少次。
所以一般使用宏最好不要传入自增自减。如果你一定要在宏里消除这个副作用,可以这样:
#define MAX(a,b) ({int __x = (a), __y = (b);(__x > __y) ? __x : __y;})
也就是:保证传入宏的参数在内部只使用一次。(注意:传入a++或++a都能得到各自正确的效果)
这里的内部变量__x,__y是不需要用括号包起来的,原因可以自己想想。
另外对宏中括号的使用补充说明两点:
因为宏中定义了临时变量,所以要用{}括起来;
因为要返回值,所以外面还要用()括起来({}不返回值);
另外,这里还有一个问题:实际中a,b不一定是int的,这个宏中的临时变量声明为int,不通用。
改进:
#define MAX(a,b,type) ({type __x = (a), __y = (b);(__x > __y) ? __x : __y;})
使用:
MAX(1,2,int); MAX(1.1,1.2,double);
是不是感觉怪怪的,有点c++的感觉~~ 这样的使用太复杂了,而且也会给代码的阅读带来难度。
我觉得好的态度是多了解些宏的可能的副作用,在实际编码中遵守第1、2条规则,不要往宏中传入自增自减的东西,就够了。不要把过多的复杂度全扔给宏,”通用”也不能盲目,因为毕竟:yy是没有极限的。
试题4:为什么标准头文件都有类似以下的结构?
Code
#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”如果n=2,移位后应该是“hiabcdefgh”
函数头是这样的:
//pStr是指向以’