C++面试笔试经典题集

(1)

char str[]="hello";
printf("%d\n",sizeof(str));

解析：答案是6，包含一个结束符 '\0'。

(2)下面哪种情况下B不能隐式转换为A?

A: class B:public A{}
B: class A:public B{}
C: class B{operator A();}
D: class A{A(const B&);}

解析：答案B。A中A表示基类，B是派生类，向上级类型转换是隐式的（也就是父类指针可以指向子类），因为部分元素丢弃可以自动完成，向下转型是显示的因为不知道应该增加的值是什么，所以B不能。

C中 operator除了表示函数重载操作符，还可以表示B类型可以转换为A类型。D拷贝函数，这个肯定是可以的。

//父类指针指向子类
#include <iostream>
using namespace std;
class A
{
public:
int x;
int y;
A(int x,int y)
{
this->x=x;
this->y=y;
}
};
class B:public A
{
public:
int m;
int n;
B(int x,int y,int m,int n):A(x,y)
{
A(x,y);
this->m=m;
this->n=n;
}
};
int main()
{
A *a;
B b(1,2,3,4);
a=&b;
printf("%d %d\n",a->x,a->y);

/*
B *pb;
A pa(5,6);
pb=&a;
*/
return 0;
}

(3)有三个类A B C定义如下, 请确定sizeof(A)
sizeof(B) sizeof(C)的大小顺序.

struct A{
A() {}
~A() {}
int m1;
int m2;
};
struct B:A{
B() {}
~B() {}
int m1;
char m2;
static char m3;
};
struct C{
C() {}
virtual~C() {}
int m1;
short m2;
};

A: A=B=C
B: A<B<C
C: A=C<B
D: A<C<B

解析：答案是D（32位机+32系统）。

首先结构体A的大小为8，很容易求出；

结构体B继承A，则B的起始存储大小从第8个字节开始，static对结构体本身大小没有影响，另外根据结构体的规则可知，其大小为最大对齐数（4）的倍数。（本来算得13）所以为16；

结构体C中有个虚函数，所以包含虚函数指针，占4个字节，（本来算得大小为10，其大小为最大对齐数（4）的倍数），所以其大小为12。

如果是64位机+64位系统答案则是 A<C=B，这种情况在C中的虚表指针是8个字节，这样C字节数是：8+4+2=14，最后在字节对齐就是16字节。

下面进行详细分析：

#include <stdio.h>
struct A
{
A(){m1=10,m2=10;};
~A(){};
int m1;
int m2;
};
struct B:A
{
B()
{
m1=10;
m2=10;

};
~B(){};
int m1;
char m2;
static char m3;
};
struct C
{
C(){m1=10,m2=10;};
virtual ~C(){};
int m1;
short m2;
};
char B::m3=10;

int main()
{
A a;
B b;
C c;
// printf("%d\n",b.A::m1);
printf("%d %d %d\n",sizeof(A),sizeof(B),sizeof(C));
}

在win32下，用vc6.0调试：



可以看到，从地址0X0018ff24开始，连续存放了b.A::m1,b.A::m2,b.m1,b.m2，内存区域中的十六进制CC,是vc6.0默认的初始化，为了对齐添加了3个字节的默认数据0xCC，这个我们可以从反汇代码中看出来：



那么问题来了，m3去哪里了呢，这个我们后面再看。



这是a地址信息，可以看到b结束后紧挨着就是a的数据。

下面看看c的内存结构：



在我们自定义数据的开始前，我们看到了传说中的虚表指针占4个字节。

最后我们再来看看B中的m3，在程序中我们定义了一个全局变量m,我们先来看看m的存储区域：



m的地址在全局区域，很明显和我们的a,b,c地址不一样。
我们再看看B中的m3的信息：



哎呀，m3和m挨着的呀，思考一下我们得出了一个结论：静态数据放在全局变量区的。

在Mac（64位）看虚表指针大小：



刚好8字节。

(4)以下代码的输出结果是?

#define a 10

void foo();
main(){

printf("%d..",a);
foo();
printf("%d",a);
}
void foo(){
#undef a
#define a 50
}

解析：选A，define在预处理阶段就把main中的a全部替换为10了. 另外，不管是在某个函数内，还是在函数外，define都是从定义开始知道文件结尾，所以如果把foo函数放到main上面的话，则结果会是50 ，50

(5)以下说法正确的是？

在多线程中不加限制的随意访问非static局部变量可能会导致运算结果出错

在多线程中不加限制的随意访问非static全局变量可能会导致运算结果出错

在多线程中不加限制的随意访问static局部变量可能会导致运算结果出错

在多线程中不加限制的随意访问static全局变量可能会导致运算结果出错

解析：选BD
无论是static还是非static的全局变量，如果不加限制随意访问的话易出现同步问题。

非static的局部变量，每个线程都是私有的，其他线程不会对其进行干扰.

对于静态局部变量，我字节测试了一下，发觉其它线程会对其进行干扰。所以觉得C也是对的。

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
struct A
{
A(){m1=10,m2=10;};
~A(){};
int m1;
int m2;
};
struct B:A
{
B()
{
m1=10;
m2=10;

};
~B(){};
int m1;
char m2;
static char m3;
};
struct C
{
C(){m1=10,m2=10;};
virtual ~C(){};
int m1;
short m2;
};
char B::m3=10;

