小凯15天快速讲完c语言-简单学习第四课

这节课笔记的排版有点问题，感觉是markdown语法有问题，当然不排除思否社区的排版问题，哈哈哈，已反馈官方啦，大家凑合看。

0. 复习

0.1 运算符

1.赋值
注意的点：
// 定义变量的时候，给的值 这时叫做初始化。
int a = 0;
int b = 10;
int c = 0;
// 定义完变量，再去给值，这个就叫赋值
a = 100; //正确的
100 = a; //错误的
a = b = c = 500;
复合赋值运算
a+=b; //相当于 a = a+b;
2.算术运算符
有几个：+ - * / % ++ --
需要注意的：
除法运算：两个整数相除，结果就是一个整数
取模运算：参与运算的两个数，必须是整数 取模运算经常被用于判断A是不是B的倍数
自增自减：自增自减的同时参与了其他运算，前置自增是先自增，再参与其他运算，后置，反过来。 3. 取地址

获取一个变量的地址，经常用于scanf_s 输入数据
注意：数组的名字，就是数组的起始地址

4.sizeof

求得一个数据类型或者一个已经定义好的变量的大小
 int a= 200; 
 sizeof(int)  就是4
 sizeof(a)    也是4
 int  arr[8] = {0};
 sizeof(arr);  这个就是32 

5.逗号

 他是优先级最低的运算符

6.关系运算符

>    >=   < <=  ==  !=   他们是用于比较大小关系的，结果只能是 true 或者false
true和false  是bool类型。
从数值上看  true  就是1    false 就是0

7.逻辑运算符

&&     
||    
!

0.2 数组

定义：
数据类型 数组名[数组长度] = {初始值};
使用：

   数组名[数组下标] = 数值;

比如：

  int   arr[10] = {0};
  arr[2] = 100; 
 scanf_s("%d",&arr[2]);

数组名是下标，给0号元素输入数据的时候，可以写成下面的方式：

 scanf_s("%d",arr);
 scanf_s("%d",&arr[0]);

注意：
如果数组有10个元素，那么下标就是 0~9
数组越界，一般是比较难以寻找的BUG
字符数组
char arr[20] = "hello";
如果想要用字符数组当成字符串使用，一般就可以直接使用数组名。
scanf_s("%s",arr,20);
如果想要打印：
printf("%s",arr);

还有四个函数：
strlen 求长度 注意 不算结尾的0
strcpy 拷贝 注意使用安全版
strcat 拼接 也是使用安全版
strcmp 比较 相等0 不等为非0

每一个函数，都有对应的wchar版本的函数。

0.3 三大结构

顺序
选择
a 单if
if()
{
}
b if-else
if()
{
}
else
{
}
c if-else-if
if()
{
}
else if()
{
}
else if()
{
}
else if()
{
}
else
{
}
switch-case
switch(数值)
case 常量1：
break;
case 常量2：
break;
case 常量3：
break;
default:
都不匹配执行这个

1.循环

while()
{

}

输出0-100的值（实际有很多种方法，能输出即可）

1.1while循环输出

`

include <stdio.h>

include <stdlib.h>

int main()
{

//第一种方法：循环输出0到100
int n = 1;
int nNum = 0;
while (n<=101)
{
    printf("%d ", nNum);
    nNum++;
    n++;
}
printf("\n");
```

//第二种方法：循环输出0到100

int nNum1 = 0;
while (nNum1 <= 100)
{
    printf("%d ", nNum1);
    nNum1++;
}

