科班C语言期末考试知识总结2016-2017真题

• for，int等保留字不能作为标识符（变量名）

• 不写函数返回值的类型，默认返回int型

• 宏定义可以出现在函数内部

• 静态变量是通过 static 关键字声明的变量，在 C 语言中有以下特点和作用：

  ---

  特点：

  1. 存储周期：静态变量的生命周期贯穿整个程序运行过程，在程序开始时分配内存，结束时释放。
  2. 初始化：未显式初始化时，静态变量默认初始化为 0（或空字符 '\0' 等）。
  3. 作用域
     • 局部静态变量：作用域限定在声明它的函数内部，但其值在函数调用结束后不会丢失。
     • 全局静态变量：作用域限定在当前源文件，不能被其他文件访问。
  4. 存储位置：静态变量存储在静态存储区，而不是栈区。

  ---

  作用：

  1. 保持数据持久化：局部静态变量在函数调用结束后不会销毁，保留上一次的值，下次调用时继续使用。
  2. 限制变量的作用域：全局静态变量只能在当前文件内访问，避免了变量命名冲突。
  3. 共享数据：通过局部静态变量，可以在函数多次调用之间共享数据。

  //局部静态变量
  #include<stdio.h>
  
  void counter()
  {
      static int cnt=0;
      cnt++;
      printf("cnt=%d\n",cnt);
  }
  int main()
  {
      counter();
      counter();
      counter();
      return 0;
  }
  

  cnt=1
  cnt=2
  cnt=3

• char *pstr = "abcd"; 这行代码中，pstr 是一个指针，它指向字符串常量 "abcd" 的首地址。这个指针可以用来访问该字符串，但不能修改它的内容，因为字符串常量被存储在只读内存区域。其作用是通过指针 pstr 存储字符串常量 "abcd" 的地址，从而可以访问该字符串。如果需要在程序中重新指向不同的字符串，pstr 可以很容易地被修改为指向其他字符串。然而，需要注意的是，pstr 指向的字符串常量是不可修改的。如果尝试通过 pstr 来修改字符串内容，会导致未定义的行为。

  #include<stdio.h>
  
  int main()
  {
      char *pstr="abcd";
      printf("%s\n",pstr);
      pstr="aaaaa";
      printf("%s\n",pstr);
      return 0;
  }
  

  abcd
  aaaaa

• #include<stdio.h>
  
  int main()
  {
      int a[10]={0,1,2,3},*p=a;   //p:指向a数组首地址的指针，即指向a[0]的地址
      printf("%d\n",*(p+1));  //解引用
      printf("%d\n",a[1]);
      printf("%p\n",(void*)p);	//为了确保输出正确，一些编译器要求将指针强制转换为 (void*) 类型
      printf("%p\n",&a[0]);
      printf("%p\n",a);
      return 0;
  }
  

  1
  1
  000000000061FDF0
  000000000061FDF0
  000000000061FDF0

• #include<stdio.h>
  
  void func(int *p,int x)
  {
      printf("%d\n",sizeof(p));
  }
  
  int main()
  {
      int a[10]={0,1,2,3};
      printf("%d\n",sizeof(a));
      func(a,4);
      return 0;
  }
  

  40
  8

​ 指针 p 存储的是数组的地址，而不是数组的内容。

​ sizeof(a) 输出 40，因为 a 是一个包含 10 个 int 类型元素的数组，总大小是 40 字节

​ sizeof(p) 输出 8，因为 p 是一个指针，指针的大小通常为 8 字节（在 64 位系统上）。

• #include<stdio.h>
  
  int sum1(int a[],int x)
  {
      int res=0;
      for(int i=0;i<x;i++) res+=a[i];
      return res;
  }
  int sum2(int* p,int x)
  {
      int res=0;
      for(int i=0;i<x;i++) res+=p[i];
      return res;
  }
  
  int main()
  {
      int a[10]={0,1,2,3};
      printf("%d %d\n",sum1(a,4),sum2(a,4));
      return 0;
  }
  

  6 6