void *fun(void *arg)
{
static int cnt=0;
cnt++;
printf("cnt 地址:%d\n",&cnt);
printf("cnt:%d\n",cnt);

return NULL;
}
int m;
int main()
{
printf("全局变量m地址:%d\n",&m);
pthread_t pid1,pid2;
pthread_create(&pid1, NULL, fun, NULL);
pthread_create(&pid2, NULL, fun, NULL);
sleep(10);
pthread_join(pid1, NULL);
pthread_join(pid2, NULL);
}

结果：



(6)函数作用：将整型数组p中n个数据增大

void increment_ints (int p [ ], int n)
{
assert(p != NULL);  /* 确保p不为空指针 */
assert(n >= 0);  /* 确保n不为负数 */
while (n)  /* 循环n次. */
{
*p++;          /* 增大p*/
p++, n--;      /* p指向下一位，n减1 */
}
}

A:*p++使得p在解引用之前增大，因为*和++两个运算符有相同的优先级并按自右向左的方式结合。

B: 数组的值是一个不能改变的值，所以p不能直接被修改。应该使用一个和p相关联的指针来完成这个操作。

C: *p++使得p在解引用之前增大，因为自增运算符的优先级比取址运算符优先级高。

D: while循环的条件必须是一个布尔类型的表达式，表达式应该为n!=0.

E: An array cannot be initialized to a variable size. The subscript n should be removed from the definition of the parameter p.

解析：选择C.

(7)下列代码的输出为：

class CParent
{
public: virtual void Intro()
{
printf( "I'm a Parent, " ); Hobby();
}
virtual void Hobby()
{
printf( "I like football!" );
}
};
class CChild : public CParent {
public: virtual void Intro()
{
printf( "I'm a Child, " ); Hobby();
}
virtual void Hobby()
{
printf( "I like basketball!\n" );
}
};
int main( void )
{
CChild *pChild = new CChild();
CParent *pParent = (CParent *) pChild;
pParent->Intro();
return(0);
}

A:I'm a Parent， I like football!

B: I'm a Parent， I like basketball!

C: I'm a Child， I like basketball!

D: I'm a Child， I like football!

解析：选择C,程序中是涉及到虚函数的调用，在基类pParent中加了Virtual关键字的函数就是虚拟函数，于是在pParent的派生类CChild中就可以通过重写虚拟函数来实现对基类虚拟函数的覆盖。当基类pParent的指针pParent指向派生类CChild的对象pChild时，对pChild的Intro()函数的调用实际上是调用了CChild的Intro()函数而不是pParent的Intro()函数。这是面向对象中的多态性的体现

(8)以下程序的输出是

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
class Base {
public:
Base(int j): i(j)  {}
virtual~Base() {}
void func1() {
i *= 10;
func2();
}
int getValue() {
return  i;
}
protected:
virtual void func2() {
i++;
}
protected:
int i;
};
class Child: public Base {
public:
Child(int j): Base(j) {}
void func1() {
i *= 100;
func2();
}
protected:
void func2() {
i += 2;
}
};
int main()
{
Base * pb = new Child(1);
pb->func1();
cout << pb->getValue() << endl; delete pb;
}

A: 11

B: 101

C: 12

D： 102

解析：选择C,用基类的指针指向不同的派生类的对象时， 基类指针调用其虚成员函数，则会调用其真正指向对象的成员函数， 而不是基类中定义的成员函数（只要派生类改写了该成员函数）。 若不是虚函数，则不管基类指针指向的哪个派生类对象，调用时都 会调用基类中定义的那个函数。

(9)阅读下面代码，程序会打印出来的值是？

#include <stdio.h>
void f(char**p)
{
*p +=2;
}
int main()
{
char *a[] = {"123","abc","456"},**p;
p = a;
f(p);
printf("%s\r\n",*p);
}

解析：程序会输出3，数组a是一个指针数组，指针p是二级指针，指向指针的一个指针，p=a,让指针p指向了数组a,即指针p里面存的是数组a地址，也即是a[0](指针)的地址，进入f函数后，构建了一个指针副本和指针p完全一致，*p为a数组中的第一个成员的值（也就是指针a[0]的值，指针a[0]的值是字符串“123”的地址），原本指针a[0]保存的是字符串"123"的地址，*p+=2过后，让a[0]指向了"3"，*p指向的是a[0]，所以最后*p指向的是字符串“3”.

下面是我改过后的代码可以参考一下：

#include <stdio.h>
void f(char**p)
{
*p +=2;
printf("f函数内:%s\n",*p);
}

void f2(char *p)
{
p+=2;
printf("f2函数内:%s\n",p);
}
int main()
{
char *a[] = {"123","abc","456"},**p;
p = a;
char *pp=*p;
printf("%s\n",pp);
f2(*p);
printf("f2函数外:%s\n",a[0]);
f(p);
printf("%s\r\n",*p);
printf("f函数外:%s\n",a[0]);
}

