#include <stdio.h>
 int main()
{
 printf("hello world\n");
 return 0;
 }

// 1.23*10^7=1.23E7

// 输出整数
// printf("%d",18);
// 输出小数
// printf("%f",1.8);
// 输出字符
// printf("%c",'A');
// 输出字符串
// printf("%s","Hello World");

/*
  整数
    short	int(默认)	   long	   long long
  小数
    float（6位）	double（15位，默认）	long double(18~19)
  字符 char
*/

#include <stdio.h>
 #include <limits.h>
 int main(void)
 {
    printf("int大小 = %u\n", sizeof(int));
    printf("int最小值：%d, 最大值：%d\n", INT_MIN, INT_MAX);
     
    printf("short大小 = %u\n", sizeof(short));
    printf("short最小值：%hd, 最大值：%hd\n", SHRT_MIN, SHRT_MAX);
     
    printf("long大小 = %u\n", sizeof(long));
    printf("long最小值：%ld, 最大值：%ld\n", LONG_MIN, LONG_MAX);
    
    printf("long long大小 = %u\n", sizeof(long long));
    printf("long long最小值：%lld, 最大值：%lld\n", LLONG_MIN, LLONG_MAX);
     
    return 0;
 }

//基本运算：+	-	*	/	%
//隐式转换：运算类型一致直接计算，类型不一致小范围变大范围

//强制转换：
#include<stdio.h>

int main()
{
    //隐式转换: short类型的数据在参与计算时候,提升为int
    //要求:强制转换需要自己手动书写
    short s1 = 10;
    short s2 = 20;
    short result = (short)(s1 + s2);
    printf("%d\n", result);
    //printf("%zu\n", sizeof((short)(s1 + s2)));
    return 0;
}
//字符和数字转换：ASCII 码表

//先用后加，b=10
int a = 10;
int b = a++;
//现加后用，b=11
int a = 10;
int b = ++a;

#include<stdio.h>
int main()
{
    int a = 10;
    int b = a++; // 先用后加，使用的是原来的值 
    			 // a=11
    int c = ++a; // 先加后用，使用的是自增之后的值
    printf("%d\n", a); // 12
    printf("%d\n", b); // 10
    printf("%d\n", c); // 12
    return 0;
}



#include<stdio.h>
int main()
{
    int i = 10;
    int j = 5;
    int k = i++ + ++i - --j - i--;
    // windows: 11 11-4 11=7

    printf("%d\n", k);

    //windows: 结果7
    //前缀优先于后缀
    //前缀统一自增/自减，再把结果拿出来用
    // int i = 10;
    // ++i + ++i;
    // 12 12 = 24

    //后缀统一先用，等整个表达式中变量用完了，再进行自增
    // int i = 10;
    // i+++ i++;

    //mac、Linux:6
    return 0;
}

/*
运算符 	 描述         	 例子         	
 =      	 直接赋值     	 int a=10,将10赋值给a 	
 +=     	 加后赋值     	 a+=b,将a+b的值给a   	
 -=     	 减后赋值     	 a-=b,将a-b的值给a   	
 *=     	 乘后赋值     	 a*=b,将axb的值给a   	
 /=     	 除后赋值     	 a/=b,将a÷b的商给a   	
 %=     	 取余赋值     	 a%=b,将a÷b的余数给a 	
*/

/*
 运算符 	 描述             	 例子   	
 ==     	 a==b           	 判断a是否等于b 	
 !=     	 a!=b           	 判断a是否不等于b 	
 >      	 a>b            	 判断a是否大于b 	
 >=     	 a>=b           	 判断a是否大于等于b 	
 <      	 a<b            	 判断a是否小于b 	
 <=     	 a<=b           	 判断a是否小于等于b 	
*/

