02day C++面试题---2

2020-3-20

1.一下程序运行后的输出结果是 0， 0

int main()
{
	int a = 1,b = 2,m = 0,n = 0,k;
	k = (n = b < a)&&(m = a);
	printf("%d,%d\n",k,m);
	return 0;
}

解：1）c语言中，&&和||的逻辑问题，当前面的语句为假时，直接判断为假，不执行后面的语句
2)>的优先级大于赋值运算符=的优先级
2.以下程序输出结果为 9,10

int main()
{
	int i = 010,j = 10;
	printf("%d%d\n",++i,j--);
}

解：1）c语言中以数字1—9开头的表示十进制
以0开头的表示八进制
以0X开头的表示十六进制
2）++a：先自增再自增
a–:先输出再自增
3.k为int类型，以下while循环执行次数 死循环

unsigned inr k = o;
while(k >= 0)
	k--;

解：k是无符号整数，永都>= 0
4.两个同名的成员函数，可以重载的是 B C
A int A::f()和double A::f()
B void A::f(int)和void A::f(short)
C void A::f()和void A::f()const
D void A::f(int)和void A::f(const int)
E const int A::f()和int A::f()
解：函数重载：
（1）不同的返回值不能区分重载函数，只有函数名、形参个数、形参类型可以
（2）const 放在函数后面是指这个成员函数为常成员函数，不修改类里的成员变量，可以起到重载的作用
（3）int 和 const int 都是 int型。
关于const&重载
（1）传值：void fun(int a )和void fun(const int a )：不可重载。
而这实际上没有区别：因为函数调用的时候，存在形实结合
的过程，所以不管有没有const都不会改变实参实际的值
（2）传指针：void fun(const char *s)和void fun(char *s)可以重载：
二者区别：
一个是“指向字符的指针”
一个是“指向const char 的指针”
void fun(char *const a)和void fun(char *s)不可重载
与int类似

2020-3-21

1.以下字符串定义与赋值中，正确的是 D
A char s[80] = {“A”,“B”,“C”}
B char s[80];s = {‘A’,‘B’,‘C’};
C char s[80],s = “ABC”;
D char s[80] = “ABC”;
解：对数组初始化必须在定义的时候，否则不能对数组进行整体赋值，只能对单个元素进行赋值
2.关于静态成员和非静态成员：
（1）静态成员存在于内存中，非静态成员需要实例化彩绘分配内存
（2）静态成员不能访问非静态成员
非静态成员可以访问静态成员
（3）非静态成员分生命周期决定于类的生命周期，而静态成员的生命周期与程序生命周期相同
3. 关于get的几类方法
（1）gets（）：读取字符串，以回车键结束
（2）fgets（）：读取一行字符，以换行符结束
（3）get（）：读取一个字符
（4）fget（）：读取一个字符，读取一个自节后后移一位
4.下面说法那些正确ABC
A const int a;//a是常量
B int const a;//a是常量
C int const *a;//a是常量指针
D const int *a;//a是指针常量
E int const *;//a是指针常量
解：AB写法相同
int const *a const int *a是常量指针
5.

#include<iostream>
#include<vector>
using namespace std;
int main()
{
	vector<int>array;
	array.push_back(100);
	array.push_back(300);
	array.push_back(300);
	array.push_back(300);
	array.push_back(300);
	array.push_back(500);
	vector<int>::iterator itor;
	for(itor = array.begin();itor != aray.end();itor++)
	{
		if（*itor == 300）
		itor = arrar.erase(itor);
	}
	for(itor = array.begin();itor != aray.end();itor++)
	cout<<*itor<<" ";
	return 0;
}

这个代码的输出结果是100 300 300 500
解：iterator::erase()有两种重载方式
（1）iterator erase(iterator _where):
删除指定未知元素，返回一个迭代器，指向删除元素的下一个元素
（2）iterator erase(iterator _first，iterator _last):
删除某范围内的元素返回一个迭代器，指向最后一个被删除元素的下一个元素
6.有以下定义：