​ 在 C 语言中，a[] 被编译器解释为 int* a，即数组名实际上会被转换为指向数组第一个元素的指针。因此，这个函数和 int sum(int* p, int x) 本质上是一样的

• 使用指针输出二维数组

  #include<stdio.h>
  
  void printMatrix(int m,int n,int *mp)
  {
      for(int i=0;i<m;i++){
          for(int j=0;j<n;j++)
              printf("%d ",*(mp+i*n+j));
          putchar('\n');
      }
  
  }
  int main()
  {
      int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12},*p;
      printMatrix(3,4,(int*)a);   //使形参与实参类型匹配
      printMatrix(3,4,a[0]);
      printMatrix(3,4,*a);
      printMatrix(3,4,&a[0][0]);
      return 0;
  }
  

  1 2 3 4
  5 6 7 8
  9 10 11 12
  1 2 3 4
  5 6 7 8
  9 10 11 12
  1 2 3 4
  5 6 7 8
  9 10 11 12
  1 2 3 4
  5 6 7 8
  9 10 11 12

• 在 C 语言中，数组不能直接赋值（例如 int a[10], b[10];a = b; 是不允许的）

• 当 p 是一个结构体指针时，你可以使用 p->member 来访问结构体成员

  #include<stdio.h>
  
  struct stc
  {
      int v;
      int id;
  }data,*p=&data;
  int main()
  {
      data.id=1;
      printf("%d\n",p->id);
      return 0;
  }
  

  1

• 命令行参数：

  argc 是 argument count 的缩写，表示命令行中传递的参数数量

  argv 是 argument vector 的缩写，表示包含所有命令行参数的数组，其中每个元素是一个字符串

  #include<stdio.h>
  int main(int argc,char *argv[])
  {
      printf("%d\n",argc);
      for(int i=0;i<argc;i++)
          printf("%s\n",argv[i]);
      return 0;
  }
  

  input

  D:\Users\Cody\Documents\C语言\source files> .\test1.exe 1 2 3 4

​ output

5
D:\Users\Cody\Documents\C语言\source files\test1.exe
1
2
3
4

• strcat 函数是 C 标准库中的一个字符串操作函数，定义在 <string.h> 头文件中。它的作用是将一个字符串追加到另一个字符串的末尾。

  语法：

  char *strcat(char *dest, const char *src);
  

  参数：

  • dest：目标字符串（接收结果的字符串）。dest 必须有足够的空间来容纳 src 字符串的内容，否则会导致缓冲区溢出。
  • src：源字符串（被追加的字符串）。

  返回值：

  • 返回 dest 字符串的指针，即 dest 字符串的地址。

  功能：

  • strcat 将 src 字符串的内容添加到 dest 字符串的末尾，并在追加过程中自动在 dest 字符串末尾添加一个终止符（'\0'）。

• 动态内存分配

  首先int *p

  1. 使用 malloc 申请内存：

  malloc 函数用于分配指定字节大小的内存块，它返回一个指向该内存块的指针。如果内存分配成功，返回指向内存的指针；如果分配失败，返回 NULL。

  语法：

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

  • n * sizeof(int)：表示需要分配的内存大小，sizeof(int) 是一个 int 类型的字节数，通常是 4 字节（根据系统的不同，可能会有所变化）。所以 n * sizeof(int) 就是分配 n 个 int 类型大小的内存。
  • (int *)：将 malloc 返回的 void* 指针强制转换为 int* 类型指针，指向 int 类型的内存。

  2. 使用 calloc 申请内存：

  calloc 函数与 malloc 类似，但是它不仅分配内存，还会初始化内存为零。

  语法：

  p = (int *)calloc(n, sizeof(int));
  

  • n：需要分配的元素个数。
  • sizeof(int)：每个元素的大小，即每个 int 的字节数。