/*
运算符 	 描述       	 	例子     	
 &&      与（而且） 	 两边都为真，结果才是真 	
 ||   	 或（或者）   两边都为假，结果才是假 	
 !       非（取反） 	 		取反     	
*/
# include <stdio.h>
int main ()
{
    // &&(与): 并且，而且
    //计算规则: 只有两边都成立，那么最终的结果才是成立的，只要有一个不成立，最终的结果都是不成立的
    printf("%d\n", 1 && 1); // 1
    printf("%d\n", 1 && 0); // 0
    printf("%d\n", 1 && 0); // 0
    printf("%d\n", 0 && 1); // 0
    printf("--\n");

    // ||(或): 或者
    //计算规则: 两边都不成立，那么最终的结果才是不成立的，只要有一个成立的，最终的结果就是成立的。
    printf("%d\n", 1 || 1); // 1
    printf("%d\n", 1 || 0); // 1
    printf("%d\n", 1 || 0); // 1
    printf("%d\n", 0 || 1); // 1
    printf("\n");

    // 取反
    //实际开发中一般只用一个
    printf("%d\n", !1); // 0
    printf("%d\n", !0); // 1

    return 0;
}

#include<stdio.h>

int main()
{
    // 三元运算符、三元表达式、问号冒号运算符
    // 格式：
    // 关系表达式？表达式1：表达式2：

    // 练习1：获取两个变量中的较大值
    // int a = 10;
    // int b = 20;
    // int c = a > b ? a : b;
    // printf("%d\n", c);
    // printf("%d\n", a > b ? a : b);

    // 练习2：获取三个变量中的最大值
    int a = 30;
    int b = 10;
    int c = 20;

    // 先求出两个数据之间的较大值
    int temp = a > b ? a : b;

    // 再拿着较大值跟第三个数据进行比较
    int max = temp > c ? temp : c;

    // 输出打印
    printf("%d\n", max);

    return 0;
}

#include<stdio.h>

int main()
{
    // 逗号运算符(分隔符)
    int i;
    printf("%d\n",(i=3,++i, i++, i+5));

    /*
    注意:每个小朋友都是拿着前一个的结果进行的操作
    第一个小朋友:变成该数字的绝对值
    第二个小朋友:除以3获取余数
    第三个小朋友:乘以10
    请问该数字最终为多少?
    */

    // 1.定义变量
    int number = -17;

    // 2.变成该数字的绝对值
    number = number >= 0 ? number : -number;

    // 3.除以3获取余数
    // number = number % 3;
    number %= 3;

    // 4.乘以10
    // number = number * 10;
    number *= 10;

    printf("%d\n", number);

    // 1.定义变量
    int number2 = -17;

    // 2.利用逗号运算符得到最终的结果
    printf("%d\n", (number2 = (number2 >= 0 ? number2 : -number2), number2 %= 3, number2 *= 10));

    return 0;
}

//小括号优先于所有
//一元  > 二元 > 三元
// && > || > 赋值

# include <stdio.h>
int main ()
{
int score;
printf("请输入数字：");
scanf("%d", &score);

if(score>=0 && score<=100)
{    
    if (score >= 90)
     {
     	printf("A\n");
     }
     else if (score >=70 && score < 90)
     {
     	printf("B\n");
     }
 	 else if (score >= 60 && score < 70) 
     {
     	printf("C\n");
     }
     else
     {
        printf("D\n");
     }
}
else
{
    printf("error");
}
return 0;
}

# include <stdio.h>
int main()
 {
    int score;
    printf("请输入数字：");
    scanf("%d", &score);
    switch (score/10)
    {
        case 10:
            printf("A\n");
            break;  
        case 9:
            printf("A\n");
            break;  
        case 8:
            printf("B\n");
            break;  
        case 7:
            printf("B\n");
            break;  
        case 6:
            printf("C\n");
            break;  
        default: 
            printf("D");
            break;  
    }
    return 0;
 }

//流程控制语句————case 穿透

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");
        break;  
}

//累加求和
# include <stdio.h>
int main()
{
    int sum = 0;
        
    for(int i=1; i<=100; i++)
    {
        sum = i+sum;
    }
    return 0;
}

//偶数求和
# include <stdio.h>
int main()
{
    int sum = 0;
        
    for(int i=1; i<=100; i++)
    {
        if(i % 2 == 0);
        {
          sum = i+sum;
        }
    }
    return 0;
}

