基本数据类型

在C语言中，数据类型可以分为：

基本数据类型

构造数据类型

指针类型

空类型的四类

最常用的整数类型、实数类型和字符类型（char、int、float、）：

整数数据是指不带小数的数字（int、short int、long int、int、short int、long int）：

笔记：

浮点数据是指带有小数的数字。

生活中有很多信息适合用浮点数据来表示，例如：人的体重（单位：公斤）、商品价格、圆周率等。

由于精度的不同，分为三种类型（float,,long）：

注意：C语言中没有字符串变量。 字符串只能存在于字符数组中，这将在后面讨论。

格式化输出语句

格式化输出语句，也可以说是占位符输出，根据格式化的类型和指定的位置，显示来自计算机的各种类型的数据。

其格式为：（“输出格式字符”，输出项）；

当输出语句包含普通字符时，可以采用如下格式：

printf("普通字符输出格式符", 输出项);

注意：格式字符的数量必须与变量、常量或表达式的数量相对应。

不可变常数

在程序执行过程中其值不改变的量称为常量。

：C语言中的常量可分为直接常量和符号常量。

在C语言中，可以用标识符来表示常量，称为符号常量。 符号常量在使用前必须定义，其一般形式为：

#define 标识符 常量值

#include 
#define POCKETMONEY 10    //定义常量及常量值
int main()
{
    // POCKETMONEY = 12;  //小明私自增加零花钱对吗？
    printf("小明今天又得到%d元零花钱\n", POCKETMONEY);
    return 0;  
}

符号常量不能更改。

自动类型转换

数据类型自动转换。

自动转换在对不同数据类型进行操作时发生，并在编译期间自动完成。

char型数据到int型数据的转换遵循的是对应的ASCII码值。

笔记：

小字节可以自动转换为大字节，但大字节不能自动转换为小字节。

char可以转换为int，int可以转换为，char可以转换为。 但它无法逆转。

投掷

强制类型转换是通过定义类型转换操作来实现的。 其一般形式为：

(数据类型) (表达式)

它的作用是强制将表达式的结果转换为类型说明符所表示的类型。

使用强制转换时应注意以下问题：

数据类型和表达式都必须用括号括起来。 例如，(int)(x/2+y)写为(int)x/2+y，表示将x转换为int类型，除以2，然后加上y。 。

转换后，原始数据的类型和变量值不会改变。 在此操作期间它只会被暂时转换。

强制转换后的运算结果不遵循舍入原则。

计算符号

C语言中的运算符：

※ 算术运算符
※ 赋值运算符
※ 关系运算符
※ 逻辑运算符
※ 三目运算符

算术运算符

C语言基本运算符：

除法运算时注意：

如果相除的两个数都是整数，则结果也为整数，省略小数部分，如8/3 = 2；

如果两个数中有一个是小数，则结果也是小数，如：9.0/2 = 4。

：求余运算时注意：

该运算仅适用于使用两个整数的余数运算，如：10%3 = 1；

: 注意： 10.0%3 是错误的； 运算后的符号取决于模数的符号，如(-10)%3 = -1； 10%(-3) = 1；

:%% 表示这里是%符号。

注意：C语言中没有幂运算符，不能使用×、÷等算术符号。

自增和自减运算符

它们经常在循环中使用。 自增和自减运算符具有以下形式：

赋值运算符

C语言中的赋值运算符分为简单赋值运算符和复合赋值运算符。

简单的赋值运算符 = 符号消失了。 我们来谈谈复合赋值运算符：

复合赋值运算符是在简单赋值运算符=之前添加其他运算符而形成的。

例如+=、-=、*=、/=、%=

分析：定义整型变量a，并赋值给3，a += 5； 该公式等价于a = a+5； 添加变量 a 和 5，然后将其分配给 a

注意：复合运算符中运算符和等号之间没有空格。

关系运算符

C语言中的关系运算符：

关系表达式的值有 true 和 false，在 C 程序中用整数 1 和 0 表示。

注：>=,=5 && 7>5，运算结果为真；

