C语言回顾day3（一）

「爱情、让人受尽委屈。」 2023-07-03 02:59 15阅读 0赞

### 文章目录 ###

*  \_Bool类型
 *  复数类型 虚数类型
 *  由基本数据类型衍生的数据类型：数组，指针，联合，结构
 *  浮点数类型（float, double, long double）
 *   *  浮点数上溢overflow
     *  浮点数下溢(underflow 比上溢更复杂)
 *  sizeof运算符
 *   *  1字节并不一定是8位哦！！！C规定了char类型占的位数为1字节，所以才是8位，如果char占16位，那一个字节就是16位，double就占4字节咯
 *  参数
 *  printf输出：刷新缓冲区

第三章的后半部分

# \_Bool类型 #

三行字，就这么简单  
![在这里插入图片描述][20200201120805829.png]  
![在这里插入图片描述][20200203152756445.png]  
![在这里插入图片描述][2020020315284016.png]![在这里插入图片描述][20200201143044937.png]

# 复数类型 虚数类型 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]

![在这里插入图片描述][20200201143144134.png]

# 由基本数据类型衍生的数据类型：数组，指针，联合，结构 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]

# 浮点数类型（float, double, long double） #

float只能保证小数点后6位的精度

浮点数的存储原理：只存储指数和尾数，一般指数分多少位，尾数又分多少位  
![在这里插入图片描述][20200201133143548.png]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]  
这个试验可以验证

#include <stdio.h>
    int main()
    {
        float x = 1.2;
        double y = 2.4;
        printf("%d, %d, %d", sizeof(x), sizeof(y), sizeof(3.8));
        return 0;
    }

4, 8, 8

我想试试float*float和double*double再截短为float会不会有精度的区别，做了下面这个实验，两种运算得到的结果是一样的！！

#include <stdio.h>
    int main()
    {
        float x, y;
        x = 1.245623451234f * 2.5454667841234f;
        y= 1.245623451234 * 2.5454667841234;
        printf("%f, %f", x, y);
        return 0;
    }

3.170693, 3.170693

#include <stdio.h>
    int main()
    {
        printf("float: %f, %e\n", 123400.0f, 123400.0f);
        printf("double: %f, %e\n", 123400.0, 123400.0);
        printf("long double: %lf, %le\n", 123400.0L, 123400.0L);
        printf("long double: %d\n", sizeof(123400.0L));
        return 0;
    }

不知道为啥long double会出错

float: 123400.000000, 1.234000e+005
    double: 123400.000000, 1.234000e+005
    long double: -254364564242548150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000, 8.102183e-320
    long double: 12

## 浮点数上溢overflow ##

#include <stdio.h>
    int main()
    {
        printf("float: %f, %e\n", 2.0e38f, 2.0e38f);
        printf("float: %f, %e\n", 2.0e39f, 2.0e39f);
        return 0;
    }

10的38次方还能正确表示，不过注意实际上存储的并不是精精准准的200000000······哦

10的39次方就超出范围了，编译器打印INF

float: 199999993605713850000000000000000000000.000000, 2.000000e+038
    float: 1.#INF00, 1.#INF00e+000

## 浮点数下溢(underflow 比上溢更复杂) ##

![在这里插入图片描述][20200201142359347.png]

NaN也算浮点值！！！长知识了  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]

不举例子还是不明白

但是我暂时找不到例子

·······

# sizeof运算符 #

![在这里插入图片描述][20200201143803559.png]

#include <stdio.h>
    int main()
    {
        printf("%d, %d, %d, %d, %d\n", sizeof(char), sizeof(short), sizeof(int), sizeof(long), sizeof(long long));
        printf("%d, %d, %d\n", sizeof(float), sizeof(double), sizeof(long double));
        return 0;
    }

1, 2, 4, 4, 8
    4, 8, 12

我用%d也用的好好的！！！如果用%zd,反而还出错了·····不知道为啥

后面添加：这是因为我没选择编译器使用的C标准，选择c99或者C11就不会出错了，也会得到正确结果

需要注意的是，虽然这里%d的结果对了，但是sizeof运算符本身返回的数据应该是无符号的整型，所以最为准确的应该用%u, %lu, %llu。%zd就是为了解决这个问题的，直接用%zd，不用考虑到底用%u, %lu, %llu的哪一个都不会出错。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 5]

zd, zd, zd, zd, zd
    zd, zd, zd

sizeof只是对象是类型是必须加圆括号  
![在这里插入图片描述][2020020116373965.png]

## 1字节并不一定是8位哦！！！C规定了char类型占的位数为1字节，所以才是8位，如果char占16位，那一个字节就是16位，double就占4字节咯 ##

这一点真实没注意过，一直以为一个字节就是死死的8bit  
![在这里插入图片描述][20200201144058629.png]![在这里插入图片描述][20200201144113408.png]

# 参数 #

![在这里插入图片描述][20200201150224495.png]![在这里插入图片描述][20200201150318640.png]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 6]

上图的最后一个红框让我回忆起昨天看的内容，scanf和printf无法检测占位符和后面参数的数量是否相等······看了红框的描述，我还是觉得编译器或者函数本身应该可以完成这件事情·······不明白为啥没做

要是占位符和后面参数的个数不相等啦，类型不匹配啦，编译器并不报错，于是就产生了陷阱！！！想起了那本书：C陷阱与缺陷，不知道有没有可能也写到这一点呢

# printf输出：刷新缓冲区 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 7]

[20200201120805829.png]: https://img-blog.csdnimg.cn/20200201120805829.png
[20200203152756445.png]: https://img-blog.csdnimg.cn/20200203152756445.png
[2020020315284016.png]: https://img-blog.csdnimg.cn/2020020315284016.png
[20200201143044937.png]: https://img-blog.csdnimg.cn/20200201143044937.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200201131041934.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200201143144134.png]: https://img-blog.csdnimg.cn/20200201143144134.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200201130908444.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200201133143548.png]: https://img-blog.csdnimg.cn/20200201133143548.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200201143116686.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200201142359347.png]: https://img-blog.csdnimg.cn/20200201142359347.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020020114265154.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200201143803559.png]: https://img-blog.csdnimg.cn/20200201143803559.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200201182536340.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200201182928156.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[2020020116373965.png]: https://img-blog.csdnimg.cn/2020020116373965.png
[20200201144058629.png]: https://img-blog.csdnimg.cn/20200201144058629.png
[20200201144113408.png]: https://img-blog.csdnimg.cn/20200201144113408.png
[20200201150224495.png]: https://img-blog.csdnimg.cn/20200201150224495.png
[20200201150318640.png]: https://img-blog.csdnimg.cn/20200201150318640.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200201150550160.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200201151018607.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70