备案控制台
开发者社区 开发与运维 文章 正文

c语言关键字理解和再认识（下）（2）

2023-05-26 43
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 一、switch case 关键字先来写一段代码来直接run起来。看看switch语句中一些注意点

六、return关键字

首先，有两个问题引出。

c语言中有字符串类型吗？

c语言中是没有字符串类型的，但是有字符串，JAVA、python、c++是有的。

计算机中如何理解删除数据？

计算机中，删除数据只是把数据设置为无效（可以这么理解，也就是把当前0|1进制的数据全部“注释”掉，可以这么理解，但是不要当作是真的把这些数据注释掉，其实删除数据是文件操控的）。


理解了这两个问题后，我们再来看这段代码：

#include <stdio.h>
char *show()
{
  char str[] = { "hello bit" };
  return str;
}
int main()
{
  char* s = show();
  printf("%s\n", s);
  return 0;
}

先来看看运行结果：

3768b35036b92c3d5dbc21b5dcf15ddc.png

显然乱码了，那么我们一起来分析一下，为什么乱码了。

首先，我们知道c语言中，函数只要被调用就要向内存开辟空间，下面我们来看看这张图：


611073508d8dcff6be933f008036b398.png

看完这张图，我们来整理一下这段代码的思路：首先有main函数，只要是函数就要在栈区开辟空间，那么首先编译器会提前预估main函数中的需要空间大小有多少，然后开辟特定的空间够main函数使用，然后调用show函数，在栈区开辟show函数栈帧，当show函数返回，栈帧释放，数据无效，然后执行main函数中的printf函数，因为show函数栈帧释放了，所以printf函数覆盖了show函数，变成了乱码

怎么证明show函数数据并没有丢失，而是无效呢？下面来看两张监视图便知。

printf函数调用前：

d07dc531c6b5cbacc86f1827c7871558.png

怎么证明show函数数据并没有丢失，而是无效呢？下面来看两张监视图便知。

printf函数调用前：

842fc13aae5374b6f5e083c854feb3ad.png

显然，show函数中的数据并不是清空了，而是无效了被pirntf函数覆盖了。


解释了show函数中的变量都是临时的，那么为什么临时变量具有临时性？

因为，函数调用，形成栈帧；函数返回，栈帧释放。

推荐：return语句不可返回指向“栈内存”的指针，因为该内存在函数体内结束时被自动销毁。


知道了这些，我们来看看返回值临时变量接收的本质。通过一段代码解释。

#include <stdio.h>
int GetData()
{
  int x = 0x11223344;
  printf("run get data!\n");
  return x;
}
int main()
{
  int g = GetData();
  printf("g = %x\n", g);
  return 0;
}

运行结果是这样的：

88700427c9fcf83491baa1be6d281337.png

我们就在想，临时变量不是具有临时性吗？不应该直接释放空间，没有返回值吗？下面我们用反汇编来看看是为什么出现这种情况。

来看两站反汇编图就能解决这个问题：

GetData函数中：


5c065249a97588f3c70a8ae9dc18b8fc.png

mian函数中：d53d1fd2c63c7eea8be92a3117b94537.png

所以，函数返回值是通过寄存器方式返回给函数调用方。

当然，如果不接受也是放在eax寄存器中,并不处理eax寄存器。

七、const关键字

const是干什么的？

是在修饰变量时，为变量附上只读属性。

（一）、const修饰只读变量

#include <stdio.h>
int main()
{
  int a = 10;
  a = 40;//ok
  const int b = 20;//不可直接被修改
  //b = 30;//err
  printf("%d\n", a);
  printf("%d\n", b);
  return 0;
}

从上述代码可以看出const修饰变量时，不可直接被修改，但是可以通过指针间接修改。

#include <stdio.h>
int main()
{
  const int a = 10;
  //a = 20;//err
  int* p = (int*)&a;
  *p = 20;
  printf("%d\n", a);
  return 0;
}
//输出结果是20

可以通过指针来修改，那么这么说const不就没有意义了吗？

不是的，const的意义：

  1. 告知编译器这里不能修改，如果修改就会出现报错。
  2. 告知程序员这里不能修改，具有“自描述”意义。

另外注意一下：

