C语言基础之基础语法、基本运算及流程控制

一、基础语法

1、关键字
(1)什么是关键字
   a> 关键字就是C语言提供的有特殊含义的符号，也叫做“保留字”。
   b> C语言一共提供了32个关键字，这些关键字都被C语言赋予了特殊含义。
(2)关键字的特征
   a> 全部都是小写。
   b> 在开发工具或者智能文本编辑工具中会显示特殊颜色。默认情况下，C语言中的所有关键字在Xcode中都会显示紫褐色。

2、标识符
(1)什么是标识符
    标识符就是在程序中自定义的一些符号和名称。要跟关键字区分开来：关键字是C语言默认提供的符号，标识符是程序员自定义的。
(2)标识符的作用
   a>标识符，从字面上理解就是用来标识某些东西的符号，标识的目的就是为了将这些东西区分开来。
   b>其实，标识符的作用就跟人类的名字差不多，为了区分每个人，就在每个人出生的时候起了个名字。
   c>C语言是由函数构成的，一个C程序中可能会有多个函数，为了区分这些函数，就给每一个函数都起了个名称。函数的名称就是标识符的一种。除了函数，以后还会学到“变量”这个概念，变量的名称也是标识符。
(3)命名
   a>命名规则（一定要遵守）
   1.只能由26个英文字母的大小写、10个阿拉伯数字0~9、下划线_组。
   2.严格区分大小写，比如test和Test是2个不同的标识符。
   3.不能以数字开头。
   4.不可以使用关键字作为标识符。
   b> 命名规范（最好遵守）
   尽量起个有意义的名称，比如一个完整的英文单词，别人一看这个名称就能才能这个标识符的作用。如果不懂英文，你也可以用拼音，尽量不要起像abcde、sfsdfsdf等这类看起来没有意义的名称。
 如果标识符中含有多个单词，可以使用驼峰标识（除开第一个单词，后面每个单词的首字母都是大写）：firstName、myFirstName，或者使用下划线_来连接：first_name、my_first_name。

3、注释
(1)什么是注释
   a>注释是在所有计算机语言中都非常重要的一个概念，从字面上看，就是注解、解释的意思。
   b>注释可以用来解释某一段程序或者某一行代码是什么意思，方便程序员之间的交流。假如我写完一行代码后，加上相应的注释，那么别人看到这个注释就知道我的这行代码是做什么用的。
   c>注释可以是任何文字，也就是说可以写中文。
   d>在开发工具中注释一般是豆沙绿色。
(2)单行注释
   a>单行注释以两个正斜杠开头，也就是以//开头，只能注释一行，从//开始到这行的结尾都是注释的内容。
   b>任何地方都可以写注释：函数外面、里面，每一条语句后面。
(3)多行注释
   多行注释以/*开头，以*/结尾，/*和*/中间的内容都是注释。
(4)注释的作用
   a>被注释的代码不会参与编译注释是写给人看的，不是给计算机看的。计算机怎么可能看得我们写的中文嘛。因此，当编译程序的时候，并不会将注释编译到.o目标文件中从.o文件的大小可以间接看出注释后的代码并没有被编译
   b>检查代码的作用
   c> 排除错误
(5)注释的嵌套现象
   a>单行注释可以嵌套单行注释、多行注释
   b>多行注释可以嵌套单行注释
   c>多行注释不能嵌套多行注释

4、C语言中的数据类型

(1)常量
   a>什么是常量： 常量，表示一些固定的数据。
   b>常量的分类
     1.整型常量(int),包括了所有的整数
     2.浮点型常量(float\double)
浮点型常量分为double和float两种数据类型：
double：双精度浮点型，其实就是小数。
float：单精度浮点型，也是小数，比double的精确程度低，也就是说所能表示的小数位数比较少。为了跟double区分开来，float 型数据都是以f结尾的，比如5.43f、-2.3f、0.0f。需要注意的是，绝对不能有10f这样格式的，编译器会直接报错，只有小数才允许加上f。
     3.字符常量(char)
   将一个数字（0~9）、英文字母（a~z、A~Z）或者 其他符号（+、-、!、?等）用单引号括起来，这样构成的就是字符常量。比如'6'、'a'、'F'、'+'、'$'等。