//统计思想
//求一个范围内能被6和8整除的数字
# include <stdio.h>
int main()
{
    int num1;
    int num2;
    int count=0;
    printf("请录入两个整数：\n");
    scanf("%d %d",&num1,&num2);
        
    int min = num1 < num2 ? num1 : num2;
    int max = num1 > num2 ? num1 : num2;
    
    for (int i = min; i <= max; i++)
    {
        if(i % 6 == 0 && i % 8 == 0)
        {
            count++;
        }
    }
    
    printf("%d\n",count);
    return 0;
}

//for循环：知道循环次数或循环范围
//while循环：不知道循环次数或循环范围，只知道循环的结束条件

//while循环的基本格式
# include <stdio.h>
int main()
{
	int i= 1;
	while(i<=3)
	{
   		printf("twikoo!\n");
    	i++;
	}

    return 0;
}

//案例1：累加求和 for
//案例2：循环读取文件内容：while

//例题：一个数字是否写为2的多少次幂
# include <stdio.h>
int main()
{
    int n;
    scanf("%d",&n);
    while(n>1 && n % 2 == 0)
    {
        n = n / 2;
    }
    if(n == 1)
    {
        printf("yes\n");
    }
    else
    {
        printf("no\n");
    }
    
    return 0;
}

//折纸问题：折纸多少次使纸张厚度大于珠峰
# include <stdio.h>
int main()
{
    int height = 8844430;
    double paper = 0.1;
    int count = 0;
    
    while(paper <= height)
    {
        //折叠纸张
        paper = paper * 2;
        count++;
    }
    printf("%d\n",count);
    
    return 0;
}


//整数反转：例如输入123，输出321
# include <stdio.h>
int main()
{
    //定义两个变量
    int number = 123;
    int rev = 0;
    //从右面开始，依次获取number的每一位数字，再拼接
    while(number != 0)
    {
        int temp = number % 10;
        number = number / 10;
        rev = rev * 10 + temp;
    }
    return 0;
}



//平方根，给一个非负整数x，计算并返回x的平方根，只保留整数部分，用循环结构
/*
思路：
任意数字，从1开始一个一个找，知道第一个相乘结果大于原来的数字
那么前一个数字就是他平方根的整数部分
*/
# include <stdio.h>
int main()
{
    int number = 17;
    int i = 17;
    while(i * i <= number)
    {
        i++;
    }
    printf("%d\n",i - 1);
    
    
    return 0; 
}
// end

//考试中出现
//举例：打印1~5
# include <stdio.h>
int main()
{
    int i = 1;
    do
    {
        printf("%d\n",i);
            i++;
    } while (i <= 5)
    
    return 0;
}

//格式1
for( ; ; )
{
    printf("Is this the real life\n");
}
//格式2
while(1)
{
    printf("Is this the real life\n");
}
//格式3
do
{
    printf("Is this the real life\n");
}while(1)

//标准格式
for(int i = 1; i <= 100; i++)
{
    if(i == 15)
    {
        break;
    }
}

//在1~100间，找到第一个即能被3又能被5整除的数字
# include <stdio.h>
int main()
{
    for (int i = 1; i <+ 100; i++)
    {
        if(i % 3 == 0 && i % 5 == 0)
        {
            printf("%d\n", i);
            break;
        }
    }
    
    return 0;
}

//continue:结束本次循环，继续下次循环
for(int i = 1; i <= 100; i++)
{
    if(i == 15)
    {
        continue;
    }
}

//练习：吃包子，跳过第三个包子
# include <stdio.h>
int main()
{
    
    for(int i = 1; i <= 5; i++)
	{
    	if(i == 3)
    	{
        	continue;
   		}
	}
    
    return 0;
}

//打印矩形
# include <stdio.h>
int main()
{
    for(int i = 1; i <= 3; i++)
    {
        
        for(int j = 1; j <= 5; j++)
        {
            printf("*");
        }
        
        printf("\n");
    }
    
    
    return 0;
}

//打印三角形
# include <stdio.h>
int main()
{
    for(int i = 1; i <= 5; i++)
    {
        
        // i = 1：表示打印第一行*	内循环 1~5
        for(int j = i; j <= 5; j++)
        {
            printf("*");
        }
        
        printf("\n");
    }
    
    
    return 0;
}

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

