C语言回顾day4（第五章运算符表达式语句）

比眉伴天荒 2023-07-03 04:52 118阅读 0赞

### 文章目录 ###

*  运算符
 *   *  赋值=
     *   *  C语言支持多重赋值（其他语言都基本不支持）
     *  指数增长
 *  截断truncation
 *   *  sizeof
     *  求模运算符 % modulus operator
     *  \++递增运算符
 *  表达式
 *  语句!\[在这里插入图片描述\](https://img-blog.csdnimg.cn/20200202191702747.png)
 *  强制类型转换（cast）运算符
 *   *  运算符总结
 *  函数原型的作用（可以实现自动类型转换！！牛逼）

# 运算符 #

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

## 赋值= ##

![在这里插入图片描述][20200202153458601.png]![在这里插入图片描述][20200202153631453.png]![在这里插入图片描述][20200202153722768.png]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]  
总之，对象一词在C语言种不是面向对象那个对象，而是指内存。这其实也不是很重要啦，感觉平时不太区分这个，只是要把概念搞清楚，赋值语句实际上是在把一个值存到变量名或者指针表示的内存上。以及明白赋值语句会用到左值右值两个术语，左值是可以被修改的可以被赋值的实体，实际上他们就是内存的标识。。而右值只能是常量。仅此而已

所以下面这句话虽然简单，但是如果不知道上面那点则根本不会知道C语言说“对象”一词实际上说的是内存  
![在这里插入图片描述][20200202155532934.png]

### C语言支持多重赋值（其他语言都基本不支持） ###

从右到左，12先赋给z, z赋值给y, y再赋值给x

#include <stdio.h>
    #include <string.h>
    int main()
    { 
        int x, y, z;
        x = y = z = 12;
        printf("%3d %3d %3d\n", x, y, z);
        return 0;
    }

12  12  12

打印平方表

#include <stdio.h>
    int main()
    {
        int x = 1;
        while(x < 11){
            printf("%-2d  %-4d\n", x, x*x);
            x += 1;
        }
        return 0;
    }

1   1
    2   4
    3   9
    4   16
    5   25
    6   36
    7   49
    8   64
    9   81
    10  100

## 指数增长 ##

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

#include <stdio.h>
    #define SQUARES 64 //棋盘格子总数
    int main()
    { 
        const double CROP = 2e16; //世界小麦年产总数
        int count = 1;
        double current, total;
        current = total = 1.0; //初始小麦粒数
        printf("square total grains fraction of world total\n");
        while(count <= SQUARES){ 
                current *= 2;
                total += current;
                printf("%4d %12.2e %12.2e\n", count, total, total/CROP);
                count++;
        }
        return 0;
    }

square   total grains   fraction of world total
       1      3.00e+000      1.50e-016
       2      7.00e+000      3.50e-016
       3      1.50e+001      7.50e-016
       4      3.10e+001      1.55e-015
       5      6.30e+001      3.15e-015
       6      1.27e+002      6.35e-015
       7      2.55e+002      1.27e-014
       8      5.11e+002      2.55e-014
       9      1.02e+003      5.12e-014
      10      2.05e+003      1.02e-013
      11      4.10e+003      2.05e-013
      12      8.19e+003      4.10e-013
      13      1.64e+004      8.19e-013
      14      3.28e+004      1.64e-012
      15      6.55e+004      3.28e-012
      16      1.31e+005      6.55e-012
      17      2.62e+005      1.31e-011
      18      5.24e+005      2.62e-011
      19      1.05e+006      5.24e-011
      20      2.10e+006      1.05e-010
      21      4.19e+006      2.10e-010
      22      8.39e+006      4.19e-010
      23      1.68e+007      8.39e-010
      24      3.36e+007      1.68e-009
      25      6.71e+007      3.36e-009
      26      1.34e+008      6.71e-009
      27      2.68e+008      1.34e-008
      28      5.37e+008      2.68e-008
      29      1.07e+009      5.37e-008
      30      2.15e+009      1.07e-007
      31      4.29e+009      2.15e-007
      32      8.59e+009      4.29e-007
      33      1.72e+010      8.59e-007
      34      3.44e+010      1.72e-006
      35      6.87e+010      3.44e-006
      36      1.37e+011      6.87e-006
      37      2.75e+011      1.37e-005
      38      5.50e+011      2.75e-005
      39      1.10e+012      5.50e-005
      40      2.20e+012      1.10e-004
      41      4.40e+012      2.20e-004
      42      8.80e+012      4.40e-004
      43      1.76e+013      8.80e-004
      44      3.52e+013      1.76e-003
      45      7.04e+013      3.52e-003
      46      1.41e+014      7.04e-003
      47      2.81e+014      1.41e-002
      48      5.63e+014      2.81e-002
      49      1.13e+015      5.63e-002
      50      2.25e+015      1.13e-001
      51      4.50e+015      2.25e-001
      52      9.01e+015      4.50e-001
      53      1.80e+016      9.01e-001
      54      3.60e+016      1.80e+000
      55      7.21e+016      3.60e+000
      56      1.44e+017      7.21e+000
      57      2.88e+017      1.44e+001
      58      5.76e+017      2.88e+001
      59      1.15e+018      5.76e+001
      60      2.31e+018      1.15e+002
      61      4.61e+018      2.31e+002
      62      9.22e+018      4.61e+002
      63      1.84e+019      9.22e+002
      64      3.69e+019      1.84e+003