#include <stdio.h>
int main()
{
  char* p = "hello world!";
  *p = "hello";
  printf("%s\n", p);
  return 0;
}

注意这段代码，字符串常量是真正意义上的不能被修改，是被系统约束的。

（二）、const可以作为数组定义的一部分吗？

int mian()
{
  const int a = 10;
  int arr[a];//err
  return 0;
}

在visual studio 2022中不能被编过的，原因是数组表达式中必须是真正意义上的常量。

（三）、const修饰指针

先通过变量赋值了解指针赋值：

#include <stdio.h>
int main()
{
  int a = 20;
  a = 30;//a指的是空间
  printf("%d\n", a);//输出30
  return 0;
}

再来了解指针赋值（重温：指针变量就是存储地址的空间，指针是地址）：

#include <stdio.h>
int main()
{
  int a = 20;
  int b = 10;
  int* p = &a;
  p = &b;//p指针变量的空间
  int* q = NULL;
  q = p;//p指的是p存储的地址
  printf("%d\n", *p);//输出10
  printf("%d\n", *q);//输出10
  return 0;
}

理解了指针变量和指针的区别，下面我们再来看看const修饰指针的四种情况。

  1. const int *P;
  2. int const *p;
  3. int *const p;
  4. const int *const p;
  1. const int *p情况下：
#include <stdio.h>
int main()
{
    int a = 10;
    const int *p = &a;
    *p = 100;//err
    p = (int*)100;//ok
    return 0;
}

注意：这里的const修饰的是int *类型（也就是修饰的是指针变量，并不是p这个指针），指的是int *指针空间不能直接被改变，换言之，就是p指针指向的内容不能被改变。p指针是可以被赋值的，所以p=100可以被编译器编过。

  1. int const *p情况下：
    这个和const int *p是一样的，只不过写法不同而已。
  2. int *const p情况下:
#include <stdio.h>
int main()
{
    int a = 10;
    int *const p = &a;
    *p = 100;//ok
    p = (int*)100;//err
    return 0;
}

注意：这里的const修饰的是p这个指针，而不是p这个指针变量，所以p=100是error，p这个指针是不能直接被修改的，这里的int并没有别修饰，所以p这个指针变量是可以被修改的，所以p=100是OK的。

  1. const int *const p情况下：
#include <stdio.h>
int main()
{
  int a = 10;
  const int* const p = &a;
  *p = 100;//err
  p = 100;//err
  return 0;
}

有了上面第一种情况和第三种情况，我们就清楚第四种情况为什么*p和p都不能被修改。

（四）、cosnt修饰函数

1.前言

重温：函数传参就要形成临时变量。

证明：

#include <stdio.h>
void show(int* _p)
{
  printf("in_show:%p\n", &_p);
}
int main()
{
  int a = 10;
  int* p = &a;
  printf("int_main:%p\n", &p);
  show(p);
  return 0;
}

运行结果：


937ccd2491fb1501cf009f7523f6b8ba.png

2.const修饰函数返回值

#include <stdio.h>
const int* GetValue()
{
  static int a = 10;
  return &a;
}
int main()
{
  const int* p = GetValue();//两边类型一样就不会报错
  //*p = 100;//err
  return 0;
}

小结：通过这段代码就能很好的解释了const修饰函数返回值，因为GetValue返回的是const修饰的指针类型，所以隐藏含义就是不让其更改。一般内置类型返回加const修饰是没有意义。

八、volatile关键字

volatile关键字是用来干什么的？

编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。

看到这段文字就是懵的。优化是什么？

正常逻辑就是把数据读取到内存中，然后再加载到CPU中的寄存器，进行运算；但是优化是什么，就是不再返回到内存再次读取，而是直接保存在寄存器中，下一次直接运算即可。

（一）、不加volatile

通过这段代码解析：

#include <stdio.h>
int pass = 1;
int main()
{
  while (pass) {
  }
  return 0;
}

看一下这段代码在Linux中的反汇编：


image.png

（二）、加volatile

#include <stdio.h>
volatile int pass = 1;
int main()
{
  while (pass) {
  }
  return 0;
}

再来看看这段代码在Lunix的反汇编：


image.png

所以，对比看出来volatile忽略了编译器的优化，保持内存可见性。

