【C语言】错题整理（三）

单选题

1.以下程序的输出结果是?

#include <stdio.h> 
main()
{
char a[10]={ '1','2','3','4','5','6','7','8','9',0},*p; int i;
i=8;
p=a+i;  //**指针p指向数组的第九位**；a为一个char类型的数组，也是数组首元素的地址。
printf("%s\n",p-3); //**p-3指向数组第六位的地址**，输出字符。最后一位0是int类型,解析为'\0'。
}

A 6
B 6789
C ‘6’
D 789

我的回答： C (错误)
正确答案： B

2.以下能对二维数组a进行正确初始化的语句是（）
A int ta[2][]={{0,1,2},{3,4,5}};
B int ta[][3]={{0,1,2},{3,4,5}};
C int ta[2][4]={{0,1,2},{3,4},{5}};
D int ta[][3]={{0,2},{},{3,4,5}};

我的回答： D (错误)
正确答案： B

对于二维数组的初始化还要注意以下几点：

1. **可以只对部分元素赋值，未赋值的元素自动取“零”值。**例如：
   int a[3][3] = {{1}, {2}, {3}};
   是对每一行的第一列元素赋值，未赋值的元素的值为 0。赋值后各元素的值为：
   1 0 0
   2 0 0
   3 0 0

2. **如果对全部元素赋值，那么第一维的长度可以不给出。**例如：
   int a[3][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
   可以写为：
   int a[][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

3. 二维数组可以看作是由一维数组嵌套而成的；如果一个数组的每个元素又是一个数组，那么它就是二维数组。当然，前提是各个元素的类型必须相同。根据这样的分析，一个二维数组也可以分解为多个一维数组，C语言允许这种分解。
   例如，二维数组a[3][4]可分解为三个一维数组，它们的数组名分别为 a[0]、a[1]、a[2]。
   这三个一维数组可以直接拿来使用。这三个一维数组都有 4 个元素，比如，一维数组 a[0] 的元素为 a[0][0]、a[0][1]、a[0][2]、a[0][3]。

3.由多个源文件组成的C程序，经过编辑、预处理、编译、链接等阶段会生成最终的可执行程序。下面哪个阶段可以发现被调用的函数未定义？

A 预处理
B 编译
C 链接
D 执行

我的回答： A (错误)
正确答案： C

●预处理， 展开头文件/宏替换/去掉注释/条件编译 （test.i main .i）
●编译， 检查语法，生成汇编 （ test.s main .s）
●汇编， 汇编代码转换机器码 (test.o main.o)
●链接 链接到一起生成可执行程序 （a.out）

4.下列main()函数执行后的结果为()

i=8;
p=a+i;
printf("%s\n",p-3);
}
int func()
{
int i,j,k=0;
for(i=0,j=-1;j=0;i++,j++)
{
k++;
}
return k;
}
int main()
{
cout<<(func());  
}
int b;

A -1
B 0
C 1
D 2

我的回答： C (错误)
正确答案： B

for(i=0,j=-1;j=0;i++,j++)

等价于

int i = 0, j = -1;
while (j = 0)
{
	i++;
	j++;
}

所以，循环次数为0，函数func()其实并没有进入for 循环内部，i，j，k,都为0。

5.以下哪种STL容器中的对象是连续存储的:()

A list
B vector
C map
D set

我的回答： A (错误)
正确答案： B

List封装了链表,Vector封装了数组；
list和vector得最主要的区别在于:
vector使用连续内存存储的，他支持[]运算符，而list是以链表形式实现的，不支持[]。
Map,Set属于标准关联容器，使用了非常高效的平衡检索二叉树：红黑树，
插入删除效率比其他序列容器高是因为不需要做内存拷贝和内存移动，直接替换指向节点的指针即可。

6.当一个类对象的生命周期结束后，关于调用析构函数的描述正确的是:（）

A 如果派生类没有定义析构函数，则只调用基类的析构函数
B 如果基类没有定义析构函数，则只调用派生类的析构函数
C 先调用派生类的析构函数，后调用基类的析构函数
D 先调用基类的析构函数，后调用派生类的析构函数

我的回答： A (错误)
正确答案： C

7.下面关于一个类的静态成员描述中,不正确的是()

A 静态成员变量可被该类的所有方法访问
B 该类的静态方法只能访问该类的静态成员函数
C 该类的静态数据成员变量的值不可修改
D 子类可以访问父类的静态成员
E 静态成员无多态特性

我的回答： C (正确)
正确答案： C

成员变量，静态方法没有多态特性。
成员变量属于前期绑定 ， 多态属于后期绑定；静态方法属于类与对象无关。

8.下面这个代码输出的是()

#include <iostream>
#include <vector>
using namespace std;
int main(void)
{
	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 != array.end(); itor++)
	{
		if (*itor == 300)
		{
			itor = array.erase(itor);
			//itor第一次指向第一个300，第二次指向第三个300，第三次指向500
			//在判断内部给它赋值下一位置后，循环外部又加1。前后加了两次，前后只删去了两个300。
		}
	}
	for (itor = array.begin(); itor != array.end(); itor++)
	{
		cout << *itor << "";
	}
	return 0;
}

A 100 300 300 300 300 500
B 100 300 300 300 500
C 100 300 300 500
D 100 300 500
E 100 500
F 程序错误

我的回答： E (错误)
正确答案： C

编程题

1.字符串中找出连续最长的数字串：读入一个字符串str，输出字符串str中的连续最长的数字串。

原题链接

【代码实现】

#include <iostream>
#include <string>
using namespace std;
int main()
{
	string s;
	while (cin >> s)
	{
		string tmps;
		string maxs;
		int maxsize = 0;
		for (int i = 0; i < s.size(); i++)
		{
			while (s[i] >= '0'&&s[i] <= '9')
			{
				tmps += s[i];
				i++;
			}
			if (maxsize < tmps.size())
			{
				maxs = tmps;
				maxsize = tmps.size();
			}
			tmps.clear();
		}
		cout << maxs << endl;
	}
	return 0;
}

2.n个数里出现次数大于等于n/2的数：输入n个整数，输出出现次数大于等于数组长度一半的数。

原题链接

【代码实现】

//法一：
#include <vector> 
#include <iostream> 
using namespace std;
int main()
{
	int n;
	vector <int> v;
	while (cin >> n)
		v.push_back(n);
	int count = 1;
	int temp = v[0];
	for (int i = 1; i < v.size(); ++i)
	{
		if (v[i] == temp)
			count++;
		else
			count--;
	    // 过半的数至少会和相邻值重复一次，v[i]保存的是过半的数
		if (count == 0)
		{
			temp = v[i];
			count++;
		}
	}
	cout << temp << endl;
	return 0;
}

//法二：
#include <vector> 
#include <iostream> 
#include <algorithm> 
using namespace std; 
int main() 
{    
	int n;    
	vector <int> v;    
	while(cin >> n)        
		v.push_back(n);        
	sort(v.begin(), v.end());        
	cout << v[v.size()/2-1] << endl;    
	return 0; 
}