return 0;

}
`

2.do-while循环

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

int main()
    {
        int i = 0;
        do
        {
            printf("%d\n", i);
            i++;
        }
        while (i < 100);
        return 0;
    }

3.for循环

#include <stdio.h>
#include <stdlib.h>
int main()
{
    //输出0~100
    for (int i = 0; i <= 100; i++)
    {
        printf("%d ", i);
    }
    return 0;
}

关于for的总结：
1.for有三条语句，第一句 用于初始化一个循环变量 第二句 用于控制循环条件 第三句 用于循环变量的变化。
2.三条语句规范上，应该按照以上的写法，实际上，写什么都行

1.4 关于三种循环的总结

1.三种循环一般情况下，是可以相互替换的。
2.当明确循环次数的时候，一般使用for循环，不能明确循环次数的时候，一般使用while循环。
3.while和for有可能一次循环体都不执行，do-while 至少执行一次循环体

对于while和for while就是简化版的for

for (; ;)

{
    printf("我是循环体\n");
}

while (1)
{
    printf("我是循环体\n");

}

1.5无限循环

当循环条件一直为真的时候，就会无限循环。也称之为死循环

1.6 break和continue

break是结束循环
continue 是结束本轮循环，直接开始下一轮循环

1.输出0~100以内的所有偶数---要求使用continue

#include <stdio.h>
#include<stdlib.h>
int main()
{

for(int i=0;i<=100;i++)
{
    if (i % 2 == 1)
    {
        continue;
    }
    else
    {
        printf("%d", i);
    }
    system("pause");
    return 0;

2.假如咱们有一个数组 int arr[8] = {5,3,6,7,1,2,9,0},从键盘上输入一个数字，判断这个数字在不在数组中，如果在的话，输出他的下标，如果不在的话，输出NO---使用break

//2. 假如咱们有一个数组  int  arr[8] = { 5,3,6,7,1,2,9,0 },
    //    从键盘上输入一个数字，判断这个数字在不在数组中，
    //    如果在的话，输出他的下标，如果不在的话，输出NO-- - 使用break
    int  arr[8] = { 5,3,6,7,1,2,9,0 };
    int nNum = 0;
    printf("请输入一个整数:");
    scanf_s("%d", &nNum);
    //_contof是用来获取数组元素的个数的
    //比如这个位置_countof(arr) 就是8
    //这个代码是有问题的
    //for (int i = 0; i < _countof(arr); i++)
    //{
    //    if (nNum == arr[i])
    //    {
    //        printf("%d\n", i);
    //        break;
    //    }
    //    else
    //    {
    //        printf("NO\n");
    //    }
    //}
    //如何能够比较好的处理这种，找到还是没找到的问题
    //方法2：使用下标去判断
    //int i = 0;
    //for (; i < 8; i++)
    //{
    //    if (nNum == arr[i])
    //    {
    //        break;
    //    }
    //}
    //if (i == 8)
    //{
    //    printf("NO\n");
    //}
    //else
    //{
    //    printf("%d\n", i);
    //}
    //方法2：使用标记
    bool nFind = false;
    for (int i = 0; i < 8; i++)
    {
        if (nNum == arr[i])
        {
            printf("%d\n", i);
            nFind = true;
            break;
        }
    }
    if (nFind == false)
    {
        printf("NO\n");
    }
    return 0;

1.7 循环的嵌套

#include <stdio.h>
#include <stdlib.h>
int main()
{

for (int i = 1; i <= 9; i++)
{
    for (int n = 1; n <= i; n++)
    {
        printf("%d ", n);
    }
    printf("\n");
}

//for (int n = 1; n <= 1; n++)
//{
//    printf("%d ", n);
//}
//printf("\n");
////....
//for (int n = 1; n <= 7; n++)
//{
//    printf("%d ", n);
//}
//printf("\n");
//for (int n = 1; n <= 8; n++)
//{
//    printf("%d ", n);
//}
//printf("\n");
//for (int n = 1; n <= 9; n++)
//{
//    printf("%d ",n);
//}
//printf("\n");
return 0;

}

练习2：打印99乘法表

 #include <stdio.h>
 #include <stdlib.h>
int main()
{
    //打印一个99乘法表
    for (int i = 1; i <=9; i++)
    {
        for (int n = 1; n <= i; n++)
        {
            printf("%d*%d=%d ", n, i, n * i);
        }
        printf("\n");
    }



//for (int n = 1; n <= 8; n++)
//{
//    printf("%d*%d=%d ", n, 8, n * 8);
//}
//printf("\n");
//for (int n = 1; n <=9; n++)
//{
//    printf("%d*%d=%d ", n, 9, n * 9);
//}
//printf("\n");
}

练习3：鸡兔同笼
方法1：

#include <stdio.h>
#include <stdlib.h>
 int main()
{
    //鸡    i只
    //兔子  j只
    //i+j==40 
    //2*i+4*j == 110
    int n = 0;
    bool bSign = false;
    for (int i = 0; i <=40; i++)
    {
        for (int j = 0; j <= 40; j++)
        {
            if (i+j==40&&2*i+4*j==110)
            {
                printf("鸡的数量是%d 兔子的数量是%d\n", i, j);
                bSign = true;
                break;
            }
            n++;
        }
        if (bSign == true)
        {
            break;
        }
    }
    printf("内层循环执行了%d次", n);
    return 0;
}

方法2：

for (int i = 0; i < 40; i++)
    {
        if (i * 2 + (40 - i) * 4 == 110)
        {
            printf("鸡的数量是%d 兔子的数量是%d\n", i, 40 - i);
            break;
        }
    }

2. 预处理

以#开头的命令，称之为预处理命令。
在编译之前，对于源代码进行一些 复制 粘贴 替换的操作。

2.1 #include包含

#inlucde的作用，就是将头文件复制粘贴到命令所在的位置。
有两种用法：
#include <文件名.h>
#include "文件名.h"
尖括号 <>和双引号 "" 有什么区别呢？？？
<>是去系统目录寻找头文件。所以一般库函数的头文件，都使用 <>
“” 先到工程所在的当前目录中寻找文件，找不到，再去系统目录里面找。
一般情况下，系统的头文件，都使用 <>
自己工程的头文件，都使用 " "

2.2 #define 宏定义

2.2.1 无参宏
经常会被用于定义一个符号常量

#include <stdio.h>
#include <stdlib.h>
#define PI 3.1415926
int main()
{
    //假如我们编写了一个UFO的程序
    //在这个程序中有100万个地方用到了圆周率
    //double pi = 3.1415926;
    double r = 4.8;
    double s = 0;
    double l = 0;
    //........
    //s = 3.141592 * r * r;
    s = PI * r * r;
    //这里有10万行代码
    //l = 2 * 3.141592 * r;
    l = 2 * PI * r;
    return 0;
}

为什么要使用无参宏？？？

1. 便于代码的修改
2. 安全，因为这是一个常量，无法在运行中去修改值
3. 起了一个名字，增强了可读性
   无参宏的本质就是 替换

2.2.2 有参宏
可以给替换的位置，填充一个参数

#include <stdio.h>
#include <stdlib.h>
#define PI 3.1415926
#define GETS(r) PI*r*r
//有参宏的局限性
#define M(n) n*n
int main()
{
    double r1 = 4.8;
    double r2 = 8.7;
    double s = 0;
    double l = 0;
    //好多代码
    s = PI * r1 * r1;
    s = GETS(r1);//PI*r1*r1
    //好多代码
    //s = PI * r2 * r2;
    s = GETS(r2);

    //有参宏的局限性：
    int n = M(8);// 8*8
    printf("%d", n);
    int m = M(4+4);//宏是纯替换，不会先把4+4算出来，再去替换
                   //所以结果就是:4+4*4+4  也就是24了
    printf("%d", m);
    return 0;

3.二维数组

include <stdio.h>

include <stdlib.h>

int main()
{

int arrTest4[12] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int arrTest1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
int arrTest2[3][4] = { {1,2,3},{4,5},{6} };
int arrTest3[][4] = { {0},{0} };//相当于是2行

for (int i = 0; i < 3; i++)
{
    for (int j = 0; j < 4; j++)
    {
        printf("%d  ", arrTest1[i][j]);
    }
    printf("\n");
}


return 0;