只要参与运算的两个变量之一为真，则结果为真。 当两个数量都为假时，结果为假。 例如：5>=5||5>8，运算结果为true；

当参与运算的变量为 true 时，结果为 false； 当参与运算的变量为假时，结果为真。 例如：!(5>8)，运算结果为true。

三元运算符

C语言中的三元运算符:?:，其格式为：

表达式1 ? 表达式2 : 表达式3;

执行过程为：

首先判断表达式1的值是否为真。 如果为真，则执行表达式2； 如果为假，则执行表达式3。

#include 
int main()
{
    //定义小编兜里的钱
    double money =12.0      ; 
    //定义打车回家的费用
    double cost =11.5       ;  
    printf("小编能不能打车回家呢："); 
    //输出y小编就打车回家了，输出n小编就不能打车回家
    printf("%c\n",money>=cost?'y':'n'                        );
    return 0;
}

操作员大赛-优先级比较
各种操作符号的顺序：

优先级 1 具有最高优先级，优先级 10 具有最低优先级。
分支结构的简单if语句
C语言分支结构语句中的if条件语句。
一个简单的if语句的基本结构如下：
if(表达式)
{
  执行代码块;
}

其语义是：如果表达式的值为true，则执行后续语句，否则不执行该语句。
注意：if()后面没有分号，直接写{}
分支结构的简单if-else语句
简单 if-else 语句的基本结构：

语义是：如果表达式计算结果为 true，则执行代码块 1，否则执行代码块 2。
注意：
if()后面没有分号，就写{}，else后面没有分号，就写{}
分支结构中的多个 if-else 语句
C语言中的多个if-else语句的结构如下：

语义是：按顺序判断表达式的值。 当某个值为true时，执行相应的代码块，否则执行代码块n。
注意：当某个条件成立时，分支结构中的其他语句不会向下执行。
分支结构中嵌套 if-else 语句
C 语言中的嵌套 if-else 语句。 嵌套if-else语句的含义是在if-else语句内写一个if-else语句。 其一般形式为：

while 循环结构的循环
一遍又一遍地执行某个动作，就是人们所说的循环。
C语言中有三种循环结构。 我们先看一下C语言中while循环的结构。

表达式代表循环条件，执行代码块就是循环体。
while语句的语义是：计算表达式的值，当值为真（非零）时，执行循环体代码块。
while语句中的表达式一般是关系表达式或逻辑表达式。 当表达式的值为 false 时，不执行循环体。 否则，循环体总是被执行。
一定要记得改变循环体中循环变量的值，否则会出现死循环（无限执行）。
如果循环体包含多个语句，则必须将其括在{}中以形成复合语句。
循环结构 do-while 循环
C语言中的do-while循环有以下一般形式：

do-while循环语句的语义是：
它首先执行循环中的执行代码块，然后判断while中的表达式是否为true。 如果为真，则继续循环； 如果为假，则终止循环。 因此，do-while循环必须至少执行一次循环语句。
注意：使用do-while结构语句时，while括号后必须有分号。
for循环的循环结构（一）
C语言中for循环的一般形式：

其执行过程如下：
执行表达式1并初始化循环变量；
判断表达式2，如果其值为true（不为0），则执行for循环体中的代码块，然后向下执行； 如果其值为 false (0)，则结束循环；
执行表达式3、(i++)等对循环变量进行操作的语句；
执行完for循环中的代码块后执行第二步； 初始化的第一步只会执行一次。
循环结束，程序继续向下执行。
注意：for循环中的两个分号必须写成
for循环的循环结构（二）
在 for 循环中：
使用for语句时应注意：
for循环中的“表达式1,2,3”不需要为空，但是两个分号（;;）不能为空。
省略“表达式1（给循环变量赋初值）”意味着不给循环变量赋初值。
省略“表达式2（循环条件）”，不进行其他处理，循环继续执行（无限循环）。
省略“表达式3（循环变量的增减）”，不进行其他处理，循环不断执行（无限循环）。
表达式1可以是设置循环变量初始值的赋值表达式，也可以是另一个表达式。
表达式1和表达式3可以是一个简单的表达式，也可以是多个以逗号分隔的表达式。