注意：单引号只能括住1个字符，而且不能是中文字符，下面的写法是错误的：'abc'、'123456'、'男'
     4.字符串常量
   将一个或者多个字符用双引号（""）括起来，这样构成的就是字符串常量。比如"6"、"男"、"哇哈哈"、"abcd"、"my_car4"，其实printf("Hello World");语句中的"Hello World"就是字符串常量。

(2)变量
   a>什么是变量： 当一个数据的值需要经常改变或者不确定时，就应该用变量来表示。比如游戏积分。
   b>定义变量
    1.目的
 任何变量在使用之前，必须先进行定义。 定义变量的目的是：在内存中分配一块存储空间给变量，方便以后存储数据。 如果定义了多个变量，就会为这多个变量分别分配不同的存储空间。
    2.格式
   变量类型 变量名;比如int num;
 变量名属于标识符,不同类型的变量占用不同大小的存储空间。内存极其有限，分配适当的存储空间
约束变量所存放的数据类型（方便运算）
   c>变量的存储
    1.所占用字节数跟类型有关，也跟编译器环境有关
                 
    2.

int b = 10;//内存由大到小寻址，优先分配内存地址较大的字节给变量。b的内存地址比a大
int a = 20;//每个变量都有地址：第一个字节的地址就是变量的地址

    3.查看内存地址：

int a;
printf("a的地址是：%p\n", &a);

    4.注意
      在变量未经初始化之前，不要尝试使用变量的值。
    5、scanf函数
    这也是在stdio.h中声明的一个函数，因此使用前必须加入#include <stdio.h>。调用scanf函数时,需要传入变量的地址作为参数,scanf函数会等待标准输入设备（比如键盘）输入数据，并且将输入的数据赋值给地址对应的变量
简单用法：

int age;
scanf("%d", &age);/*执行到scanf函数时，会等待用户的键盘输入，并不会往后执行代码。scanf的第1个参数是"%d"，说明要求用户以10进制的形式输入一个整数。这里要注意，scanf的第2个参数传递的不是age变量，而是age变量的地址&age，&是C语言中的一个地址运算符，可以用来获取变量的地址.输入完毕后，敲一下回车键，目的是告诉scanf函数我们已经输入完毕了，scanf函数会将输入的值赋值给age变量*/

其他用法：
**用scanf函数接收3个数值，每个数值之间用中划线-隔开
scanf("%d-%d-%d", &a, &b, &c);
3个%d之间是用中划线-隔开的，因此我们在每输入一个整数后都必须加个中划线-，比如这样输入 ，不然在给变量赋值的时候会出问题
注意：数值之间的分隔符是任意的，不一定要用中划线-，可以是逗号、空格、星号*、井号#等等，甚至是英文字母,在输入的时候以相应的分隔符隔开即可。
**用scanf函数接收3个数值，每个数值之间用空格隔开
scanf("%d %d %d", &a, &b, &c);3个%d之间是用空格隔开的，我们在每输入一个整数后必须输入一个分隔符，分隔符可以是空格、tab、回车
**注意
scanf中不要包含\n，比如scanf(“%d\n”, &a); 这将导致scanf函数无法结束

#include <stdio.h>
//主函数
int main()
{
//声明变量
int a,b;
//输入a和b的值
scanf("%d,%d",&a,&b);
printf("a和b的和是%d\n",a+b);

//不同的间隔符，输入时需要相应的间隔符
scanf("%d %d",&a,&b);//空格、Tab、回车都行
printf("a和b的和是%d\n",a+b);

scanf("%d--%d",&a,&b);
printf("a和b的和是%d\n",a+b);

scanf("%d@@%d",&a,&b);
printf("a和b的和是%d\n",a+b);

scanf("%d %d",&a,&b);//空格、Tab、回车都行
printf("a和b的和是%d\n",a+b);
return 0;
}

二、基本运算

1、算术运算
   C语言一共有34种运算符，包括了常见的加减乘除运算
  (1)加法运算+
 除开能做加法运算，还能表示正号：+5、+90
  (2)减法运算-
 除开能做减法运算，还能表示符号：-10、-29
  (3)乘法运算*
   注意符号，不是x，而是*
  (4)除法运算/
 注意符号，不是÷，也不是\，而是/。整数除于整数，还是整数。1/2的值是0，这个并不是二分之一
  (5)取余运算%
 什么是取余：两个整数相除之后的余数。%两侧只能是整数。正负性取决于%左侧的数值
  (6)注意点
   a>自动类型转换