结果：



如果不清楚函数参数副本的可以看一下下面的博客：

C语言指针初探 一 指针与函数

(10)下述程序的输出是______。

#include<stdio.h>

int main()
{
static char *s[] = {"black", "white", "pink", "violet"};
char **ptr[] = {s+3, s+2, s+1, s}, ***p;
p = ptr;
++p;
printf("%s", **p+1);
return 0;
}

解析：输出结果是ink,分析方式和上一题一样的，ptr是一个二级指针数组，分别指向s[3],s[2]，s[1],s[0]，指针p是一个指向二级指针的三级指针，p=ptr.p存的是ptr的地址，,++p过后指向了下一个指针（也就是ptr[1]），此时p的地址是ptr[1]的地址，*p为ptr[1]的值，也就是s[2]的地址,**p指向了字符串s[2].

修改代码如下：

#include<stdio.h>

int main()
{
static char *s[] = {"black", "white", "pink", "violet"};
char **ptr[] = {s+3, s+2, s+1, s}, ***p;
p = ptr;
printf("%0x %0x\n",&ptr[0],p);
printf("%0x %0x\n",ptr[0],&s[3]);
++p;
printf("%0x %0x\n",&ptr[1],p);
printf("%s", **p+1);
return 0;
}

结果：



仔细分析一下很容易就明白的。

(11)当一个类A 中没有声明任何成员变量与成员函数,这时sizeof(A)的值是多少？

解析：空类的长度为1字节，如果对象完全不占用内存空间，那么空类就无法取得实例对象的地址，this指针失效，因此不能被实例化，而类的定义是由成员数据和成员函数组成，在没有成员数据的情况下，还可以有成员函数，因此任然需要实例化，分配了1字节的空间用于类的实例化，这1字节的数据并没有被使用。

(12) 在64位系统下，分别定义如下两个变量：char *p[10]; char(*p1)[10];请问，sizeof(p)和sizeof (p1)分别值为____。
解析：分别为 80，8 ，p是指针数组，含有10个指针元素，p1只是一个指向数组的指针而已。

(13)设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？

C c;
void main()
{
A*pa=new A();
B b;
static D d;
delete pa;
}

解析：A B D C

这道题主要考察的知识点是 ：全局变量，静态局部变量，局部变量空间的堆分配和栈分配。

其中全局变量和静态局部变量是从 静态存储区中划分的空间，二者的区别在于作用域的不同，而之所以是先释放 D 在释放 C的原因是， 程序中首先调用的是 C的构造函数，然后调用的是 D 的构造函数，析构函数的调用与构造函数的调用顺序刚好相反。

局部变量A 是通过 new 从系统的堆空间中分配的，程序运行结束之后，系统是不会自动回收分配给它的空间的，需要程序员手动调用 delete 来释放。

局部变量 B 对象的空间来自于系统的栈空间，在该方法执行结束就会由系统自动通过调用析构方法将其空间释放。

之所以是 先 A 后 B 是因为，B 是在函数执行到 结尾 "}" 的时候才调用析构函数， 而语句 delete a ; 位于函数结尾 "}" 之前。

(14)若char是一字节，int是4字节，指针类型是4字节，代码如下：

class CTest
{
public:
CTest():m_chData(‘\0’),m_nData(0)
{
}
virtual void mem_fun(){}
private:
char m_chData;
int m_nData;
static char s_chData;
};
char CTest::s_chData=’\0’;

问：

（1）若按4字节对齐sizeof(CTest)的值是多少？

（2）若按1字节对齐sizeof(CTest)的值是多少？

4字节对齐情况下：
4字节虚表指针（存放位置0-3）,char型数据一字节（存放在位置4）,int型数据因为要数据对齐，所以从位置8开始放（8%4=0），位置5，6，7空着，静态数据存放在全局区。
所以最后结果为：4+1+3+4=12.
1字节对齐情况下：就是4+1+4=9.

解析：12，9

注意：

(1) 先找有没有virtual 有的话就要建立虚函数表，需要虚表指针（32位系统 4字节）

(2) static的成员变量属于类域，不算入对象中

(3) 空类或者只有成员函数 占1字节.
(4)字节对齐

(15)类成员函数的重载、覆盖和隐藏区别描述正确的有？

A:
覆盖是指在同一个类中名字相同，参数不同

B: 重载是指派生类函数覆盖基类函数，函数相同，参数相同，基类函数必须有virtual关键字

C: 派生类函数与基类函数相同，但是参数不同，会"隐藏"父类函数

D: 函数名字相同，参数相同，基类无virtual关键字的派生类的函数会"隐藏"父类函数

解析：C D

一、成员函数被重载的特征：

（1）相同的范围（在同一个类中）；

（2）函数名字相同；

（3）参数不同；

（4）virtual 关键字可有可无。

二、覆盖是指派生类函数覆盖基类函数，特征是：

（1）不同的范围（分别位于派生类与基类）；

（2）函数名字相同；

（3）参数相同；

（4）基类函数必须有virtual 关键字。

三、“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏。

（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏。

待续。。。