表达式2通常是关系表达式或逻辑表达式，但也可以是数值表达式或字符表达式。 只要它的值不为零，循环体就会被执行。
每个表达式中的变量必须在 for 循环之前定义。
如何求出一个数的百位、十位和个位。 循环结构的三个循环比较。
while、do-while、for这三种循环在具体使用情况下有所不同，如下：
当循环次数已知时，更适合使用for循环；
当循环数量未知时，适合使用 while 或 do-while 循环：
但本质上，while、do-while 和 for 循环可以相互转换。
循环结构的多个循环
多重循环是出现在循环结构的循环体内的循环结构。
实际开发中，一般最多采用三层再循环。
因为循环层数越多，运行时间越长，程序也越复杂，所以一般2-3层多次循环就足够了。 另外，不同的循环还可以嵌套。
多个循环执行过程中，外层循环为父循环，内层循环为子循环。
父循环执行一次，所有子循环都需要执行，直到跳出循环。 父循环进入下一次，子循环继续执行……

：打印一堆三角星
#include 
int main()
{
    int i, j, k;
    for(i=1; i<5; i++)
    {
        /* 观察每行的空格数量，补全循环条件 */
        for(j=i; j<5; j++)  
        {
            printf(" ");    //输出空格
        }
        /* 观察每行*号的数量，补全循环条件 */
        for( k=0;k<2*i-1;k++) 
        {
            printf("*");   //每行输出的*号
        }
        printf("\n");     //每次循环换行
    }
    return 0;
}

使用 for 循环打印 9×9 乘法表
#include 
int main() 
{ 
    // 定义相乘数字i,j以及结果result
    int i, j, result;
     for(i=9;i>=1;i--)
     {
        for(j=1;j<=i;j++)
        {
            printf("%d*%d=%d ",i,j,result=i*j);
        }
        printf("\n");
     }
    return 0;
}

结束语句的break语句
那么当你循环5次时，就需要中断，不能继续训练。 在C语言中，可以使用break语句来做到这一点。
使用break语句时要注意以下几点：
Break 不能在没有循环结构的单独 if-else 语句中使用。
在多级循环中，break 语句仅跳出当前循环。
结束语句的语句
然后当你循环5次时，你需要中断并继续训练。在C语言中，你可以使用以下语句来做到这一点
该语句的作用是结束本次循环，开始执行下一个循环。
break 语句和语句的区别是：
break是跳出当前整个循环，结束本次循环，开始下一个循环。
分支结构语句
语句结构如下：

：声明还应注意以下几点：
case后面的各个常量表达式的值不能相同，否则会出错。
如果没有休息； 在case子句之后，将继续执行直到break； 遇到之前的语句就会被跳出。
以下表达式语句只能是整数或字符类型。
case 后面允许有多个语句，不需要用 {} 括起来。
每个case和子句的顺序可以改变，而不影响程序执行结果。
该子句可以省略。
：带有if语句的应用（计算一年中的第几天）
#include 

int main() 

{ 

    /* 定义需要计算的日期 */

    int date = 0;

    int year = 2008;

    int month = 8;

    int day = 8;

    switch(month)

    {

        case 12:date+=30;

        case 11:date+=31;

        case 10:date+=30;

        case 9:date+=31;

        case 8:date+=31;

        case 7:date+=30;

        case 6:date+=31;

        case 5:date+=30;

        case 4:date+=31;

        case 3:

        if((year%4==0&&year%100!=0)||year%400==0)

        {

            date+=29;

        }

        else

        {

            date+=28;

        }
        case 2:

        date+=31;

        case 1:

        date+=day;

        printf("%d年%d月%d日是该年的第%d天",year,month,day,date);

        break;

        default:

        printf("error");

        break;

    }

    return 0;

}

