C及C++每日练习(3)

选择题：

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; 
    printf("%s\n", p - 3); 
}

A.6 B. 6789 C. '6' D.789

对于本题，首先创建了一个大小为 $10$ 的字符数组，数组名为 $a$ ，接着创建了 $char*$ 类型的指针 $p$ ，随后，让 $p$ 赋值为 $a+i$ ，即 $a+8$ ，此处的加法是针对于指针的加法，在对指针做加法时，表示的是跳过 $sizeof(type)*n$ 个字节，即跳过指针指向数组类型 $*n$ 个字节。在本题中，进行加法后，指针指向元素 $'9'$ 。

在进行打印是，打印的初始位置为 $p-3$ ，即从元素 $'6'$ 开始对数组进行打印，此时的打印类型为% $s$ ，对于这种类型的打印，当遇到结束标志'\0'时停止打印，需要注意的是，此处数组中的 $0$ 并不是待打印的元素 $0$ ，而是表示打印结束的标志，因此答案选择 $B$

2.以下程序的输出结果是（）

#include <iostream.h> 
int main() 
{ 
    int x=3,y=3; 
    switch(x%2) 
    { 
    case 1: 
        switch (y) 
        { 
        case 0: 
            cout<<"first"; 
        case 1: 
            cout<<"second"; 
            break; 
        default: 
            cout<<"hello"; 
        } 
    case 2: 
        cout<<"third"; 
    } 
    return 0; 
}

A.second third B.hello C. first second D.hellothird

对于本题，主要考察对于 $switch$ 选择语句的语法规则。在上述给出的代码中，由于 $x$ % $2==1$ ，因此在进入 $switch$ 选择语句时，执行 $case\, \, 1$ 的情况，在 $case\, \, 1$ 中，由于 $y==3$ ，因此执行 $default$ 情况下的语句，即打印字符串 $hello$ ，在此处需要注意，由于在 $case\, \, 1$ 中，并不存在 $break$ ，因此，在执行完 $case\, \, 1$ 后，代码会继续执行 $case \, \, 2$ 中所对应的代码，即打印字符串 $third$ 。因此，答案选择 $D$

3.以下能对二维数组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}};

在初始化二维数组时，需要注意以下的点：表示二维数组行数的参数可以省略，但是表示二维数组列数的参数不能省略。并且，在初始化其中一行时，必须连续初始化，不能出现中断。

在给出上面的两点后，对比各个选项，其中选项 $A$ 省略了列参数，因此错误，对于选项 $C$ ，由于数组的参数表示数组是一个两行四列的数组，但是在初始化时，确实三行，因此错误。对于选项 $D$ 由于出现了不连续初始化，因此错误。答案选择 $B$

4.能把函数处理结果的二个数据返回给主调函数，在下面的方法中不正确的是（）

A. return这二个数

B.形参用数组

C.形参用二个指针

D.用二个全局变量

对于本题， $BC$ 两个选项的返回方式大致相同，都是采用指针，正确。对于 $D$ ，由于全局变量的作用范围是整个程序，因此正确。对于选项 $A$ ，由于一个函数只能返回一个值，所以错误。

5.int *p[4] 与选择项中的（）等价

A. int p[4]

B. int *p

C. int *(p[4])

D. int (*p)[4]

对于题目中题目中给定的 $int*p[4]$ ，由于 $[]$ 的结合优先级大于 $*$ ，因此， $p$ 会先和 $[]$ 结合，再和 $*$ 结合，此时的 $p$ 为指针数数组，即数组中存放了 $4$ 个类型为 $int*$ 的指针。

对于 $A$ 选项，此时的 $p$ 只是一个数组的名称，所以不等价

对于 $B$ 选项，此时的 $p$ 表示 $int$ 类型的指针

对于 $C$ 选项， $p$ 先和 $[]$ 结合，再和 $*$ 结合，此时的 $p$ 是指针数组，于 $A$ 等价。

对于选项 $D$ ， $p$ 先和 $*$ 结合，再与 $[]$ 结合，此时的 $p$ 是一个数组指针。

综上，答案选择 $C$

6.设变量已正确定义，以下不能统计出一行中输入字符个数（不包含回车符）的程序段是

A.n=0;while(ch=getchar()!='\n')n++;
B.n=0;while(getchar()!='\n')n++; 
C. for(n=0;getchar()!='\n';n++); 
D.n=0;for(ch=getchar();ch!='\n';n++);

对于选项 $A$ ，其整体逻辑为：用变量 $ch$ 接收 $getchar()$ 读取的字符，如果不为'\n',则继续统计。因为'\n'为换行标志，因此可以正确的统计出字符个数。

对于选项 $B$ ，则是直接利用 $getchar()$ 函数读取的字符进行判断，原理于选项 $A$ 相同，正确。

对于选项 $C$ ，是将 $getchar()$ 函数作为 $for$ 循环中判断是否结束的标志，正确。

