秒客网

一、四个月的课程体系
    1、语言基础
        1、c语言10day
        2、oc语言（真正开发语言）6day
        3、foudation（库）
    2、iOS 核心编程
        1、视图层（如何做QQ的样子，手势、动画）
    3、iOS 高级编程
        1、系统服务
        2、网络编程
    4、游戏开发
        1、学习C ++（主要用来开发游戏）可以跨平台
        2、cocos2d-x
        3、swift语言以及iOS8开发
 二、什么是ios开发
      1.移动便携式开发：android 和 iOS
       2.iOS开发（iOS程序员、iOS软件工程师）
       3.android 和 iOS区别
                a.     iOS基于unix，安全稳定。android基于linux的虚拟机，安全性低
                 b.    iOS强大的sdk、开发工具，不开源，apple公司，App             Store（08年上线），高端用户使用
     android开源，google公司，googleplay应用商店，各种用户人群，
三、ios开发环境
 1.mac操作系统
     1）操作系统os：管理硬件资源和软件资源
     2）macos：apple公司，自我封闭
     3）iOS：设备:iPhone（2007年1月9日），iPod，touch，iPad，      apple tv
2. 布局:菜单栏、桌面、dock（快捷键）
3.格式化u盘：磁盘工具——ms-dos（fat）
4.软件安装
      1、*.dmg（setup.exe虚拟光驱）
      2、*.app（绿色软件）直接安装
      3、直接从app store
 5.pwd、cd、is命令
  1、操作计算机的两种方式
            a.图形化操作方式（操作直观）
            b.命令行的操作方式（操作便捷，节约资源）
  2、操作命令（终端快捷操作）
     a.ls命令（查看当前文件夹下的文件或者子目录）
     b.pwd（查看当前操作目录）
     c.cd+空格+子目录名称（切换子目录）
     d.cd+空格+..（退回上一级目录）
     e.clear清除屏幕信息
     f.mkdir+空格+文件夹（创建一个目录）
     g.rm+空格-f空格  删除
3.相对路径和绝对路径（路径两种表达方式）
  1./代表硬盘根目录（/uses/tarena/doc）
  2.相对路径：相当于当前操作状态下的文件（或目录）的位置
  3.绝对路径：根据硬盘根目录开始，文件（或目录）的位置
4.文件夹的创建与查看

12.31
c语言（1973年贝尔实验室）
    1.四大部分：*处理器（控制器、运算器）、存储器、输入设          备、输出设备    （1946年，冯诺依曼)
    2.计算机语言分类
   机器语言、汇编语言、高级语言
    3.编程：自己有个想法，通过计算机语言使计算机理解，并帮我  们实现。
一、c语言执行步骤：
   一.编辑程序
         1.编写c语言的代码，保存在扩展名.c的文件中，源文件。
         2.编写代码有三种方式：
                  a.vi命令方式系统自带
                  b.ultraedit网络下载
                  c.xcode网络下载
  二.编译(gcc  文件名.c)
      将c语言转换成计算机识别的代码
  三.运行(./a.out)
       经过编辑、连接之后，源程序文件就可以生成可执行文件
* vi的使用-补充（c语言快捷键）：shift+“：”进入编辑功能
   wq退出
   “i”insert进入编辑模式
四.xcode简单的使用
1.创建项目
2.创建一个osx—command line Tool
3.main.c进行编程
4. 菜单栏product编译-run执行
5.改字体（苹果-第二个prefer..偏好设置-第五个改字体）
五.#include指令
   1.在编译之前做的事情
   2.相当于复制操作
   3.加载系统提供的标准函数库
*“”是加载系统自定义功能
 《》是加载系统功能
六.变量
    1.数据类型：字符型char、整数型int、浮点型float/double、指  针、结构、联合等类型。
    2.语法格式：变量类型  变量名=初始化值
    3.保存运算中临时的值，number1=10赋值，可以多次赋值，但只会保留最后一次的值（右—左）
    4.变量命名：a.必须以字母或下划线开头
                       b.包含字母、下划线或数字（不要出现空格）
                       c.不能与关键字冲突
                       d.大小写敏感的
                       e.长度一般不会限制，但会被编辑器截断

*变量放在等号左边就是存值操作，变量放在等式右边就是取值操作 i=10(存),j=i(取).把右面的赋值给左边的，从右向左

1.4
数据类型和变量赋值
1.整数类型
（char、int）小数类型（float、double）
         a.有符号类型（整数、负数、0）范围   （ -128~127）
               *所占存储空间的第一位为符号位。
               *二进制符号位，最左边0+，1代表负数
         b.无符号整型（整数、0）（0~255）256
         c.有符号的整型（int，4个字节 ）（-2^31~2^31-1）
     *Byte、KB、MB、GB、TB、PB（1024）
     如：1KB=1024B
    超出最大值从最小值开始运算
    超出最小值从最大值开始运算
  d.有符号的短整型（short int，2字节）
  e.有符号的长整型（long int，8字节）
  f.有符号的长长整型（long long int）
  g.无符号的整型（unsigned int，4字节）
  h.无符号短整型（unsigned  short int，2字节）
  i.无符号长整型（unsigned  long int，8字节）
  j.无符号长长整型（unsigned  long long  int，8字节)
2.进制
   a.十进制%d（0-9）逢十进一
   b.八进制%o（0-7）逢八进一
   c.十六进制%x（0-9ABCDEF）逢十六进一
   d.二进制（0、1）逢二进一
           int i=11 //十进制
           int i=011 //八进制
           int i=0x11 //十六进制
*c语言不能使用二进制
     1.十进制转换二进制（除二取余，将余数从下向上读出）
举例：
32/2=17……0
17/2=8……1
8/2=4……0
4/2=2……0
2/2=1……0
1/2=0……1
将余数从下向上读出：100010

     2.二进制数转化成十进制数（按权相加）
  0       1     0    1    1    1  0   1位（从右向左）93
128   64   32  16   8    4  2   1权
举例：
1001110
0*2^0=0
1*2^1=2
1*2^2=4
1*2^3=8
0*2^4=0
0*2^5=0
1*2^6=64
得出的值相加=0+2+4+8+0+0+64=78
     3.十进制数转换成八进制数、十六进制数
   方法：辗转相除，从下向上取余
34/8=16……6
16/8=2……0
2/8=0……2
从下向上对应的八进制数：206
     4.八进制数、十六进制数转换成十进制数
   方法：按权相加法
6*8^0=6
0*8^1=0
2*8^2=128
按权相加：=134
     5.二进制数转换成八进制数
   方法：从最后一位开始，每三位二进制数，相当于一个八进制数。前面不足3为补0
举例：100  010=42
6.二进制转换成十六进制数
   方法：每四位，不足补0
举例：0010  0010->22
3.字符（%c）
 1.通过数值直接赋值  2.通过字符直接赋值
*.2f保留两位有效数字
4.变量：临时保存数据，数据的容器
   常量：不可改变的值（具体的数值）
   字面值：不可改变的值,就是数值（字符、数值）
  *变量=字面值（常量）数据

练习题：
C语言中整数-8在内存中存储形式是：     原码->反码->补码（只有负数存的是补码）(2个字节=16位)
A）1111，1111，1111，1000             B）1000，0000，0000，1000
C）0000，0000，0000，1000             D）1111，1111，1111，0111

一、知识点
   一.scanf(“%d”,&i);&取地址

例题：
1.输入两个数，并输出两个数
#include <stdio.h>

int main(int argc, const char * argv[])
{
    int i=0,j=0;
  
    printf("pelease input a number:");
    scanf("%d",&i);
    printf("pelease input nest number:");
    scanf("%d",&j);
    printf("i=%d\nj=%d",i,j);
    return 0;

}

2.输入两个数，求其面积、周长、和
int main(int argc, const char * argv[])
{
    int i=0,j=0,sum=0,mj=0,zc=0;
    printf("pelease input a number:");
    scanf("%d",&i);
    printf("pelease input nest number:");
    scanf("%d",&j);
    mj=i*j;
    zc=(i+j)*2;
    sum=i+j;
    printf("面积=%d\n周长=%d\n和=%d\n",mj,zc,sum);
    return 0;
}

3.输入两个数求和、差、积、商
int i = 0 , j = 0;
    //输入函数 要依赖于变量 要临时保存在键盘上输入的数据
    //程序会发生阻塞状态
    //友好性差 配合输出语句结合使用
    printf("please input first Number:\n");
    scanf("%d",&i);//&得到变量在内存中的地址，将键盘上输入的数据保存在变量中
    printf("please input second Number:\n");
    scanf("%d",&j);
    //输出函数
    printf("i:%d\n",i);
    printf("j:%d\n",j);
    
    int sum = 0;//求和
    int sub = 0;//求差
    int mul = 0;//求积
    int div = 0;//求商
    sum = i+j;
    sub = i-j;
    mul = i*j;
    div = i/j;//整数相除取整数部分
    printf("sum:%d\n",sum);
    printf("sub:%d\n",sub);
    printf("mul:%d\n",mul);
    printf("div:%d\n",div);
    return 0;
结果：
please input first Number:
45
please input second Number:
2
i:45
j:2
sum:47
sub:43
mul:90
div:22


4.数据类型省略写法
int main(int argc, const char * argv[])
{
    signed int i=0;//有符号整型 可以省略signed
    unsigned int i2=0;//无符号整型
    short i3=0;//有符号短整型 可以省略 int 关键字
    unsigned short i4=0;//
    long i5=0;//有符号长整型 可以省略int
    unsigned long i6=0;
    long long i7=0;//长长整型 可以省略signed 和int 关键字
    unsigned long long i8=0;//
    
    return 0;
}
知识点 
二、进制转换

5.输入一个数，分别以十进制、八进制、十六进制输出变量
int main(int argc, const char * argv[])
{
    int i,j,k;
    printf("输入：");
    scanf("%d%d%d",&i,&j,&k);
    printf("i=%d j=%o k=%x\n",i,j,k);//分别以十进制%d、八进制%o、十六进制%x输出变量
    return 0;
}
6.十进制、八进制、十六进制之间的转换
int i=11,j=011,k=0x11;
    printf("i=%d j=%o k=%x\n",i,i,i);//分别以十进制、八进制、十六进制输出变量
    printf("i=%d j=%o k=%x\n",j,j,j);
    printf("i=%d j=%o k=%x\n",k,k,k);
    return 0;
 结果：i=11 j=13 k=b
      i=9 j=11 k=9
      i=17 j=21 k=11

7.制表符(\t)  空3个字符，一个汉字
printf("1234567890123456\n");
    printf("helloword!\n");
    printf("hello\tword!\n");
    
    return 0;
结果
1234567890123456
helloword!
hello   word!

8.整型数据溢出
//数据溢出
    int i = 2147483647;//999 + 1
    int j = i + 1;//超出最大值从最小值开始运算
    int k = -2147483648;
    int l = k - 1;//超出最小值从最大值开始运算
    printf("j:%d\n",j);
    printf("l:%d\n",l);
    return 0;
结果：
j:-2147483648
l:2147483647

9.浮点型（float：%f  double: %lf）
    float f = 3.1415926;//100
    double d = 3.1415926;//200
    float f2 = d;//100 = 200
    //%.2f保留两位有效数字
    printf("float:%.2f\n",f);
    printf("double:%lf\n",d);
    return 0;
结果：
float:3.14
double:3.141593

知识点
三、sizeof:计算存储空间的大小，单位：字节
sizeof（）对应的数据类型是 long unsigned int ->%ld

10.sizeof所占空间大小
int i = 10;
    long l = 20l;
    long long ll = 30ll;
    char c = 10;
    
    float f = 10.1f;
    double d = 10.1;
    long double ld = 10.1l;
    //求出某种类型或变量或字面值(常量)或表达式所占内存空间大小
    //一定注意 变量的空间一定要大于字面值的空间，否则“可能”出现数据问题。
    unsigned long int length = sizeof(d=20.1); //sizeof（）不负责计算表达式的值
    printf("d:%lf\n",d);
    printf("length:%lu\n",length);
结果：
d:10.100000
length:8
知识点
四、运算符

11.优先级与结合性
      int i = 3+4*5;
    printf("i:%d\n",i);
    int i2 = 3/2;//整数相除 结果还是整数
    double d = 3.0/2;//如果相除时，有小数，则结果为小数
    printf("i2:%d\n",i2);
    printf("d:%lf\n",d);
    
    //取余运算符%
    int i3 = -5%2;
    printf("i3:%d\n",i3);
    
    //向0取整
    int i4 = -5/2;
    printf("i4:%d\n",i4);
    
    //符号问题
    int i5 = -5/-2;//与数学中的符号相同
    printf("i5:%d\n",i5);
    int i6 = 5%-2;//与前面的数字的符号相同
    printf("i6:%d\n",i6);
结果：
i:23
i2:1
d:1.500000
i3:-1
i4:-2
i5:2
i6:1

12.例题：输入一个秒数 求时分秒
    int inputSecond = 0;
    printf("请输入一个秒数:\n");
    scanf("%d",&inputSecond);
    
    int hour=0,minute=0,second=0;
  
   //hour = inputSecond/3600;
   //minute = (inputSecond-hour*3600)/60;
   //second = inputSecond -hour*3600 - minute*60;
  
    hour = inputSecond/3600;
    minute = inputSecond%3600/60;
    second = inputSecond%60;
    
    printf("input的秒数=%d时%d分%d秒\n",hour,minute,second);

结果：
请输入一个秒数:
3666
input的秒数=1时1分6秒

13.自增自减运算符
    int i = 10;
    //i++;//自增1 i = i + 1;
    i--;//自减1 i = i - 1;
    printf("i:%d\n",i);
    
    int j = 10;
    //int k = ++j;//前缀表达式 先自增 再运算(赋值)
    int k = j++;//后缀表达式 先运算 后自增
    printf("k:%d\n",k);
    
    i = 10;
    k=++i+(++i)+i++;
    printf("k:%d\n",k);
    return 0;
