选择题

（6）因为p2被const修饰所以p2不可以被改变，但是p2的指向可以被改变
（7）因为指针p3被const修饰，所以p3的指向不能被改变，但是*p3可以被改变

int main()
{
    int a = 10;
    int b = 5;
    const int* p1 = &a;
    int* const p2 = &a;
    p1 = &b;
    cout << "*p1:" << *p1 << endl;
    //*p1 = 8;//不能修改
    //p2 = &b;//不能修改
    *p2 = 8;
    cout << "*p2:" << " " << *p2 << endl;
    cout << "a:" << " " << a << endl;
    return 0;
}

常量指针和指针常量的区别：
常量指针，指针所指空间的值不能发生改变，不能通过指针解引用修改指针所指空间的值，但指针所指空间可以发生改变
常量指针，该指针是一个常量，可以通过解引用改变指针所指空间的值，但是指针的指向不能发生改变
3.

A：acx和acy都是字符数组，是在栈上开辟的空间，内容可以被修改
B：szx和szy都是指针字符串，在常量区开辟的空间，且字符串相同，因此他们指向同一块空间
C：acx是字符串初始化字符数组，字符串结尾默认有一个\0，因此acx占用空间比acy大
D：szx内容修改实际是指针的指向发生了改变，字符串常量本身并不会被修改
5.

A：宏定义是没有类型安全检测的
B：因为宏定义是在编译阶段进行傻瓜式的替换的，不能被调试，因此我们要尽量使用const常量，而避免使用宏定义
D：相对于函数调用，宏定义可以提高程序的运行效率，宏定义没有创建函数栈帧和函数压栈的开销

7.

A: 存放的是10个int类型的指针的数组，指针数组
B：一个指针指向的是大小为10的int类型的数组，数组指针，因为[ ]优先级高于所以这里添加了()
C：指向一个参数为一个int类型的函数指针
D：是有10个指向参数为一个int类型的指针数组
注意区分：
指针数组和数组指针：
指针数组: int p[10]，本质是一个数组，数组里面存放的是指针
数组指针：
int (p)[10],本质是一个指针，指针指向的是一个数组
int (p[10])[5],p是一个数组，数组中存放的类型是int ( * )[5]
判断类型的方法：去掉第一个和p结合的，产生的是p的类型，而剩下的是指向的类型
例如：
int p的含义是p先和结合说明p是一个指针，剩下的是int，所以p是一个指向int类型的指针

int (p)[10]:p先和结合说明p是一个指针,指向的是一个含有10个int类型的数组int [10]

数组指针和函数指针
数组指针：int (*p)[10]
函数指针：int (*p)(int, int)
9.

这题主要考察的是位段：
什么是位段，位段的作用是做什么？
位段的作用是用来减少空间开辟的
结构体内如果类型为int,unsigned int或char类型就可采用位段来进行存储
位段的定义：类型后面定义变量，变量后面加冒号：，冒号后面加上该类型存放所需要的比特位，注意这里最后的结果也要进行内存对齐。具体请查看博客文章C语言三万字总结
10.

int main()
{
	int a[4] = { 1,2,3,4 };
	cout << &a << endl;
	cout << &a + 1 << endl;
	cout << &a[0] << endl;
	cout << &a[0] + 1 << endl;

	cout << endl;

	int b[][3] = { 1,2,3,4,5,6 };
	cout << &b << endl;
	cout << &b + 1 << endl;
	cout << &b[0] << endl;
	cout << &b[0] + 1 << endl;

	return 0;
}

&a + 1加的是整个数组的大小
对于一维数组&a[0] + 1加的是一个元素的大小
对于二维数组&a[0] + 1加的是一行数组的大小

编程题

1.

思路：先让字符串整体逆序，再对每个单词进行逆序

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

int main() {
    string s;
    getline(cin, s);
    //先整体逆置
    reverse(s.begin(), s.end());
    //再对每个单词进行逆置
    auto begin = s.begin();
    auto end = s.begin();
    while(begin != s.end())
    {
        while(*end != ' ' && end != s.end())
        {
            ++end;
        }
        reverse(begin, end);

        //如果end = s.end(),就不能让begin = end + 1了，加了的话会出现越界
        if(end != s.end())
        {
            begin = end + 1;
            end = begin;
        }
        else {
            begin = end;
        }
        
        
    }
    cout << s << endl;
    return 0;
}
// 64 位输出请用 printf("%lld")

2.

理解题意：本题意思就是这个无序序列，在不被改动的情况下，最少可以被分为几个非递增或非递减序列，比如1，2，2，3，2，3，3,1就可以被分为1,2，2，3,和2,3与1这三个序列

#include <iostream>
#include <vector>

using namespace std;

int main() {
    int n = 0;
    cin >> n;
    vector<int> v(n, 0);
    for (int i = 0; i < n; i++) {
        cin >> v[i];
    }

    int count = 0;
    int j = 0;
    while(j < n)
    {
        if(j + 1 == n)
        {
            count ++;
            break;
        }

        if (v[j] < v[j + 1]) {
            while (j < n && v[j] <= v[j + 1]) {
                j++;
            }
            j++;
            count++;
        } else if (v[j] > v[j + 1]) {
            while (j < n && v[j] >= v[j + 1]) {
                j++;
            }
            j++;
            count++;
        } else {
            j++;
        }
    }

    cout << count << endl;
    return 0;

}
// 64 位输出请用 printf("%lld")