正确：只能在循环体内使用
臭名昭著的 goto 语句
C语言中也有这样的语句，就是goto语句。  goto 语句是无条件分支语句。
goto语句的使用格式为：
goto 语句标号;


自创函数
C语言提供了大量的库函数：例如stdio.h提供了输出函数
自定义函数的一般形式：

注意：
[]中包含的内容可以省略，省略数据类型说明，默认为int类型函数； 省略参数表示该函数为无参数函数，不省略参数表示该函数为有参函数；
函数名称遵循标识符命名约定；
：尽量将自定义函数放在主函数之前。 如果想放在main函数之后，需要在main函数之前声明自定义函数。 声明格式为：
[数据类型说明] 函数名称（[参数]）;

函数调用
当我们需要使用自定义函数的时候，我们就要调用它，那么当我们调用它的时候，就称为函数调用。
在C语言中，函数调用的一般形式为：
函数名（[参数]）;

注意：
调用无参数函数时，可以省略[]包含。
[]可以是常量、变量或者其他构造类型数据和表达式，多个参数之间用逗号分隔。
有或没有参与
不需要函数参数的函数称为无参数函数，需要函数参数的函数称为有参函数。
有参函数和无参函数的一般形式如下：

有参数函数和无参数函数的唯一区别是 () 中多了一个参数列表。
：正式参与实参
函数参数分为形式参数和实参两种。
就像小明一样，只是说说而已，没有实际行动；
就像小刚其实可以采取行动一样。
函数的形参和实参有以下特点：
函数调用结束返回调用函数后，形参变量就不能再使用了。
无论实参是什么类型的量，在进行函数调用时都必须有确定的值，以便将这些值传递给形参。 因此，应提前使用赋值等方法为实际参数获取一定的值。

函数返回值
函数的返回值是指函数被调用后执行函数体中的程序段得到的值，并返回给调用函数。
关于函数的返回值需要注意以下几点：
声明的一般形式是：
return 表达式   或者为：return (表达式);

注意：如果两者不一致，以函数返回类型为准，并自动进行类型转换。
注意：
void 函数可以有执行代码块，但不能有返回值。
如果:void函数中有语句，该语句只能结束该函数。 其格式为：;
递归函数(1)
递归是指函数在其函数体内调用自身。
执行递归函数会重复调用自身，每次都会进入一个新的级别。
注意递归函数必须有结束条件
递归函数（2）
我们来分析一下5的阶乘的例子，看看它的运算过程：

程序计算5的阶乘时，首先进行递归，当n=1或n=0时返回1，然后回溯计算并返回。 由此可见，递归函数必须有结束条件。
递归函数的特点：
每一级函数调用都有自己的变量，但函数代码不会被复制。 例如，计算5的阶乘时，每次递归时变量都会不同；
每个调用都会返回一次。 例如计算5的阶乘时，每次递归都会返回到下一次；
在递归函数中，递归调用之前的语句与各级被调用函数的执行顺序相同；
在递归函数中，递归调用后语句的执行顺序与被调用函数的顺序相反；
递归函数中必须有终止语句。
一句话概括递归：自调用和完成状态
任务
第一天，猴子摘了N个桃子，吃了一半。 当他不满意时，他又吃了一份。 第二天，他吃了剩下的一半桃子，又吃了一个。 从现在开始，我每天都会吃前一天剩下的一半又一个。 第十天，想吃的时候，桃子只剩下一个了。 第一天摘了多少个桃子？ 并反向打印每天剩下的桃子数量。
#include 
int getPeachNumber(int n)  
{
    int num;    
    if(n==10)
    {
       return 1;      
    } 
    else
    {
        num = (getPeachNumber(n+1)+1)*2;  
        printf("第%d天所剩桃子%d个\n", n, num); 
    }
    return num;
}
int main()
{
    int num = getPeachNumber(1);
    printf("猴子第一天摘了:%d个桃子。\n", num);
    return 0;
}