# 截断truncation #

![在这里插入图片描述][20200202163403142.png]  
注意**负数整数的除法中，使用趋零截断**，比如-10/3的结果本来是-3.3，那么结果就会被截断为-3， 从C99标准以后都这样了

## sizeof ##

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

great!!

#include <stdio.h>
    int main()
    { 
        size_t intsize;
        intsize = sizeof(int);
        printf("There are %zd bytes in an int variable.\n", intsize);
        return 0;
    }

There are 4 bytes in an int variable.

## 求模运算符 % modulus operator ##

余数 remainder  
![在这里插入图片描述][20200202171126604.png]

## \++递增运算符 ##

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

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

#include <stdio.h>
    int main()
    { 
       int x = 0;
       printf("++x\n");
       while(++x<2){ 
            printf("%d\n", x);
       }
       printf("x++\n");
       x = 0;
    while(x++<2){ 
            printf("%d\n", x);
       }
        return 0;
    }

可以看得出==++x是先递增然后再去看while的条件是否为真，x++是先看while的条件然后递增==，所以x++能打印出2

++x
    1
    x++
    1
    2

#include <stdio.h>
    int main()
    {
        int x = 0;
        while(x<2){
        printf("%d\n", x);
        ++x;
        }
        return 0;
    }

0
    1

可以用++把程序缩短，更紧凑，通过把++放进while条件里，但是注意要把x的初始值减1哦，不然不能得到一样的结果

#include <stdio.h>
    int main()
    {
        int x = -1;
        while(++x<2){
        printf("%d\n", x);
        }
        return 0;
    }

进一步区分++x和x++

#include <stdio.h>
    int main()
    {
       int x = 1, y = 1;
       int x_pre, y_post;
       x_pre = ++x;
       y_post = y++;
       printf("x   ++x   y   y++\n");
       printf("%3d %3d %3d %3d\n",x, x_pre, y, y_post);
        return 0;
    }

x   ++x   y   y++
      2   2   2   1

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

# 表达式 #

表达式就是内存和操作这些内存的运算符  
![在这里插入图片描述][20200202190821164.png]![在这里插入图片描述][20200202190956661.png]![在这里插入图片描述][20200202191528507.png]  
![在这里插入图片描述][20200202192604231.png]

# 语句![在这里插入图片描述][20200202191702747.png] #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]  
花括号括起来的就是一个块

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

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

# 强制类型转换（cast）运算符 #

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

/*pound.c 打印井号*/
    #include <stdio.h>
    int main()
    {
        int x, y;
        x = 1.2 + 2.3; // 自动类型转换,3.5截断为3
        y = (int)1.2 + (int)1.3;//强制类型转换
        printf("x=%d y=%d", x, y);
        return 0;
    }

x=3 y=2

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

终于明白为啥很多人说C++很多陷阱，抱怨不迭，原来是因为语言为了不给程序员设置障碍而故意放开了一些东西，所以就更考研程序员自己的灵活应用能力了，并不是说语言不好

总之类型转换是很容易掉坑的，要时刻清楚自己的类型对不对

