【820复试】C语言题目错题

1.若有代码段

int *p = (int*)malloc(sizeof(int));

则向内存申请到的内存空间中存入正数123的语句为()

我选的是
scanf("%d",&p);

//正确答案：
scanf("%d",p);

2.有以下语句定义

int x =5;
const int * const p = &x;
const int &q=x; 
int const *next=&x;
const int *j=&x;

则有语法错误的是（）*p=1; q++; (*j)++; 错误
next++;正确

const修饰指针变量：
const在*的左边，则指针指向的变量的值，不可直接通过指针改变（可以通过其他途径改变）；
在*的右边，则指针的指向不可变。
简记为“左定值，右定向”。

3.算式 3<<2|3 的结果是（）——15 【重要】

先进行位运算，3<<2，3左移2位，即0011，左移2位得到1100，与3相与，得到1111，即15

4.下面有关C++的类和C里面的struct的描述，正确的有？ ABCD

A.在C++中，来自class的继承默认按照private继承处理，来自struct的继承默认按照public继承处理

B.class的成员默认是private权限，struct默认是public权限

C.c里面的struct只是变量的聚合体，struct不能有函数

D.c++的struct可有构造和析构函数

5.以下叙述中正确的是（） D

A.如果函数带有参数，就不能调用自己

B.所有函数均不能接受函数名作为实参传入

C.函数体中的语句不能出现对自己的调用

D.函数名代表该函数的入口地址

A.递归调用
B.qsort(a.begin(),a.end(), cmp)。此处的cmp是函数
C.递归

6.若有定义：char s[3][4];

则下列对数组元素s[i][j]的各种引用形式中，正确的是（） B

A.* (s+i)[j] B.* (&s[0][0]+4 * i+j) C.* ((s+i)+j) D.* ( * (s+i)[j])

A要修改为(*(s+i))[j]才正确， 运算完s+i后要和[j]结合，在和*结合
C正确写法为* (*(s+i)+j)
D正确写法何A相同

7.已知数组D的定义是int D[4][8];现在需要把这个数组作为实参传递给一个函数进行处理。下列可以作为对应的形参变量说明的是（）。【重要】

int (*s)[8]或者 int D[][8]。

若是 int D[4][]或者 int *s[8]都是错误的形参变量说明

8.下列程序的运行结果是PP 10003，请为横线处选择合适的程序（ ）

#include <stdio.h>
#include <string.h>
 
struct STU {
    char name[10];
    int num;
};
 
void f(char _____, int num) {
    struct STU s[2] = {{"SS", 10001}, {"PP", 10002}};
    num = s[1].num;
    strcpy(name, s[1].name);
}
 
main() {
    struct STU s[2] = {{"YY", 10003}, {"LL", 10004}}, *p;
    p = s;
    f(p->name, p->num);
    printf("%s %d\n", p->name, p->num);
}

要填*name 或者 name[]

9.下面代码的输出（）【重要】

int main() {
    int a[5]  = {1, 2, 3, 4, 5};
    int *ptr = (int*)(&a + 1);
    printf("%d, %d", *(a + 1), *(ptr - 1));
    //a 为 int 型数组首地址，数组长度为 5，a + 1 表示 a[1] 的地址。
    //&a 可以理解为表示一个列数为 5 的 int 型二维数组的首地址，那么 &a + 1 表示列为 5 的 int 型二维数组第 		1 行首地址，
	//然后转为 int 型指针赋值给 ptr，可以理解为 ptr 为 a[5] 的地址（可以这么理解，实际不存在 a[5]），
	//ptr - 1 即为 a[4] 的地址。因此正确答案为2, 5
    return 0;
}

10.以下代码的输出结果是? define的应用 【细】

#include <stdio.h>
#define a 10 
 
void foo();  
int main(){ 
   printf("%d..", a); 
   foo(); 
   printf("%d", a); 
} 
void foo(){ 
   #undef a 
   #define a 50 
}
输出结果为10..10
//define在预处理阶段就把main中的a全部替换为10了.
//不管是在某个函数内，还是在函数外，define都是从定义开始知道文件结尾，所以如果把foo函数放到main上面的话，则结果会是50

//若改为下述程序
#include <stdio.h>
#define a 10 
 