int a = 10.6;
int b = 10.5 + 1.7;//自动将大类型转换为了小类型，会丢失精度。

   b>自动类型提升

int b = 10.5 + 10;//将右边的10提升为了double类型
double b = 1.0 / 2;//解决除法的精度问题

   c>强制类型转换

double a = (double)1 / 2;
double b = (double)(1 / 2);

2、赋值运算

  (1)简单赋值
   等号左边不能是常量，比如10 = 11;
  (2)复合赋值
   复加减乘除余：a += 4 + 5;

3、自增自减

  (1)简单使用
   ++ 自增运算符。如a++，++a，都等价于a = a+1。自减运算符。如a--，--a，都等价于a = a-1。5++是错误的。
  (2)++a和a++的区别
   先加1再运算，先运算后加1

4、sizeof
  (1)作用
     用来计算一个变量或者一个常量、一种数据类型所占的内存字节数。
  (2)基本形式
sizeof( 变量\常量 )
sizeof 变量\常量
sizeof( 数据类型 )，这个括号不能去掉

#include <stdio.h>
//主函数
int main()
{
int a;
printf("a占得字节数为%ld\n",sizeof a);
printf("a占得字节数为%ld\n",sizeof(a));
printf("10占得字节数为%ld\n",sizeof 10);
printf("1.2f占得字节数为%ld\n",sizeof(1.2f));
printf("1.2占得字节数为%ld\n",sizeof(1.2));
printf("int占得字节数为%ld\n",sizeof (int));
printf("char占得字节数为%ld\n",sizeof(char));
printf("double占得字节数为%ld\n",sizeof(double));
return 0;
}
/*运行结果如下：
a占得字节数为4
a占得字节数为4
10占得字节数为4
1.2f占得字节数为4
1.2占得字节数为8
int占得字节数为4
char占得字节数为1
double占得字节数为8*/

5、关系运算(比较运算)
   a>条件判断
   默认情况下，我们在程序中写的每一句正确代码都会被执行。但很多时候，我们想在某个条件成立的情况下才执行某一段代码，这种情况的话可以使用条件语句来完成，但是我们暂时不学习条件语句，先来看一些更基础的知识：如何判断一个条件成不成立。
   b>真假
 在C语言中，条件成立称为“真”，条件不成立称为“假”，因此，判断条件是否成立，就是判断条件的“真假”。C语言规定，任何数值都有真假性，任何非0值都为“真”，只有0才为“假”。也就是说，108、-18、4.5、-10.5等都是“真”，0则是“假”。
   c>关系比较
   开发中经常要比较，比如斗地主游戏中牌的大小。利用关系运算符就可以比较两个值的大小。关系运算符的运算结果只有2种：如果条件成立，结果就为1，也就是“真”；如果条件不成立，结果就为0，也就是“假”。
   d>使用注意
关系运算符中==、!=的优先级相等，<、<=、>、>=的优先级相等，且前者的优先级低于后者：2==3>1
关系运算符的结合方向为“从左往右”： 4>3>2
关系运算符的优先级小于算术运算符：3+4>8-2

#include <stdio.h>
//主函数
int main()
{

printf("%d\n",3 > 4 + 7);//0
printf("%d\n",(3 > 4) + 7);//7
printf("%d\n", 5 != 4 + 2 * 7 > 3 == 10);//0
return 0;
}

6、逻辑运算
 逻辑运算的结果只有2个：“真”为1，“假”为0
  (1)&& 逻辑与
    a>使用格式：“条件A && 条件B”
    b> 运算结果
    只有当条件A和条件B都成立时，结果才为1，也就是“真”；其余情况的结果都为0，也就是“假”。因此，条件A或条件B只要有一个不成立，结果都为0，也就是“假”
    c> 运算过程:总是先判断条件A是否成立'如果条件A成立，接着再判断条件B是否成立：如果条件B成立，“条件A && 条件B”的结果就为1，即“真”，如果条件B不成立，结果就为0，即“假”。
 如果条件A不成立，就不会再去判断条件B是否成立：因为条件A已经不成立了，不管条件B如何，“条件A && 条件B”的结果肯定是0，也就是“假”
    d> 举例