（三）、const和volatile关键字的同时使用问题

#include <stdio.h>
int main()
{
  const volatile int a = 10;
  printf("%d\n", a);
  return 0;
}

这里visual studio 2022是不会报错的，原因是const是从写入内存角度，而volatile是从读取内存数据角度谈的，二者不冲突。

九、extern关键字

extern在多文件使用

声明变量、声明函数

extern int a; //声明变量
extern void function();//声明函数

声明函数时不建议舍掉extern，在上一篇中，我们已经说了extern，这里就不再赘述了

十、struct关键字

这里我们不说语法细节部分，我们只是单纯理解一下空结构体多大和柔性数组，后期我们针对结构体再次解释。

（一）、空结构体有多大

#include <stdio.h>
struct stu {
};
int main()
{
  printf("%d\n", sizeof(struct stu));
  return 0;
}//直接这样写会出现报错
//在visual studio 2022中提示结构体中必须至少要有一个成员

这是在visual studio 2022中，编译器报错处理。而用gcc编译则是：


977bf1bfc8822b3c0bb3467cfca54b33.png

打印出来的结果是0。

（二）、柔性数组

柔性数组就是C99中，结构中的最后一个元素允许是未知大小的数组，但是结构中的柔性数组成员前面必须至少有一个其他成员。


介绍了基本柔性数组的概念，我们一起来通过一段代码来知道柔性数组怎么用这个问题。

首先，柔性数组占用空间吗？


aa2682770c717f949275cd598fcafca5.png

通过这个图就能说明柔性数组是不占空间的。


我们再来看看柔性数组是用来干什么的？

#include <stdio.h>
struct stu{
  int num;
  //........还有很多的成员，直接省略简化
  int arr[0];
};
int main()
{
  int i = 0;
  struct stu* p = malloc(sizeof(struct stu) + sizeof(int) * 10);//加大空间
  p->num = 10;
  for (i = 0; i < p->num; i++) {
    p->arr[i] = i;
  }
  free(p);//free释放空间
  return 0;
}

这段代码怎么理解呢？调试起来通过一张图去理解。

72cbfdb12d81c986282f5b7a9d5bd62c.png

这里暂时只说这么多，理解一下即可，后期会对柔性数组再次全面认识

十一、union关键字

这里就不谈语法知识了，后期还会对union进行再一次的认识。

（一）、大小端对于union的影响

#include <stdio.h>
union un {
  int a;
  char c;
}u;
int main()
{
  printf("%zd\n", sizeof(union un));
  return 0; 
}//输出结果是4

通过这段代码，我们一起来探讨一下union的内存分布问题：


53b4ce4263d3660159c90196a46191b7.png

这个图解释了上面的代码的内存分布，这里有个问题，就是这个char c 空间是在高地址处还是低地址处？


通过打印地址进行检验：

#include <stdio.h>
union un {
  int a;
  char c;
}u;
int main()
{
  printf("%p\n", &u);
  printf("%p\n", &(u.a));
  printf("%p\n", &(u.c));
  return 0;
}

运行结果：


17f0ed7d3036b38c7ec3af3807205e1d.png

通过这个问题可以看出，每个共用体元素都是第一个元素，每个元素的起始地址都是相同的，都是从低地址处开始的。

再来看看大小端对union共用体的影响，首先还是把代码run起来。

#include <stdio.h>
union un {
  int a;
  char c;
};
int main()
{
  union un x;
  x.a = 1;
  if (x.c == 1)
  {
    printf("小端\n");
  }
  else
  {
    printf("大端\n");
  }
  return 0;
}//输出结果是小端

怎么对这里的x.a和x.c分析呢？看图：


060a9bcc7707b8abb1bdf2bc13eb8ec6.png

小端的话值就是1，大端的话值为0。

（二）、补充

还是一样把代码run起来：

#include <stdio.h>
union un {
  int a;
  char c[5];
};
int main()
{
  printf("%d\n", sizeof(union un));
  return 0;
}输出结果是8

这个就很好理解，就是当共用体中空间大小不是定义类型空间大小的倍数的时候，就按共用体中所有类型空间大小的大于整个共用体的空间的最小倍数。例如这里的：整个共用体的空间大小是5，这里面有两个类型int和char，在高于5的情况下，两个类型的最小公倍数是8，所以打印出8。