//制表符 \t 打印表格案例的时候可以对齐

//给定正整数n ，获取小于等于n的所有质数
//这个题一点也不简单
# include <stdio.h>
int main()
{
    
}


//幂级数列：计算 1^1+...+10^10
# include <stdio.h>
int main()
{
    long long res = 0;
    
    for(int i = 1; i <= 10; i++)
    {
        long long pow = 1;
            
        for(int j = 1; j <= i; j++)
        {
            pow = pow * i;
        }
        
        res = res + pow
    }
    
    return 0;
}

//一般只用于跳出循环嵌套

// 函数格式
# include <stdio.h>

void playGame()
{
    printf("准备人物\n");
    printf("准备开局\n");
    printf("开始对线\n");
    printf("碾压崩盘\n");
    printf("问候队友\n");
    printf("疯送人头\n");
    printf("下吧继续\n");
}

int main()
{
    /*
    函数最基本定义格式：
    void 函数名()
    {
        函数体;
    }
    
    函数的调用方式：
    	函数名();
    */
    //调用playGame函数
    playGame();
    printf("------"\n);
    playGame();
    
    return 0;
}

//练习题：定义一个函数，求10+20
# include <stdio.h>

void sum()
{
    int num1 = 10;
    int num2 = 20;
    int sum = num1 + num2;
    printf("%d", sum);
}


int main()
{
    sum();
    return 0;
}

//带有形参的函数
# include <stdio.h>

void sum(int num1, int num2)
{
    int sum = num1 + num2;
    printf("%d", sum);
}


int main()
{
    sum(10 , 20);
    return 0;
}

//带有返回值的函数
# include <stdio.h>

int sum(int base, int additional)
{
    int sum = base + additional;
    return sum;
}

int main()
{
    int score1 = sum(93, 10);
    int score2 = sum(87, 9);
    if(score1 > score2)
    {
        printf("1");
    }
    else if(score1 < score2)
    {
        printf("21");
    }
    else if(score1 = score2)
    {
        printf("3");
    }
    
    return 0;
}

/*
math.h:
pow()		幂
sqrt()		平方根
ceil()		向上取整
floor()		向下取整
abs()		绝对值
*/

//整数默认值：0	小数默认值：0.0	字符默认值："\0"	字符串默认值：NULL

//定义储存五个学生的年龄并初始化
# include <stdio.h>
int main()
{
    int arr[5] = {17, 18, 19, 20, 21};
    return 0;
}

/*
定义一个长度为5的数组，并进行初始化：1，2，3，4，5
获取索引为0，2，4的元素并求和
把最后一个索引的元素改为10
*/
# include <stdio.h>
int main()
{
    int arr[] = {1, 2, 3, 4, 5};
    int num1 = arr[0];
    int num2 = arr[2];
    int num3 = arr[4];
    int sum = num1 + num2 + num3;
    printf("%d\n",sum);
    
    arr[4] = 10;
    return 0;
}

//遍历：获取数组中每一个元素
//定义一个长度为5的数组，并进行初始化：1，2，3，4，5，遍历数组，把元素打印到控制台
# include <stdio.h>
int main()
{
    int arr[5] = {1, 2, 3, 4, 5};
    
    /*
    printf("%d\n",arr[0]);
    printf("%d\n",arr[1]);
    printf("%d\n",arr[2]);
    printf("%d\n",arr[3]);
    printf("%d\n",arr[4]);
    */
    for(int i = 0; i < 5; i++)
    {
        //i表示数组的每一个索引
        printf("%d\n",arr[i]);
    }
    
    return 0;
}

//内存：软件运行用于临时存储数据
//内存地址：编号
# include<stdio.h>
int main()


	//获取变量内存地址
{
	int a =0;
	printf("%p\n",&a);

	int b = 20;
	int c = 30;
	printf("%p\n",&b);
	printf("%p\n",&c);

	printf("-------------------------------\n");

	//获取数组的内存地址
	int arr[] = {1,2,3};
	printf("%p\n",&arr[0]);//数组的首地址
	printf("%p\n",&arr[1]);//内存的角度：偏移量
	printf("%p\n",&arr[2]);

	return 0;
}


