2018 C++ 答题

一、选择题

1. char *p的赋值，字符指针；
2. char &a 的初始化，字符变量的引用，应该用一个字符变量去初始化，如果加上修饰词const使其变成常引用，即不能通过引用修改变量值，也能用字符常量初始化：const char &a = 'v';
3. 赋值构造函数的构造，参数为对象的引用；
4. 纯虚函数的声明格式：virtual 函数类型 函数名 (参数表) = 0;这里的函数类型就是返回值，声明为纯虚函数之后，基类中就可以不再给出函数的实现部分，带有纯虚函数的类是抽象类；
5. const int *a中const修饰的是int，表示指向的对象是个常量，不可通过指针更改，常量指针；int * const a中const修饰的是指针变量，表示指针的指向对象不可更改始终指向同一个对象，指针常量；
6. fun(m + n, x + y, fun(m + n, z, (x, y)))中的实参个数：三个 （存疑 ；
7. B a; c(2); *p自动调用了几次构造函数：两次，第一次默认构造函数，第二次带参数的构造函数；
8. int a[] = {1, 2, 3, 4}; int * p = a;中第二句语句的含义：定义一个整型指针指向数组开头第一个元素即a[0]；
9. 有参数的格式化头文件：；无参数格式化的头文件：（存疑；
10. 编译时的多态指静态多态，通过1）函数重载，2）函数模板；运行时的多态指动态多态，即通过虚函数和基类指针（引用）；
11. 联编是指一个计算机程序自身彼此关联的过程，在这个联编过程中，需要确定程序中的操作调用(函数调用)与执行该操作(函数)的代码段之间的映射关系；按照联编所进行的阶段不同，可分为静态联编和动态联编。动态联编：又称动态关联，是指只有在程序运行时才能确定要调用的函数，即通过虚函数和基类指针（引用）；静态联编：联编工作在程序编译连接阶段进行；
12. 函数重载的返回值错误：函数的返回值不同不能作为重载的条件，编译器会显示重定义错误；函数重载的条件：1）同名，2）形参类型不同、个数不同或者顺序不同；
13. 运算符重载要求：优先级和结合性不会改变，不能改变操作对象个数，至少有一个操作对象是自定义类型；不能重载的运算符：类属关系运算符"."，成员指针运算符".*"，作用域分辨符"::"，三目运算符"?:"；
14. 赋值运算符重载：（存疑。

二、阅读题

1. 程序输出

Void fun（）{
	cout<<sizeof(bool)<<", "<<sizeof(char)<<", "<<sizeof(short int)<<", "<<sizeof(int) <<", "
	<<sizeof(int)<<", "<<sizeof(long int)<<", "<<sizeof(float)<<", "<<sizeof(double)<<", "
	<<sizeof(long double);
//输出各类型的所占字节数
}

——————输出结果————————
1, 1, 2, 4, 4, 4, 4, 8, 8

2. 程序输出

void fun(int m, int n ){
	float a;
	float b;	
	int *p1 = &m, *p2 = &n;
	a = p1 == &n; 		//判断p1是否指向n并把bool值返回给a
	b = (-*p1 / *p2) + 9.0;		//-m/n + 9
	cout << "a=" << a << ", b=" << b << endl;
}

int main(){
	fun (5,8);
	return 0;
}

——————输出结果——————
a=0, b=9			//注意输出格式，后面没有小数点

3. 从键盘输入一串字符，统计个数，包含’\0’

4. 说明下面程序的功能

int fun(int m){
	int i, p = 1, s = 0;
	for(i = 1; i <= m; i++){
		p *= i;			//p是m！，即m的阶r乘
		s += p;			//s是阶乘的前n项和，细心！
	}
	return s;
}

——————程序功能——————
输出1! + 2! + 3! + .... + m!

三、编程题

1. 有一个牛顿迭代公式 Xn = Xn-1 - f(Xn-1) / f'(Xn-1);编写一个 func1 函数实现并输出x^3 + 2x^2 + 3x + 4 = 0 在 x = 1 附近的根。