## 运算符总结 ##

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

# 函数原型的作用（可以实现自动类型转换！！牛逼） #

![在这里插入图片描述][20200203114447299.png]![在这里插入图片描述][20200203121517781.png]![在这里插入图片描述][20200203121533210.png]![在这里插入图片描述][20200203121638356.png]![在这里插入图片描述][20200203114533480.png]![在这里插入图片描述][20200203121608900.png]

/*pound.c 打印井号*/
    #include <stdio.h>
    void pound(int n); //函数原型
    int main()
    { 
        int x = 4;
        float y = 5.0;
        char z = "!"; //ASCII码为33
        pound(x);
        pound(y); //相当于pound((int)y),函数原型在这里就起到了作用
        pound(z); //相当于pound((int)z)
        return 0;
    }
    void pound(int n){ 
        while(n-->0)
        printf("#");
        printf("\n");
    }

####
    #####
    ####################################################################

上面程序中的pound函数的n是形式参数（formal argument），是一个int变量，而main函数中调用pound函数时，pound(x)传入的x=4是实际参数(actual argument)。

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

如果把函数原型那句代码改为旧的函数声明，则float 打印出错，因为编译器只会把float自动转换为double，并不能进一步转换为int，这时候就只能在代码里显式地强制转换了

void pound(); //函数声明

####
    
    ####################################################################

这个示例是关于自动类型转换的

#include <stdio.h>
    int main()
    { 
        char c1 = 'S', c2 = 'O';
        int diff = c1 - c2;
        float num = diff;
        printf("%c%c%c%d %4.2f\n", c1, c2, c1, diff, num);
        return 0;
    }

SOS4 4.00

[20200202163752120.png]: https://img-blog.csdnimg.cn/20200202163752120.png
[20200202153458601.png]: https://img-blog.csdnimg.cn/20200202153458601.png
[20200202153631453.png]: https://img-blog.csdnimg.cn/20200202153631453.png
[20200202153722768.png]: https://img-blog.csdnimg.cn/20200202153722768.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200202154018292.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200202155532934.png]: https://img-blog.csdnimg.cn/20200202155532934.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200202162040500.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200202163403142.png]: https://img-blog.csdnimg.cn/20200202163403142.png
[20200202170544121.png]: https://img-blog.csdnimg.cn/20200202170544121.png
[20200202170850977.png]: https://img-blog.csdnimg.cn/20200202170850977.png
[20200202171126604.png]: https://img-blog.csdnimg.cn/20200202171126604.png
[20200202190600774.png]: https://img-blog.csdnimg.cn/20200202190600774.png
[20200202183925711.png]: https://img-blog.csdnimg.cn/20200202183925711.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200202190700505.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200202190821164.png]: https://img-blog.csdnimg.cn/20200202190821164.png
[20200202190956661.png]: https://img-blog.csdnimg.cn/20200202190956661.png
[20200202191528507.png]: https://img-blog.csdnimg.cn/20200202191528507.png
[20200202192604231.png]: https://img-blog.csdnimg.cn/20200202192604231.png
[20200202191702747.png]: https://img-blog.csdnimg.cn/20200202191702747.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/2020020219282545.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200202192223580.png]: https://img-blog.csdnimg.cn/20200202192223580.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200202193306911.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200203115052552.png]: https://img-blog.csdnimg.cn/20200203115052552.png
[2020020311550939.png]: https://img-blog.csdnimg.cn/2020020311550939.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20200203115749660.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NjA3ODk0,size_16,color_FFFFFF,t_70
[20200203114447299.png]: https://img-blog.csdnimg.cn/20200203114447299.png
[20200203121517781.png]: https://img-blog.csdnimg.cn/20200203121517781.png
[20200203121533210.png]: https://img-blog.csdnimg.cn/20200203121533210.png
[20200203121638356.png]: https://img-blog.csdnimg.cn/20200203121638356.png
[20200203114533480.png]: https://img-blog.csdnimg.cn/20200203114533480.png
[20200203121608900.png]: https://img-blog.csdnimg.cn/20200203121608900.png
[20200203113931608.png]: https://img-blog.csdnimg.cn/20200203113931608.png
[20200203113945798.png]: https://img-blog.csdnimg.cn/20200203113945798.png