//数组作为函数的参数
//定义处：arr表示的就是完整的数组
//函数中的arr；只是一个变量，用于记录数组的首地址
# include<stdio.h>
int main()
{

	int arr[]={1,2,3,4,5,4,5,4,5,4,5,4,5,4,5,4,5,4,5};
	int len = sizeof(arr) /sizeof(int);
	printArr(arr,len);



	return 0;

}

void printArr(int arr[], int len)
{
	for (int i = 0; i<len; i++)
	{
		printf("%d\n",arr[i]);
	}
}

//数组算法题
//求最值：已知数组元素为{33,5,22,44,55},找出数组最大值并打印在控制台
# include<stdio.h>
int main()

{
	int arr[]={33,5,22,44,55};
	int max = arr[0];
	int len = sizeof(arr) /sizeof(int);
	for(int i=0; i<len;i++)
	{
		if(arr[i]>max)
		{
			max =arr[i];
		}
	}

	printf("%d\n",max);

	return 0;
}

//遍历数组求和：生成10个1~100之间的随机数存入数组，求出数组值和
# include<stdio.h>
# include<stdlib.h>
# include<time.h>

int main()
{
	//定义数组
    int arr[10]={0};
	int len =sizeof(arr) /sizeof(int);
    
    //生成10个1~100之间的随机数存入数组
    //设置种子
	srand(time(NULL));
    //生成随机数
	for(int i=0;i<len;i++)
	{
		int num = rand() % 100 + 1;
        //把随机数存入数组
		arr[i] = num;
	}
	
    //利用累加求和思想求数组所有数据的和
	int sum = 0;
	for(int i= 0;i<len; i++)
	{
		sum=sum+arr[i];
	}
	printf("%d\n",sum);

	
	return 0;
}



//数组求和：生成10个1~100之间的随机数存入数组，要求数据不能重复
//1. 求出所有数据的和
//2. 求所有数据平均数
//3. 统计多少个数据比平均值小
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// 判断num是否在数组中存在
int contains(int arr[], int len, int num) {
    for (int i = 0; i < len; i++) {
        if (arr[i] == num) {
            return 1;
        }
    }
    return 0;
}

int main() {
    // 定义数组
    int arr[10] = {0};
    int len = sizeof(arr) / sizeof(int);

    // 生成10个1~100之间的随机数存入数组
    srand(time(NULL));
    for (int i = 0; i < len;) {
        int num = rand() % 100 + 1;
        // 存入前先做判断，如果不存在再添加
        if (!contains(arr, i, num)) { // 注意这里传递的是i而不是len
            arr[i] = num;
            i++;
        }
    }

    // 利用累加求和思想求数组所有数据的和
    double sum = 0;
    for (int i = 0; i < len; i++) {
        sum += arr[i];
    }
    printf("Sum: %.2f\n", sum);

    // 求平均数
    double average = sum / len;
    printf("Average: %.2f\n", average);

    // 统计有多少个数字比平均数小
    int count = 0;
    for (int i = 0; i < len; i++) {
        if (arr[i] < average) {
            count++;
        }
    }
    printf("Numbers less than average: %d\n", count);

    // 保持控制台窗口打开（可选）
    system("pause");

    return 0;
}

//反转数组
//键盘录入5个数据并存入数组，并遍历反转再次遍历
# include <stdio.h>

void printArr(int arr[], int len)
{
    for(int i=0; i<len; i++)
    {
        printf("%d",arr[i]);
    }
}


int main()
{
    //定义数组
    int arr[5]={0};
    int len = sizeof(arr) / sizeof(int);
    //键盘录入数据
    for(int i=0; i<len;i++)
    {
        printf("请输入%d个元素\n",i+1);
        scanf("%d",&arr[i]);
    }
    
    //遍历数组
    printArr(arr,len);
    
    //反转数组
    int i=0;
    int j=len -1;
    while(i<j)
    {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
        
        
        i++;
        j--;
    }
    printArr(arr,len);
    
    
    return 0;
}