对于选项 $D$ ，这里需要注意，由于 $for$ 循环中第一个;之前的内容是表示初始化变量，因此，再这种书写方法中， $ch$ 一直是 $getchar()$ 第一次读取的字符，不会继续向后读取，因此错误，答案选择 $D$ 。

7.下面3段程序代码的效果一样吗（）

int b; 
(1)const int *a = &b; 
(2)int const *a = &b; 
(3)int *const a = &b;

A. (2)=(3)

B. (1)=(3)

C. (1)=(2)

D.都不一样

对于判断常量指针和指针常量的题目，在C及C++每日练习(2)-CSDN博客中给出了详细的解释，这里只进行大概的说明：对于常量指针，表示指针指向的内容为常量，不能通过解引用的方式来修改指向的内容，但是可以改变指针的指向，即可以指向另一个常量。其特点是 $const$ 在 $*$ 之前。

对于指针常量，表示指针本身就是一个常量，因此，不能改变指针的指向，但是可以通过解引用的方式来改变指针所指向的内容。

因此， $(1)$ 是一个常量指针， $(2)$ 同样也是常量指针， $(3)$ 是指针常量，所以答案选择 $C$

8.32位系统中，定义**a[3][4],则变量占用内存空间为()。

A.4 B. 48 C.192 D.12

由于是 $32$ 位地址，因此，指针的大小为 $4$ 字节，在上面提到了 $[]$ 的结合优先级是大于 $*$ 的，因此，题目中的代码表示， $a$ 是一个三行四列的二维数组，并且数组中存储的内容是二级指针。因此变量 $a$ 占用内存空间的大小为 $12*4$ ，即 $48$ 字节。

9.假设在一个 32 位 little endian 的机器上运行下面的程序，结果是多少？

#include <stdio.h> 
int main(){ 
  long long a = 1, b = 2, c = 3;  
  printf("%d %d %d\n", a, b, c);   
 return 0; 
}

A.1,2,3 B. 1,0,2 C.1,3,2 D.3,2,1

对于本题，首先需要看到，创建的三个变量的类型为 $long\, \, long$ ，但是在打印时，却是采用打印 $int$ 变量的格式。并且，在题干中给出的信息为：机器是一个 $32$ 位的小端机。对于小端机，其定义为：低位存低地址。对于大端机，其特点为低位存高地址。例如存储一个 $1$ ，如果采用 $16$ 进制进行表示，并且左边为低地址，右边为高地址。则在小端机中存储为 $01\, 00\, 00\, 00$ 。如果是一个大端机，则为 $00\, 00\, 00\, 01$ 。

在了解了大端机，小端机的概念后，还需要直到，对于 $printf$ 函数，其需要打印的变量的入栈参数是从右向左入栈的，并且从高地址进行入栈，因此，三个变量入栈的顺序为 $3,2,1$ 具体效果可以由下面的图展示：

由于栈的性质是后进先出，并且，% $d$ 是将四个字节的内容以十进制的方式进行打印，因在打印时，首先打印后进入的内容的前四个字节的内容，即 $01\, 00\, 00\, 00$ ,随后继续打印，即打印 $00\, 00\, 00\, 00$ ，最后再打印 $02\, 00\, 00\, 00$ .因此答案选择 $B$

编程题：

第一题较为简单，创建 $3$ 个 $string$ 类型的对象，第一个命名为 $str$ ，用于接收题目的输入，剩下二个命名为 $com,max$ ，当 $str[i]$ 所对应的字符为数字时 $com+=str[i]$ ，如果 $str[i]$ 不是数字，此时对应的情况时，连续的数字串已经被遍历完毕，此时让 $max,com$ 进行比较，如果 $max<com$ ，则令 $max = com$ 。随后清楚 $com$ 中的内容。

需要注意的一个点是，如果最大的数字串恰好在给定字符串的末尾结束，例如 $abc123egf1234567$ ，此时需要注意对于一个长度为 $n$ 的字符串循环时，需要循环 $n+1$ 次，即 $i<=str.size()$ 。对于代码如下：

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

int main() 
{
    string str,max,com;
    cin >> str;
    for(int i = 0; i <= str.size(); i++)
    {
        if(str[i] >= '0' && str[i] <= '9')
        {
            com += str[i];
        }
        else 
        {
            if(max.size() < com.size())
            {
                max = com;
            }
            
                com.clear();
            
        
        }

    }
    cout << max;
    return 0;
}
// 64

题目较为简单，由于需要找出现次数大于数组长度一半的数字，所以直接对数组进行排序，取中间数，随后再进行一次遍历，如果这个是数字在数组中的出现次数超过一半，则返回整个数，代码如下：

class Solution {
public:
 
    int MoreThanHalfNum_Solution(vector<int>& numbers) {
        sort(numbers.begin(),numbers.end());
        int mid = numbers[numbers.size()/2];
        int count = 0;
        for(int i = 0; i < numbers.size(); i++)
        {
            if(numbers[i] == mid)
            {
                count++;
            }
        }

        if(count > (numbers.size()/2))
        {
            return mid;
        }
        return 0;

    }
};