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

川长思鸟来 2022-04-25 09:18 249阅读 0赞

## 单选题 ##

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中的连续最长的数字串。

[原题链接][Link 1]

【代码实现】

#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个整数，输出出现次数大于等于数组长度一半的数。

[原题链接][Link 2]

【代码实现】

//法一：
    #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; 
    }

[Link 1]: https://www.nowcoder.com/practice/bd891093881d4ddf9e56e7cc8416562d?tpId=85&&tqId=29864&rp=1&ru=/activity/oj&qru=/ta/2017test/question-ranking
[Link 2]: https://www.nowcoder.com/practice/eac8c671a0c345b38aa0c07aba40097b?tpId=85&&tqId=29866&rp=1&ru=/activity/oj&qru=/ta/2017test/question-ranking