//例题：打乱数组中的数据
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    int arr[]={1,2,3,4,5};
    int len = sizeof(arr) / sizeof(int);
    
    
    srand(time(NULL));
    for (int i = 1; i < len; i++)
    {
        int index = rand() % len;
        int temp = arr[i];
        arr[i]=arr[index];
        arr[index]=temp;
    } 
       
    for(int i = 0; i< len;i++)
    {
        printf("%d\n",arr[i]);
    }
    
    
    return 0;
}

//指针：内存地址
//定义格式：
//int a = 10;
//int* p = &a;

//利用指针查询内存地址
# include <stdio.h>
int main()
{
    //利用指针获取变量中数据 / 存储数据
    int a = 10;
    int* p = &a;
    printf("%d\n",*p)；
    //利用指针存储数据 / 修改数据
    *p = 200；
    printf("%d\n",*p)；    
    printf("%d\n",a)；
    
    
    return 0;
}

//给指针变量赋值的时候，不能把一个数值赋给指针变量

//作用1：操作其它函数中的变量
//作用2：函数返回多个值
//作用3：函数结果和计算状态分开
//作用4：更好操作数组和函数

//作用1：代码实现
#include <stdio.h>

//定义两个变量，交换其在变量中记录的值

// 定义一个交换函数
void swap(int* p1, int* p2) {
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int main() {
    // 1. 定义两个变量
    int a = 10;
    int b = 20;

    // 2. 调用swap函数
    printf("调用前:%d,%d\n", a, b);
    swap(&a, &b);
    printf("调用后:%d,%d\n", a, b);

    return 0;
}


/*
作用1：细节
*/
#include <stdio.h>
int* method();

int main() {
    // 调用method函数，并使用该函数中的变量a
    int* p = method();
    printf("%d\n", *p); // 这里可能会有问题，因为method函数结束后，局部变量a的生命周期结束
    return 0;
}

int* method() 
{
    static int a = 10;//此时变量一直保存
    return &a; // 返回局部变量a的地址
}


//指针作用2：函数返回多个值
#include <stdio.h>

void findMinMax(int *arr, int size, int *min, int *max) {
    if (size <= 0) return; // 如果数组大小为0，则返回

    *min = *max = arr[0]; // 初始化最小值和最大值为数组的第一个元素

    for (int i = 1; i < size; i++) {
        if (arr[i] < *min) {
            *min = arr[i]; // 更新最小值
        }
        if (arr[i] > *max) {
            *max = arr[i]; // 更新最大值
        }
    }
}

int main() {
    int arr[] = {3, 5, 1, 8, 2};
    int size = sizeof(arr) / sizeof(arr[0]);
    int min, max;

    findMinMax(arr, size, &min, &max);

    printf("最小值: %d\n", min);
    printf("最大值: %d\n", max);

    return 0;
}

//指针作用3：函数的结果和计算状态分开
//练习：定义一个函数，将两数相除，求出余数
#include <stdio.h>


void findRemainder(int dividend, int divisor, int *remainder) 
{
    if (divisor == 0)
    {
        printf("除数不能为0\n");
        return;
    }
    *remainder = dividend % divisor;
}


int main() 
{
    int dividend = 10;
    int divisor = 3;
    int remainder;

    findRemainder(dividend, divisor, &remainder);

    printf("余数: %d\n", remainder);

    return 0;
}

//基础的指针运算
#include <stdio.h>

int main() {
    // 定义变量
    int a = 10; // 假设 a 的值为 10
    int *p = &a; // p 是指向 a 的指针

    // 打印 p 的地址
    printf("%p\n", p);

    // 打印 p - 1 的地址，即 p 往前移动 sizeof(int) 步
    printf("%p\n", p - 1);

    // 打印 p - 2 的地址，即 p 往前移动 2 * sizeof(int) 步
    printf("%p\n", p - 2);

    return 0; // 返回 0 表示程序正常退出
}




/*
指针运算有意义的操作:
指针跟整数进行加、减操作(每次移动一个步长)
指针跟指针进行减操作(间隔步长)
指针运算无意义的操作:
指针跟整数进行乘除操作指针跟指针进行加、乘、除操作
*/
#include <stdio.h>

int main() {
    // 前提条件：保证内存空间是连续的

    // 数组
    int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    // 获取0索引的内存地址
    int *p1 = &arr[0];

    // 通过内存地址（指针p）获取数据
    printf("%d\n", *p1);
    printf("%d\n", *(p1 + 1));

    // 获取5索引的内存地址
    int *p2 = &arr[5];

    // p2 - p1间隔了多少步长
    printf("%d\n", p2 - p1); // 5 * sizeof(int) = 20
    printf("%p\n", p1);
    printf("%p\n", p2);

    return 0;
}





/*
野指针：指针指向的空间未分配
悬空指针：指针指向的空间已分配，但是被释放了
*/

// 野指针：指针指向的空间未分配
#include <stdio.h>

int* method();
    
int main() 
{
    // 野指针：指针指向的空间未分配
    int a = 10;
    int *p1 = &a;
    printf("%p\n", p1);
    printf("%d\n", *p1);

    // p2 野指针
    int *p2 = p1 + 10;

    printf("%p\n", p2);
    printf("%d\n", *p2);
    
    // 忌空指针：指针指向的空间已分配，但是被释放了
    int* p3 = method();
    printf("拖点时间\n");
    printf("%p\n", p3);
    printf("%d\n", *p3);
    
    return 0;
}

int* method() 
{
    int num = 10; // 假设 num 的值为 10
    int* p = &num;
    return p;
}




//void类型指针
#include <stdio.h>

int main() {
    /* void类型的指针 */

    // 1.定义两个变量
    int a = 10;
    short b = 20;

    // 2.定义两个指针
    int *p1 = &a;
    short *p2 = &b;

    // 3.输出打印
    printf("%d\n", *p1);
    printf("%d\n", *p2);

    // 不同类型的指针之间，是不能互相赋值的
    // void类型的指针打破上面的观念
    // void没有任何类型，好处是可以接受任意类型指针记录的内存地址
    void *p3 = p1;
    void *p4 = p2;
	
    //缺点：void类型指针无法获得里面数据，也不能加减运算
    
    return 0;
}

#include<stdio.h>
int main()
{
// 定义变量
int a = 10;
int b = 20;

// 定义一级指针
int* p = &a;

// 定义二级指针
int** pp = &p;

// 作用一：利用二级指针修改一级指针里面记录的内存地址
*pp = &b;

// 作用二：利用二级指针获取到变量中记录的数据

// 输出打印
printf("%p\n", &a);
printf("%p\n", &b);
printf("%p\n", p);
printf("%d\n", **pp);

    return 0；
}

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

// 1. 定义数组
int arr[] = {10, 20, 30, 40, 50};
int len = sizeof(arr) / sizeof(int);

// 2. 获取数组的指针
// 实际上获取的：数组的首地址
int* p1 = arr;
// int* p2 = &arr[0]; // 这一行被注释掉了，但可以作为另一种获取数组首地址的方式

// 3. 利用循环和指针遍历数组获取里面的每一个元素
for (int i = 0; i < len; i++) {
    printf("%d\n", *p1++);
}

return 0;
}





