选择题

#include<iostream>
#include<cstdio>
using namespace std;
int main(){
	int m=0123, n=123;
	printf("%o %o\n", m, n);
	return 0;
}

程序运行后的输出结果是（）
A 0123 0173
B 0123 173
C 123 173
D 173 173

这道题考查输出的格式，要区分各种进制的表达格式

二进制：1010b

八进制：0123456

十进制：123

十六进制：0x123

%d是十进制，%o是八进制，%x是十六进制输出。%o代表的是八进制整型输出整数，数字前0代表八进制、0x代表16进制，因此m输出为123，十进制123转换为8进制为173，所以n输出为173，因此答案选C

以下哪个选项一定可以将flag的第二个bit置0（）

A flag&=~2
B flag|=2
C flag^=2
D flag>>=2

按位或（有1就是1） 按位与（同1才为1） 按位异或（相同为0，不同为1）

一个一个看即可，选A

请声明一个指针，其所指向的内存地址不能改变，但内存中的值可以被改变（）

A const int const *x = &y;
B int * const x = &y;
C const int *x = &y;
D int const *x = &y;
E const int * const x = &y;

本题还是对const修饰的考查，要求所指向的内存地址不能改变，内存中的值可以被改变：即x本身不能变，而*x解引用的值可以改变故选B

以下C语言指令：运行结果是什么？

int a[5] = {1,3,5,7,9};
int *p = (int *)(&a+1);
printf(“%d,%d”,*(a+1)，*(p-1));

A 2,1
B 3,1
C 3,9
D 运行时崩溃

数组名只有在& 和 sizeof之后表示数组本身，其余都表示数组首元素的地址
&a是一个地址，类型为int(*)[5],&a + 1 是跨越了一个数组大小，p被强转为（int*），p-1指向9，*(a+1)是3 选C

二维数组X按行顺序存储，其中每个元素占1个存储单元。若X[4][4]的存储地址为Oxf8b82140,X[9][9]的存储地址为Oxf8b8221c,则X[7][7]的存储地址为()

A Oxf8b821c4
B Oxf8b821a6
C Oxf8b82198
D Oxf8b821c0

答案选A

根据下面递归函数：调用函数Fun(2)，返回值是多少（）

int Fun(int n)
{
	if(n==5)
		return 2;
	else
		return 2*Fun(n+1);
}

A 2
B 4
C 8
D 16

这个自己展开一下就知道结果了选D

以下程序的输出结果是：

#include <iostream>
using namespace std;
void func(char **m)
{
	++m;
	cout<<*m<<endl;
}

int main()
{
	static char *a[]={"morning", "afternoon", "evening"};
	char **p;
	p=a;
	func(p);
	return 0;
}

A afternoon
B 字符o的起始地址
C 字符o
D 字符a的起始地址

数组名表示数组首元素的地址，数组除了放在&和sizeof之后才表示数组本身，所以这里的*a指的是首元素的地址也就是morning的地址
++m也就是偏移一个元素的大小，也就是指向了afternoon故选A

求函数返回值，输入x=9999

int func(int x){
    int count=0;
    while (x)
    {
	count++;
	x=x&(x-1);//与运算
    }
    return count;
}

A 8
B 9
C 10
D 12

所以9999的二进制有8个1，故选A

#include <stdio.h>
int cnt = 0;
int fib(int n) 
{
	cnt++;
	if (n == 0)
		return 1;
	else if (n == 1)
		return 2;
	else
		return fib(n - 1) + fib(n - 2);
}
void main() {
	fib(8);
	printf("%d", cnt);
}

下列程序执行后,输出的结果为（）
A 41
B 67
C 109
D 177

cnt实际统计的是：斐波那契递归的总次数

答案选B

在32位系统环境，编译选项为4字节对齐，那么sizeof(A)和sizeof(B)是（）

struct A
{
	int a;
	short b;
	int c;
	char d;
};
struct B
{
	int a;
	short b;
	char c;
	int d;
};

A 16,16
B 13,12
C 16,12
D 11,16

结构体内存对齐：

第一个成员在与结构体变量偏移量为0的地址处。

其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的值为8

结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。

如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

选C

---

编程题

计算糖果

这题一开始我的做法就是直接for循环进行嵌套,无脑强行求出结果：

#include <iostream>
#include <string>
using namespace std;
int main()
{
    int sum1, sum2, sum3, sum4;
    cin >> sum1 >> sum2 >> sum3 >> sum4;
    int a=0, b=0, c=0;
    int flag = 0;
    for (a = -30; a <=30; a++)
    {
        for (b = -30; b <= 30; b++)
        {
            for (c = -30; c <= 30; c++)
            {
                if ((a - b) == sum1 && (b - c) == sum2 && (a + b) == sum3 && (b + c) == sum4)
                {
                    cout << a << " " << b << " " << c << endl;
                    flag = 1;
                    break;
                }
            }
        }
    }
    if(flag == 0)
    {
        cout<<"No"<<endl;
    }
    return 0;
}

但是现在我们来看一看题目所给出的条件：

#include <iostream>
#include <string>
using namespace std;
int main()
{
    int a,b,c,d;
    cin>>a>>b>>c>>d;
    int A = (a+c)/2;
    int B1 = (b+d)/2;
    int B2 = (c-a)/2;
    int C = (d-b)/2;
    if(B1!=B2)
    {
        cout<<"No"<<endl;
    }
    else
    {
        cout<<A<<" "<<B1<<" "<<C<<endl;
    }
    return 0;
}

进制转换

先考虑M是正负数问题，可以利用flag来标记一下.当M==0的时候也要处理一下。

然后创建两个字符串ret和table，ret用来存放结果，由于是利用拼接+=,所以最后的结果我们需要倒置一下，而table用来存储进制所代表的数字字母。最后再去一一求出M的每一位数字即可。

#include <iostream>
#include <algorithm>
using namespace std;
int main() {
    int M,N;
    cin>>M>>N;
    bool flag = true;
    string ret;
    string table = "0123456789ABCDEF";
    if(M<0)
    {
        M = -M;
        flag = false;
    }
    if(M == 0)
    {
        ret="0";
    }
    while(M)
    {
        ret+=table[M%N];
        M/=N;
    }
    if(flag == false)
    {
        ret+='-';
    }
    reverse(ret.begin(),ret.end());
    cout<<ret<<endl;
}