void foo(){ 
   #undef a 
   #define a 50 
}
int main(){ 
   printf("%d..", a); 
   foo(); 
   printf("%d", a); 
} 
输出结果就为50..50
    
    //若是这样呢
#define a 10
void foo();
void prin();

int main()
{
    prin();
    printf("%d ", a);
    foo();
    printf("%d ", a);
    
}
void foo()
{
#undef a
#define a 50
}
void prin()
{
    printf("%d ", a);
}
//输出结果为 50 10 10

11.以下叙述中正确的是（B）【重要】

A.即使不进行强制类型转换，在进行指针赋值运算时，指针变量的基类型也可以不同
B.如果企图通过一个空指针来访问一个存储单元，将会得到一个出错信息
C.设变量p是一个指针变量，则语句p=0;是非法的，应该使用p=NULL;
D.指针变量之间不能用关系运算符进行比较

指针变量的赋值只能赋予地址， 决不能赋予任何其它数据，否则将引起错误；
p=NULL ；和 p=0 ；是等价的；
指向同一数组的两指针变量进行关系运算可表示它们所值数组元素之间的关系，指针之间的比较是地址，即看谁的地址二进制数值大，相当于依旧是两个数相比。

12.有以下定义

char x[ ]="abcdefg";
char y[ ]={'a','b','c','d','e','f','g'};
则正确的叙述为（C）
A.数组 x 和数组 y 等价
B.数组 x 和数组 y 的长度相同
C.数组 x 的长度大于数组 y 的长度
D.数组 x 的长度小于数组 y 的长度
//因为字符串的末尾还有一个'\0'
但是字符数组最后没有结束符

13.以下程序的输出结果是（）【重要】

