选择题
1.使用printf函数打印一个double类型的数据，要求：输出为10进制，输出左对齐30个字符，4位精度。以下哪个选项是正确的？
A %-30.4e
B %4.30e
C %-30.4f
D %-4.30f
对于 %m.nf ，double对应%f.要求打印double类型数据，输出10进制，输出左对齐，30个字符，4位精度,默认的是右对齐，左对齐要加-负号，30字符宽度对应m；4精度对应n.所以是：%-30.4f
2.请找出下面程序中有哪些错误（）
int main(){
int i = 10;
int j = 1;
const int *p1;//(1)
int const *p2 = &i; //(2)
p2 = &j;//(3)
int *const p3 = &i;//(4)
*p3 = 20;//(5)
*p2 = 30;//(6)
p3 = &j;//(7)
return 0;
}
A 1,2,3,4,5,6,7
B 1,3,5,6
C 6,7
D 3,5
const修饰所涉及到的问题：
对于常量指针：const int *a
指针指向空间的值不能发生改变，不能通过指针解引用修改指针所指空间的值，但是指针的方向可以发生改变
而对于指针常量： int * const a
指针本身是一个常量，指针的指向不能发生改变，但是指针所指向空间的值是可以发生改变的，可以通过指针解引用改变指针所指空间的值
对于这两个的区分方法：
const * 的相对位置： const在 的左边为常量指针；const在*的右边就表示一个指针常量*
p1、p2是常量指针，p3是指针常量，选C
3.下面叙述错误的是（）
char acX[]="abc";
char acY[]={'a','b','c'};
char *szX="abc";
char *szY="abc";
A： acX与acY的内容可以修改
B ：szX与szY指向同一个地址
C ：acX占用的内存空间比acY占用的大
D ：szX的内容修改后，szY的内容也会被更改
题目解析：
zcX和zcY都是在栈上开辟的空间，可以修改
szX和szY都是指针，指向同一个字符串，所以使用同一块空间
zcX是字符串初始化是：abc\0，而acY只有abc，所以acX占用的空间比acY大
对于D：szX是一个指针，内容改变也就是，szX的指向改变 ，并不会改变abc，所以D是错误的。
4.在头文件及上下文均正常的情况下，下列代码的运行结果是（）
int a[] = {1, 2, 3, 4};
int *b = a;
*b += 2;
*(b + 2) = 2;
b++;
printf("%d,%d\n", *b, *(b + 2));
A 1,3
B 1,2
C 2,4
D 3,2
数组最终变成{3,2,2,4},而最终么指针b指向的是2，*（b+2）指向的是4
5.下列关于C/C++的宏定义，不正确的是（）
A 宏定义不检查参数正确性，会有安全隐患
B 宏定义的常量更容易理解，如果可以使用宏定义常量的话，要避免使用const常量
C 宏的嵌套定义过多会影响程序的可读性，而且很容易出错
D 相对于函数调用，宏定义可以提高程序的运行效率
B选项的说法恰好是相反的。因为宏定义没有安全类型检测，所以会有安全隐患，在预处理阶段进行了替换，所以应该是尽量使用const常量；宏定义相比于函数调用，函数调用会开辟栈帧，而宏定义没有在开辟栈桢，减少了开销，所以提高了运行效率。
6.有以下定义：
int a[10];
char b[80];
函数声明为：
void sss(char[],int[]); //参数都是数组
则正确的函数调用形式是（）
A sss(a,b);
B sss(char b[],int a[]);
C sss(b[],a[]);
D sss(b,a);
这个比较简单，选D。
7.用变量a给出下面的定义:一个有10个指针的数组,该指针指向一个函数,该函数有一个整形参数并返回一个整型数（）
A int *a[10];
B int (*a)[10];
C int (*a)(int);
D int (*a[10])(int);
int *a[10] ：[]的运算符优先级高于*，a先和[]结合，所以a是数组，数组里存放int类型的指针 ,a是指针数组
int (*a)[10]：a先和*结合，是一个指针，指向的是一个大小为10的int 数组,a是数组指针
int (*a)(int)：a先和*结合，是一个指针，指向（int）函数，是一个函数指针
int (*a[10])(int)：a先和[]结合，表示是一个数组，再和*结合，为指针数组，指针指向的是函数，函数有int类型，并返回int。所以最后是函数指针数组,故选D
8.以下 C++ 函数的功能是统计给定输入中每个大写字母的出现次数（不需要检查输入合法性，所有字母都为大写），则应在横线处填入的代码为（）
void AlphabetCounting(char a[], int n) {
int count[26] = {}, i, kind = 10;
for (i = 0; i < n; ++i)
_________________;
for (i = 0; i < 26; ++i)
{ printf("%c=%d", _____, _____);
}
}
A ++count[a[i]-‘Z’] ‘Z’-i count[‘Z’-i]
B ++count[‘A’-a[i]] ‘A’+i count[i]
C ++count[i] i count[i]
D ++count[‘Z’-a[i]] ‘Z’- i count[i]
“Z - a[i]” : 对应的是出现的大写字母在数组对应的位置 ；‘Z’- i : 对应大写字母；count[i]:记录的是出现的次数
i是取决于n的，可能大于26，就会出现越界访问，故选D
9.在32位cpu上选择缺省对齐的情况下，有如下结构体定义：
struct A{
unsigned a : 19;
unsigned b : 11;
unsigned c : 4;
unsigned d : 29;
char index;
};
则sizeof（struct A）的值为（）
A 9
B 12
C 16
D 20
本题就是在考查位段和内存对齐相关知识：
4字节（32）： 19 + 11=30（a+b）剩余两个，重新开
4字节（32）： 4（c）剩二十八不够d放，重新开
4字节（32）：29（d）
1字节（8） ：1（index）
总共是13个字节，但是要4的整数倍，所以16个字节
10.下面代码会输出()
int main(){
int a[4]={1,2,3,4};
int *ptr=(int*)(&a+1);
printf("%d",*(ptr-1));
}
A 4
B 1
C 2
D 3
（&a+1）：对数组名进行取地址，+1会向后偏移指针类型的大小，也就是偏移了数组类型大小，而（ptr-1）是向前偏移一个int类型的大小,最终为4，选A
编程题
整体倒置，在每个单词倒置：
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
string s;
getline(cin,s);
reverse(s.begin(),s.end());
auto start = s.begin();
while(start!=s.end())
{
auto end = start;
while(end!=s.end()&&*end!=' ')
{
++end;
}
reverse(start,end);
if(end!=s.end())
{
start = end+1;
}
else
{
start = end;
}
}
cout<<s<<endl;
return 0;
}
非递增和非递减相对于递增和递减而言，并不是单调的，可能出现相同的数字，所以是非递增和非递减。
非递增：v[i]>=v[i+1] 非递减v[i]<=v[i+1]
对于这道题，我们可以对数组进行划分，通过去判断是即将进入非递减还是非递增状态，相等的情况不需要进行处理，通过计数器进行记录即可。
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
int n;
cin>>n;
vector<int> v;
int count = 0;
v.resize(n+1);//多给出一个是为了防止越界
v[n] = 0;//最后一个初始化为0
for(size_t i = 0;i<n;i++)
{
cin>>v[i];
}
int i= 0;
while(i<n)
{
if(v[i]<v[i+1])
{
while(i<n&&v[i]<=v[i+1])
{
++i;
}
++count;
++i;
}
else if(v[i] == v[i+1])//不需要处理
{
++i;
}
else
{
while(i<n&&v[i]>=v[i+1])
{
++i;
}
++count;
++i;
}
}
cout<<count<<endl;
return 0;
}