逻辑与的结合方向是“自左至右”。比如表达式 (a>3) && (a<5)
若a的值是4：先判断a>3，成立；再判断a<5，也成立。因此结果为1
若a的值是2：先判断a>3，不成立，停止判断。因此结果为0
因此，如果a的值在(3, 5)这个范围内，结果就为1；否则，结果就为0
    e> 注意
 若想判断a的值是否在(3, 5)范围内，千万不能写成3<a<5，因为关系运算符的结合方向为“从左往右”。 比如a为2，它会先算3<a，也就是3<2，条件不成立，结果为0。再与5比较，即0<5，条件成立，结果为1。因此 3<a<5的结果为1，条件成立，也就是说当a的值为2时，a的值是在(3, 5)范围内的。这明显是不对的。正确的判断方法是：(a>3) && (a<5)
 C语言规定：任何非0值都为“真”，只有0才为“假”。因此逻辑与也适用于数值。比如 5 && 4的结果是1，为“真”；-6 && 0的结果是0，为“假”

  (2)|| 逻辑或
    a>使用格式
“条件A || 条件B”
    b>运算结果
    当条件A或条件B只要有一个成立时（也包括条件A和条件B都成立），结果就为1，也就是“真”；只有当条件A和条件B都不成立时，结果才为0，也就是“假”。
    c>运算过程
    总是先判断条件A是否成立。 如果条件A成立，就不会再去判断条件B是否成立：因为条件A已经成立了，不管条件B如何，“条件A || 条件B”的结果肯定是1，也就是“真”
  如果条件A不成立，接着再判断条件B是否成立：如果条件B成立，“条件A || 条件B”的结果就为1，即“真”，如果条件B不成立，结果就为0，即“假”
    d>举例
   逻辑或的结合方向是“自左至右”。比如表达式 (a<3) || (a>5)。
 若a的值是4：先判断a<3，不成立；再判断a>5，也不成立。因此结果为0。
 若a的值是2：先判断a<3，成立，停止判断。因此结果为1。
 因此，如果a的值在(-∞, 3)或者(5, +∞)范围内，结果就为1；否则，结果就为0。
    e>注意
    C语言规定：任何非0值都为“真”，只有0才为“假”。因此逻辑或也适用于数值。比如 5 || 4的结果是1，为“真”；-6 || 0的结果是1，为“真”；0 || 0的结果是0，为“假”

  (3)! 逻辑非
    a>使用格式
    “! 条件A”
    b>运算结果
    其实就是对条件A进行取反：若条件A成立，结果就为0，即“假”；若条件A不成立，结果就为1，即“真”。也就是说：真的变假，假的变真。
    c>举例
逻辑非的结合方向是“自右至左”。比如表达式 ! (a>5)
若a的值是6：先判断a>5，成立，再取反之后的结果为0
若a的值是2：先判断a>3，不成立，再取反之后的结果为1
因此，如果a的值大于5，结果就为0；否则，结果就为1
    d>注意
 可以多次连续使用逻辑非运算符：!(4>2)结果为0，是“假”，!!(4>2)结果为1，是“真”，!!!(4>2)结果为0，是“假”。
 C语言规定：任何非0值都为“真”，只有0才为“假”。因此，对非0值进行逻辑非!运算的结果都是0，对0值进行逻辑非!运算的结果为1。!5、!6.7、!-9的结果都为0，!0的结果为1。

  (4)优先级
 逻辑运算符的优先级顺序为： 小括号() > 负号 - > ! > 算术运算符 > 关系运算符 > && > ||。
 表达式!(3>5) || (2<4) && (6<1) ：先计算 !(3>5)、(2<4)、(6<1)，结果为1，式子变为1 || 1 && 0，再计算1 && 0，式子变为1 || 0，最后的结果为1
 表达式3+2<5||6>3 等价于 ((3+2) < 5) || (6>3)，结果为1
 表达式4>3 && !-5>2 等价于 (4>3) && ((!(-5)) > 2) ，结果为0

7、三目运算符
N目运算符->三目运算符 