//arr参与运算，退化成第一个元素的指针

//sizeof运算的时候，不会退化，arr还是整体
//&arr获取地址的时候，不会退化

#include <stdio.h>
int main()
{
// 练习: 数组指针的细节
// arr参与计算的时候,会退化为第一个元素的指针
// 特殊情况:
// sizeof运算的时候,不会退化,arr还是整体
// &arr获取地址的时候,不会退化

// 1. 定义数组
int arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 2. sizeof运算的时候,不会退化,arr还是整体
printf("%zu\n", sizeof(arr)); // 40

// 3. &arr获取地址的时候，不会退化，记录的内存地址第一个元素的首地址，也是数组的首地址，步长:数据类型*数组的长度 40
// arr参与计算的时候,会退化为第一个元素的指针,记录的内存地址第一个元素的首地址,也是数组的首地址,步长:数据类型 int 4
printf("%p\n", arr);
printf("%p\n", arr + 1); // 4
printf("%p\n", &arr + 1); // 40

return 0;
}







//利用索引遍历第一种格式的二维数组
#include <stdio.h>

//### 二维数组
// 定义格式和遍历方式

// 定义格式方式一:
// m:表示二维数组的长度
// n:表示每一个一维数组的长度
// 数据类型 arr[m][n]=
// { {1,2,3,4,5}, {1,2,3,4,5}, {1,2,3,4,5} };
#include <stdio.h>
int main()
{
    
    //### // 1.定义一个二维数组
    int arr[3][5] = {
        {1, 2, 3, 4, 5},
        {11, 22, 33, 44, 55},
        {111, 222, 333, 444, 555}
    };

    // 2.利用索引的方式进行遍历
    // arr[0]:表示二维数组当中的第一个一维数组,{1,2,3,4,5}
    // arr[1]:表示二维数组当中的第二个一维数组,{11,22,33,44,55}

    for(int i = 0; i < 3; i++) {
        // i:依次表示二维数组中的索引
        for(int j = 0; j < 5; j++) {
            // j:依次表示一维数组中的索引
            // 内循环:遍历每一个一维数组
            printf("%d ", arr[i][j]);
        }
        // 当内循环结束之后,表示一维数组遍历完毕了
        printf("\n");
    }

    return 0;
}