补充知识：

递归（recursion）：递归常被用来描述以自相似方法重复事物的过程，在数学和计算机科学中，指的是在函数定义中使用函数自身的方法（A调用A）；
递归是一个树结构，从字面可以其理解为重复“递推”和“回归”的过程，当“递推”到达底部时就会开始“回归”，其过程相当于树的深度优先遍历；
递归是自己调用自己，旨在缩小问题规模。
递归算法要求：1）递归主体，2）终止条件。

迭代（iteration）：重复反馈过程的活动，每一次迭代的结果会作为下一次迭代的初始值（重复调用A）；
迭代是一个环结构，从初始状态开始，每次迭代都遍历这个环，并更新状态，多次迭代直到到达结束状态；
迭代是自己执行很多次，旨在更接近目标。
迭代算法要求：1）确定迭代变量，一个可直接或者间接由旧值推出新值的值，2）迭代关系式，如何更新迭代变量，3）对迭代过程进行控制，何时终止迭代。

代码待更新…

2. 打开文件（纯英文文本），从文件中读取数据，并统计文本中大写字母的个数、空格的字数、标点符号的个数、单词的个数（连续的英文字符算一个单词）、数字的个数（连续的数字算一个数）、其他字符的个数。

//写的很水，勉强能用，不知道有没有曲解题意，毕竟没有实现同一个单词的个数

#include<fstream>
#include<iostream>
using namespace std;

int main() {
	ifstream fin("testFile.txt");
	int upper = 0;			//大写字母的个数
	int space = 0;			//空格个数
	int word = 0;			//单词个数
	int num = 0;				//数字个数
	int end = 0;				//句号个数
	int others = 0;			//其他个数

	char ch;
	int flag = 0;					//表示开始计数，得遇到一个单词才行
	int a = 0;

	do {
		ch = fin.get();
		if (ch == ' ') {
			space++;
			a = 1;
		}
		else if (ch >= 'A' && ch <= 'Z') {		//开启计数
			upper++;
			flag = 1;
			a = 0;
		}
		else if (ch >= 'a' && ch <= 'z') {
			flag = 1;
			a = 0;
		}
		else if (ch >= '0' && ch <= '9')
			num++;
		else if (ch == '.') {
			end++;
			a = 1;
		}
		else
			others++;

		if (flag == 1) {
			if (a == 1) {
				word++;
				flag = 0;
			}
		}
	} while (ch != EOF);
	cout << upper << ". " << word << ". " << space << ". " << num << ". " << end << endl;
	return 0;
}

3. 编写一个 employee 类，成员有姓名、入职时间、当前月收入、连续三年的业绩、公司总人数等；编写成员函数判断是否加薪（三年业绩大于等于 9）or 辞退（三年业绩小于等于6）；编写一个友元函数，计算公司应支出所有员工的月工资和年工资。要求写构造函数和析构函数。

#include<iostream>
#include<string>
using namespace std;

const int MaxSize = 10;

class employee {
public:
	employee(const char *name) {	
		strcpy_s(myName, name);
		numbers++;
	}
	employee(const employee &em) {
		strcpy_s(myName, em.myName);
		myGrade = em.myGrade;
		myTime = em.myTime;
		myIncome = em.myIncome;
		numbers++;
	}
	~employee() {
		numbers--;
	}

	void panduan() {
		if (myGrade >= 9)
			cout << "加薪" << endl;
		else if (myGrade <= 6)
			cout << "辞退" << endl;
	}

	friend void allGrade(int *month, int *year);

private:
	char myName[MaxSize];
	int myTime;
	int myIncome;
	int myGrade;
	static int numbers;
};

void allGrade(int *month, int *year) {		//存疑
	;
}

int employee::numbers = 0;			//静态数据成员的数据话格式，不用加static

int main() {
	employee  a("233");
	return 0;
}