int main (){
    char arr[2][4];
    strcpy (arr[0],"you");
    strcpy (arr[1],"me");
    arr[0][3]='&';
    printf("%s \n",arr);
    return 0;
}
因为arr是一个2行4列的二维数组，每一行可以存放最多三个字符的字符串。
执行strcpy(art[0],"you”);后则将字符串"you”放置在数组arr的第一行上，即a[0][0]=’y’,a[0][1]=’o’,a[0][2]=’u',a[0][3]=’\0’(字符串结尾符)。
执行strcpy(arr[1],”me”)；后则将字符串”me”放置在数组arr的第二行上，即a[1][0]=’m'，a[1][1]=’e’,a[1][2]=’\0’(字符串结尾符)，         
由于二维数组在内存中是以行序存放的，执行arr[0][3]=’&’；后，第一行与第二行将视为一个字符串"you&me”，而数组名则是该字符串的首地址。

14.对下面变量声明描述正确的有（）【重要】

int *p[n]; //e.g:int *p[4]; 表示指针数组，有四个元素，每个元素都是整型指针。
int (*)p[n]; //错误声明
int *p()； //int *p(void) 表示函数，此函数无参，返回整型指针。
int (*)p(); //错误声明
// int(*P)(void); 表示函数指针，可以指向无参，且返回值为整型指针的函数。

这种题型的关键是明白  *  的优先级低于[]和（），p先和哪个符号结合是关键。 
//对于AB：
int *p[n];
int (*)p[n]; 
定义相同，p先与[]结合，因为其优先级比*高，所以p是一个数组，然后再与*结合，说明数组里的元素是指针类型，然后再与int结合，说明指针所指向的内容的类型是整型的，所以，p是一个有n个指针的数组，该数组的指针是指向整型的
//对于CD：
int *p()；
int (*)p();
定义相同，p先与( )结合，说明p是一个函数，( )里没有内容，说明该函数没有参数，然后再与外面的int *结合，说明函数返回的指针是整型的

总结：

 int *p[4]; //表示指针数组，有四个元素，每个元素都是整型指针。 
 int (*p)[4]; //表示行指针，所指对象一行有四个元素。
 int *p(void); //表示函数，此函数无参，返回整型指针。
 int(*P)(void) ;//表示函数指针，可以指向无参，且返回值为整型指针的函数。  

15.程序的正确输入格式要一模一样

以下程序

main() {  
    int m, n, p;
    scanf("m=%dn=%dp=%d", &m, &n, &p);
    printf("%d%d%d\n", m, n, p);
}

若想从键盘上输入数据，使变量m中的值为123，n中的值为456，p中的值为789，则正确的输入是（）

应该输入：m=123n=456p=789

16.有函数定义：【形参匹配】

void test(int a){} 
void test(float a){} 

则以下调用错误的是：D
A.test(1); B.test(‘c’); C.test(2+‘d’); D.test(0.5)

0.5类型模糊，既匹配int类型也匹配float类型。
D正确的调用方法应该是test(0.5f)就不会出现多种匹配导致编译出错。

当字符c为实参时，可以由int类型接收，重写的函数只会调用一次。 0.5即可由int类型接收也可由float接收。

17.有一个如下的结构体：【结构体大小】

struct A{
 long a1;
 short a2;
 int a3;
 int *a4;
};

请问在64位编译器下用sizeof(struct A)计算出的大小是多少？ 答：24

第一个，8字节
第二个，2字节，加起来是10，对齐到12
第三个，4字节，加起来是16
第四个，8字节，加起来是24

32位编译器：32位系统下指针占用4字节
      char ：1个字节
      char*（即指针变量）: 4个字节（32位的寻址空间是2^32, 即32个bit，也就是4个字节。同理64位编译器）
      short int : 2个字节
      int：  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   4个字节
      long long:  8个字节
      unsigned long:  4个字节
64位编译器：64位系统下指针占用8字节
      char ：1个字节
      char*(即指针变量): 8个字节
      short int : 2个字节
      int：  4个字节
      unsigned int : 4个字节
      float:  4个字节
      double:   8个字节
      long:   8个字节
      long long:  8个字节
      unsigned long:  8个字节

18.ASCII码不一定能全部输出，因为含有一些特殊空字符，输出结果看不出来；ASCII码是ANSI的子集。

19.在上下文和头文件正常的情况下，以下代码输出的值是：

int x = 4;
void incre() {
    static int x = 1; //只执行一次
    x *= x + 1;  //x=2  x=2*3=6  x=6*7=42
    printf("%d", x);
}
int _tmain(int argc, _TCHAR *argv[]) {
    int I;
    for (i = 1; i < x; i++) { //执行三次incre()
        incre();
    }
    return 0;
}

输出：2642

int x=4 不变，for循环执行3次，调用3次incre()方法，在incre()方法里面的x变量的值一直在变。

每次调用incre()就执行一次 x=x*(x+1);

第一次：x=1*(1+1)=2

第二次：x=2*(2+1)=6

第三次：x=6*(6+1)=42

20.下列关于const和#define定义常量的区别，说法不正确的有（D）

A.define宏是在预处理阶段展开。const常量是编译运行阶段使用
B.宏没有类型，不做任何类型检查，仅仅是展开。const常量有具体的类型，在编译阶段会执行类型检查
C.define宏仅仅是展开，有多少地方使用，就展开多少次，不会分配内存。const常量会在内存中分配(可以是堆中也可以是栈中)
D.const定义和#define定义的常量在程序运行过程中只有一份拷贝
//D选项：const定义的常量只有一次拷贝没毛病，而define定义的变量在内存中并没有拷贝，因为所有的预处理指令都在预处理时进行了替换。 

21.有以下程序

int main(){
    int p[8] = {11, 12, 13, 14, 15, 16, 17, 18}, i = 0, j = 0;  
    while(i++ < 7) if(p[i]%2) j += p[i];
    printf("%d\n",j);
}

程序运行后的输出结果是：45

主要是在i++<7处
i=0时,i++<7，此时进入循环但是i=1，if判断为false
i=1时,i++<7，进入循环，但是i=2,if判断为true，j+=13;
。。。
。。。
j=13+15+17=45

22.下列程序的输出是（）

#include <stdio.h>
int main(void) {
    int a[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}, *p[4], i;
    for (i = 0; i < 4; i++) p[i] = &a[i * 3];
    printf("%d\n", p[3][2]); //12
    return 0;
}
p[3]=&a[9],p[3][2]=p[3]+2，指向a[11]=12

23.运行Test函数会有什么样的结果？

char* getmemory(void){
    char p[]= " hello world";
    return p;  //返回栈内存（动态数据区）的地址
    		  //栈空间在返回时被回收，从而不能逻辑返回
}
void test(void){
    char *str=NULL;
    str=getmemory();
    printf(str);  //输出乱码
}

若修改getmemory()函数为下述：
char* getmemory(void){
    char *p= " hello world";
    return p;  //返回的是静态数据区的地址
}
则能正常输出

24.说明“double(*ptr)[N];”中的标识符ptr是（）

ptr是一个指向由N个double类型元素组成的一维数组的指针

若是double *ptr[N]，则为一个double 类型的指针数组。带上就是一个指向一维数组的指针。

25.是已知变量p、q是两个同类型的指针变量，下列表达式有语法错误的是（C）

A.p+1  B.q++  C.(*p-q)/2  D.*p(*q)
//D是函数指针，属于函数指针的调用，e.g:p(2,3), (*p)(2,3)
A是指针p指向的地址的下一位置； 
B是改变指针变量q存储的地址值；
D是指针变量p和q所指向的值之间的运算；
C的错误在于参与该运算的q所代表的含义不清晰。    

26.对于下面代码段

char *const name = new char[5]；

下面的语句中正确的是（A）

A.name[3]='q'；
B.name="line";
C.name=new char[5];
D.name=new char('q');
//name被定义常指针，所以它所指的内容能改变，但指针本身的内容不可以修改，name[3]='q'，修改了name所指的内容

而name="line";name= new char[5]；name=new char（'q'）；以不同的方法修改了常指针

指针和 const 谁在前先读谁 ；
*象征着地址，const象征着内容；
谁在前面谁就不允许改变
所以
int const *p = new int[10]; //不允许修改指针指向的内容，但是可以更换指针指向
int *const p = &a;  //不允许修改p指针的指向，但是可以更改指针指向的内容，即可以更改变量a的值

27.结构体的sizeof

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

Q：在32位机器上用gcc编译以上代码，求sizeof(A)，sizeof(B)分别是（）

整个结构体的一定要是最长那个位的整数倍对齐。
1. 结构体变量的首地址 必须 是内部最宽数据类型的倍数（虽然和做题没什么关系） 
2. 按顺序一个变量一个变量看，要求current变量的首地址 必须是自己大小的倍数。 
3. 到了最后一个变量，要求整个结构体的大小的最宽数据类型的倍数。

class A { //最大的为4字节
    int a;   // 4Byte
    short b; //2Byte，起始地址4是2的倍数，不补， sum=4+2
    int c;  //4Byte，补short的那行2B，sum = 4+2+2(补)+4
    char d; //1Byte，sum=4+2+2(补)+4+1+3(补)=16
};

class B { //最大的为8字节
    double a; //8Byte 
    short b; //2Byte，sum=8+2
    int c; //4Byte，不是sum的整数倍，sum = 8+2+2(补)+4
    char d; //1Byte， sum=8+2+2(补)+4+1 = 17
    	   //对齐 sum=8+2+2(补)+4+1+7(补)=24Byte
};

28.设已定义浮点型变量data，以二进制代码方式把data的值写入输出文件流对象outfile中，正确的语句是（）C

A.outfile.write((double ) &data, sizeof(double));
B.outfile.write((double ) &data, data);
C.outfile.write((char *) &data, sizeof(double));
D.outfile.write((char *) &data, data);

29.在C语言中，下面的说明汇总，正确的函数定义有（BE）

A.void f(void)  //函数声明 非定义
B.void f(void){} //正确
C.f(int s){} //无返回值类型。编译通过但不规范
D.f(int s){return s+1;} //无返回类型，但有return
E.double f(){return 0.0;} //正确

30.有以下程序【重要】

#include <stdio.h>
#include <stdlib.h>
void fun(int *p1, int *p2, int *s) {
    //此时的s指向的确实是a的首地址
    s = (int *)malloc(sizeof(int)); //malloc/realloc会重定向指针的地址，导致地址变化
    *s = *p1 + *(p2++); //所以这里的赋值就没有用，从而赋值失败
}
int main() {
    int a[2] = {1, 2}, b[2] = {10, 20}, *s = a;
    fun(a, b, s);
    printf("%d \n", *s); //输出：1
}
若将fun函数更改为下述：
void fun(int *p1, int *p2, int *s) {
    *s = *p1 + *(p2++); //先引用后++，即 *s=*p1+*p2; p2++;  加括号也没用
}
//那么最后输出的就是11

程序运行后的输出结果是? 1

31.做逻辑运算&、|、！、&&、||、^(异或)运算时，用二进制表示数，按规则运算得到答案即可，是多少就是多少。

【持续更新~~~】