const int * const p = &x;//指针常量
cosnt int &q = x;//q是常引用，不可修改
int const * next = &x;//next是常量
const int *j = &x;//j是常量

解：（*j）++:*j是地址，（*j）++相当于地址加1

2020-3-22

1.在main函数执行之前，还会执行什么代码
解：全局对象的构造函数
2.以下程序的输出结果为 9

#include"stdlib.h"
int func(int x,int y)
{
	return (x+y);
}
int main()
{
	int a = 1,b = 2,c = 3,d = 4,e = 5;
	printf("%d\n",func(a+b,b+c,c+a),(d,e));
	return 0;

}

3.下面程序的输出结果是 75

int a,b;
b = (a = 3*5,a*4,a*5);
printf("%d",b);

解：逗号表达式是将括号中所有表达式的值算出来，但只使用最后一个表达式
4.以下选项中合法的实型常数是 C
A 5E2.0
B E-3
C 2E0
D1.3E
解：（1）实型常熟又称实数或浮点数{1）小数形式 2）指数形式}
（2）指数形式：
1）E(e前面为十进制整数或实数不能省略
2）E(e)后面十进制整数切不能为实数且不能省略
5.当一个类的函数被说明为virtual，则在该类的所有派生类中的同原型函数 都是虚函数
相关知识点：
（1）成员函数被重载的特征
1）相同的范围 2）函数名相同
3）参数不同 4）virtual关键字可有可无
（2）覆盖：是指派生类函数覆盖基类函数
1)不同的范围（分别位于派生类和基类） 2）函数名字相同
3）参数相同 4）基函数必须有virtual关键字
（3）隐藏：是指派生类的函数屏蔽了共同名的基类函数
规则：
1）如果派生类的函数与基类的函数同名，但参数不同。此时，不论有无virtual关键字，基类的函数都将被隐藏
2）如果派生类的函数与基类函数同名，并且参数也相同，惨基类函数没有virtual关键字，此时，基类的函数被隐藏。
6.有如下程序

#include"stdil.h"
class A
{
public:
	virtual void Test()
	{
		printf("A test\n");
	}
};
class B:public A
{
public:
	void func()
	{
		Test();
	}
	virtual void Test()
	{
		printf("B test\n");
	}
};
class C :public B
{
public:
	virtual void Test()
	{
		printf("C test\n");
	}
};

int main()
{
	C c;
	((B*)(&c))->func();
	((B)C).func();
}

解：
1)((B*)(&c))->func()：编译阶段系统发现：B类型有一个非虚函数func，静态绑定，相当于B::fun((B*)(&c)),传入this指针是B类型
在func（）内部调用this->Test()，由于Test（）是虚函数，动态绑定，通过虚函数表调用C::Test()
2）((B)C)强制类型转换发生对象切割，相当于C初始化为一个临时对象B temp，vptr指向B的虚函数表，等价于B temp.func();
7.

class A {virtual ~A(){}};
class B{virtual ~B(){ }};
class C:public A,public B{ };

C *pc = new C();
A *pa = (A*)pc;
B *pb = (B*)pc;

pa == pc && pb != pc;
解：在多继承中，派生类和被继承类的第一个基类地址相同，与第二个基类地址不同

8.关于虚函数，下面那些描述是正确的的 BDF
A 虚函数是重载的工具
B Java中所有的函数都是虚函数
C 通过虚函数，类体系获得了多态性的支持
D 虚函数必须在子类中实现
E 虚函数不能被子类继承
F 在C++中，基类的析构函数建议设为虚析构函数
解：
（1）Java中普通成员函数就是虚函数，加上final编程非虚函数
（2）在C+++中，基类指针可以指向派生类对象，以及基类中拥有的虚函数，是支持多调性的前提，但虚函数分存在是为了多态
（3）虚函数可以由子类继承并重写的函数，后期绑定