递归演示。
有5个人坐在一起，问第5个人多大了？ 他说他比第四个人大2岁。 当我问第四个人多大年纪时，他说他比第三个人大两岁。 我问第三个人，他说他比第二个人大两岁。 问第二个人，说比第一个人大两岁。 最后我问第一个人，他说他10岁了。 第五个人多大了？
程序分析：
使用递归方法，递归分为两个阶段：回溯和递归。 如果你想知道第五个人的年龄，你需要知道第四个人的年龄，依此类推，直到第一个人（10岁），然后返回。
#include  
int dfs(int n) {
    return n == 1 ? 10 : dfs(n - 1) + 2;
}
int main() 
{

    printf("第5个人的年龄是%d岁", dfs(5)); 
    return 0;
} 

本地和全球
C语言中的变量按照作用范围可以分为两种类型，即局部变量和全局变量。
变量存储类
：C语言按照变量的生命周期来划分，可以分为静态存储模式和动态存储模式。
C语言中的存储类别分为四类：
1、用关键字auto定义的变量是自动变量。 自动可以省略。 如果不写auto，则隐式设置为“自动存储类别”，是一种动态存储方式。 喜欢：

2、修改的变量是静态变量。 如果是在函数内部定义的，则称为静态局部变量； 如果在函数外部定义，则称为静态外部变量。 以下是静态局部变量：

注意：静态局部变量属于静态存储范畴。 存储单元分配在静态存储区域中，在程序的整个运行期间不会被释放。 静态局部变量在编译时被赋值初始值，即初始值只被赋值一次； 如果定义局部变量时没有赋予初始值，对于静态局部变量，编译时会自动赋予初始值0（对于数字变量）或空字符（对于字符变量）。
3.为了提高效率，C语言允许将抖音（）放在CPU中的一个寄存器中。 这种类型的变量称为“寄存器变量”，并用关键字声明。 例如：

：注意：只有局部自动变量和形参才能作为寄存器变量； 计算机系统中寄存器的数量是有限的，不能定义任意数量的寄存器变量； 局部静态变量不能定义为寄存器变量。
4. 声明的变量是外部变量。 外部变量的含义是函数可以调用该函数之后定义的变量。 喜欢：

内部和外部功能
静态变量仅分配一次
外部功能练习
你好ç
#include 
#include "test.c"   //引用test.c文件
extern void printLine()     //这里定义的方法对吗？
{
   printf("**************\n");   
}
int main()
{
    say();
    return 0;
}

测试.c
#include 
void printLine();
static void say(){
printLine();
printf("I love imooc\n");
printf("good good study!\n");
printf("day day up!\n");
printLine();
}

对于hello.c，直接引入test.c文件。 然后就可以调用testc中的say()方法了
不过，test.c 尚未引入，您可以通过声明调用另一个源文件中公开的方法。
联合训练
北京出租车收费规则如下：
每公里单价2.3元
起步价13元（含3公里）
23:00（含）至次日凌晨5:00（不含）乘坐出租车，每公里加收20%。
每次乘车需加收燃油附加费1元。
小明每天乘坐出租车上下班。 他的公司到他家的距离是12公里。 他早上九点上班，下午六点下班。
请编写一个小程序，计算小明每天打车的总费用。
#include 

float taxifee(int clock,int miles)
{
    float money;
    if(miles<=3)
    {
        money=14;
        printf("费用为14\n");
    }
    else
    {
        if(clock>=23 || clock<5)
        {
            money=13+1+2.3*(miles-3)*1.2;
            printf("夜间车费为：%f\n",money);
        }
        else
        {
            money=13+1+2.3*(miles-3);
            printf("日间车费为：%f\n",money);
        }
    }

    return money;    
}
int main()
{
    printf("打的总费用：%.1f\n",taxifee(9,12)+taxifee(18,12));
    return 0;
}

第一次接触数组
程序中也需要容器，但是这个容器有点特殊。 它是程序中数据类型一致的连续的、固定大小的内存空间。 它还有一个好听的名字，叫做数组。数组可以理解为一个大小固定、物品类型相同的购物袋。
包里的物品是按照一定的顺序排列的。