03day C++面试题---3

2020-3-23

1.已知int[10] = {0,1,2,3,4,5,6,7,8,9},*p = a;不能表示数组a中元素的式子是 C
A *a
B *p
C a
B a[p-a]
解：
AB：对数组名进行操作时，数组名会退化成常量指针，该指针指向首元素的地址
C ：一个指向十足首元素地址的指针
D ：a[p-a] = a[0]

2.假定a为一个数组，则下面存在错误的表达式是B
A a[i]
B *a++
C *a
D (a+1)
解：
1）++运算符优先级高于
2）数组名啊是常量指针，不能++
（*a）++可以
3.

int main()
{
	int x;
	scanf("%d",&x);//5
	if(x--<5)//条件不成立，调到else中，然后x-- 即x = 4
		printf("%d",x);
	else
		printf("%d",x++);//x输出，然后x++
	return 0;
}

程序运行后，如果从键盘上输入5，则输出结果是 4

4.表达式0x17&013的值是0x13
0x13: 0 0 0 1 0 0 1 1
0x17: 0 0 0 1 0 1 1 1
结果：0 0 0 1 0 0 1 1 0x13
5.以下代码运行结果为 [1 3 5]

func = lambda x :x % 2;
result = filter(func,[1,2,3,4,5]);
printf(list(result));

解：
filter函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的列表
lambda x:x%2
是一个取余过程，依次取1-5数通过filter进行啊判断1为真保留，0为假舍弃

2020-3-24

1.C语言字符以\0结束，\0在内存中的表示为B
A \0由\和0两个字符组成
B 在内存中实际表示为0
C ASCII码表示为0X2A
D \0不同的操作系统表示方法不一样，依赖实现
解：
1）’\0’就是8位的00000000，因为字符类型中并没有对应的这个字符，所以这么写
2）’\0’字符串是结束标志
3）’\0’是转译字符，告诉编译器，这不是字符，而是空字符
2.以下多线程对int型变量x的操作，哪个不需要进行同步 D
A ++x
B x=y
C x++
D x=1
解：1）同步：害怕在操作过程的时候被其他线程也进行读取操作，一旦是原子性的操作就不会发生这种情况
2）原子性操作：一步到位的操作（个人理解），其他线程不可能哎在中间干涉。
3.执行printf("%5s",“abcdefg”)后，输出abcdefg
解：
1）%.5s:字符串中最多输出5个字符
2）%5s：输出至少4个字符
4.关于struct和class下列说法正确的是B
A struct的成员默认是public，class的成员默认是private
B struct不能继承，class可以继承
C struct可以有无参构造函数
D struct 的成员变量只能是public
解：
1）在C语言中结构体是不能继承的，但在C++中是可以的
2）结构体的访问权限也有public、protected、private三种，结构体默认为public
3）类中默认是private
5.关于stl的说法正确的是AC
A map的迭代器的key是const类型，无法对其进行修改
B stl的排序算法，一般比传统分快速排序快的原因是因为选取中值的算法好
C list是双链表实现，插入元素的复杂度是O(1)
D vector的大小会增大或减小，但容量只会增大不会减小
解：
1）std：：sort先采用快排，若递归深度过大，则转用堆排，与选取中值无关
2）std：：vector可以调用shrink_to_fit()归还多余空间

2020-3-25

1.执行如下代码后输出结果为 2,5

int main()
{
	int a[5]={1,2,3,4,5};
	int *ptr=(int*)(&a+1);
	printf("%d,%d",*(a+1),*(ptr-1));
}

解：&a的类型是一个指向大小为5的int型数组的指针
2.

class A
{
public:
	virtual void f(){cout<<"A::f()";}
	void ()const{cout<<"A::f()const";}
};
class B:public A
{
public:
	void f(){cout<<"B::f()";}
	void f()const{cout<<"B::f()const";}
};
void g(const A * a){a->f();}

int main()
{
	A *p = new B();
	p->f();
	g(p);
	delete(p);
	return 0;
}

输出结果为B::f（）A::f()const
解：
1）由于分（）在基类中声明为虚的，则p->f（）根据对象类型（B）调用B::f()，此时编译器对虚方法使用动态联编，输出B：：f（）
2）由于f()const在基类中未声明为虚的，所以p->f（）const根据指针类型（A）调用A::f()const，此时编译器对非虚方法使用静态联编输出A::f()const
3.

#include"stdio.h"
class Base
{
public:
	Base(){Init();}
	virtual void Init(){printf("Base Init\n");}
	void func(){printf("Base func\n");}
};
class Derived:public Base
{
public:
	virtual void Init(){printf("Derived Init\n");}
	void func(){printf("Derived func\n");}
};
int main()
{
	Derived d;
	((Base*)&d)->func();
	return 0;
}

输出结果为 Derived Init Base func
理由同上
解：
构造函数不要用虚函数。基类构造函数的时候，虚函数是非虚函数，不会走到派生类中。即采用静态绑定