#include <stdio.h>
//主函数
int main()
{
printf("%d\n",3 > 4 + 7);//结果为0
printf("%d\n",(3 > 4) + 7);//<span style="font-family: Arial, Helvetica, sans-serif;">结果为</span><span style="font-family: Arial, Helvetica, sans-serif;">7</span>
printf("%d\n", 5 != 4 + 2 * 7 > 3 == 10);//结果为0
return 0;
}

三、流程控制

1、流程控制
   (1)顺序结构：默认的流程结构。按照书写顺序执行每一条语句。
   (2)选择结构：对给定的条件进行判断，再根据判断结果来决定执行哪一段代码。
   (3)循环结构：在给定条件成立的情况下，反复执行某一段代码。
2、选择结构-if
   (1)关于if(a==0)

#include <stdio.h>
//主函数
int main()
{
    int a=1;
    /*if(a==1)
        printf("a真的是1\n");
    if(a=1)
        printf("a是1\n");*/
    //当我们判断a的值时，可能会把等号写成赋值符号，但这只会警告
    //为了避免这种错误，我们往往把常量写在左边，这样如果把等号写成赋值符号就会直接报错
    if(1==a)
        printf("a真的是1\n");
    else
        printf("a不是1\n");
    return 0;
}

   (2)关于if中定义变量

#include <stdio.h>
//主函数
int main()
{
    int a=1;
    /*下面代码会报错，因为b的作用域不明确
    if(1==a)
        int b=0;*/
    //如果要在if语句中定义新的变量，必须用大括号括住
    if(0==a)
    {
        int b;
    }
    return 0;
}

3、选择结构-switch
   (1)简单使用
    switch(表达式) { case 数值1: break; … default: break;}
注意：

#include <stdio.h>
//主函数
int main()
{
    int a=1;
    switch (a)
    {
        case 1:
            a++;
            printf("%d\n",a);
            //没有break，那么将继续执行下面的语句知道遇到break或switch的大括号
        case 2:
            a++;
            printf("%d\n",a);
        case 3:
            a++;
            printf("%d\n",a);
        default :
            printf("--------\n");
    
    }
    
    printf("################################\n");
    
    switch (a)
    {
        
        case 1:
            a++;
            printf("%d\n",a);
        //case语句没有相符的条件，所以执行default语句，然后直到遇到break或者大括号才跳出
        default :
            printf("--------\n");
        case 2:
            a++;
            printf("%d\n",a);
            //break;
        case 3:
            a++;
            printf("%d\n",a);
    }
    return 0;
}

   (2)if和switch的对比
    很多情况可以互换。 if用得比较多，比较灵活，switch只能某个单值

4、循环结构-while
   (1)简单使用   

/*
 while的用法
 */

#include <stdio.h>
//主函数
int main()
{
    int i=0;
    while(i++<100)
    {
        if(i%2==0)
            continue;//i是偶数时继续该循环
        if(i==15)//i等于15时跳出循环
            break;
        printf("i的值是%d\n",i);
    }
   return 0;
}

   (2)特点
      只有条件成立才会执行循环体

/*
提示用户输入一个正整数n，计算1-2+3-4+5-6+…+n的和
 */

#include <stdio.h>
//主函数
int main()
{
    int i=1;
    int b,sum=0;
    scanf("%d",&b);
    while(i<=b)
    {
        //i为偶数时，就加-i
        if(i%2==0)
            sum+=-i;
        //i为奇数时，就加i
        else
            sum+=i;
        i++;
    }
    printf("这个和是%d\n",sum);
   return 0;
}

5、循环结构-do while
 特点：一定会执行一次循环体

6、循环结构-for
 初始化语句等可以是多句（把printf放到for的括号中）
陷阱
1> 死循环 for(;;);
2> for循环体内部变量的作用域
3> 作用域混淆
for (int i = 0; i<5; i++) int a = 10;

/*
九九乘法表
 */

#include <stdio.h>
//主函数
int main()
{
    for(int i=1;i<=9;i++)
    {
        for(int j=1;j<=i;j++)
        {
            printf("%d*%d=%d\t",j,i,j*i);
        }
        printf("\n");//换行
    }
    return 0;
}

7、 break和continue
   1. break
    使用场合：switch\循环结构
    循环嵌套下的break
   2. continue
    使用场合：循环结构
    循环嵌套下的continue