结果：
i:9
k:10
k:35
14.关系运算符
    int i = 10;
    int j = 20;
    //>、<、>=、<=、==、!= 关系
    printf("i>j:%d\n",i>j);//0 不成立
    printf("i<j:%d\n",i<j);//1 成立
    printf("i==j:%d\n",i==j);//0
    printf("10>20:%d\n",10>20);
    printf("10.1>20.1:%d\n",10.1>20.1);
    printf("10.1>20:%d\n",10.1>20);
    printf("\'A\'>\'B\':%d\n",\'A\'>\'B\');//ASC码
    printf("\'A\'<\'B\':%d\n",\'A\'<\'B\');
结果：
i>j:0
i<j:1
i==j:0
10>20:0
10.1>20.1:0
10.1>20:0
\'A\'>\'B\':0
\'A\'<\'B\':1
15.练习题：
用户从控制台输入一个年龄,由程序判断该年龄是否大于18岁，结果输出1为真，0为否
   int age = 0;
    printf("请输入一个年龄:\n");
    scanf("%d",&age);
    printf("age>18:%d\n",age>18);
结果：
请输入一个年龄:
45
age>18:1
16. 布尔类型（bool）
C99 版本新添加的数据类型 逻辑值类型bool类型
    #include <stdbool.h> 头文件
    bool flag = false;//true 1 false 0
    printf("flag:%d\n",flag);
结果：0
知识点
五、if语句条件分支语句    if…else    if…else if

//条件 关系表达式
//逻辑值 真 (1 true 或 非0) 假(0 false)
1.if 语句书写有三种形式
    //普通语句（大括号可以省略）只会执行一条语句
    if(true) printf("congratulation!");
区别
  1. //普通语句（大括号可以省略）没有括号，只会执行一条语句
    if(true)
        printf("congratulation!");
    
        printf("congratulation!");


  2.//复合语句  要么多执行 要么都不执行 把多条语句变成一个整体
    if(true){
        printf("congratulation!");
    
        printf("congratulation!");
    }

  3.//空语句
    if(age>18);

2.if…else
int age = 18;
    
    if (age>=18) {
        printf("你已经成年了!\n");
    }else{
        printf("你还未成年!\n");
    }
结果：你已经成年了!

3. if…else if…else
 if(表达式1)语句1；
else if(表达式2) 语句2；
else if(表达式3) 语句3；
        ……
else 语句5；
执行方式从头开始判断真假

17.练习 输入小写字母 得到相应的大写字母
char ch;
    printf("shuru");
    scanf("%c",&ch);
    if(ch>=97){
        ch=ch-32;得到大写字母
        printf("=%c",ch);
    
    }else{
        ch=ch+32;得到小写字母
        printf("=%c",ch);
    }
    return 0;
18.输入一个分数，判断这个分数是否及格?
   int score = 0;
    printf("请输入一个分数:\n");
    scanf("%d",&score);
  
     if (score>=90) {
     printf("您的分数是优秀\n");
     }
     else if(score>=60){
     printf("您的分数是及格\n");
     }
     else{
     printf("您的分数是不及格\n");
     }
结果：
请输入一个分数:
95
您的分数是优秀
19.输入一个分数，得到相应的级别
    int score=0;
    printf("input:");
    scanf("%d",&score);
    if(score>100) printf("GO OUT !!!");
    else if(score>=90) printf("A");
    else if(score>=80) printf("B");
    else if(score>=60) printf("C");
    else printf("D");
    return 0;
20.else if和if 比较
else if 相当于过一个十字路口：一次判断，多种选择
但是if 相当于过多个十字路口：多次判断
1.一次判断 多种选择 只会选择其一执行(满足条件)
    int score = 0;
    printf("请输入一个分数:\n");
    scanf("%d",&score);   
    if (score>=60) {
     printf("60\n");
     }else if (score>=70){
     printf("70\n");
     }else{
     printf("else\n");
     }
结果：
请输入一个分数:
90
60
2.多次判断 多次执行(满足条件)
   int score = 0;
    printf("请输入一个分数:\n");
    scanf("%d",&score);
     if (score>=60) {
     printf("if 60\n");
     }
     if (score>=70) {
     printf("if 70\n");
     }
结果：
请输入一个分数:
80
if 60
if 70
3.if在大括号里如果满足条件依次执行
    int score = 0;
    printf("请输入一个分数:\n");
    scanf("%d",&score);
     if (score>=60) {
      printf("if 60\n");
         printf("if 70\n");}

结果：
请输入一个分数:
80
if 60
if 70
21.逻辑运算符（&&、||）
    int i=0,j=10;//逻辑与短路（短路与）
    if((1!=1)&&(i=10))//若第一个表达式的值为假，后面的表达式不再计算
    printf("i=%d",i);
    //短路或  若第一个表达式值为真，后面的表达式不再计算
    if((1==1)||(j=20))
    {
        printf("j=%d",j);
    }
    return 0;
结果：
i:0
j:1
22.取地址&与寻址运算符*
    int i = 30;
    
    int* p = &i;//得到变量在内存中位置
    printf("p:%p\n",p);
    
    //通过寻址运算符 根据地址直接操作内存
    //取
    printf("内存中的数据:%d\n",*p);
    //存
    *p = 40;
    printf("i:%d\n",i);
    
    
结果：
p:0x7fff5fbff70c
内存中的数据:30
i:40

作业

1.输入一个年份，求该年一共有多少天。
    int year;
    printf("请输入年份：\n");
    scanf("%d",&year);
    if(year%400==0||((year%4==0)&&(year%100!=0)))
        {printf("366天\n");}
    else{printf("365天\n");}
结果：
请输入年份：
2005
365天
老师的程序： int days=365+(year%400==0||((year%4==0)&&(year%100!=0)))

2.输入一个年份，输入一个月份，求该月有多少天?
   //1.输入年份
    int year = 0;
    printf("请输入年份:\n");
    scanf("%d",&year);
    //2.输入月份
    int month = 0;
    printf("请输入月份:\n");
    scanf("%d",&month);
    //3.判断不同的月份 天数是不一样的
    //1 3 5 7 8 10 12 31天
    //4 6 9 11 30天
    //2 闰年 29天 平年28天
    int days = 0;//用来保存所求天数
    if (month==4||month==6||month==9||month==11) {
        days = 30;
    }else if (month==2){
        days = 28 + ((year%400==0)||(year%4==0 && year%100!=0));
    }else{
        days = 31;
    }
    //4.输出天数
    printf("year:%d month:%d days:%d\n",year,month,days);
结果：
请输入年份:
2005
请输入月份:
12
year:2005 month:12 days:31
3.准备回家过年了，交通工具，通过输入工资，
小于1300(最低工资)，程序要报错，工资大于10000
坐飞机回家，如果大于5000，就坐火车回家，如果大于
3000，就坐汽车回家。大于1500，就骑自行车回家，都
不满足，步行。
    int i=0;
    printf("请输入工资：");
    scanf("%d",&i);
    if(i>=10000)
        printf("飞机\n");
    else if(i>=5000)
        printf("火车\n");
    else if(i>=3000)
        printf("汽车\n");
    else if(i>=1500)
        printf("自行车\n");
    else if(i<1300)
        printf("程序报错\n");
    else
        printf("步行\n");

4.通过键盘输入4个值，求4个值中的最大值，最小值，和。
    //1.输入4个值
    int num1=0,num2=0,num3=0,num4=0;
    int sum = 0;
    printf("请输入第一个数:\n");
    scanf("%d",&num1);
    sum+=num1;
    printf("请输入第二个数:\n");
    scanf("%d",&num2);
    sum+=num2;
    printf("请输入第三个数:\n");
    scanf("%d",&num3);
    sum = sum + num3;
    printf("请输入第四个数:\n");
    scanf("%d",&num4);
    sum = sum + num4;
    //2.求最大值 算法(逻辑)
    int max = num1;//标尺
    if (num2>max) {max = num2;}
    if (num3>max) {max = num3;}
    if (num4>max) {max = num4;}
    printf("max:%d\n",max);
    //求最小值
    int min = num1;//标尺
    if (num2<min) {min = num2;}
    if (num3<min) {min = num3;}
    if (num4<min) {min = num4;}
    printf("min:%d\n",min);

    //3.求最小值
    //4.求和
    //sum = sum + num3; 累加
    //sum += num3;累加 但效率更高 (编译原理)
    //sum = num1+num2+num3+num4;
    printf("sum:%d\n",sum);
结果：
请输入第一个数:
8
请输入第二个数:
6
请输入第三个数:
5
请输入第四个数:
9
max:9
min:5
sum:28

知识点
六、运算符

23.赋值运算符
int i = 20;
    int j = 10;
    int k = 15;
    int l = 0;
    l = (i = (j = (k = 5)));//从右向左运算的 右结合
    printf("i:%d j:%d k:%d l:%d\n",i,j,k,l);
结果：i:5 j:5 k:5 l:5

1.按位异或操作
    printf("5&3:%d\n",5&3);   //0000 0101
    int i = 5;            //0000 0011
    printf("~5:%d\n",~i);
    int j = 3;
    printf("5^3:%d\n",i^j);//按位异或操作
结果：
5&3:1
~5:-6
5^3:6

2.调换两个值（^）
    int l = 5;
    int r = 4;
    printf("调换前: l:%d r:%d\n",l,r);
    l^=r;//l=l^r;
    r^=l;//r=r^l;
    l^=r;//l=l^r;
    /*
    int temp = 0;//中间临时变量 桌
    temp = l;
    l = r;
    r = temp;
     */
    printf("调换后: l:%d r:%d\n",l,r);

结果：
调换前: l:5 r:4
调换后: l:4 r:5

3.按位左移 按位右移 标识一些有规律的数据
    int i2 = 1;
    //数据(二进制数)<<(左移)移动位数
    //0000 0001 <<1 0000 0010
    printf("i2<<1:%d\n",i2<<1);
    //0000 0001 <<2 0000 0100
    printf("i2<<2:%d\n",i2<<2);
结果：
i2<<1:2
i2<<2:4

4.多目运算符
    int i = 10;
    int j = 20;
    char c ;
    c = i<j?\'a\':\'b\';
    printf("c:%c\n",c);
结果：c:a

24.重构利用多目运算符，输入字符 如果大写 转换小写 如果小写 转换大写
    char ch;
    char ch2;
    printf("请输入一个字符:\n");
    scanf("%c",&ch);
    //2.判断 大->小 小->大
    //ch2 = (ch>=\'A\' && ch<=\'Z\')?ch+(\'a\'-\'A\'):ch-(\'a\'-\'A\');
    //多目运算符的嵌套
    /*
     条件表达式?表达式1:表达式2;
     条件表达式?(条件表达式?表达式1:表达式2):表达式2;
     */
    ch2 = (ch>=\'A\' && ch<=\'Z\')?ch+(\'a\'-\'A\'):(ch>=\'a\'&&ch<=\'z\')?ch- (\'a\'-\'A\'):\'?\';
    printf("ch:%c->ch2:%c\n",ch,ch2);
结果：
请输入一个字符:ch:a->ch2:A

知识点
七、swich语句
25.输入一个小写的数字 输出相应的大写数字 1->一
    //1.输入一个小写数字
    int number = 0;
    printf("请输入一个小写的数字:\n");
    scanf("%d",&number);
    //2.根据不同的值进行不同的处理(条件分支)
    
    switch (number) {
        case 1:
            printf("一\n");
            break;//终止switch语句继续执行
        //case \'a\':printf("A\n");
        case 2:
            printf("二\n");
            break;
        case 3:
            printf("三\n");
            break;
        default:printf("您输入的数据有误!\n");
            break;
    }
结果：
请输入一个小写的数字:
2
二

26.重构成绩等级制输入分数求级别
    int score = 0;
    printf("请输入一个分数:\n");
    scanf("%d",&score);
    //2.求相应的级别
    //100/10 10 95/10 9 90/10 9
    switch (score/10) {
        case 10:
        case 9:printf("A\n");break;
        case 8:
        case 7:printf("B\n");break;
        case 6:printf("C\n");break;
        default:printf("D\n");
            break;
结果：
请输入一个分数:
90
A
27.重构等级制度输入一个分数级别
    //二、输入一个分数级别
    //求分数的范围 A "您的分数范围是90~100"
    //1.输入一个级别
    char level;
    printf("请输入一个分数的级别:\n");
    scanf("%c",&level);
    //2.根据级别求分数范围
    /* if分支语句
    if (level==\'A\'||level==\'a\') {
        printf("分数的范围是90~100\n");
    }else if (level==\'B\'||level==\'b\'){
        printf("分数的范围是70~90\n");
    }else if (level==\'C\'||level==\'c\'){
        printf("分数的范围是60~70\n");
    }else{//E
        printf("分数的范围是0~60\n");
    }*/
    
    //switch语句
    switch (level) {
        default:
            printf("0~60\n");
            break;
        case \'B\':
        case \'b\':printf("70~90\n");break;
        case \'C\':
        case \'c\':printf("60~70\n");break;
        case \'A\':
        case \'a\':printf("90~100\n");break;
结果：
请输入一个分数的级别:
a
90~100
28.switch练习
//1.输入数字
    int number = 0;
    printf("==================\n");
    printf("1.显示全部记录\n");
    printf("2.查询登录记录\n");
    printf("3.退出\n");
    printf("==================\n");
    printf("请输入你需要的功能:\n");
    scanf("%d",&number);
    //2.根据不同数字 进行不同处理
    switch (number) {
        case 1:
            printf("执行显示全部记录\n");
            break;
        case 2:
            printf("执行查询登录记录\n");
            break;
        case 3:
            printf("退出系统\n");break;
        default:
            printf("您输入的数据有请误!\n");
            break;
    }
结果：
==================
1.显示全部记录
2.查询登录记录
3.退出
==================
请输入你需要的功能:
2
执行查询登录记录

知识点
八、for   循环

1.for循环
    //0 1 2 3 4 5 6 7 8 9
    //循环语句 重复的执行一段代码
    for (int i = 0; i<10; i++) {
        //循环体
        printf("跑了第%d圈\n",i);
    }
    
    //可以省略表达式1 可以放到其它位置 可能会出现问题
    //可以省略表达式2 默认值是1 不可以放到其它位置
    //可以省略表达式3 可以放到其它位置 但必须放在循环体的最后一条件语句
    //三个表达式都可以省略
    /*
    for (int i=0;i<10;i++) {
        printf("Hello\n");
    }
    */
结果：
跑了第0圈
跑了第1圈
跑了第2圈
跑了第3圈
跑了第4圈
跑了第5圈
跑了第6圈
跑了第7圈
跑了第8圈
跑了第9圈



29.循环作业

1.重构字母转换（if语句）（逻辑运算符）
大写—>小写，小写—>大写，不是字母—>您输入的数据有误

2.求1-100的和1+2+3+5.....=5050
    //求(输出)1到100的和。
    //1.拿1~100数
    //表达式1 循环标识
    //表达式2 循环条件
    //表达式3
   
    int sum = 0;
    for (int i = 1; i<=100; i++) {
        //printf("i:%d\n",i);//循环体
        sum=sum+i;//累加求和
    }
    //2.求和
    printf("sum:%d\n",sum);
结果：sum:5050

3.输出1到100直间的奇数（不能被2整除的是奇数）
4.输出1到100之间的偶数（能被2整除的是偶数）
    for (int i = 1; i<=100; i++) {
        //2.根据条件取得的数
        if(i%2==0){
            printf(“偶数:%d\n”,i);
        }
    }
   
    /*也可以用这样的办法求
    for (int i = 1; i<=100; i=i+2) {
        printf("i:%d\n",i);
    }
    */

5.重构求10个数的最大值、最小值、和
    int num = 0;
    int sum = 0;
    
    printf("请输入第1个数:\n");
    scanf("%d",&num);
    int max = num;//标尺
    int min=num;
    sum = sum + num;//求和
    for (int i = 1; i<4 ; i++) {
        printf("请输入第%d个数:\n",i+1);
        scanf("%d",&num);
        sum = sum + num;//求和 求累"积"?
        //求最大值 求最小值?
        if (num>max) {
            max = num;
        }
        if (num<min) {
            min = num;
        }
    }
    printf("sum:%d\n",sum);
    printf("max:%d\n",max);
    printf("max:%d\n",min);
结果：
请输入第1个数:
50
请输入第2个数:
60
请输入第3个数:
40
请输入第4个数:
10
sum:160
max:60
max:10
6.在键盘上输入一个数（任意正整数），求该数的长度
123—3  4567—4
    int i=0,c;
    printf("请输入：\n");
    scanf("%d",&c);
    while(c)
    { c=c/10;
        i++;}
        printf("长度为：%d\n",i);
结果：
请输入：
123456
长度为：6

7.打印水仙花数，水仙花数是一个3位数100—999，每个位的数值的立方刚好是这个数的本身。
153=1*1*1+5*5*5+3*3*3，求水仙花数有哪些
    int i;
    int a,b,c;
    
    for(i=100;i<1000;i++){
    a=i/100;
    b=i%100/10;
    c=i%10;
    {if(i==a*a*a+b*b*b+c*c*c)
    
        printf("%d\n",i);}}
结果：
153
370
371
407
知识点
九、while循环
/* 标准的while循环
    //int i = 0;//表达式1 循环标识
    //在while循环中 表达式2是不可以省略的
    while (i<10) {//表达式2 循环条件
        printf("Hello\n");
        //i++;//表达式3 循环规律
    }
     */
    //通过while循环的使用 只关注条件
    /*
    while (1<10) { //表达式2 循环条件
        printf("hello\n");
    }*/
    
    //while循环的使用
    int num = 1;//保存用户输入的数据
    int count1 = 0;//统计正数有多少个
    int count2 = 0;//统计负数有多少个
    while (num!=0) {  遇到0就停止循环
        printf("执行循环体\n");
        printf("请输入一个数:\n");
        scanf("%d",&num);
        printf("您输入的数为:%d\n",num);
        //判断是正数还是负数
        if (num>=0) {//正数
            count1++;
        }
        if (num<0) {//负数
            count2++;
        }
    }
    printf("正数有:%d个\n",count1++);
    printf("负数有:%d个\n",count2++);
    
    printf("程序结束!\n");
    //多次输入一个数，只要不为0，就一直输入，统计
    //输入的数，有多少个是正数，有多少个是负数。
结果：
执行循环体
请输入一个数:
60
您输入的数为:60
执行循环体
请输入一个数:
-60
您输入的数为:-60
执行循环体
请输入一个数:
0
您输入的数为:0
正数有:2个
负数有:1个
程序结束!

知识点
十、随机数
#include <stdio.h>
//1.导入头文件
#include <time.h>
#include <stdlib.h>
#include <stdbool.h>
int main(int argc, const char * argv[])
{
    /*
    int i = 200;
    char c;
    //类型转换 int->char
    c = (char)i;//告诉其它程序员 类型转换 有风险
    */
    //2.使用函数 (unsigned)将有符号->符号
    srand((unsigned)time(0));//种子
    //0~21亿
    //0~9 %10
    //0~99 %100
    //1~100 %100+1
    int num = rand()%100+1;//随机数
    //printf("num:%d\n",num);
    bool isFlag = false;//标识是否猜正确
    int inputNum = 0;//输入一个数
    int count = 0;//统计猜数次数
    while (!isFlag) {
        printf("请输入您猜的数:\n");
        scanf("%d",&inputNum);
        count++;
        //判断
        if (inputNum==num) {
            printf("您猜对了!\n");
            isFlag = true;
            printf("您一共猜了%d次!\n",count);
        }else{
            printf("请继续猜!\n");
            if (inputNum>num) {
                printf("您上次输入的数大了\n");
            }else{
                printf("您上次输入的数小了\n");
            }
        }
    }
结果：
请输入您猜的数:
60
请继续猜!
您上次输入的数小了
请输入您猜的数:
80
请继续猜!
您上次输入的数大了
请输入您猜的数:
70
请继续猜!
您上次输入的数大了
请输入您猜的数:
65
请继续猜!
您上次输入的数小了
请输入您猜的数:
69
您猜对了!
您一共猜了5次!

知识点
十一、do…while循环
//表达式1 循环标识 就算条件不成立 至少执行一次
    int i = 20;
    do {
        printf("HelloWorld\n");//循环体
        i++;//表达式3
    } while (i<10);//表达式2 循环条件
    /* 第一次循环不会进行判断
     do{
     }while(表达式2)
     */
    /* 三个循环的区别
        for循环可以直接确定循环的次数
        while循环关注循环的条件
        do...while循环 第一次循环不会进行判断，每次判断的是下一次循环是否执行
     */
    //重构猜数练习
结果：HelloWorld  （先执行do循环体的结果）

2.练习
模拟输入用户名密码(数字)，设置一个数据库(模拟数据写死)中用户名密码(123,456)，匹配则显示登录成功(则循环停止)，否则登录失败，重新登录。

#include <stdio.h>
int main(int argc, const char * argv[])
{
    //1.模拟输入用户名密码(数字)
    int username = 0;//用户名
    int password = 0;//密码
    //2.设置一个数据库(模拟数据写死)中用户名密码(123,456)
    int d_username = 123;
    int d_password = 456;
    //3.匹配则显示登录成功(则循环停止)，否则登录失败，重新登录。
    //a.输入数据
    do{
        printf("输入用户名:\n");
        scanf("%d",&username);
        printf("请输入密码:\n");
        scanf("%d",&password);
    }while ( !(username==d_username && password==d_password) );
    printf("登录成功!\n");
    //用户名和密码 都相同 登录成功
    //(username==d_username && password==d_password)
或（同时使用break和continue）

//1.模拟输入用户名密码(数字)
    int username = 0;//用户名
    int password = 0;//密码
    //2.设置一个数据库(模拟数据写死)中用户名密码(123,456)
    int d_username = 123;
    int d_password = 456;
    //3.匹配则显示登录成功(则循环停止)，否则登录失败，重新登录。
    //a.输入数据
    do{
        printf("输入用户名:\n");
        scanf("%d",&username);
        printf("请输入密码:\n");
        scanf("%d",&password);
        if (username==d_username && password==d_password) {
            printf("登录成功!\n");
            break;
        }else{
            printf("登录失败，请重新登录!\n");
            continue;
        }
    }while (1);
    //用户名和密码 都相同 登录成功
    //(username==d_username && password==d_password)

三个循环的特点：
for:循环可以直接确定循环次数
while ：关注循环的条件
do…while 循环：第一次循环不会进行判断，每次判断的是下一次循环是否执行！

知识点
十二、break，continue
1.循环中使用break;
  break;不但可以终止switch，也可以终止for循环语句
 举例：
int main()
{
    int i=0;
    for (; i<10; i++) {
        if (i==3) {
            break;//终止循环的继续执行
        }
        printf("hello:%d\n",i);
    }
}
练习：
编写一个求和程序。用户从控制台输入的整数的个数 不受限制,直到输入整数0为止。将输入的整数逐个相加后, 把结果输出。
    int sum = 0;
    while (1) {
        //1.输入一个整数
        int num = 0;
        printf("请输入一个数:\n");
        scanf("%d",&num);
        //2.循环输入 直接输入0时结束 break
        if (num==0) {
            break;
        }
        //3.求输入整数之和并输出
        sum+=num;
        printf("sum:%d\n",sum);
    }
结果：
请输入一个数:
45
sum:45
请输入一个数:
64
sum:109
请输入一个数:
0
2.continue可以终止当次循环，继续下一次循环
相当于跳过当次，接着执行下面的
int main()
{
    for (int i=0; i<10; i++) {
        if (i==3) {
            continue;
        }
        printf("hello word:%d\n",i);
    }
    return 0;
}
结果：
hello word:0
hello word:1
hello word:2
hello word:4
hello word:5
hello word:6
hello word:7
hello word:8
hello word:9

3.清空缓冲区
scanf(“%*c”);
举例：有关回车所占的位置清空
int main()
{
    char a,b;
    printf("input:");
    scanf("%c",&a);
    scanf("%*c");//清空缓冲区
    
    printf("input:");
    scanf("%c",&b);
    printf("a；%db:%d",a,b);
}

知识点
十三、for循环嵌套（相当于乘法）
int main()
{
1.循环嵌套 外面的循环执行一次 里面的循环执行一遍
2.描述的是一个二维表 外面的循环代表行  里面的代表列
3.使用循环的嵌套输出指定的图形
4.for可以嵌套 while可以嵌套 do…while 也可以嵌套
5.for…while混合嵌套
    for (int j=0; j<2; j++) {//行
        for (int i=0; i<3; i++) {//列
            printf("i:%d j:%d\n",i,j);
        }
        printf("|\n");
    }
    return 0;
}
结果：
i:0 j:0
i:1 j:0
i:2 j:0
|
i:0 j:1
i:1 j:1
i:2 j:1
|
2.输出指定的图形
for (int j=0; j<3; j++) {
        for (int i=0; i<5; i++) {
            printf("*");
        }
       printf("\n");
    }

3.while里面嵌套while
int main()
{
    int i=0;
    while (i<9) {//行
        int j=0;
        while (j<9) {
            printf("%d%d ",i,j);
            j++;
        }
        printf("\n");
        i++;
        }
   
    return 0;
}
执行结果：
00 01 02 03 04 05 06 07 08 
10 11 12 13 14 15 16 17 18 
20 21 22 23 24 25 26 27 28 
30 31 32 33 34 35 36 37 38 
40 41 42 43 44 45 46 47 48 
50 51 52 53 54 55 56 57 58 
60 61 62 63 64 65 66 67 68 
70 71 72 73 74 75 76 77 78 
80 81 82 83 84 85 86 87 88 
4.while里面嵌套for
for (int i = 0; i<9; i++) {
        int j = 0;
        while (j<9) {
            printf("%d%d ",i,j);
            j++;
        }
        printf("\n");
    }

作业：

1.打印图形(简单)
    a.*****
    for (int i = 0;i<5; i++) {
        printf("*");
    }
    printf("\n");
    b.   *
        **
        ***
        ****
        *****
for (int j = 1; j<6; j++) { //行
        for (int k = 0; k<j; k++) {//列打印内容
            printf("*");
        }
        printf("\n");
    }

    c.*****
       ****
       ***
       **
       *
for (int j = 1; j<6; j++) { //行
        for (int k = 0; k<6-j; k++) {//列打印内容
            printf("*");
        }
        printf("\n");
    }

    d.    *
         ***
          *****
for(int i=1;i<4;i++){
        
        for(int p=0;p<2*i-1;p++){
            printf("*");
        }
                printf("\n");
    }

e. * * * * 
     * * * * 
       * * * * 
         * * * * 
for(int i=1;i<5;i++){
        
        for(int p=0;p<i;p++){
            printf(" ");
        }
        for(int j=0;j<4;j++){
            
            printf("* ");
            
        }printf("\n");
    }

2.99乘法表(中)
    1*1=1
    2*1=2 2*2=4
    3*1=3 3*2=6 3*3=9
    ……
for (int i=1; i<=9; i++) {
        for (int j=1; j<=i; j++) {
            printf("%d*%d=%d ",i,j,i*j);
        }
        printf("\n");
    }

3.三角形的输出(中)
for(int i=1;i<5;i++){
        
        for(int p=1;p<5-i;p++){
            printf(" ");
        }
        for(int j=0;j<2*i-1;j++){

            printf("*");
           
        }printf("\n");
    }
  *
  ***
 *****
*******

4.输入一个数 求数的位数…(高)
    for/while/do…while
    123->3 4567->4
int num = 0;
    printf("请输入一个数:\n");
    scanf("%d",&num);
    int length = 0;//除的次数(长度)
    while (1) {
        length++;
        num = num/10;
        if (num==0) {
            break;
        }
    }
    printf("length:%d\n",length);
结果：
请输入一个数:
12345
length:5
知识点
十四、一维数组
一维数组
数组是用来存储多条相同数据类型的数据结构（容器）
定义数组：
int array[3];
访问元素：array[0]=10;

数组名是地址：不能给数组名赋值
数组变量只可以在初始化的时候赋值并且是常量
举例：%p
int array[3];//数组类型 元素类型 数组名【长度】
    array[0]=10;//数组名【下标】 变量=（存值）=变量（取值）
    array[1]=20;
    array[2]=30;
    printf("array[0]:%d\n",array[0]);
    printf("array[1]:%d\n",array[0]);
    printf("array[2]:%d\n",array[0]);
    return 0;

举例
int array[3];//数组类型 元素类型 数组名【长度】
    array[0]=10;//数组名【下标】 变量=（存值）=变量（取值）
    array[1]=20;
    array[2]=30;
    printf("array[0]:%d\n",array[0]);
    printf("array[1]:%d\n",array[0]);
    printf("array[2]:%d\n",array[0]);
    
    int i=10;
    printf("address:%p\n",&i);//&取地址运算符
    
    printf("array address:%p\n",&array);//array数组变量 array[0]数组元素变量
    printf("array address:%p\n",array);
    //得到数组中首元素的地址 &array[0]
    printf("array address:%p\n",&array[0]);
结果：array[0]:10
array[1]:10
array[2]:10
address:0x7fff5fbff8d8
array address:0x7fff5fbff8dc
array address:0x7fff5fbff8dc
array address:0x7fff5fbff8dc



练习：通过键盘输入5个数，输入后输出相应的5个数是什么

int array2[5]={};//初始化
    int j;
    //数组使用的时候，经常与循环（for）结合使用
     //输入5个数
    for (int i=0; i<5; i++) {
        printf("input:",i+1);
        scanf("%d",&array2[i]);
        
    }//输出5个数
    for (int j=0; j<5; j++) {
        printf("output:%d",array2[j]);
    }

 2. //数组所占空间＝元素所占空间*数组的长度
    //?只要知道数组的名字 就能求出数组的长度
    //数组的长度＝数组所占空间/元素所占空间
    
    float array3[3] = {10.1,20.1,30.1};
    //数组变量只可以在初始化的时候赋值并且是常量
    //array3 = {10.1,20.1,30.1};
    //array3 = &...
    
    int length = 0;
    //sizeof 变量 类型 常量 表达式
    printf("sizeof(array3) size:%lu\n",sizeof(array3));
    printf("sizeof(array3[0]) size:%lu\n",sizeof(array3[0]));
    length = sizeof(array3)/sizeof(array3[0]);
    printf("length:%d\n",length);
    
    //输出5个数
    for (int j=0; j<sizeof(array3)/sizeof(array3[0]); j++) {
        printf("第%d个数:%f\n",j+1,array3[j]);
    }
结果：
sizeof(array3) size:12
sizeof(array3[0]) size:4
length:3
第1个数:10.100000
第2个数:20.100000
第3个数:30.100000

3.可变数组
1、在C语言中，可变数组指的是数组在声明前其长度是可变的，一旦声明，数组的长度就不可变了。
2、在oc语言中，专门有一种数据类型叫可变数组，数组在使用过程中，其长度是可变的。
int count;
    printf("请输入班级的人数:\n");
    scanf("%d",&count);
    //可变数组在使用前 必须确定数组的长度
    //一但声明，数组的长度不可修改
    int scores[count];//可变数组 是不能初始化
    int sum = 0;
    for (int i = 0; i<count; i++) {
        printf("请输入第%d个的成绩:\n",i+1);
        scanf("%d",&scores[i]);
        sum+=scores[i];
    }
    printf("sum:%d\n",sum);

练习：输入10个数，求10个数中的最大值，最小值，和。并且输入该值所在位置(最大值，最小值)
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main(int argc, const char * argv[])
{
    int nums[5] = {0};
    srand((unsigned)time(0));
    //1.输入5个数
    for (int i = 0; i<5; i++) {
        /* 输入5个数
        printf("请输入第%d个数:\n",i+1);
        scanf("%d",&nums[i]);
         */
        /*随机生成5个数*/
        nums[i]= rand()%100+1;
       
    }
    //2.得到最大值 得到相应的位置
    int maxIndex = -1;
    int minIndex = -1;
    //a.标尺 (1)拿第一个值当标尺
    //int max = nums[0];
    //(2)指定一个值作为标尺
    //给最小值一个最大值的初值
    //给最大值一个最小值的初值
    int max = 0;
    int min = 100;
    //b.每一个值和标尺比
    //得到数组中的每一个元素 "遍历"
    for (int i = 0; i<5; i++) {
        if(nums[i]> max){
            max = nums[i];
            maxIndex = i;//保存最大值的下标
        }
        if (nums[i]<min) {
            min = nums[i];
            minIndex = i;
        }
    }
    printf("max:%d maxIndex:%d\n",max,maxIndex);
    printf("min:%d minIndex:%d\n",min,minIndex);
    //3.得到最小值 得到相应的位置
    //4.求和
结果：
max:95 maxIndex:3
min:29 minIndex:1

4.数组的复制、拷贝
    int array[3] = {4,5,6};
    int array2[3];
    //不可以直接赋值数组变量
    //array2 = array;//数组一但声明 地址是不可修改
    for (int i = 0; i<3; i++) {
       array2[i] = array[i];//取出第一个数组中每一个元素
    }
    //查看数组2中的内容
    for (int j = 0; j<3; j++) {
        printf("array2[%d]:%d\n",j,array2[j]);
    }
结果：
array2[0]:4
array2[1]:5
array2[2]:6

5.数组的乱序

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main(int argc, const char * argv[])
{
    int array[10] = {1,2,3,4,5,6,7,8,9,0};
    srand((unsigned)time(0));
    for (int i = 0; i<10; i++) {
        //x交换位置 随机生成
        /*
            0~9
            1~9
            2~9
            3~9
         */
        int x = rand()%(10-i)+i;//只是为了更随机
        //array[i]当前的位置
        //array[x]随机生成的交换位置
        //交换两个值
        int temp = array[i];
        array[i] = array[x];
        array[x] = temp;
    }
    //输出交换后的数组内容
    for (int i = 0; i<10; i++) {
        printf("array[%d]:%d\n",i,array[i]);
    }
    
    return 0;
}
结果：
array[0]:4
array[1]:1
array[2]:8
array[3]:0
array[4]:9
array[5]:6
array[6]:3
array[7]:7
array[8]:5
array[9]:2

6.正反向遍历
int main()
{
    int array[5]={1,2,3,4,5};
    for (int i=0; i<5; i++) {
        printf("%d",array[i]);
        
    }
    printf("\n");
    for (int i=4; i>=0; i--) {
        printf("%d",array[i]);
    }
    return 0;
}
结果
12345
54321
7.数组元素的重复
若输入数据有重复的数字，把重复的数据表现出来
int main()
{
    int num=0;
    int count=0;
//    int temp=num;//复制一份输入的值
    int array[count];
    
    printf("input");
    scanf("%d",&num);
    int temp=num;
    while (temp) {//求长度
        count++;
        temp/=10;
 //       printf("%d",temp);
    }
    for (int i=0; num; i++) {//求出数组中的每一个数值
        array[i]=num%10;//取出每一位的值并保存
        num/=10;
    }
    for (int i=0; i<count; i++) {//每次都是与前一次进行比较
        for (int j=0; j<i; j++) {
    //        printf("%d%d",i,j);
            if (array[i]==array[j]) {
                printf("chongf%d\n",array[i]);
            }
        }
    }
    return 0;
    
}
结果：
input5864564
chongf4
chongf8
chongf5


练习：
随机产生6个红球和1个篮球，并且红球不重复，并输出红球和篮球
int main()
{
    //1.生成几个随机数
    //2.随机数的范围
    //3.随机数的样子
    //4.所求随机数 红 蓝
    int blue=0;
    int red[6]={0};
    srand((unsigned)time(0));
    blue=rand()%16+1;
    for (int i=0; i<6; i++) {//red[i]=当前生成的随机数
        red[i]=rand()%33+1;
        for (int j=0; j<i; j++) {//red[j]=之前生成的随机数
            if (red[j]==red[i]) {
                i--;
                break;//只要发现一个重复的，后面的就不需要判断了
            }
        }
    }
    
    //判断之前是否有重复
    for (int i=0; i<6; i++) {
        printf("%d ",red[i]);
    }
    printf("%d\n",blue);
}

练习 日历

int days[40] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,1,2,3,4,5,6,7,8,9,10};//40应该是365
    int startIndex = 1;//1号在星期几
    int index = 0;//取到几号了
    printf("一\t二\t三\t四\t五\t六\t日\n");
    if (startIndex==1) {
        printf(" \t");
    }
    do {
        if(startIndex%7!=0){//标识 所在位置
            printf("%d\t",days[index++]);
        }else{
            printf("\n%d\t",days[index++]);
        }
        startIndex++;
        if (index==40) {
            break;
        }
    }while (1);
    printf("\n");
结果：
一    二    三    四    五    六    日
     1    2    3    4    5    6    
7    8    9    10    11    12    13    
14    15    16    17    18    19    20    
21    22    23    24    25    26    27    
28    29    30    1    2    3    4    
5    6    7    8    9    10    

知识点
十五、二维数组
   //元素类型 数组名[数组长度];
     int array[3]={0};初始化
    //array[下标] 下标<数组长度
    // 数组= 存值     =数组 取值
    //二维数组 3外层(一维)数组的长度,2内层(二维)数组的长度
    //元素类型 二维数组名[一维长度][二维长度];
    int array[3][2];
    //二维数组的操作 array[下标1][下标2]
  int array2[4][3]={1,2,3,4,5,6,7,8,9,10,11,12};
  //二维数组与循环嵌套使用
    //外层循环对应二维数组一维的下标
    //内层循环对应二维数组二维的下标
  //   printf("%d",array2[2][0]);

int array[3][2]={{1,2},{3,4},{5,6}};//对应元素内容
int array1[3][2]={1,2,3,4,5,6};//整体赋值
int array2[3][2]={1,2,3,4};//依次赋值 自动补零

练习
 1.输入5个学生，3门课的成绩，
 2.求每个学生 总成绩 X
   求每个课程 总成绩 Y
 3.显示
#include <stdio.h>

int main(int argc, const char * argv[])
{
    //保存5个学生3门课的成绩
    int score[3][5] = {0};
    int sum[3] = {0};//各门课的总成绩
    int psum[5] = {0};//各个人的总成绩
    //输入每一个学生的成绩
    for (int i=0; i<3; i++) {
        for (int j=0; j<5; j++) {
            //printf("请输入%d行(课程)%d列(姓名)的成绩\n",i,j);
            printf("请输入");
            //课程
            switch (i) {
                case 0:
                    printf("语文");
                    break;
                case 1:
                    printf("数学");
                    break;
                case 2:
                    printf("英语");
                    break;
            }
            //姓名
            switch (j) {
                case 0:
                    printf("张");
                    break;
                case 1:
                    printf("李");
                    break;
                case 2:
                    printf("王");
                    break;
                case 3:
                    printf("赵");
                    break;
                case 4:
                    printf("钱");
                    break;
            }
            printf("的成绩\n");
            scanf("%d",&score[i][j]);
            //求每门课的成绩和
            sum[i]+=score[i][j];
            //求每个人的总成绩和
            psum[j]+=score[i][j];
        }
    }
    printf("\t张\t李\t王\t赵\t钱\n");
    //输出每一个学生的成绩
    for (int i=0; i<3; i++) {
        //每一行的行头
        switch (i) {
            case 0:
                printf("语文");
                break;
            case 1:
                printf("数学");
                break;
            case 2:
                printf("英语");
                break;
        }
        printf("\t");
        for (int j=0; j<5; j++) {
            printf("%d\t",score[i][j]);
        }
        printf("\n");
        
    }
    //查看每门课的总成绩
    for (int i = 0; i<3; i++) {
        switch (i) {
            case 0:
                printf("语文");
                break;
            case 1:
                printf("数学");
                break;
            case 2:
                printf("英语");
                break;
        }
        printf("的总成绩为:%d\n",sum[i]);
    }
    //每个人的总成绩?
    return 0;
}
结果：
……
80
请输入英语钱的成绩
80
    张    李    王    赵    钱
语文    60    60    60    60    60    
数学    70    70    70    70    70    
英语    80    80    80    80    80    
语文的总成绩为:300
数学的总成绩为:350
英语的总成绩为:400
知识点
十六、函数

特点：1.结构清晰2.重复使用

1.函数的参数 
#include <stdio.h>
//1.声明
//返回值类型 函数名(参数);
//推荐：***只要使用函数一定要声明
void sayHello(int i);//函数的原型
//void代表空 声明时不写参数 代表任意个数的参数
//如果不需要参数必须声明成void
//***函数的声明与函数的定义可以一致
//声明的时候 定义的时候 参数形参
//参数:如果函数执行的时候 需要有参考依据就要使用参数
void sayHello(){ //函数体 真正解决问题代码
    printf("Hello\n");
}
//void sayHello5();
//2.定义
void sayHello5(){
 printf("Hello\n");
 printf("Hello\n");
 
}
练习1：
想输出几个Hello就输出几个Hello
void sayHelloN(int n);//声明
void sayHelloN(int n){
    for (int i=0; i<n; i++) {
        printf("Hello\n");
    }
}
//程序执行的->main()->sayHello();
int main(int argc, const char * argv[])
{
    //3.调用 如果定义的时候有参数，调用的时候就必须输入参数，声明与调用要统一
    //sayHello(20);//调用时候的参数就是实参
    //sayHello5();
    sayHelloN(3);
    printf("...几百行\n");
    //sayHello5();//函数中定义的代码可以多次使用
结果：
Hello
Hello
Hello
...几百行

练习2：
   早 晚 中 吃啥？
 //写函数根据不同值来决定吃什么
 //0鱼香肉丝 1地三鲜 2土豆丝 3.宫爆鸡丁
 //other.吃饺子
#include <stdio.h>
//1.声明
void eat(int num);//根据数据决定吃什么
//2.定义
//如果函数需要多个参数，需要用,号分隔开。
//参数的类型不限制，但必须声明其类型。
//void eat(int num1,int num2)
//void eat(int num1,char ch)
void eat(int num){
    //0鱼香肉丝 1地三鲜 2土豆丝 3.宫爆鸡丁
    switch (num) {
        case 0:
            printf("鱼香肉丝\n");
            break;
        case 1:
            printf("地三鲜\n");
            break;
        case 2:
            printf("土豆丝\n");
            break;
        case 3:
            printf("宫爆鸡丁\n");
            break;
        default:
            printf("吃饺子\n");
            break;
    }
}
#include <time.h>
#include <stdlib.h>
int main(int argc, const char * argv[])
{
    srand((unsigned)time(0));
    int temp;
    printf("早上起床了,吃啥呢?\n");
    //scanf("%d",&temp);
    temp = rand()%5;
    //参数也可以是一个表达式，但必须有结果
    eat(1+2);
    
    printf("又到中午了,吃啥呢?\n");
    temp = rand()%5;
    eat(temp);
    
    printf("晚上了,吃啥呢?\n");
    temp = rand()%5;
    eat(temp);
结果：
早上起床了,吃啥呢?
宫爆鸡丁
又到中午了,吃啥呢?
地三鲜
晚上了,吃啥呢?
宫爆鸡丁

2.函数的返回值

练习
/带饭
//吃什么口味的 0甜 1咸 2辣
//0->鱼(Y) 1->土(T) 2->尖(J)

#include <stdio.h>
/char buy(int taste);
//如果定义了返回值类型 函数执行后必须有返回值
char buy(int taste){
    switch (taste) {
        case 0:
            return \'Y\';
            break;
        case 1:
            return \'T\';
            break;
        case 2:
            return \'J\';
            break;
        default:
            return \'Y\';
    }
}

int main(int argc, const char * argv[])
{
    //中午帮我带个饭 我要辣的
    //调用一个函数的时候，如果函数有返回值，必须要接收或处理
    char ch = buy(0);
    printf("ch:%c\n",ch);
结果：ch:Y

3.函数的参数是数组

1.求数组的长度
    int a[]={1,2,3,4,5};
    int length=sizeof(a)/sizeof(a[0]); 求数组的长度
    printf("length:%d\n",length);
结果：
length:5

2.参数是数组
#include <stdio.h>
void func(int length,int *p);
void func(int length,int *p){
    for (int i = 0; i<length; i++) {
        printf("array[%d]:%d\n",i,*(p+i));
    }
}
//参数 如果是数组，必须指定两个值
//1.数组的长度 2,数组名
void func2(int lenght,int array[]);
void func2(int lenght,int array[]){
    for (int i = 0; i<lenght; i++) {
        printf("array[%d]:%d\n",i,array[i]);
    }
}


int main(int argc, const char * argv[])
{
    int array[] = {1,2,3,4,5};
    int length = sizeof(array)/sizeof(array[0]);
    printf("length:%d\n",length);
    
    //int *p = &i;
    //int *p = &array[0];
    int *p = array;
    
    //func(array);
    //如果函数的参数是数组 使用两个参数
    //参数1 为数组的长度 参数2 数组的指针
    func2(length,array);
    
    return 0;
}
结果：length:5
array[0]:1
array[1]:2
array[2]:3
array[3]:4
array[4]:5

作业：
1.求两个数的和

#include <stdio.h>
#include<stdlib.h>
#include<time.h>

int count(int a,int b);
int count(int a,int b){
    
    //printf("%d",sum);
    return a+b;
   }

int main(int argc, const char * argv[]) {
    int a;
    int i,j;
    srand((unsigned)time(0));//随机得到两个数
    i=rand()%10;
    j=rand()%10;
    a= count(i,j);// return的返回值赋给a
    printf("%d",a);
结果：11

2.重构 成绩打印

#include <stdio.h>
void kemu(int i);
void xingming(int j);

void kemu(int i){
    switch (i) {
        case 0:
            printf("语文");
            break;
        case 1:
            printf("数学");
            break;
        case 2:
            printf("英语");
            break;
    }
  
}
void xingming(int j){
    switch (j) {
        case 0:
            printf("张");
            break;
        case 1:
            printf("李");
            break;
        case 2:
            printf("王");
            break;
        case 3:
            printf("赵");
            break;
        case 4:
            printf("钱");
            break;
    }
 
}

int main(int argc, const char * argv[])
{
    //保存5个学生3门课的成绩
    int score[3][5] = {0};
    int sum[3] = {0};//各门课的总成绩
    int psum[5] = {0};//各个人的总成绩
    //输入每一个学生的成绩
    for (int i=0; i<3; i++) {
        for (int j=0; j<5; j++) {
            printf("请输入");
            //课程
            kemu(i);
            //姓名
            xingming(j);
            printf("的成绩:");
            scanf("%d",&score[i][j]);
            //求每门课的成绩和
            sum[i]+=score[i][j];
            //求每个人的总成绩和
            psum[j]+=score[i][j];
        }
    }
    printf("\t张\t李\t王\t赵\t钱\n");
    //输出每一个学生的成绩
    for (int i=0; i<3; i++) {
        //每一行的行头
        kemu(i);
        printf("\t");
        for (int j=0; j<5; j++) {
            printf("%d\t",score[i][j]);
        }
        printf("\n");
        
    }
    //查看每门课的总成绩
    for (int i = 0; i<3; i++) {
        kemu(i);
        printf("的总成绩为:%d\n",sum[i]);
    }
    //每个人的总成绩
    for (int j=0; j<5; j++) {
        xingming(j);
        printf("的总成绩为:%d\n",sum[j]);
    }
    return 0;
}
结果：
请输入语文张的成绩:60
请输入语文李的成绩:60
请输入语文王的成绩:60
请输入语文赵的成绩:60
请输入语文钱的成绩:60
请输入数学张的成绩:70
请输入数学李的成绩:70
请输入数学王的成绩:70
请输入数学赵的成绩:70
请输入数学钱的成绩:70
请输入英语张的成绩:80
请输入英语李的成绩:80
请输入英语王的成绩:80
请输入英语赵的成绩:80
请输入英语钱的成绩:80
    张    李    王    赵    钱
语文    60    60    60    60    60    
数学    70    70    70    70    70    
英语    80    80    80    80    80    
语文的总成绩为:300
数学的总成绩为:350
英语的总成绩为:400
张的总成绩为:300
李的总成绩为:350
王的总成绩为:400
赵的总成绩为:60
钱的总成绩为:60

3.使用一个函数调换两个数。
#include <stdio.h>
#include<stdlib.h>
#include<time.h>
void count(int i,int j);
void count(int i,int j){
    printf("交换之前的值：i=%d j=%d\n",i,j);
    int temp=0;
    temp=i;
    i=j;
    j=temp;
    printf("交换之后的值：i=%d j=%d\n",i,j);
}

int main(int argc, const char * argv[]) {
    int a=0,b=0;
    srand((unsigned)time(0));
    a=rand()%100;
    b=rand()%100;
   // printf("主函数交换之前的值：i=%d j=%d\n”,a,b);去掉
    count(a,b);
    //实参与形参不是一个内存空间（传递的只是值）
   // printf("主函数交换之后的值：i=%d j=%d\n”,a,b);去掉
    return 0;
}
结果：
主函数交换之前的值：i=66 j=41
交换之前的值：i=66 j=41
交换之后的值：i=41 j=66
主函数交换之后的值：i=66 j=41

4.求两个数的最大值？
5.求两个数的最小值？
#include <stdio.h>
#include<stdlib.h>
#include<time.h>
void count(int i,int j);
void count(int i,int j){
    int min=0,max=0;
    max=i;min=i;
    if (i<j) {
        max=j;
    }
    if (i>j) {
        min=j;
    }
    printf("max:%d,min:%d\n",max,min);
    
}

int main(int argc, const char * argv[]) {
    int a=0,b=0;
    srand((unsigned)time(0));
    a=rand()%100;
    b=rand()%100;
    count(a,b);
结果：
max:54,min:17

6.输入分数求级别，输入级别求分数？重构输入10个学生信息，得到相应结果。
#include <stdio.h>
#include<stdlib.h>
#include<time.h>
//void a(int i);
//void b(char j);
//void xingming(int k);

void a(int i){
    i=i/10;
    switch (i) {  //输入分数求级别0~60D 60~70C 70~90B 90~100A
        case 6:
            printf("C\n");
            break;
        case 7:
        case 8:
            printf("B\n");
            break;
        case 9:
        case 10:
            printf("A\n");
            break;
            
        default:printf("D\n");
            break;
    }
}

void b(char j){
    switch(j){
        case \'A\':
        case \'a\':printf("90~100\n");break;
        case \'B\':
        case \'b\':printf("70~90\n");break;
        case \'C\':
        case \'c\':printf("60~70\n");break;
        default:printf("60\n");  break;
    }
 
    
}


void xingming(int k){
    switch (k) {
        case 0:
            printf("张");
            break;
        case 1:
            printf("李");
            break;
        case 2:
            printf("王");
            break;
        case 3:
            printf("赵");
            break;
        case 4:
            printf("钱");
            break;
    }
    
}

int main(int argc, const char * argv[]) {
  
    
    for (int i=0; i<5; i++) {//输入5个人的信息
        int fenshu;
        printf("请输入");
        xingming(i);
        printf("的分数:");
        scanf("%d",&fenshu);
        printf("对应的等级是：");a(fenshu);
    }
    scanf("%*c");//缓存
    for (int i=0; i<5; i++) {//输入5个人的信息
        char dengji;
        printf("请输入");
        xingming(i);
        printf("的等级:");
        scanf("%c",&dengji);
        
        printf("对应的范围是：");b(dengji);
    }

        return 0;
}
结果：
请输入张的分数:60
对应的等级是：C
请输入李的分数:50
对应的等级是：D
请输入王的分数:90
对应的等级是：A
请输入赵的分数:80
对应的等级是：B
请输入钱的分数:70
对应的等级是：B
请输入张的等级:a
对应的范围是：90~100
请输入李的等级:对应的范围是：60
请输入王的等级:D
对应的范围是：60
请输入赵的等级:对应的范围是：60
请输入钱的等级:C
对应的范围是：60~70

4.return与exit关键字

return：

1.有返回值类型，必须有return关键字
2.没有返回值类型，也可以使用return关键字
3.当函数的执行过程中，如果碰到return关键字，会终止函数的继续执行

#include <stdio.h>
void fun();
void fun(){
    //有返回值类型，必须有return关键字
    //没有返回值类型，也可以使用return关键字
    return ;//当函数的执行过程中，如果碰到return关键字，会终止函数的继续执行
    printf("函数结尾");
}
int main(int argc, const char * argv[]) {
    fun();
    printf("程序结尾\n");
结果：
程序结尾

exit：（#include <stdlib.h>）
1.终止程序的继续执行
#include <stdio.h>
#include <stdlib.h>
void func();
void func(){
    printf("2.func函数开始执行了\n");
    //1.有返回值类型 必须有return关键字
    //2.没有返回值类型 也可以使用return关键字
    //return ;
   exit(0);//终止程序的继续执行
    //当函数的执行过程中 如果碰到return关键字，会终止函数的继续执行
    printf("函数末尾!\n");
}
int main(int argc, const char * argv[])
{
    printf("1程序开始!\n");
    func();
    printf("3.程序末尾!\n");
    return 0;
}
结果：
1程序开始!
2.func函数开始执行了

练习：
输出一组数的和、最大值、最小 值  
        在主函数中创建一个长度为10的数组,数组内放置10 个0~99之间(包含0,包含99)的随机数作为数组内容。   按要求分别编制自定义函数求数组中的最大值、最小值并 计算出所有数组元素的和。   在主函数中将各自定义函数的返回值打印显示在界面上。
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
//得到一个随机数 0~99
int getRandom();
int getRandom(){
    return rand()%100;
}
//得到一组数中的最大值
int getArrayMax(int length,int array[]);
int getArrayMax(int length,int array[]){
    int max = 0;
    for (int i= 0; i<length; i++) {
        if(array[i]>max){
            max = array[i];
        }
    }
    return max;
}
//得到一组数中的最小值
int getArrayMin(int length,int array[]);
int getArrayMin(int length,int array[]){
    int min = 99;
    for (int i= 0; i<length; i++) {
        if(array[i]<min){
            min = array[i];
        }
    }
    return min;
}
//得到一组数的和
int getArraySum(int length,int array[]);
int getArraySum(int length,int array[]){
    int sum = 0;
    for (int i=0; i<length; i++) {
        sum+=array[i];
    }
    return sum;
}
//得到数组所有的内容
void outputArrayValue(int length,int array[]);
void outputArrayValue(int length,int array[]){
    for (int i = 0; i<length; i++) {
        printf("array[%d]:%d\n",i,array[i]);
    }
}
int main(int argc, const char * argv[])
{
    int array[10] = {0};
    //生成随机数
    srand((unsigned)time(0));
    for (int i=0; i<10; i++) {
        array[i] = getRandom();
    }
    //得到最大值
    int max = getArrayMax(10, array);
    //得到最小值
    int min = getArrayMin(10, array);
    //得到和
    int sum = getArraySum(10, array);
    printf("max:%d min:%d sum:%d\n",max,min,sum);
    //显示数组中的所有内容
    outputArrayValue(10, array);
   
    return 0;
}
结果：
max:78 min:10 sum:504
array[0]:18
array[1]:30
array[2]:46
array[3]:75
array[4]:78
array[5]:52
array[6]:50
array[7]:10
array[8]:76
array[9]:69


5.递归函数
函数中调用函数就叫做递归。（一不小心死循环）
    1.递归工作原理：
              1.必须有退出条件
              2.必须保证递归后。算法简化
#include <stdio.h>
int func(int num);
int func(int num){
    printf("num:%d\n",num);
    if (num==1) {
        return 1;//终止条件
    }
    return num*func(num-1);//保证递归后算法简化   复制一个继续执行然后返回值                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
}//函数中调用函数 递归 一不小心死循环
//程序的编译顺序是自上下向的
//程序的运行顺序main函数的调用顺序
int main(int argc, const char * argv[]) {
   int num1= func(3);3的阶乘，是几的阶乘就写几
    printf("num1=%d\n",num1);
    return 0;
}
结果：
num:3
num:2
num:1
num1=6（6相当于3的阶乘3!=3*2*1）

知识点
十六、变量的作用域
一、变量的作用域  (变量的使用范围)
1.不同级的代码块是可以重名的
2.i取值是就近原则
3.在上一级代码中声明的变量，是可以在下一级代码中使用
4.在下一级代码中声明的变量，是不可以在上一级代码中使用
5.声明在大括号外面的变量叫全局变量（整个程序中都可以用）
6.声明在大括号里面的变量叫局部变量（只能在大括号的内部使用）
7.参数是个特殊的局部变量，作用域范围，是函数的内部
8.for 循环的表达式1也是个特殊的局部变量，作用域的范围只能在for  循环体内部使用
#include <stdio.h>

int main(int argc, const char * argv[]) {
    //变量i 作用域
    int i=10;上一级代码块    全局变量
    {
      //代码块
        int i=20;//不同级的代码块是可以重名的    下一级代码块      局部变量
        //i取值是就近原则
        printf("i1:%d\n",i);
    }
    printf("i2:%d\n",i);
    return 0;
}
结果：
i1:20
i2:10

二、变量的生命周期（局部变量）在内存中存在的情况
   1.自动变量auto   
         auto关键字 是没有动态变量一说的  不可使用
   2.静态变量static
     static在声明的开始，当程序结束时后结束
       
#include <stdio.h>
void func2(){
    //自动变量  默认值就是auto
    auto int i=10;//生 创建内存空间    auto可以省略
    //静态变量
    static int i2=20;//生 死：当程序结束的时候
    i++;
    i2++;
    printf("i:%d\n",i);
    printf("i2:%d\n",i2);
}//出了作用域 死 回收内存空间

int main(int argc, const char * argv[]) {
    func2();
    func2();
    
    
    return 0;
}
结果：
i:11
i2:21
i:11
i2:22
二、变量的生命周期（全局变量）
 全局变量的作用域在整个程序的内部，多个函数可以共享这个全局变量  
 全局变量的生命周期：
    程序开始的时候——生
    程序结束的时候——死
 
三、全局变量中的static和auto

1.auto关键字 是没有动态变量一说的  不可使用
2.static关键字 和生命周期没有关系，在多文件开发中，如果要区分全局变量在不同文件中的访问范围，需要使用static关键字修饰

四、栈操作
先进后出，后进先出
练习：使用程序来模拟放球、取球的问题  
      用数字来代表球,向栈中放入一个数字1代表放入了1 号球,向栈中放入一个数字2代表放入了2号球,依次类推。 同样,从栈中取出数字1代表取出了1号球。
#include <stdio.h>
//网兜
int balls[3]={0};
//网兜状态标识
int ballIndex = -1;//网兜空的时候为-1

//判断有没有满 1.满 0.未满
int isFull(){
    if (ballIndex==2) {
        return 1;
    }else{
        return 0;
    }
}

//存球
void push(int ball);
void push(int ball){
    //判断有没有满
    if (!isFull()) {//没满 存
        ballIndex++;
        balls[ballIndex]=ball;
    }else{ //满 不存
        printf("网兜已经满了，不能存值!\n");
    }
}

//网兜是否为空 1空 0非空
int isEmpty();
int isEmpty(){
    if (ballIndex==-1) {
        return 1;//为空
    }else{
        return 0;//非空
    }
}

//取球
int pop();
int pop(){
    //网兜是否为空
    if (!isEmpty()) {//非空 取
        int temp = balls[ballIndex];
        balls[ballIndex] = 0;//还要将原来位置的值清零
        ballIndex--;
        return temp;
    }else{//空 不能取
        printf("网兜为空，不能取球!\n");
        return 0;
    }
}

//查看网兜状态
void showBalls();
void showBalls(){
    printf("===================\n");
    for (int i=2; i>=0; i--) {
        printf("balls[%d]:%d\n",i,balls[i]);
    }
    printf("===================\n");
}

int main(int argc, const char * argv[])
{
    showBalls();
    push(1);
    showBalls();
    push(1);
    showBalls();
    push(2);
    showBalls();
    push(3);
    showBalls();
    int ball = pop();
    printf("取走了一个球:%d\n",ball);
    showBalls();
    ball = pop();
    printf("取走了一个球:%d\n",ball);
    showBalls();
    ball = pop();
    printf("取走了一个球:%d\n",ball);
    showBalls();
    ball = pop();
    printf("取走了一个球:%d\n",ball);
    showBalls();
    return 0;
}
结果：
===================
balls[2]:0
balls[1]:0
balls[0]:0
===================
===================
balls[2]:0
balls[1]:0
balls[0]:1
===================
===================
balls[2]:0
balls[1]:1
balls[0]:1
===================
===================
balls[2]:2
balls[1]:1
balls[0]:1
===================
网兜已经满了，不能存值!
===================
balls[2]:2
balls[1]:1
balls[0]:1
===================
取走了一个球:2
===================
balls[2]:0
balls[1]:1
balls[0]:1
===================
取走了一个球:1
===================
balls[2]:0
balls[1]:0
balls[0]:1
===================
取走了一个球:1
===================
balls[2]:0
balls[1]:0
balls[0]:0
===================
网兜为空，不能取球!
取走了一个球:0
===================
balls[2]:0
balls[1]:0
balls[0]:0
===================

知识点
十七、指针
1.什么是指针
内存被分为字节,每个字节有唯一的地址,指针指的就是内 存地址
2.指针变量
保存指针的变量,就叫指针变量。(保存地址)  
    int i;//int类型变量
    i=10;
    int* p;//*指针类型变量
    p=&i;
    printf("p->:%d\n",*p);
结果：
p->:10

3.每个指针变量能指向一种特定类型的对象(地址,内存区 域)

4.指针是引用数据类型,因为本身没有保存数据,只是保存了 数据的地 址,间接的找到内存中的数据

*5.得到一个指针，可以得到两个值
        1.直接得到数据在内存的地址    指针的值     地址
        2.间接得到内存中保存的数据    指针指向（值）
    int i;//int类型变量
    i=30;
    int* p;//*指针类型变量
          p = &i;//得到变量在内存中位置   （指针的值）一块内存地址
    printf("p:%p\n",p);
    
    //通过寻址运算符 根据地址直接操作内存
    //取
    printf("内存中的数据:%d\n",*p);
    //存
    *p = 40; 指针指向的内存区域
    printf("i:%d\n",i);
    
    
结果：
p:0x7fff5fbff70c
内存中的数据:30
i:40

6.指针可以作为参数（形参）

定义函数时，可以使指针类型作为参数，多个变量共用一个内存空间

练习 交换两个值的地址

#include <stdio.h>
//共用一块内存区域
void change(int* p1,int* p2);
void change(int* p1,int* p2){
    printf("change1 i:%d j:%d\n",*p1,*p2);
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
    printf("change2 i:%d j:%d\n",*p1,*p2);
}

int main(int argc, const char * argv[])
{
    int i = 10;
    int j = 20;
    printf("main1 i:%d j:%d\n",i,j);
    change(&i, &j);
    printf("main2 i:%d j:%d\n",i,j);
    return 0;
}
结果：
main1 i:10 j:20
change1 i:10 j:20
change2 i:20 j:10
main2 i:20 j:10

求一组数的最大值、最小值    
         在主函数中创建一个长度为10的数组,数组内放置10 个0~99之间(包含0,包含99)的随机数作为数组内容, 按要求编制一个自定义函数同时返回数组中的最大值、最 小值,然后在主函数中将自定义函数的返回值打印显示在 界面上。
#include <stdio.h>
#include<stdlib.h>
#include<time.h>
int num();
int num(){
    return rand()%100;
}

void func(int length,int a[],int* maxp,int* minp);
void func(int length,int a[],int* maxp,int* minp){
    for (int i=0; i<length; i++) {
        if (a[i]>*maxp) {
            *maxp=a[i];
        }
        if (a[i]<*minp) {
            *minp=a[i];
        }
    }
}
int main(int argc, const char * argv[]) {
    int max=0,min=99;
    int a[10]={0};
    //使用随机数生成10个数
    srand((unsigned)time(0));
    for (int i=0; i<10; i++) {
        a[i]=num();
        printf("a[%d]=%d\n",i,a[i]);
    }
   //求一组数的最大值和最小值
    func(10,a, &max,&min);
    printf("max:%d min:%d\n",max,min);
    
    return 0;
}
结果：
a[0]=72
a[1]=11
a[2]=16
a[3]=38
a[4]=52
a[5]=78
a[6]=20
a[7]=92
a[8]=42
a[9]=53
max:92 min:11

7.指针可以作为返回值

定义函数的时候，可以使用指针类型作为返回值，可以共享函数中的内存空间。注意：函数中的变量不能是自动变量，自动变量一旦超出作用域就销毁了，如果想使用，必须延长变量的生命周期，使它变成静态变量。


#include <stdio.h>
//2.使用全局变量
//int i=30;
int* func();
int* func(){//指针作为参数，共享函数中的内存空间
    static int i=10;//1.延长变量生命周期    （只有第一次执行，第二次调用便使用i++）
    i++;
    printf("i:%d\n",i);
    return &i;
}
int main(int argc, const char * argv[]) {
    int* ip;
    ip=func();
    *ip=20;
    func();
    
    return 0;
}
结果：
i:11
i:21

8.指针的加减操作
指针支持加整数、减整数、指针的比较和相减,但运算的单位 由指针的类型决定。 
   指针变量+1 相当于移动了一个数据位
   int类型指针+1  =  地址+4        
   char类型指针+1  =地址+1  
1.int 类型的指针加减

#include <stdio.h>

int main(int argc, const char * argv[]) {
    int a[3]={1,2,3};
    int* p=a;//等于int* p=&a[0];
    printf("*p:%d  %p\n",*p,p);
    printf("*(p+1):%d  %p\n",*(p+1),p+1);
    printf("*(p+2):%d  %p \n",*(p+2),p+2);
    return 0;
}
结果：
*p:1      0x7fff5fbff77c
*(p+1):2  0x7fff5fbff780
*(p+2):3  0x7fff5fbff784

2.char类型的指针加减

#include <stdio.h>

int main(int argc, const char * argv[]) {
    char a[3]={\'a\',\'b\',\'c\'};
    char* p=a;//等于int* p=&a[0];
    printf("*p:%c  %p\n",*p,p);
    printf("*(p+1):%c  %p\n",*(p+1),p+1);
    printf("*(p+2):%c  %p \n",*(p+2),p+2);
    return 0;
}
结果：
*p:a      0x7fff5fbff77d
*(p+1):b  0x7fff5fbff77e
*(p+2):c  0x7fff5fbff77f

3.通过for循环  根据地址取值

#include <stdio.h>

int main(int argc, const char * argv[]) {
   int a[3]={1,5,2};
   int* p=a;//等于int* p=&a[0];

   //通过for循环 根据地址取值
    for (int i=0; i<3; i++) {
    //*(p+i)与(*p)+1结果是不同的
    printf("*(p+i):%d\n",*(p+i));正确的输出
    printf("*(p)+i:%d\n",(*p)+i);
}
结果：
*(p+i):1
*(p)+i:1
*(p+i):5
*(p)+i:2
*(p+i):2
*(p)+i:3


9.二级指针
    int i=10;
    int* ip=&i;//指针
    int** ip2=&ip;//二级指针
    int*** ip3=&ip2;//三级指针
    printf("ip3:%d\n",***ip3);
结果：
ip3:10

10.指针与数组

共同点：两者都可以表示地址

不同点：
 一、所占内存空间不同
    1. 和具体内存中，所保存的数据无关
  2.所有内存的地址所占内存空间都是一样大的
  3.指针地址所占内存空间在macos64位系统下， 地址所占8字节
     4.数组所占的内存空间=元素所占的内存空间*元素的长度(个数)
例题：
    int i = 10;
    char ch = \'a\';
    int* p1 = &i;
    char* p2 = &ch;
    //所占内存空间
    //和具体内存中，所保存的数据是无关
    //所有内存的地址所占内存空间都是一样大的
    //macos64位 地址所占8B
    printf("p1 size:%ld\n",sizeof(p1));
    printf("p2 size:%ld\n",sizeof(p2));
    
    //数组所占的内存空间=元素所占内存空间*元素个数
    int array[5];
    int* p = array;
    printf("p size:%ld %p\n",sizeof(p),p);
    printf("array size:%ld *%p\n",sizeof(array),array);

结果：
p1 size:8
p2 size:8
p size:8 0x7fff5fbff790

二、赋值
     1.指针变量的值是可以改变的
       2.数组一但声明，其值是不可以改变的，而是保存数据在内存中的地址，在使     用的时候通过地址间接得到数据的值。

 例题：   
    int array[5];
    int* p = array;
    printf("p size:%ld %p\n",sizeof(p),p);
    printf("array size:%ld *%p\n",sizeof(array),array);
    //赋值
    int i2 = 10;
    int j2 = 20;
    int* p3 = &i2;
    p3 = &j2;//指针变量的值是可以改变的 赋值
    
    int array2[5];
    int array3[10];
    //array2 = array3;错误的表示//是不可以改变数组变量的值的
结果：
array size:20 *0x7fff5fbff790

11、引用———c语言中数据类型主要分为两大类

 基本数据类型：int char double float
 变量本身就保存了我们需要的数据
 引用数据类型：指针
 变量本身并没有保存数据

数据->(Create创建Read读取Update更新Delete删除)

12.进程空间

•进程是正在运行的程序,在内存中。  
• 每个进程在内存中占据的空间称进程空间  
1.进程空间的内存分配
    1.代码区(正文段,  text)  只读      程序代码
    2.全局区(全局静态区)    读、写     全局变量、静态变量
    3.堆区(*区,  heap)   读、写
     4.栈区(堆栈,    stack)     读、写     动态变量（局部变量）
知识点
十八、字符串
 1.三种字符串的创建:
  一、字面值字符串
       1.在代码区创建了一个字符串 会在结尾自动加\0 （只读）
        2.字符串有自己的占位符%s
        3.字符串使用，会从首地址一个字节一个字节的读取数据，直到读到\0位     置表示结束
    //在代码区创建了一个字符串 会在结尾自动加\0
    char* p= "string1";//可以与指针变量结合使用
    printf("string2\n");//直接与输出函数使用
    //字符串有自己的占位符%s
    printf("%s\n",p);
    char* p2= "string1";
    //如果字符串的内容相同，代码区只会创建一个字符串
    printf("p:%p,p2:%p\n",p,p2);//地址
    //字符串使用，会从首地址一个字节一个字节的读取数据，直到读到\0位置 表示结束
    char* p3="str\0ing1\n";
    printf("p3:%s\n",p3);
结果：
string2
string1
p:0x100000f6e,p2:0x100000f6e
p3:str
         4.证明  代码区   只读
    char* p3="str\0ing1\n";
    printf("p3:%s\n",p3);
    char* cp=p3;
    printf("cp+1:%c\n",*(cp+1));  //读
    //*(cp+1)=\'w\';//如果非要改 程序就异常   //写
结果：
p3:str
cp+1:t

二、字符数组的字符串
       1.保存在内存中栈区  内容就算相同，也会开辟不同的内存空间
     2.字符数组的字符串与普通的字符数组最大的区别是否有 结束符\0
  3.栈区 读写....
    char str[4]={\'s\',\'t\',\'r\',\'\0\'};
    char str2[4]={\'s\',\'t\',\'r\',\'\0\'};
    char* cp = str2;
    *(cp+1) = \'w\';//可以改变栈区的数据
    printf("str address:%p value:%s\n",str,str);
    printf("str2 address:%p value:%s\n",str2,str2);
结果：
str address:0x7fff5fbff7a4 value:str
str2 address:0x7fff5fbff7a0 value:swr

三、字符指针

对于字符串来讲引用类型：

1.字符指针即可以与字面值字符串结合使用
2.也可以与字符数组的字符串结合使用

练习：通过键盘输入一个字符串
    //char* input="*********";通过字面值定义字符串不可取
    char input[10];
    char* inputp=input;
    printf("请输入一个字符串信息：\n");
    scanf("%s",input);
    printf("str:%s\n",inputp);
结果：
请输入一个字符串信息：
hello
str:hello

三种字符串创建的比较
                    内存              内容相同               读写        结束符
    a.字面值       代码区            只会创建一个      只读         自动
    b.字符数组   栈区                会创建多个          读写         手动
    c.字符指针   保存地址(栈) 无关                      无关         无关

2.字符串函数库

#include <string.h>

     帮我们解决常用字符串的问题
  a.字符串的赋值strcpy（参数1，参数2）
               参数1：目标字符串位置（复制到哪里）
               参数2：源字符串位置（字符串的来源）
           *注：
    char* str="helloworld\n";
    char str2[15];
    //复制一个字符串
    strcpy(str2, str);
    printf("str2:%s\n",str2);
结果：
str2:helloworld
   
   b.字符串的拼接strcat（参数1，参数2）
          1. 将第一个字符串的内容与第二个字符串的内容拼接在一起，保存在第一个  字符串中。
      *注：参数1的空间>=两个字符串内容之和
    char str3[10]={\'h\',\'e\',\'l\',\'\0\'};
    char*str4="wor\n";
    strcat(str3, str4);
    printf("str3:%s\n",str3);
结果：
str3:helwor

      c.字符串的长度  （返回值长度）strlen（参数）
 练习：求字符串的长度，不包含结束符
     1.  char* str5 = "helloworld!\n";
    unsigned long length = strlen(str5);
    printf("length:%lu\n",length); 
结果：
 length:12   
     2.   char str5[10] = {‘h’,’e’,’l’,’\0’};//   ‘\0’不占内存空间
      unsigned long length = strlen(str5);
      printf("length:%lu\n",length);
结果：length:3


      d.字符串的比较
            比较两个字符串的内容strcmp（参数1，参数2）
            1. 字符串的比较不可以使用==号，==通常比较的是两个数的值，字符串是引用数据类型，比较的是两个字符串的地址，与使用场景不符
        2.标准做法：比较两个字符串中每一个字符的ASC码值，全都相同，两个字符串是相同的。
              *注：结果得到的是两个字符串中ASC码的差值，若差值为0，则两个字符串相等。
       char *str6 = "Heflo";
    char *str7 = "HEllo";
    int i = strcmp(str6, str7);
    printf("i:%d\n",i);ASC码的差值
结果：i:32

练习：模拟登录，三次输入机会

//输入内容
    char username[20],password[20];
    //模拟数据库中的数据
    char* d_username = "admin";
    char* d_password = "123";
    int count = 0;
    while (1) {
        count++;
        printf("请输入用户名:\n");
        scanf("%s",username);
        printf("请输入密码:\n");
        scanf("%s",password);
        //判断登录是否成功
        if (strcmp(username, d_username)==0
            &&
            strcmp(password, d_password)==0
            ) {
            printf("登录成功!\n");
            break;
        }else{
            printf("用户名或密码错误!\n");
            if (count==3) {
                exit(0);//程序结束
            }
        }
    }
    printf("登录成功后...");
结果：
请输入用户名:
fcp
请输入密码:
lbm
用户名或密码错误!
请输入用户名:
admin
请输入密码:
123
登录成功!
登录成功后...
3.字符串数组

两种形式：
   1.字面值字符串数组
    字面值字符串数组中的字符串是不能改变的

    //字面值字符串数组
   char* str = "zhangsan";
    char* str2 = "lisi";
    char* strs[2] = {str,str2};
    printf("strs size:%lu\n",sizeof(strs));
    //遍历字符串数组   输出strs[2]
    for (int i = 0; i<2; i++) {
        printf("strs[%d]:%s\n",i,strs[i]);
    }
结果：
strs size:16
strs[0]:zhangsan
strs[1]:lisi

    2.数组字符串数组
    数组字符串数组中的字符串是可以改变的
//数组字符串的数组
    //char str3[10] = {\'z\',\'h\',\'a\',\'\0\'};
    //char str4[10] = {\'l\',\'i\',\'s\',\'\0\'};
    char strs2[2][10]={{\'z\',\'h\',\'a\',\'\0\'},{\'l\',\'i\',\'s\',\'\0\'}};
    printf("strs2 size:%lu\n",sizeof(strs2));
    for (int i=0; i<2; i++) {
        printf("strs2[%d]:%s\n",i,&strs2[i][0]);
    }
结果：
strs2 size:20
strs2[0]:zha
strs2[1]:lis

作业
a.所有功能在使用前一定要登录
    b.先注册才能登录
    c.存钱存到帐号中(只有一个帐号)
    d.取钱，取帐号中的钱(减)，不足，取钱失败提示。
    e.查看余额
    f.0退出程序 如果不退出系统，循环执行。
        /==============/
                    系统功能
                1.注册
                2.登录
                3.存钱
                4.取钱
                5.查看余额
                0.退出
        /==============/
                请输入您要选择的功能:_

#include <stdio.h>
#include <string.h>
void registerUser();
int isLogin();
void save();
//登录状态的标识
int flag = 0;

//保存用户名/密码
char username[20];
char password[20];
//临时保存用户输入的内容
char inputUsername[20];
char inputPassword[20];

void menu(){
    printf("==================\n");
    printf("系统功能\n");
    printf("1.注册\n");
    printf("2.登录\n");
    printf("3.存钱\n");
    printf("4.取钱\n");
    printf("5.查看余额\n");
    printf("0.退出\n");
    printf("==================\n");
}

int inputNum(){
    int num = 0;
    printf("请输入您需要的功能(0~5):\n");
    scanf("%d",&num);
    return num;
}

void select(int num){
    switch (num) {
        case 1:
            printf("进入注册功能\n");
            registerUser();
            break;
        case 2:
            printf("进入登录功能\n");
            flag = isLogin();
            break;
        case 3:
            printf("进入存钱功能\n");
            save();
            break;
        default:
            printf("您输入的数据有误，请重新输入\n");
            break;
    }
}
//向银行存钱
void save(){
    //判断登录状态 登录成功才可以存钱，未登录不能存钱
    if (flag) {
        printf("开始存钱!...\n");
    }else{
        printf("未登录，请先登录!\n");
    }
}

//注册一个用户
void registerUser(){
    printf("注册一个用户:\n");
    printf("输入一个用户名:\n");
    scanf("%s",username);
    printf("输入一个密码:\n");
    scanf("%s",password);
    printf("注册成功!\n");
}

//登录功能
int isLogin(){
    printf("登录功能!\n");
    printf("输入一个用户名:\n");
    scanf("%s",inputUsername);
    printf("输入一个密码:\n");
    scanf("%s",inputPassword);
    //和数据库进行匹配
    if (strcmp(inputUsername, username)==0
        &&
        strcmp(inputPassword, password)==0) {
        printf("登录成功!\n");
        return 1;
    }else{
        printf("用户名或密码错误!\n");
        return 0;
    }
}

int main(int argc, const char * argv[])
{
    //(高内聚 低耦合)->程序更灵活
    while (1) {
        //1.显示菜单
        menu();
        //2.输入选择的选项
        int num = inputNum();
        //3.输入不同的值，选择相应的功能
        select(num);
    }
    return 0;
}
结果：
==================
系统功能
1.注册
2.登录
3.存钱
4.取钱
5.查看余额
0.退出
==================
请输入您需要的功能(0~5):
1
进入注册功能
注册一个用户:
输入一个用户名:
fcp
输入一个密码:
lbm
注册成功!
==================
系统功能
1.注册
2.登录
3.存钱
4.取钱
5.查看余额
0.退出
==================
请输入您需要的功能(0~5):
3
进入存钱功能
未登录，请先登录!
==================
系统功能
1.注册
2.登录
3.存钱
4.取钱
5.查看余额
0.退出
==================
请输入您需要的功能(0~5):
2
进入登录功能
登录功能!
输入一个用户名:
fcp
输入一个密码:
lbm
登录成功!
==================
系统功能
1.注册
2.登录
3.存钱
4.取钱
5.查看余额
0.退出
==================
请输入您需要的功能(0~5):

9.字符串数组
    有两种形式，字面值字符串数组，数组字符串数组。
    字面值字符串数组中的字符串是不能改变的。
    数组字符串数组中的字符串是可以改变的。

作业：
    a.有五虎上将，zhangfei、guanyu、huangzhong、zhaoyun、machao。
        输入一个人名，判断是否是五虎上将?
#include <stdio.h>
#include <string.h>

int main(int argc, const char * argv[]) {
    char* tigger[5]={"zf","gy","hz","zhy","mc"};
    char username[10];
    printf("请输入一个人名!\n");
    scanf("%s",username);
    for (int i=0; i<5; i++) {
        if (strcmp(username,tigger[i])==0) {
            printf("%s是五虎上将",username);
        }
    }
    
    return 0;
}
结果：
请输入一个人名!
gy
gy是五虎上将
    b.输入三个人的姓名，并保存?
char usernames[3][20];
    //输入三个人的姓名
    for (int i = 0; i<3; i++) {
        printf("请输入第%d个人的名字:\n",i+1);
        scanf("%s",&usernames[i][0]);
    }
    //输出三个人的姓名
    for (int i = 0; i<3; i++) {
        printf("第%d人的名字:%s\n",i+1,&usernames[i][0]);
    }
结果：
请输入第1个人的名字:
fcp
请输入第2个人的名字:
lbm
请输入第3个人的名字:
wjy
第1人的名字:fcp
第2人的名字:lbm
第3人的名字:wjy

知识点
十八、一些计算机操作指令

1.const关键字
     1.可以把一个变量，变成常量
     2. 由于指针变量相当于两个值：
            指针的值  int* const p
            指针指向的值 const int* p
     3.  有些函数在使用内存地址是，希望内存中的数据是只读的，不需修改，就会加上const关键字
    const int i=10;//将变量->常量
    //i=20;
    printf("i:%d\n",i);
    
    int j=20;
    int k=30;
    int* p=&j;
    //指针的值  int* const p
    p=&k;
    //指针指向的值 const int* p
    *p=40;
    printf("k:%d",k);
结果：
i:10
k:40


2.命令行参数
./a.out 640*480->main()……
main(参数1：长度，参数2：值)
        数组中第一个内容是命令 …
3.预处理指令

#预编译指令
   在编译之前做的事情：
       例:1.导入头文件...
            2.条件编译....
            #ifndef    ZBS
           没有条件编译此处
            #else
           有条件编译此处
            #endif
 编译：gcc main.c—DZBS
            ./a.out
            #ifdef SIZE //如果定义了SIZE宏条件成立
        #ifndef SIZE //如果没定义SIZE宏条件成立              #if 1==1 //条件成立 #if 条件表达式或逻辑表达式
#include <stdio.h>

int main(int argc, const char * argv[]) {
    int num=0;
    printf("轻点菜：");
    scanf("%d",&num);
#ifndef ZBS
    if (num==1) {
        printf("您点的是鱼香肉丝\n");
    }else if (num==2){
        printf("您点的是地三鲜\n");
 
    }else {
        printf("没有这个菜\n");
    
    }
#else
    if (num==1) {
        printf("没有这个菜\n");
    }else if (num==2){
        printf("没有这个菜\n");
        
    }else {
        printf("真没有这个菜\n");
        
    }
#endif
    return 0;
}
结果：gcc main.c—DZBS就执行else的代码

          3.宏…  （#define  PI …）
                 1.把复杂的操作变得更简单 ，不会改变原代码
                 2.宏与变量最大的区别，不占内存空间，当编译前会自动替换代码中的变量
                 3.宏的值一旦确定是不可改变的
#include <stdio.h>
//#预编译指令 PI文本标识  3.1415926替换内容
//宏与变量最大的区别，不占内存空间，当编译前会自动替换代码中的变量
#define PI 3.1415926//PI宏的文本

int main(int argc, const char * argv[]) {
    //圆的面积=派*r*r;
    int r=0;
    printf("请输入一个半径：\n");
    scanf("%d",&r);
    //printf("圆的面积为：%lf\n",3.1415926*r*r);
    printf("圆的面积为：%lf\n",PI*r*r);
    return 0;
}
结果：
请输入一个半径：
8
圆的面积为：201.061926

        4.宏可以和数组搭配使用
           #define SIZE 6
           int main(int argc, const char * argv[]) {
    
           int a[SIZE]={0};
     5.宏函数
 与内存空间没有关系 跟类型与没有关系
        #include <stdio.h>
     #define MUL(x,y)x*y
     int i=10;
     int j=20;
     printf("i:%d*j:%d=%d",i,j,i*j);
     printf("%d\n",MUL(i,j));
     printf("%d\n",MUL(2+3,4+5));//2+3*4+5
     printf("%d\n",21/MUL(2+3,4+5));//21/2+3*4+5
结果：
i:10*j:20=200
200
19
27

练习：
1.输入一个字母将小写->大写…
2.条件编译
    iphone4 
    iphone5~5s
    iphone6
    iphone6plus
    ipad1~4
    ipad mini

知识点
十九、大型软件开发
1.多文件编程
当程序较大时,为了提高可读性,一般将程序拆分成多个文 件,每个文件负责一个功能块
2.多文件编程的操作步骤
多人开发  将原文件拆分成三个文件,分别为*.h、*.c、 main.c
例：输入一个数并输出
    1.输入功能拆分放到两个文件中
           .h函数的声明
           .c函数的定义
    2.使用前必须导入头文件
    3.编译的时候，必须连接
          系统的函数库已经默认与程序连接到了一起
               连接：将多个文件的的目标文件合在一起，就是连接
                   gcc -c input.c 目标文件->*.o
                          如： gcc -c  input.c转成input.o
                   gcc 目标文件1 目标文件2....->a.out
                            如：gcc  input.o  main.o——>./a.out——-得到编译结果
’           总：1.只有.h 和.o别人可以使用你的函数了，但无法得到源代码。闭源
                   2 .h 和.c别人可以使用你的函数了，并且知道你是如何实现的。开源
3.在多文件开发中
       .h文件中 ，主要放的是函数声明、宏，但不能放变量的声明，一切与内存有关的操作都不可以
       .c文件中，主要放程序源代码，变量的声明、函数的定义..
               全局变量只能放在.c文件中
                     **如果想使用其他文件中的全局变量必须使用extern关键字修饰。
                               extern  int  array；
                     **使用static修饰全局变量，该全局变量只能在当前文件中使用（私有）
                           static不但可以修饰全局变量，还可以修饰函数
4.批处理命令：make

知识点
二十、结构体

• 结构体语法格式   
1.struct{  
      成员;       
   }变量名;  
2.typedef  struct  {  //常用格式
      int  age;//成员                
      char  name[20];  
   }Student2;//别名 
例: （标准定义）
  //给类型(定义)起名字
    typedef struct {
        int age;//成员
        char sex;
    }NewPerson2;//新名字 //变量名
    NewPerson2 person5 = {22,\'F\'};
    //结构体如果声明在函数的外部，所有函数都可以使用
    NewPerson2 person6 = {23,\'M\'};
    printf("age5:%d sex5:%c\n",person5.age,person5.sex);//取值
    printf("age6:%d sex6:%c\n",person6.age,person6.sex);//取值
结果：
age5:22 sex5:F
age6:23 sex6:M


*结构体其他表示方法
 一、//数据结构 人的信息(年龄，性别)
    struct{
        int age;//成员
        char sex;
    }person1,person2={19,\'F\'};//变量名
    person1.age = 18;//赋值
    person1.sex = \'M\';
    printf("age:%d sex:%c\n",person1.age,person1.sex);//取值
    printf("age2:%d sex2:%c\n",person2.age,person2.sex);//取值
    //int i
    //i = 10;
    //int i = 10;
    //给结构起个名字 struct Person == int
 二、   struct Person{
        int age;
        char sex;
    };
    
    //struct Person person3 = {20,\'M\'};
    struct Person person3;
    person3.age = 21;
    person3.sex = \'F\';
    printf("age3:%d sex3:%c\n",person3.age,person3.sex);//取值
    
三、    //给类型起名字 typedef 原来的名字 新名字
    typedef struct Person NewPerson;
    NewPerson person4 = {22,\'M\'};
    printf("age4:%d sex4:%c\n",person4.age,person4.sex);//取值

结果：
age:18 sex:M
age2:19 sex2:F
age3:21 sex3:F
age4:22 sex4:M

2.结构体所占内存空

   //结构体所占内存空
    typedef struct{
        char ch;//1
        short i;//2
    } Stu;
    printf("Stu size:%ld\n",sizeof(Stu));
结果：
Stu size:4

作业：
练习：创建四个学生信息(学号、姓名、性别、年龄)，所有的信息要使用键盘输入并保存。
typedef struct{
        int num;
        char name[10];//保存字符串的内容
        //char *cp;//保存字符串的地址
        char sex;
        int age;
    } Student;
        Student stus[4];
    for (int i = 0; i<4; i++) {
        printf("请输入学号:\n");
        scanf("%d",&stus[i].num);
        printf("请输入姓名:\n");
        scanf("%s",stus[i].name);
        scanf("%*c");
        printf("请输入性别:\n");
        scanf("%c",&stus[i].sex);
        printf("请输入年龄:\n");
        scanf("%d",&stus[i].age);
    }
    
    for (int i = 0; i<4; i++) {
        printf("学号:%d\n",stus[i].num);
        printf("姓名:%s\n",stus[i].name);
        printf("性别:%c\n",stus[i].sex);
        printf("年龄:%d\n",stus[i].age);
    }

知识点
二十一、联合、枚举

一、联合
   1. 联合的用法、语法和结构非常相似,但联合中所有成员分配 的内存是同一块。(只能保存一个 成员信息,联合的空间以 最大成员所占的空间为值)    
   2. 联合可以用一块内存对应多种数据类型  
   3. 联合与结构的区别,结构可以保存多个成员信息,而联合只能保存一个成员信息且最后一个

#include <stdio.h>

typedef union{ //联合语法格式
    int i;
    char ch;
    
}LianHe;

int main(int argc, const char * argv[])
{
    printf("LianHe:%ld\n",sizeof(LianHe));
    LianHe lh;
    lh.i=10;
    printf("i:%d\n",lh.i);
    lh.ch=\'a\';
    printf("ch:%c\n",lh.ch);
    printf("i:%d\n",lh.i); 
   
    return 0;
}
结果：
LianHe:4
i:10
ch:a
i:97

二、枚举

 1.语法格式：
//定义一个枚举
enum{MON,TUE,WEN};
或
//typedef 类型名字  新名字
typedef enum{  //常用类型
   MON,TUE,WEN
}week;

2.在声明的时候修改枚举值
//如果需要修改枚举值 只能在声明的时候修改
//后面的元素=前面的元素+1
  1. typedef enum{
     MON=1,TUE,WEN
   }week;
结果：
MON:1
TUE:2
WEN:3
  2. typedef enum{
     MON,TUE=2,WEN
   }week;
结果：
MON:0
TUE:2
WEN:3

3.typedef enum{false,true} bool;
    bool b1 = false;
    printf("b1:%d\n",b1);
结果：0

练习：
#include <stdio.h>

//定义一个枚举
//enum{MON,TUE,WEN};

//typedef 类型名字  新名字
//如果需要修改枚举值 只能在声明的时候修改
//后面的元素=前面的元素+1
typedef enum{
   MON=1,TUE,WEN
}week;

void take(week i){
    switch (i) {
        case MON:
            printf("星期一：要去交水费\n");
            break;
        case TUE:
            printf("星期二：要去交电费\n");
            break;
        case WEN:
            printf("星期三：要去交煤气费\n");
            break;
        default:
            break;
    }
}

int main(int argc, const char * argv[])
{
    printf("MON:%d\n",MON);
    printf("TUE:%d\n",TUE);
    printf("WEN:%d\n",WEN);
    
    int week=0;
    printf("请选择今天星期几：\n");
    printf("1.星期一\n");
    printf("2.星期二\n");
    printf("3.星期三\n");
    
    scanf("%d",&week);
    take(week);
    return 0;
}
结果：
MON:1
TUE:2
WEN:3
请选择今天星期几：
1.星期一
2.星期二
3.星期三
1
星期一：要去交水费

练习
输入一个整数,求春夏秋冬    
       用户从控制台输入一个整数,由程序判断该整数是春 夏秋冬哪个季节。春夏秋冬分别用一个枚举常量表示
#include <stdio.h>

typedef enum{
    SPRING,SUMMER,AUTUMN,WINTER
}Season;

void func(int num){
    switch (num%4) {
        case SPRING:
            printf("春天来了！\n");
            break;
        case SUMMER:
            printf("夏天来了！\n");
            break;
        case AUTUMN:
            printf("秋天来了！\n");
            break;
        case WINTER:
            printf("冬天来了！\n");
            break;
            
        default:
            break;
    }
    
    
}

int main(int argc, const char * argv[])
{   int num=0;
    printf("请输入任意一个整数数字：");
    scanf("%d",&num);
    func(num);
结果：
请输入任意一个整数数字：897231
冬天来了！

知识点
二十二、高级指针

一.双指针(二级指针)
#include <stdio.h>
void change(int j){//值传递
    j = 20;
    printf("j:%d\n",j);
}
void change2(int* p){//地址传递
    *p = 20;
    printf("*p:%d\n",*p);
}
/*
char** change3(){
    char* str = "Hello";
    return &str;
}
 */
void change4(char** p){
    *p = "Hello";
}
int main(int argc, const char * argv[])
{
    int i = 10;
    //change(i);
    change2(&i);
    printf("i:%d\n",i);
    char *p;//保存一个字符串的位置
    change4(&p);
    printf("p:%s\n",p);
    return 0;
}
结果：
*p:20
i:20
p:Hello

二、void指针

1.任意类型的指针
2.malloc分配堆内存时,由于无法确定内存存储类型,所以可 以使用void*代表任意指针类型
#include <stdio.h>
typedef enum{INT,CHAR,FLOAT,DOUBLE} type;
void output(void* p,type t){
    switch (t) {
        case INT:
            //char c = (char)200;//类型转换
            printf("%d\n",*((int*)p));
            break;
        case CHAR:
            printf("%c\n",*(char*)p);
            break;
        case FLOAT:
            //char c = (char)200;//类型转换
            printf("%f\n",*((float*)p));
            break;
        case DOUBLE:
            printf("%lf\n",*(double*)p);
            break;
    }
}
int main(int argc, const char * argv[])
{
    int i = 10;
    output(&i,INT);
    char c = \'a\';
    float f = 10.1f;
    double d = 20.1;
    output(&f,FLOAT);
    return 0;
}
结果：
10
10.100000

三、函数指针
#include <stdio.h>
//1.返回值类型
 void func(){
  printf("Hello, World!\n");
}
//2.
int func2(){
    return 10;
    
}
//3.
int func3(){
    return 1;
    
}
int main(int argc, const char * argv[])
{    printf("%p\n",&func);
     printf("%p\n",func);
    //函数指针变量*funcp 保存函数指针 func
 //1.返回值类型....参数...
    void(*funcp)()=func;//调用没有括号func
    funcp();
 //2.
    int(*funcp2)()=func2;
    int i=funcp2();
    printf("i:%d\n",i);
 //3.
    int(*funcp3)(int)=func3;
    int i2=funcp3(5);
    printf("i2:%d\n",i2);

    
    return 0;
}
结果：
0x100000e40
0x100000e40
Hello, World!
i:10
i2:1

四、对内存管理

   1.malloc函数
           a.导入头文件
            #include <stdlib.h>
           b.分配一个堆内存的空间，可以根据参数大小分配相应内存空间
                 空间的首地址  malloc（空间大小）
                     语法：void*malloc（4）；//字节
            c.分配变量
            int  *p;   p  =  (int*)malloc(sizeof(int));
练习：
#include <stdio.h>
#include <stdlib.h>
int main(int argc, const char * argv[])
{   //输入三个数并输出
    int a[3]={0};//栈
    printf("a address:%p\n",a);
    //开辟堆空间 void*malloc(size_t)
    //堆内存的分配不一定成功
    //如果成功则得到一个地址，如果不成功得到NULL
    int*p;//分配变量
    p=(int*)malloc(sizeof(int)*3);//语法格式
    if (p!=NULL) {
        //使用前做类型转换
        printf("p address:%p\n",p);
        for (int i=0; i<3; i++) {
            printf("请输入%d第个数：",i+1);
            //scanf("%d",&a[i]);
            scanf("%d",(p+i));
        }
        
        //输出函数
        for (int i=0; i<3; i++) {
            //printf("第%d个数为：%d\n",i+1,a[i]);
            printf("第%d个数为：%d\n",i+1,*(p+i));
        }
    }
    else{
        printf("分配内存失败");
        
    }
    return 0;
}
结果：
a address:0x7fff5fbff83c
p address:0x100103b10
请输入1第个数：3
请输入2第个数：5
请输入3第个数：6
第1个数为：3
第2个数为：5
第3个数为：6
           
   2.calloc函数
         a.分配一个堆内存空间
         b.#include <stdlib.h>
    c.空间的首地址 calloc（元素的个数，元素的大小）
                   语法：void*calloc（4，size（int））；
   calloc与malloc的区别是，不但分配内存空间，而且还会将分配到的内存空间清0
//开辟堆空间 void*calloc(size_t，size_t)
//参数1 元素的个数 参数2 元素的类型
int*p;//分配变量
    p=(int*)calloc(3,sizeof(int));
以上输入输出函数程序只改变此句，结果不变

  3.realloc函数
         调整一个内存空间，存在两种情况，如果原来的位置可以调整，则首地址不变。如果原来的位置不可以调整，创建一个新的内存空间，并将原来数据自动复制过来，将原来的内存自动销毁，返回新的内存的首地址。调整内存空间也可能有风险，即创建不成功。
      a.空间的首地址 realloc(原来首地址,调整后的空间大小)
              void* realloc(p,sizeof(int)*5);
      b.调整内存空间也不一定成功，所以尽量创建一个新的变量来保存。
#include <stdio.h>
#include <stdlib.h>
int main(int argc, const char * argv[])
{
    //输入三个数，保存并输出
    int array[3]={0};//栈
    printf("array address:%p\n",array);
    //开辟堆空间 void* calloc(size_t,size_t)
    //叁数1 元素的个数 参数2 元素的类型
    //堆内存分配不一定成功
    //如果成功则得到一个地址，如果不成功得到NULL
    int* p = (int*)malloc(sizeof(int)*3);
    printf("p address:%p\n",p);
    //调整内存空间 参数1 原来空间的首地址 参数2 调整后的大小
    int* p2=(int*)realloc(p,sizeof(int)*4);
    printf("p2 address:%p\n",p2);
    if (p2!=NULL) {//分配内存成功
        p = p2;//分配成功后，如果得到新的地址，会自动将原来的销毁。
        printf("p address:%p\n",p);
        //使用前做类型转换
        for (int i = 0; i<4; i++) {
            printf("请输入第%d个数:\n",i+1);
            //scanf("%d",&array[i]);
            scanf("%d",(p+i));
        }
        for (int i = 0; i<4; i++) {
            printf("第%d个数:%d\n",i+1,*(p+i));
        }
    }else{
        printf("分配内存失败!\n");
    }
    free(p);//释堆空间
    //野指针:一个指针指向一个不合法区域
    p = NULL;//空指针 用来解决野指针
    //在OC访问一个空指针是合法并且不会报错
    //printf("p->value:%d\n",*p);
    //printf("p address:%p\n",p);
    return 0;
}
结果：
array address:0x7fff5fbff82c
p address:0x100103b10
p2 address:0x100103b10
p address:0x100103b10
请输入第1个数:
6
请输入第2个数:
4
请输入第3个数:
3
请输入第4个数:
4
第1个数:6
第2个数:4
第3个数:3
第4个数:4

  4.free函数
       可以将堆空间销毁掉（释放）
          free(堆空间首地址);
    销毁堆空间时，指针变量依然是有值的，但是指向了一个不合法的内存区域，野指针。当程序对野指针进行操作是不合法的，会报错的。标准的做法，将野指针赋NULL值，变成空指针。在OC当中，就可避免操作问题，并且不会报错。