#include <stdio.h>
union un {
  int i;
  char a[4];
}*p,u;
int main()
{
  p = &u;
  p->a[0] = 0x39;
  p->a[1] = 0x38;
  p->a[2] = 0x37;
  p->a[3] = 0x36;
  printf("ox%x\n", p->i);
  return 0;
}//输出结果是ox36373839

这就很简单理解，因为数据储存是以小端方式存储的，a数组和i都是从低地址处进入共用体的空间的，低地址对应的是低权值，所以打印结果是：ox36373839。

十二、enum关键字

enum是枚举关键字，它的作用是什么呢？

列举很多常量，这些常量都是有相关性的。

#include <stdio.h>
enum color {
  RED,
  YELLOW,
  WHITE,
  BLUE,
  BLACK,
  GREEN
};
int main()
{
  printf("%d\n", RED);
  printf("%d\n", YELLOW);
  printf("%d\n", WHITE);
  printf("%d\n", BLUE);
  printf("%d\n", BLACK);
  printf("%d\n", GREEN);
  return 0;
}

看一下这段代码，运行结果是：

012345。所以可以看出枚举常量标识符代表的是一个整型值，并不是字符串。


再来看看这段代码：

#include <stdio.h>
enum color {
  red=3,
  yellow,
  white,
  blue,
  black=5,
  green
};
int main()
{
  printf("%d\n", red);
  printf("%d\n", yellow);
  printf("%d\n", white);
  printf("%d\n", blue);
  printf("%d\n", black);
  printf("%d\n", green);
  return 0;
}

输出结果是：345656。

可以看出，枚举常量整型值是从初始开始依次递增的。

十三、typedef关键字

typedef作用是什么？

本质上就是对类型进行重命名。

（一）、对不同类型的重命名

对一般类型进行重命名


257af9b13f46ee29cec0c86f93b977bd.png

对指针进行重命名

1a8901f16022bed1936ede9da7d98e5c.png

对结构体进行重命名


522cca511768d374efeebafc0b3f5eba.png

对数组进行重命名


8f8a6735bda6cf4413280c754377b8bc.png

  1. 对指针和数组重命名不推荐。

（二）、typedef与#define区别

1.问题一

typedef int * ptr_t;//重新定义新类型，相当于一个独立的类型。
ptr_t p1,p2;
//问：p1,p2分别是什么类型？

看图：


7aac9acccc16d0892b601c13b3e47edc.png

看图便知：p1,p2两个变量的类型都是指针类型。


在这里补充一点：

typedef int * ptr_t;
int* p1,p2;
//问：这里的a,b变量都是一样的类型吗？

看图：

5967998b119bae23d368f855b7187509.png

看图便知,p1的类型是int*，p2的类型是int，为什么呢？你可以理解为就近原则吧，p1离 * 更近，所以p1变量是int 指针类型，从本质上来说这是规定，不要问为什么。
这里我们看到int修饰 两个变量时一个是int *,一个是int。那么我们怎么用同一形式定义两个指针呢？

int *p1,*p2;

这样就是定义两个指针类型。

#define PTR_T int*
PTR_T p1,p2;
//问：p1,p2分别是什么类型？

看图：

481d6be8a125a5ccf5c70ec53514dd27.png

看图便知，p1变量是int*指针类型给，p2变量是int类型。和上述的（int * p1,p2;）一个道理。

2.问题二

先看两段代码，再一次理解typedef和define宏定义的区别：

typedef int int32;
int main()
{
    unsigned int32 b;//err
    return 0;
}//typedef定义的是一个独立类型，不能再对类型进行修饰

#define INT32 int 
int main()
{
    unsigned INT32 a;//ok
    return 0;
}

3.typedef static int s_int行不行

不行的。报错显示：指定了一个以上的存储类。

对这个报错显示进行解释：

存储类型关键字有五个：auto、extern、register、static、typedef这五个。存储关键字，不可以同时出现，也就是说，在变量定义的时候只能有一个。



