//利用索引遍历第二种格式二维数组
#include <stdio.h>
int main()
{
    
    // 1.定义三个一维数组
    int arr1[3] = {1, 2, 3};
    int arr2[5] = {1, 2, 3, 4, 5};
    int arr3[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 预先计算每一个数组真实的长度
    int len1 = sizeof(arr1) / sizeof(int);
    int len2 = sizeof(arr2) / sizeof(int);
    int len3 = sizeof(arr3) / sizeof(int);

    // 再定义一个数组,装所有数组的长度
    int lenArr[3] = {len1, len2, len3};

    // 2.把三个一维数组放入到二维数组当中
    // 数组的数据类型,跟内部存储的元素类型保持一致
    // arr1:使用数组名进行计算的时候,退化为指向第一个元素的指针,此时不再表示数组的那个整体了
    // 指针---内存地址 64位win 8个字节
    int* arr[3] = {arr1, arr2, arr3};

    // 3.利用索引遍历arr
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < lenArr[i]; j++) {
            printf("%d ", arr[i][j]);
        }
        printf("\n");
    }

    return 0;
}







//利用指针遍历第一种格式二维数组
#include <stdio.h>

int main() 
{
    // 定义一个二维数组
    int arr[3][5] = 
    {
        {1, 2, 3, 4, 5},
        {11, 22, 33, 44, 55},
        {111, 222, 333, 444, 555}
    };

    // 获取二维数组的指针
    // 数组指针的数据类型：要跟数组内部元素的类型保持一致
    int (*p)[5] = arr;

    for (int i = 0; i < 3; i++) 
    {
        // 遍历一维数组
        for (int j = 0; j < 5; j++) 
        {
            printf("%d ", *(*p + j));
        }
        // 换行
        printf("\n");

        // 移动二维数组的指针，继续遍历下一个一维数组
        p++;
    }

    return 0;
}







//利用指针遍历第二种格式二维数组
#include <stdio.h>

int main() {
    // 1.定义三个一维数组
    int arr1[5] = {1, 2, 3, 4, 5};
    int arr2[5] = {11, 22, 33, 44, 55};
    int arr3[5] = {111, 222, 333, 444, 555};

    // 2.把三个一维数组的内存地址,再放入到二维数组当中
    int* arr[3] = {arr1, arr2, arr3};

    // 3.获取指针
    int** p = arr;

    // 4.遍历数组
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 5; j++) {
            printf("%d ", *(*p + j));
        }
        // 换行
        printf("\n");

        // 移动指针
        p++;
    }

    return 0;
}


//数组指针：指向数组的指针
//指针数组：存放指针的数组