文章标签：
Java
C++
C语言
Python
Linux
程序员
存储
编译器
关键词：
C语言关键字
txfwuupyzmygs
目录
相关文章
那一脸阳光
|
22天前
|
存储 程序员 C语言
C语言关键字是什么？什么是关键字？什么是字符和ascll码值
C语言关键字是什么？什么是关键字？什么是字符和ascll码值
那一脸阳光
33 0
炫酷的伊莉娜
|
16天前
|
存储 C语言
【C语言】数据：数据类型关键字
【C语言】数据：数据类型关键字
炫酷的伊莉娜
22 0
稻草人敲代码
|
16天前
|
存储 编译器 C语言
c语言中static关键字的作用
c语言中static关键字的作用
稻草人敲代码
8 0
GR鲸鱼
|
16天前
|
编译器 C语言 C++
从C语言到C++③(第一章_C++入门_下篇)内联函数+auto关键字(C++11)+范围for+nullptr（下）
从C语言到C++③(第一章_C++入门_下篇)内联函数+auto关键字(C++11)+范围for+nullptr
GR鲸鱼
20 0
GR鲸鱼
|
16天前
|
存储 安全 编译器
从C语言到C++③(第一章_C++入门_下篇)内联函数+auto关键字(C++11)+范围for+nullptr（上）
从C语言到C++③(第一章_C++入门_下篇)内联函数+auto关键字(C++11)+范围for+nullptr
GR鲸鱼
23 0
热爱嵌入式的小佳同学
|
22天前
|
算法 C语言
C语言易混淆、简单算法、结构体题目练习、常见关键字总结-2
C语言易混淆、简单算法、结构体题目练习、常见关键字总结
热爱嵌入式的小佳同学
18 0
热爱嵌入式的小佳同学
|
22天前
|
算法 编译器 API
C语言易混淆、简单算法、结构体题目练习、常见关键字总结-1
C语言易混淆、简单算法、结构体题目练习、常见关键字总结
热爱嵌入式的小佳同学
22 1
ohh.
|
22天前
|
安全 编译器 C语言
C语言中的const关键字
C语言中的const关键字
ohh.
19 2
阿甘兄
|
7月前
|
存储 安全 编译器
13 C++ - const关键字（比较C语言)
13 C++ - const关键字（比较C语言)
阿甘兄
48 0
早點睡.
|
22天前
|
程序员 C语言
在C语言中，typedef是一种用来创建新的数据类型名的关键字
在C语言中，typedef是一种用来创建新的数据类型名的关键字
早點睡.
13 0

热门文章

最新文章

  • 1
    [C语言]链表实现贪吃蛇及部分模块优化
  • 2
    C语言及程序设计提高例程-35 使用指针操作二维数组
  • 3
    C语言库函数大全及应用实例七
  • 4
    C语言OJ项目参考(2284)按长度截断
  • 5
    《C语言及程序设计》实践项目——分支结构程序设计体验
  • 6
    《C语言程序设计：问题与求解方法》——0.2节理想厨房系统的一个炒菜实例
  • 7
    让你提前认识软件开发(19)：C语言中的协议及单元测试示例
  • 8
    文件锁操作《精通Unix下C语言编程与项目实践》之三
  • 9
    《C语言课程设计》一2.3　命名规则
  • 10
    （2）巩固一下C语言基础知识，谁动手，谁收获。
  • 1
    C语言的形参跟实参区别跟联系
    11
  • 2
    【程序环境和预处理】C语言
    34
  • 3
    【动态内存管理】C语言
    31
  • 4
    【指针的进阶】C语言
    29
  • 5
    【深度剖析数据在内存中的存储】C语言
    27
  • 6
    C语言递归问题【青蛙跳台阶】和【汉诺塔】
    16
  • 7
    c语言——俄罗斯方块
    50
  • 8
    用Java（C语言也可以看）实现冒泡排序和折半查找（详细过程图）+逆序数组
    34
  • 9
    C语言刷题：整数加逗号、删除公共字符、求最小公倍数和将字符串倒置
    35
  • 10
    【JavaSE】运算符详解及与C语言中的区别
    61

    • 相关课程

    更多
  • 你的第一门C语言课
  • C语言学习教程

    • 相关电子书

    更多
  • 低代码开发师（初级）实战教程
  • 冬季实战营第三期：MySQL数据库进阶实战
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    2024年阿里云免费云服务器及学生云服务器申请教程参考