欢迎大家来到IT世界,在知识的湖畔探索吧!
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <string.h>
#include <Windows.h>
#include <stdlib.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
//int main()
//{
// printf("hello Word\n");
// return 0;
//}
//
//int main()
//{
// int num1 = 0;
// int num2 = 0;
// int sum = 0;
// scanf("%d%d", &num1, &num2);
// sum = num1 + num2;
// printf("sum=%d\n", sum);
// return 0;
//}
//--------------枚举常量-----------------
// enum Sex//enum为枚举关键字
//{
// MALE, //成为枚举常量
// FEMALE,
// SECRET
//};
//int main()
//{
// //enum Sex a = SECRET;
// printf("%d\n", MALE);//值为0
// printf("%d\n", FEMALE);//值为1
// printf("%d\n", SECRET);//值为2
// return 0;
//}
//--------字符串---------
//int main()
//{
// char arr1[] = "abc";
// char arr2[] = { 'a', 'b', 'c' };
// printf("%s\n", arr1);
// printf("%s\n", arr2);
// //strlen全称是string length,计算字符串长度的，遇到\0停止计算，且\0不算作长度
// printf("%d\n", strlen(arr1));//结果是3
// printf("%d\n", srelen(arr2));//结果任意值
// return 0;
//}
//-------转义字符-----------
//int main()
//{
// //printf("c:\test\32\test.c");
// //printf("\32");
// //printf("c:\\test\\32\\test.c");
// //printf("%d\n", strlen("c:\test\32\test.c"));//打印结果为13,即长度为13
// printf("%d\n", strlen("\x61"));//打印结果为1即长度为1
// return 0;
//}
//-------------------------------
//int main()
//{
// int input = 0;
// printf("加入比特\n");
// printf("你要好好学习吗(1/0)\n");
// scanf("%d", &input);
// if (input == 1)
// printf("一份好工作\n");
// else
// printf("卖红薯\n");
//
// return 0;
//}
//-----------------------------
//int main()
//{
// int line = 0;
// printf("加入比特\n");
// while (line < 20000)
// {
// printf("敲一行代码:%d\n",line);
// line++;
// }
// if (line >= 20000)
// printf("ding~找到一个好工作d=====(￣▽￣*)b\n");
//
// return 0;
//}
//------------------------
//int Add(int x, int y)
//{
// int z = x + y;
// return z;
//}
//int main()
//{
// int a = 100;
// int b = 200;
// int sum = 0;
// sum = Add(a, b);
// printf("sum=%d\n", sum);
//
// return 0;
//}
//*************交换两个数******************
//int main()
//{
// //交换两个整形变量
// int a = 3;
// int b = 5;
// int c = 0;//空瓶
// printf("交换前：a=%d b=%d\n", a, b);
// c = a;
// a = b;
// b = c;
// printf("交换后：a=%d b=%d\n", a, b);
// return 0;
//}
//-------不使用第三个变量-----------
//int main()
//{
// int a = 3;
// int b = 5;
// printf("交换前：a=%d b=%d\n", a, b);
// a = a + b;//a放的是和，b还是原来的b
// b = a - b;//b得到原来的a
// a = a - b;//a得到原来的b
// printf("交换后：a=%d b=%d\n", a, b);
// return 0;
//}
//---------优化--------
//int main()
//{
// int a = 3;//二进制：011
// int b = 5;//二进制：101
// printf("交换前：a=%d b=%d\n", a, b);//^是按位异或：相同为0不同为1
// //
// a = a^b;//此处a=110 b=101
// b = a^b;//此处a=110 b=011
// a = a^b;//此处a=101 b=011
// printf("交换后：a=%d b=%d\n", a, b);
// return 0;
//}
//**************找出单身狗*****************
//int main()
//{
// int arr[] = { 1, 2, 3, 4, 5, 1, 2, 3, 7, 5, 4 ,7,8};
// int i = 0;
// int sz = sizeof(arr) / sizeof(arr[0]);//计算数组元素个数
//
// for (i = 0; i < sz; i++)//从下标0开始取出一个数
// {
// int j = 0;
// int count = 0;//定义计数器
// for (j = 0; j < sz; j++)//数组的每个数与取出的一个数对比
// {
// if (arr[i] == arr[j])
// {
// count++;
// }
// }
// if (count == 1)//计数器为2说明有两个相同数字，为1则就为单身狗
// {
// printf("单身狗:%d\n", arr[i]);
// break;
// }
// }
//
// return 0;
//}
//---------优化------------
//3^3=0;5^5=0;所以可得a^a=0;0^5=5;0^3=3;所以可得0^a=a; 即相同数字异或为0，任何数和0异或等于任何数本身
//符合交换律：3^5^3=3^3^5=5
//int main()
//{
// int arr[] = { 1, 2, 3, 4, 5, 1, 2, 3, 7, 5, 4 ,7,8};
// int i = 0;
// int ret = 0;
// int sz = sizeof(arr) / sizeof(arr[0]);//计算数组元素个数
//
// for (i = 0; i < sz; i++)//从下标0开始取出元素
// {
// ret = ret^arr[i];//逐个异或
// }
// printf("单身狗：%d\n", ret);
// return 0;
//}
//--------------------------------------------
//int main()
//{
// int a = 0;//申请了4个字节的空间
// //printf("%p\n", &a);
// int* p = &a;//p是一个变量-指针变量；int*表示是整形的指针类型
// *p = 20;//* - 解引用操作符/间接访问操作符
// printf("a=%d\n", a);
//
// return 0;
//}
//int main()
//{
// //printf("%d\n", sizeof(char*));//地址大小都是4个字节
// //printf("%d\n", sizeof(short*));//4个字节
// //printf("%d\n", sizeof(int*));//4个字节
// //printf("%d\n", sizeof(double*));//4个字节
// double d = 3.14;
// double* pd = &d;
// printf("%d\n", sizeof(pd));//地址的大小和操作系统有关，32位的为4个字节，64位的为8个字节
// //*pd = 5.5;
// //printf("%lf\n", d);
// //printf("%lf\n", *pd);
// return 0;
//}
////**********************结构体*************************
//struct Book//结构体的类型
//{
// char name[20];//书名
// short price;//价格
//};//这里的分号不可缺少！！！！！！
//
//int main()
//{
// //利用结构体类型--创建一个该类型的结构体变量
// struct Book b1 = { "C语言程序设计", 55 };
// printf("书名:%s\n", b1.name);//此处的.为属性操作符，用于访问结构体成员
// printf("价格:%d元\n", b1.price);
// b1.price = 15;
// printf("修改后的价格:%d元\n", b1.price);
//
// ------------------------------------------
// struct Book b1 = { "C语言程序设计", 55 };
// struct Book* pb = &b1;//*表明是指针变量
// //利用指针打印出书名和价格 //.操作符 结构体变量.成员（需要结合解引用，麻烦）
// printf("%s\n", (*pb).name);//解引用 ↑
// printf("%d\n", (*pb).price);// ↓
// //也可以不利用解引用打印直接利用pb打印 //->操作符 结构体指针->成员
// printf("%s\n", pb->name);
// printf("%d\n", pb->price);
//
// return 0;
//}
//******************选择结构和循环结构***************
//int main()
//{
// int age = 127;
// /*if (age < 18)
// printf("未成年\n");
// else
// printf("已成年\n");*/
//
//
// /*if (age < 18)
// printf("未成年\n");
// else if (age < 28)
// printf("青年\n");
// else if (age < 50)
// printf("壮年\n");
// else if (age < 90)
// printf("老年\n");
// else
// printf("长寿\n");*/
//
//-----------------------------
// if (age < 18)
// printf("未成年\n");
// else if (age >= 18 && age < 28)
// printf("青年\n");
// else if (age >= 28 && age < 50)
// printf("壮年\n");
// else if (age >= 50 && age < 90)
// printf("老年\n");
// else
// printf("长寿\n");
//
// return 0;
//}
//------------练习：判断一个数是否为奇数----------
//int main()
//{
// int i = 0;
// while (i <= 100)
// {
// if (i % 2 == 1)
// printf("%d ", i);
// i++;
// }
// return 0;
//}
//----------switch语句---------
//int main()
//{
// int day = 0;
// scanf("%d", &day);
// switch (day)
// {
// case 1:
// printf("星期一\n");
// break;
// case 2:
// printf("星期二\n");
// break;
// case 3:
// printf("星期三\n");
// break;
// case 4:
// printf("星期四\n");
// break;
// case 5:
// printf("星期五\n");
// break;
// case 6:
// printf("星期六\n");
// break;
// case 7:
// printf("星期七\n");
// break;
// default:
// printf("输入错误\n");
// }
// return 0;
//}
//---------练习，输出1-100之间的奇数-------
//int main()
//{ //-----第一种------
// /*int i = 0;
// while (i <= 100)
// {
// if (i % 2 == 1)
// printf("%d ", i);
// i++;
// }
//*/
// //-----第二种------
// /*int i = 0;
//
// for ( ;i<100; i++)
// {
// if (i % 2 == 1)
// printf("%d ", i);
// }*/
//
// return 0;
//}
//************学习while循环************
//打印1-10个数字
//int main()
//{
// int i = 1;
// while (i <= 10)
// {
// printf("%d ", i);
// i++;
// }
// return 0;
//}
//-------break-----
//int main()
//{
// int i = 1;
// while (i <= 10)
// {
// if (i == 5)
// break;
// printf("%d ", i);
// i++;
// }
// return 0;//打印结果为1 2 3 4结束
//}
//---------continue------
//int main()
//{
// int i = 1;
// while (i <= 10)
// {
// if (i == 5)
// continue;
// printf("%d ", i);
// i++;
// }
// return 0;//打印结果为1 2 3 4死循环
//}
//int main()
//{
// //int ch = 0;
// //while ((ch = getchar()) != EOF) //getchar()获取字符,putchar()输出字符 //EOF 即end of file 文件结束标志，本质是-1
// //{ //获取不到EOF一直执行循环，输入ctrl+z可以输入EOF
// // putchar(ch);
// //}
//
// //int ret = 0;
// //int ch = 0;
// //char passward[20] = { 0 };
// //printf("请输入密码:");//输入密码后，密码和所按的回车即\n也被存储在输入缓冲区
// //scanf("%s", passward);//此时输入密码，并把密码存放在passward数组中，此时输入缓冲区中还剩下\n
// ////此时若无getchar();语句，则\n被取走
// ////被取走的\n的ASCLL码值为10
// //printf("请确认（Y/N）：");
// ////getchar();//清空输入缓冲区，即把\n取走以免\n的ASCLL码值进入判断语句
// //// //但是当缓冲区字符超过一个就失效了
// //while ((ch = getchar()) != '\n')//循环取，直至取到\n停止
// //{
// // ;
// //}
// //
// // ret = getchar();//此时输入缓冲区为空取不到值，等待用户输入
// //if (ret == 'Y')
// //{
// // printf("确认成功\n");
// //}
// //else
// //{
// // printf("放弃确认\n");
// //}
//
//
//
// int ch = 0;
// while ((ch = getchar()) != EOF)
// {
// if (ch<'0' || ch>'9')//小于0或者大于9的跳过打印，在0-9内打印
// continue;//跳过本次循环体
// putchar(ch)
// } //只输出数字
//
// return 0;
//}
//**************学习For循环*************
//int main()
//{
//for循环本质是优化while循环
//while循环的组成：
//int i=0; ←初始化
//while (i < 10) ←判断部分
//{
// ..... ←循环部分
// i++;←调整部分
//}
//-------------用for循环打印1-10-------------
//int i = 0;
//// 初始化 判断 调整 //判断部分本质是判别真假即0或者非零，谨记！！！！！！！！
//// ↓ ↓ ↓
//for (i = 1; i <= 10; i++)
//{
// printf("%d ", i); //←循环
//}
//-----for循环和while循环中的continue对比-----
//int i = 0;
//for (i = 1; i <= 10; i++)
//{
// if (i == 5)
// continue;//←执行到此语句时跳过本次循环体，然后执行调整部分i++
// printf("%d ", i);
//}//打印结果为1 2 3 4 6 7 8 9 (结束循环)
//--------对比while循环------
//int i = 1;
//while (i <= 10)
//{
// if (i == 5)
// continue;//←执行到此语句时跳过本次循环体，i++也在循环体中被跳过，进入死循环
// printf("%d ", i);
// i++;
//}//打印结果为1 2 3 4(仍然在循环中)
//----------不可在for循环体内修改循环变量，防止失控----------
//int i = 0;
//for (i = 1; i < 10; i++)
//{
// if (i = 5) //修改了变量i，进入死循环
// printf("haha\n");
// printf("hehe\n");
//}
// return 0;
//}
//
//-------注意尽量不要省略条件---------
//int main()
//{
// int i = 0;
// int j = 0;
// for (; i < 10; i++)// i=0 1 2 3 4 5 6 7 8 9 10 循环结束
// {
// for (; j < 10; j++)//j=0 1 2 3 4 5 6 7 8 9 10 10 10 10 10 10 10 10 10 10
// {
// printf("hehe\n");
// }
// }
// //只打印10个hehe
// //第二个for循环缺少初始化，所以j的值保留了
// //造成的结果只有i=0的时候打印了10个hehe，其余全部因j=10跳出了循环不打印
// return 0;
//}
//----------练习：判断循环多少次------
//int main()
//{
// int i = 0;// 此处k赋值为1，1为非零恒为真，所以死循环
// int k = 0;// ↓
// for (i = 0, k = 0; k = 1; i++, k++)//若改为for(i=0,k=0;k=1;i++,k++)恒为真，死循环
// printf("1\n"); //若改为for(i=0,k=0;k==0;i++,k++)则循环一次
// return 0;
//}
//-------------------
//int main()
//{
// int i = 0;// 此处k赋值为0，0恒为假，所以不进入循环
// int k = 0;// ↓
// for (i = 0, k = 0; k = 0; i++, k++)
// printf("1\n");
// return 0;
//}
//-------------
//int main()
//{
// int i = 0;// 此处判断k值为0则条件成立，当k的值是0时为真，所以循环一次
// int k = 0;// ↓
// for (i = 0, k = 0; k ==0; i++, k++)
// printf("1\n");
// return 0;
//}
//*************学习do-while循环**************
//int main()
//{
//打印1-10
/*int i = 1;
do
{
printf("%d ", i);
i++;
} while (i <= 10);*/
//-----break和continue的用法----
//int i = 1;
//do
//{
// if (i == 5)
// //break; 打印结果1234结束
// //continue; 打印结果1234未结束循环
// printf("%d ", i);
// i++;
//} while (i <= 10);
//--------------------*****练习********----------------------
//求n的阶乘
//int main()
//{
// int i = 0;
// int ret = 1;
// int n = 0;
// scanf("%d", &n);
// for (i = 1; i<=n; i++)
// {
// ret = ret*i;
// }
// printf("ret=%d\n", ret);
// return 0;
//}
//---------求1!+2!+3!+4!--------------
//int main()
//{
// int i = 0;
// int ret = 1;//若等于0则乘多少都为0
// int n = 0;
// int sum = 0;
// //1+2+6+24=33
// for (n = 1; n <= 4; n++)//n的阶乘相加4次
// {
// ret = 1;//初始化，防止重复运算导致错误
// //初始化运行过程n=1时：循环1次，ret初始值为1结束值为1；ret=1*1=1(为1!)
// //n=2时：循环2次，ret初始值为1结束值为1；ret=1*1*2=2(为2!)
// //n=3时：循环3次，ret初始值为1结束值为1；ret=1*1*2*3=6(为3!)
// //n=4时：循环4次，ret初始值为1结束值为1；ret=1*1*2*3*4=24(为4!)
// //若不初始化n=1时:循环1次，ret初始值为1结束值为1；ret=1*1=1
// //n=2时:循环2次，ret初始值为1结束值为2；ret=1*1*2=2
// //n=3时:循环3次，ret初始值为2结束值为12；ret=2*1*2*3=12
// //n=4时:循环4次，ret初始值为12结束值为288；ret=12*1*2*3*4=288
// for (i = 1; i <= n; i++)//n的阶乘
// {
// ret = ret*i;
// }
// sum = sum + ret;//把每个数字的阶乘相加
// }
// printf("sum=%d\n", sum);//sum=33
// return 0;
//}
//-------求1！+2!+3!+...+10!----------
//int main()
//{
// int i = 0;
// int ret = 1;
// int n = 0;
// int sum = 0;
// for (n = 1; n <= 10; n++)//n的阶乘相加10次
// {
// ret = 1;//初始化，防止重复运算导致错误
// for (i = 1; i<=n; i++)//n的阶乘
// {
// ret = ret*i;
// }
// sum = sum + ret;
// }
// printf("sum=%d\n", sum);
// return 0;
//}
//------优化-------
//int main()
//{
// int ret = 1;
// int n = 0;
// int sum = 0;
// for (n = 1; n <= 4; n++)
// {
// ret = ret*n;//循环到几就是几的阶乘
// sum = sum + ret;//依次相加
// }
// printf("sum=%d\n", sum);
//}
//--------折半查找------
//int main()
//{
// int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12 };//有序数组
// int k = 7;
// int left = 0;//左下标
// // 计算数组arr所占的字节
// // （此处为44个字节） 单个元素所占的字节数，此处为下标是0的元素所占的字节(4个字节)
// // ↓ ↓
// int sz = sizeof(arr) / sizeof(arr[0]);//计算出sz数组的总长度，为11
// int right = sz - 1;//右下标
// while (left <= right)
// {
// int mid = (left + right) / 2;//中间值
// if (arr[mid] > k)//说明要找的k在mid的左边
// {
// right = mid - 1;//右下标移到中间值左移一个
// }
// else if (arr[mid] < k)//说明要找的k在mid的右边
// {
// left = mid + 1;//左下标移到中间值右移一个
// }
// else
// {
// printf("找到了，下标是%d\n", mid);
// break;
// }
// }
// if (left>right)
// printf("找不到\n");
//
//
//
// return 0;
//}
//-------打印一串字符，从两端到中间依次显示---
//int main()
//{
// char arr1[] = "welcome to bit!!!!!!!";
// char arr2[] = "#####################";
// int left = 0;
// //int right = sizeof(arr) / sizeof(arr[0]) - 2; //减去2是因为字符串结尾有\n,
// int right = strlen(arr1) - 1;
// while (left <= right)
// {
// arr2[left] = arr1[left];//替换左下标
// arr2[right] = arr1[right];//替换右下标
// left++;//左下标右移一个
// right--;//右下标左移一个
// system("cls");//执行系统命令的一个函数-cls，效果为清空屏幕
// printf("%s\n", arr2);
// Sleep(1000);//休息1秒
// }
//
// return 0;
//}
//--------模拟用户登录，用户只能登陆三次-----
//int main()
//{
// int i = 0;
// int a = 3;
// char passward[20] = { 0 };
// for (i = 0; i < 3; i++)
// {
// printf("请输入密码：");
// scanf("%s", passward);
// if (strcmp(passward, "123456") == 0)
// //strcmp函数是string compare(字符串比较)的缩写，用于比较两个字符串并根据比较结果返回整数。
// //形式为strcmp(str1,str2)，若str1=str2，则返回零；若str1<str2，则返回负数；若str1>str2，则返回正数。
//
// {
// printf("登陆成功\n");
// break;
// }
// else
// {
// a--;
// printf("密码错误请重试，还剩余%d次机会\n",a);
// }
// }
// if (i==3)
// printf("三次机会已用光，退出程序\n");
//
// return 0;
//}
//-------作业--------
//static关键字使得局部变量变得静态，离开了作用范围不被重置初始化
//就相当于int b出了sum函数就失忆了，每次回来都是3；
//但static int b不在失忆，能记得上一次的数值所以能累加起来数值
//int sum(int a)//a每次循环都是2
//{
// int c = 0;
// static int b = 3;//静态局部变量，延长生命周期到整个main函数
// c += 1;//c每次循环都是0，所以这里的c一直就是1
// b += 2;//b每次循环都加2
// return (a + b + c);
//}
//int main()
//{
// int i;
// int a = 2;
// for (i = 0; i < 5; i++)
// {
// printf("%d,", sum(a));
// }
// return 0;//结果8，10，12，14，16
//}
//-------三个数字从大到小输出-------
//int main()
//{
// int a = 0;//a放最大值
// int b = 0;//b次之
// int c = 0;//c放最小值
// int nmb= 0;//中间值
// scanf("%d %d %d", &a, &b, &c);//输入时的间隔符号要注意格式与函数内保持一致，否则间隔符就参与排序
// if (a < b)//若b比a大，就交换一下把较大的值放到a里
// {
// nmb = a;
// a = b;
// b = nmb;
// }
// if (a < c)//若c比a大，就交换一下把较大的值放到a里
// {
// nmb = a;
// a = c;
// c = nmb;
// } //此时，三个数中最大的值放到了a里，在比较b和c的值就可以了
// if (b < c)//若c比b大，就交换一下把较大的值放到b里
// {
// nmb = b;
// b = c;
// c = nmb;
// }
//
// printf("%d %d %d", a, b, c);
//
//
// return 0;
//}
//--------打印1-100之间的所有的3的倍数-------
//int main()
//{
// int i = 0;
// int a = 1;
// for (i = 0; i < 100; i++)
// {
// if (a % 3 == 0)
// {
// printf("%d ", a);
//
// }
// a++;
// }
//
// return 0;
//}
//-----求最大公约数-辗转相除法--------
//求两个数最大公约数就是两个数取模为0的数，若不为0用较小的数和余数再次取模，一直循环到取模为0的数
//int main()
//{
// int m = 0;
// int n = 0;
// int r = 0;
// scanf("%d%d", &m, &n);
// while (m%n)//取余结果不为零的进入循环体调整各参数位置，即开始辗转
// {
// r = m%n;//把余数储存
// m = n;//较小的数存到m
// n = r;//余数存到n，为进入下一个循环做好准备，在下一次循环中即为较小的数对余数取模
// }
//
// printf("%d\n", n);
//
// return 0;
//}
//-------打印1000年到2000年之间的闰年---
//判断是否为闰年的依据
//1.能被4整除并且不能被100整除
//2.能被400整除
//int main()
//{
// int year = 0;
// int a = 0;//定义计数器
// for (year = 1000; year <= 2000; year++)
// {
// if (year % 4 == 0 && year % 100 != 0)//&&逻辑与：需两边都满足
// {
// printf("%d ", year);
// a++;
// }
// else if (year % 400 == 0)
// {
// printf("%d ", year);
// a++;
// }
// }
//}
// printf("\n闰年数为:%d\n", a);
//// //------进化版----
// int main()
// {
// int year = 0;
// int a = 0;//定义计数器
// for (year = 1000; year <= 2000; year++)
// {
// if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))//||逻辑或：两边满足一个即可
// {
// printf("%d ", year);
// a++;
// }
// }
// printf("\n闰年数为:%d\n", a);
//
// return 0;
// }
//-----打印100-200之间的素数----
//判断素数规则：1.试除法，产生2到i-1个数字
//素数：只能被1和本身整除的数
//int main()
//{
// int i = 0;
// int j = 0;
// int a = 0;//计数器
// for (i = 100; i <= 200; i++)
// {
// for (j = 2; j < i; j++)
// {
// if (i%j == 0)//判断2到i本身之间的数有无可整除的数
// {
// break;
// }
// }
// if (i == j)
// {
// a++;
// printf("%d ", i);
// }
// }printf("\n素数个数为：%d \n", a);
// return 0;
//}
//-------优化------
//如果i=a*b,那么a或者b中至少有一个数字小于等于开平方i
// int main()
//{
// int i = 0;
// int j = 0;
// int a = 0;//计数器
// for (i = 100; i <= 200; i++) //for(i=101;i<=200;i+=2) 因为偶数不可能是素数，直接跳过偶数
// { //在开平方i之前找就可以了
// for (j = 2; j <=sqrt(i); j++)//sqrt() 为非负实数平方根函数//是数学库函数
// {
// if (i%j == 0)
// {
// break;
// }
// }
// if (j>sqrt(i))
// {
// a++;
// printf("%d ", i);
// }
// }printf("\n素数个数为：%d \n", a);
//
// return 0;
//}
//--------作业：找出1-100所有含有9的数字-----
//int main()
//{
// int i = 0;
// int a = 0;//计数器
// for (i = 1; i <= 100; i++)
// {
// if (i % 10 == 9 )//说明个位为9
// {
// a++;
// printf("%d ", i);
// }
// else if (i / 10 == 9)//说明十位为9
// {
// a++;
// printf("%d ", i);
// }
// }
// printf("\n个数为：%d\n", a);
//
// return 0;
//}
//----分数求和；计算1/1-1/2+1/3-1/4+1/5.....+1/99-1/100的值-----
//int main()
//{
// int i = 0;
// double sum = 0.0;//求和结果采用浮点型存储
// int flag = 1;
// for (i = 1; i <= 100; i++)
// {
// sum += flag*1.0 / i;//要得到小数，要保证除号两端必须至少有一个浮点数
// flag = -flag;//改变正负符号
// }
// printf("%lf\n", sum);//打印浮点数要用%lf
//
// return 0;
//}
//-------求最大值：求10个整数中最大值------
//int main()
//{
// int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// int i = 0;
// int max = arr[0];//假设数组中第一个为最大值
// int sz = sizeof(arr) / sizeof(arr[0]);
// for (i = 1; i < sz; i++)
// {
// if (arr[i]>max)
// max = arr[i];
// }
// printf("max= %d\n", max);
//
// return 0;
//}
//-------乘法口诀，打印9*9乘法口诀----
//int main()
//{
// int i = 0;//行数
// for (i = 1; i <= 9; i++)//行数 打印9行
// {
// int j = 0;//列数
// for (j = 1; j <= i; j++)//有几行就打印几列
// {
// printf("%d*%d=%-2d ", i, j, i*j);//%2d 打印两位靠右对齐，%-2d 打印两位靠左对齐
// }
// printf("\n");//每行末尾回车
// }
//
// return 0;
//}
//------二分查找；在一个整形有序数组中查找某个数，找到打印下标，找不到打印：找不到------
//int main()
//{
// int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8,9,10 };
// int k = 0;
// printf("请输入要查找的值：");
// scanf("%d", &k);
// int sz = sizeof(arr) / sizeof(arr[0]);
// int right = sz-1;
// int left = 0;
// while (left <= right)
// {
// int mid = (left+right)/2;
// if (k > arr[mid])
// {
// left = mid + 1;
// }
// else if (k < arr[mid])
// {
// right = mid - 1;
// }
// else
// {
// printf("找到了下标为：%d\n", mid);
// break;
// }
// }
// if (left>right)
// printf("找不到\n");
//
//
// return 0;
//}
//-------猜数字游戏：1.电脑会生成一个随机数2.猜数字----------
// rand()需要调用#include <stdlib.h>头文件
//使用time()函数需要引用头文件#include <time.h>
//void menu()
//{
// printf("****************************\n");
// printf("***** 1.play 0.exit *****\n");
// printf("****************************\n");
//}
//void game()
//{
// //游戏本体
//
// int ret = 0;
// int guess = 0;//接收猜的数字
// //1.生成一个随机数，
// ret = rand() % 100 + 1;//把随机数限定到1-100之间，若不限定的范围为0-32767之间
// //rand()生成随机数函数，需要sranf（）函数设置随机起点
// //2.猜数字
// while (1)
// {
// printf("请猜数字：");
// scanf("%d", &guess);
// if (guess > ret)
// {
// printf("猜大了\n");
// }
// else if (guess < ret)
// {
// printf("猜小了\n");
// }
// else
// {
// printf("恭喜你，猜对了！\n");
// break;
// }
// }
//
//}
//
//
//int main() //时间戳：当前计算机的时间减去计算机的起始时间(1970年1月1日0时0分0秒)=(xxxxx)秒即为时间戳
//
//{
// int input = 0;
//// 强制转换为无符号整型
//// ↓
// srand((unsigned int)time(NULL));//在调用rand()函数生成随机数之前，需要使用srand()函数来为rand()函数设置随机数的起点，用时间戳作为srand函数的参数来设置随机数的生成起始点；注:随机数起点不要频繁设置，频繁设置随机效果不好，所以要放在循环外面
//// ↑ ↑
//// ↑ time()函数返回时间戳 ————> time(time_t*timer)函数 ； time()函数返回的值是time_t类型。
//// srand()函数的参数需为unsigned int即无符号整型 ↑ ↑
// do // time()函数的参数类型为time_t*的指针 time_t的本质是long长整型
// {
// menu();
// printf("请选择：");
// scanf("%d", &input);
// switch (input)
// {
// case 1:
// game();//进入到游戏
// break;
// case 0:
// printf("退出游戏\n");
// break;
// default:
// printf("选择错误\n");
// break;
// }
// }
// while (input);
//
// return 0;
//}
//*******************goto语句**********************
//适合的场景是多层循环内跳出
//int main()
//{
// again://要用冒号结尾!!!!!!
// printf("hello\n");
// goto again;//again相当于标记，执行进程跳转到标签处
// //----或者----
// printf("hello\n");
// goto a;
// printf("你好\n");//这里的作用是跳过本语句
//a:
// printf("hehe\n");
//
// return 0;
//}
//-*************自动关机程序*************************-
//sysem()函数需要头文件#include <stdlib.h>
//int main()
//{
// char input[20] = { 0 };
// system("shutdown -s -t 60");//sysem()是执行系统命令的函数//shutdown -s -t 60 是60秒关机的指令
//again:
// printf("你的电脑将在一分钟内关机，请输入：我是猪，以取消关机\n请输入:");
// scanf("%s", input);
// if (strcmp(input, "我是猪") == 0)//strcmp()比较两个字符串的函数
// {
// system("shutdown -a");
// }
// else
// {
// goto again;//用while(1)循环也可以实现
// }
//
//
// return 0;
//}
//----------或者用while实现----------
//int main()
//{
// char input[20] = { 0 };
// system("shutdown -s -t 60");//sysem()是执行系统命令的函数//shutdown -s -t 60 是60秒关机的指令
// while (1)
// {
// printf("你的电脑将在一分钟内关机，请输入：我是猪，以取消关机\n请输入:");
// scanf("%s", input);
// if (strcmp(input, "我是猪") == 0)//strcmp()比较两个字符串的函数
// {
// system("shutdown -a");
// break;
// }
// }
//
// return 0;
//}
//*********文档学习函数*****************
//int Add(int x, int y)
//{
// int z = x + y;
// return z;
//}
//int main()
//{
// int a = 100;
// int b = 200;
// int sum = 0;
// sum = Add(a, b);
// printf("sum=%d\n", sum);
//
// return 0;
//}
//--------strcpy函数-------------
//int main()
//{
// char arr1[] = "bit";
// char arr2[20] = "#######";//目的地要比源头长，否则会溢出
// strcpy(arr2, arr1);//string copy-字符串拷贝
// //将按源指向的 C 字符串复制到按目的地指向的数组中，包括终止空字符（并在该点停止）
// printf("%s\n", arr2);
// return 0;
//}
//---------memset-----------
//int main()
//{
// char arr[] = "hello word";
// memset(arr, '*', 5);//memset(要改变值的内存块，要设置成*，改变几个字节)
// printf("%s\n", arr);//结果***** word
// return 0;
//}
//-------------- 写一个函数可以找到两个整数中的最大值----
// //定义函数
//int get_max(int x, int y)//用x，y接收a，b
//{
// if (x > y)
// return x;
// else
// return y;
//}
//int main()
//{
// int a = 10;
// int b = 20;
// //函数的使用
// int max = get_max(a, b);//get_max获取a，b的最大值
// printf("max=%d\n", max);
// return 0;
//}
//---------自定义函数也可用数字做参数---
// //定义函数
//int get_max(int x, int y)//用x，y接收a，b
//{
// if (x > y)
// return x;
// else
// return y;
//}
//int main()
//{
// //函数的使用
// int max = get_max(100, 300);//get_max可直接比较数值
// printf("max=%d\n", max);
// return 0;
//}
//************写一个函数来交换两个整型变量的内容****
//-----正常交换-----
//int main()
//{
// int a = 10;
// int b = 20;
// int tmp = 0;
// printf("a=%d,b=%d\n", a, b);
// tmp = a;
// a = b;
// b = tmp;
// printf("a=%d,b=%d\n", a, b);
// return 0;
//}
//-----用函数封装---
//void Swap1(int x, int y)//此处只交换x,y,与a，b无关
//{
// int tmp = 0;
// tmp = x;
// x = y;
// y = tmp;
//}
//int main()
//{
// int a = 10;
// int b = 20;
// printf("a=%d,b=%d\n", a, b);
//调用Swap1函数（传值调用）
// Swap1(a, b);
// printf("a=%d,b=%d\n", a, b);
//
// return 0;//交换失败
//}
//------使用指针修正---
//void Swap2(int* pa, int* pb)//pa、pb是形参，当&a、&b传递过来时才分配内存
// //此时形参时实参的一份临时拷贝
// //无需返回值，所以用void
//{
// int tmp = 0;
// tmp = *pa;
// *pa = *pb;
// *pb = tmp;
//}
//int main()
//{
// int a = 10;
// int b = 20;
// printf("a=%d,b=%d\n", a, b);
// //调用Swap2函数（传址调用）
// Swap2(&a, &b);//&a、&b是实参
// printf("a=%d,b=%d\n", a, b);
// return 0;//交换成功
//}
//********练习**************
//----使用函数打印100-200之间的素数---
//int is_prime(int n)
//{
// int j = 0;
// for (j = 2; j < n; j++)
// {
// if (n%j == 0)//判断2到i本身之间的数有无可整除的数
// {
// return 0;
// }
// }
// if (n == j)
// {
// return 1;
// }
//}
//int main()
//{
// int i = 0;
// for (i = 100; i <= 200; i++)
// {
// //判断i是否为素数
// if (is_prime(i) == 1)
// printf("%d ", i);
// }
// return 0;
//}
//------优化-------
//int is_prime(int n)
//{
// int j = 0;
// for (j = 2; j <= sqrt(n); j++)
// {
// if (n%j == 0)//判断2到i本身之间的数有无可整除的数
// {
// return 0;
// }
// }
// if (j>sqrt(n))
// {
// return 1;
// }
//}
//int main()
//{
// int i = 0;
// for (i = 100; i <= 200; i++)
// {
// //判断i是否为素数
// if (is_prime(i) == 1)
// printf("%d ", i);
// }
// return 0;
//}
//-------写一个函数判断1000到2000年是不是闰年----
//int is_leap_year(int y)//函数的功能要单一独立，不要再函数内打印
//{
// if ((y % 4 == 0 && y % 100 != 0) || (y % 400 == 0))
// return 1;
// else
// return 0;
//}
//int main()
//{
// int year = 0;
// for (year = 1000; year <= 2000; year++)
// {
// //判断year是否为闰年
// if (1 == is_leap_year(year))
// {
// printf("%d ", year);
// }
// }
// return 0;
//}
//------写一个函数，实现一个整型有序数组的二分查找-----
//如果找到了返回这个数的下标，找不到返回-1
//函数内求参数数组的个数无法实现，需在外部求出
//int binary_search(int arr[], int k)//本质上arr是一个指针
//{
// int left = 0;
// int sz = sizeof(arr) / sizeof(arr[0]);//arr的大小是4个字节，arr[0]是四个字节，所以sz=1
// int right = sz - 1;
// while (left <= right)
// {
// int mid = (left + right) / 2;//中间元素的下标
// if (arr[mid] < k)
// {
// left = mid + 1;
// }
// else if (arr[mid]>k)
// {
// right = mid - 1;
// }
// else
// {
// return mid;
// }
// }
// return -1;//找不到的情况
//}
//int main()
//{
// int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// int k = 7;
// int ret = binary_search(arr, k);//传递过去的是arr数组首元素的地址，编译器防止空间浪费
// if (ret == -1)
// {
// printf("找不到指定的数字\n");
// }
// else
// {
// printf("找到了，下标是：%d\n", ret);
// }
// return 0;//找不到
//}
//-------修改---------
//int binary_search(int arr[], int k,int sz)
//{
// int left = 0;
// int right = sz - 1;
// while (left <= right)
// {
// int mid = (left + right) / 2;
// if (arr[mid] < k)
// {
// left = mid + 1;
// }
// else if (arr[mid]>k)
// {
// right = mid - 1;
// }
// else
// {
// return mid;
// }
// }
// return -1;//找不到的情况
//}
//int main()
//{
// int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// int k = 7;
// int sz = sizeof(arr) / sizeof(arr[0]);
// int ret = binary_search(arr, k,sz);//传递过去的是arr数组首元素的地址
// if (ret == -1)
// {
// printf("找不到指定的数字\n");
// }
// else
// {
// printf("找到了，下标是：%d\n", ret);
// }
// return 0;//找不到
//}
//-----写一个函数，每调用一次这个函数，就会将num的值增加1---
//void Add(int* p)
//{
// (*p)++;//*p++因为++优先级较高，作用于p
//}
//int main()
//{
// int num = 0;
// Add(&num);
// printf("num=%d\n", num);
// Add(&num);
// printf("num=%d\n", num);
// Add(&num);
// printf("num=%d\n", num);
// Add(&num);
// printf("num=%d\n", num);
// return 0;
//}
//---随便写的------
//void Add(int* p)
//{
// (*p)++;//*p++因为++优先级较高，作用于p
//}
//int main()
//{
// int num = 0;
// while (num < 5)
// {
// Add(&num);
// printf("num=%d\n", num);
// }
//
// return 0;//打印结果：5
//}
//********链式访问*********
//int main()
//{
// int len = 0;
// //第一种正常写法
// len = strlen("abc");
// printf("%d\n", len);
// //第二种，用链式访问
// printf("%d\n", strlen("abc"));
//
// return 0;
//}
//-----例子----
//int main()
//{ //printf函数编译成功后返回字符的个数
// printf("%d", printf("%d", printf("%d", 43)));
// //首先第一个执行的printf打印43，返回值为2
// //所以第二个执行的printf函数打印2，返回值为1
// //第三个执行的printf打印1，返回值为1
// return 0;//打印结果：4321
//}
//*******函数声明和定义***
// //函数声明 正确用法：函数声明放到头文件里，在头文件新建add.h文件
//int Add(int x, int y);
//
//int main()
//{
// int a = 10;
// int b = 20;
// int sum = 0;
// //函数的调用 正确用法：要使用Add函数只需包含头文件即可#include "add.h"
// //引用库函数用<>，引用自定义函数用""
// sum = Add(a, b);
// printf("%d\n", sum);
// return 0;
//}
// //函数的定义 正确用法：放到在源文件新建add.c的文件里
//int Add(int x, int y)
//{
// int z = x + y;
// return z;
//}
//********函数递归**********
//int main()
//{
// printf("hehe\n");
// main();
// return 0;//循环一段时间后报错：stack overflow栈溢出
//}
//-----练习接受一个整型值(无符号)，按照顺序打印它的每一位----
//void print(int n)//定义函数
//{
// if (n > 9)//如果是两位数以上就调用函数，一位数就跳出打印
// {
// print(n / 10);//拆除n的末位数字在递归调用函数//定义函数到此处相当于循环体
// }
// printf("%d ", n % 10);//一位数打印本身，多位数打印末位数
//}
//int main()
//{
// unsigned int num = 0;
// scanf("%d", &num);
// print(num);//调用函数
// return 0;
//}
//------编写函数不允许创建临时变量，求字符串的长度-----
//int my_strlen(char* str)//循环计数
//{
// int count = 0;//创建了临时变量，不符合要求
// while (*str != '\0')//遇到\0就停止计数
// {
// count++;//长度加一
// str++;//元素的地址后移一位
// }
// return count;
//}
//int main()
//{
// char arr[] = "bit";//数组元素包括b i t \0
// int len = 0;
// len = my_strlen(arr);//数组只能传递首元素的地址
// printf("len=%d\n", len);
// return 0;
//}
//------用递归改进-------
// //大事化小
// //my_strlen("bit");
// //1+my_strlen("it");
// //1+1+my_strlen("t");
// //1+1+1+my_strlen("");
// //1+1+1+0=3
//int my_strlen(char* str)// }
//{ // |→相当于循环体
// if (*str != '\0') // |
// return 1 + my_strlen(str + 1);// }
// else
// return 0;
//}
//int main()
//{
// char arr[] = "bit";
// int len = 0;
// len = my_strlen(arr);
// printf("len=%d\n", len);
// return 0;
//}
//******递归与迭代*********
//-----循环求n阶乘-------
//int Fac(int n)
//{
// int i = 0;
// int ret = 1;
// for (i = 1; i <= n; i++)
// {
// ret *= i;
// }
// return ret;
//}
//int main()
//{
// int n = 0;
// int ret = 0;
// scanf("%d", &n);
// ret = Fac(n);
// printf("%d\n", ret);
// return 0;
//}
//-----递归求n的阶乘------
//int Fac(int n)
//{
// if (n <= 1)
// return 1;
// else
// return n*Fac(n - 1);
//}
//int main()
//{
// int n = 0;
// int ret = 0;
// scanf("%d", &n);
// ret = Fac(n);
// printf("%d\n", ret);
// return 0;
//}
//----求第n个斐波那契数列------
//int Fib(int n)
//{
// if (n <= 2)
// return 1;
// else
// return Fib(n - 1) + Fib(n - 2);
//}
//int main()//斐波那契数列是前两个数字的和等于第三个数字
//{ //前两个数都是1
// int n = 0;
// int ret = 0;
// scanf("%d", &n);
// ret = Fib(n);
// printf("%d\n", ret);
// return 0;//效率太低
//}
//------用循环-----
//int Fib(int n)
//{
// int a = 1;
// int b = 1;
// int c = 1;
// while (n > 2)//必须知道前两个数才能算斐波那契数列，都为1
// {
// c = a + b;
// a = b;
// b = c;
// n--;//例n=4则需要循环求2两次，当n=4一次，当n=3一次
// }
// return c;
//}
//int main()
//{
// int n = 0;
// int ret = 0;
// scanf("%d", &n);
// ret = Fib(n);
// printf("%d\n", ret);
// return 0;//效率很高
//}
//********数组的创建和初始化********
//int main()//sizeof()和strlen()区别
//{
// char arr4[] = "abcdef";
// printf("%d\n", sizeof(arr4));//sizeof()计算的是arr4所占的空间的大小，针对变量、数组、类型的大小
// printf("%d\n", strlen(arr4));//strlen()求字符串长度，只针对字符串
// return 0;
//}
//-------一维数组的创建和初始化-----
//int main()//一维数组在内存中是连续存放的
//{
// int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// int sz = sizeof(arr) / sizeof(arr[0]);
// int i = 0;
// for (i = 1; i < sz; i++)
// {
// printf("&arr{%d}=%p\n", i, &arr[i]);
// }
// return 0;
//}
//********二维数组的使用*****
//int main()//第一行放123，第二行放45（用花括号括起来视作一个一维数组）
//{
// int arr[3][4] = { { 1, 2, 3 }, { 4, 5 } };
// int i = 0;
// for (i = 0; i < 3; i++)
// {
// int j = 0;
// for (j = 0; j < 4; j++)
// {
// printf("%d ", arr[i][j]);
// }
// printf("\n");
// }
// return 0;
//}
//-----存储--
//int main()
//{
// int arr[3][4] = { { 1, 2, 3 }, { 4, 5 } };
// int i = 0;
// for (i = 0; i < 3; i++)
// {
// int j = 0;
// for (j = 0; j < 4; j++)
// {
// printf("&arr[%d][%d]=%p\n",i,j, &arr[i][j]);
// }
// printf("\n");
// }
// return 0;
//}
//*****数组作为函数参数*******
//----实现一个冒泡排序函数将一个整型数组排序。----
//void bubble_sort(int arr[], int sz)
//{
// int i = 0;
// for (i = 0; i < sz - 1; i++)//确定冒泡排序的趟数
// {
// int j = 0;
// for (j = 0; j < sz - 1 - i; j++) //决定每一趟冒泡排序比较的次数//比较完一趟在从第一个数字比较
// { //sz-1-i减去最后面已经排好顺序的数字
// if (arr[j]>arr[j + 1])//比后一个数大就交换，比后一个数小就不变比较下一个
// {
// int tmp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = tmp;//排好序的数字都在最后面
// }
// }
// }
//}
//int main()
//{
// int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
// int i = 0;
// int sz = sizeof(arr) / sizeof(arr[0]);
// bubble_sort(arr, sz);//冒泡排序，对arr升序
// for (i = 0; i < sz; i++)
// {
// printf("%d ", arr[i]);
// }
// return 0;
//}
//----优化-----
//void bubble_sort(int arr[], int sz)
//{
// int i = 0;
// for (i = 0; i < sz - 1; i++)//
// {
// int flag = 1;//假设这一趟要排序的数据已经有序
// int j = 0;
// for (j = 0; j < sz - 1 - i; j++)
// {
// if (arr[j]>arr[j + 1])
// {
// int tmp = arr[j];
// arr[j] = arr[j + 1];
// arr[j + 1] = tmp;
// flag = 0;//本趟排序不完全有序
// }
// }
// if (flag == 1)//比较一趟之后有序，就跳出
// {
// break;
// }
// }
//
//}
//int main()
//{
// int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
// int i = 0;
// int sz = sizeof(arr) / sizeof(arr[0]);
// bubble_sort(arr, sz);//冒泡排序，对arr升序
// for (i = 0; i < sz; i++)
// {
// printf("%d ", arr[i]);
// }
// return 0;
//}
//------数组名------
//int main()
//{
// int arr[10] = { 1, 2, 3, 4, 5 };
// printf("%p\n", arr);//结果008FFC10
// printf("%p\n", &arr[0]);//结果008FFC10
// printf("%d\n", *arr);//结果1，根据地址解引用找到1
// return 0;
//}
//-----分辨----
//int main()
//{
// int arr[10] = { 1, 2, 3, 4, 5 };
// printf("%p\n", arr);//008FFA04第一个元素的地址
// printf("%p\n", &arr[0]);//008FFA04第一个元素的地址
// printf("%p\n", &arr);//008FFA04整个数组的地址，代表的是从首元素地址开始
// return 0;
//}
//----对比---
//int main()//分别加一可以证明他们的本质区别
//{
// int arr[10] = { 1, 2, 3, 4, 5, 6, 7 };
// printf("%p\n", arr);//00d3f900
// printf("%p\n", arr+1);//00d3f904 加了一个元素的4字节
//
// printf("%p\n", &arr[0]);//00d3f900
// printf("%p\n", &arr[0]+1);//00d3f904 加了一个元素的4字节
//
// printf("%p\n", &arr);//00d3f900
// printf("%p\n", &arr+1);//00d3f91c 加了一整个数组的4*7=28字节 ;1c=28
// return 0;
//}
//实现三子棋
//实现扫雷
//************操作符***********
//int main()//算术右移，右边丢弃，左边补原符号位
//{
// int a = -1;//负数按照补码的方式存储，正数存储的也是补码（正数的补码和原码相同）
// //1000000000000001-原码
// //1111111111111110-补码
// //1111111111111111-补码
// int b = a >> 1;//移位移的是内存中的二进制位
// printf("%d\n", b);
// return 0;//结果为-1，证明负数右移之后还是负数
//}
//----有除二的效果----
//int main()
//{
// int a = 16;
// int b = a >> 1;
// int c = a >> 2;
// printf("%d %d\n", b,c);//结果分别为8 4
// return 0;
//}
//-----左移-----
//int main()
//{
// int a = 5;
// int b = a << 1;
// printf("%d\n", b);
// return 0;//10
//}
//----负数---
//int main()
//{
// int a = -5;
// int b = a << 1;
// printf("%d\n", b);
// return 0;//-10
//}
//---注意---
//int num = 10;
//num >> -1;//错误
//*******&、|、^********
//int main()
//{
// //&按2进制位与
// int a = 3;
// int b = 5;
// int c = a&b;
// //011
// //101
// //001
// printf("%d\n", c);
// return 0;
//}
//---|---
//int main()
//{
// //|按2进制位或
// int a = 3;
// int b = 5;
// int c = a | b;
// //011
// //101
// //111
// printf("%d\n", c);//7
// return 0;
//}
//---^---
//int main()
//{
// //^按2进制位异或 相同为0，相异为1
// int a = 3;
// int b = 5;
// int c = a^b;
// //011
// //101
// //110
// printf("%d\n", c);
// return 0;
//}
//****编辑代码实现求一个整数存储在内存中的二进制中的1的个数***
//int main()
//{
// int num = 0;
// int count = 0;
// scanf("%d", &num);
// //统计num的补码中有几个1
// while (num)
// {
// if (num % 2 == 1)//判断末位是否为1
// count++;
// num = num / 2;//去掉判断过的末位
// }
// printf("%d\n", count);
// return 0;//但负数会出现问题
//}
//----优化-----
//int main()
//{
// int num = 0;
// int count = 0;
// scanf("%d", &num);//当num&1，比如num=3即0011，num&1即为0011&0001，末位为1时&1必定为1，末位是0&1必定是0
// int i = 0;
// for (i = 0; i < 32; i++)
// {
// if (1 == ((num >> i) & 1))
// count++;
// }
// printf("%d\n", count);
// return 0;
//}
//*****操作符****
//int main()
//{ // sizeof的()变量名时可以省略，类型时不可以省略
// int arr[10] = { 0 };
// printf("%d\n", sizeof(arr));//40//计算变量名和计算类型大小相同
// printf("%d\n", sizeof(int [10]));//40 数组去掉数组名即为类型
// printf("%d\n", sizeof(int [5]));//20 []内影响大小
// return 0;
//}
//int main()
//{
// short s = 0;
// int a = 10;
// printf("%d\n", sizeof(s = a + 5));//2
// printf("%d\n", s);//0
// return 0;
//}
//----~按位取反---
//int main()
//{
// int a = 0;
// //00000000000000000000000000000000 - 0的补码
// //取反
// //11111111111111111111111111111111 - 补码
// //11111111111111111111111111111110 - 反码
// //10000000000000000000000000000001 - 原码 即为-1
// printf("%d\n", ~a);
// return 0;
//}
//----~的应用------
//把1011的第三位改成1
//与0100或运算就可以了
//1111
//int main()
//{
// int a = 11;
// a = a | (1 << 2);
// //把1011的第三位改成1，或上一个0100
// //把0001向左移2位就得到了0100
// printf("%d\n", a);//这时a变成1111
// a = a & (~(1 << 2));
// //把1111的第三位改为0，与上一个1011
// //把0001向左移2位就得到了0100按位取反就得到了1011
// printf("%d\n", a);
// return 0;
//}
//----++和--的使用-----
//int main()
//{
// int a = 10;
// printf("%d\n", ++a);//++a语句之前变量a的值+1//前置++，先++后使用
// return 0;//11
//}
//int main()
//{
// int a = 10;
// printf("%d\n", a++);//a++语句之后变量a的值+1//后置++，先使用，再++ 10
// printf("%d\n", a);//11
// return 0;
//}
//****逻辑与或****
//int main()
//{
// int i = 0, a = 0, b = 2, c = 3, d = 4;
// i = a++ && ++b && d++;//a=0为假&&后面不计算，不运行//用后自加一
// printf("a=%d\n b=%d\n c=%d\n d=%d\n", a, b, c, d);
// return 0;//1 2 3 4
//}
//------
//int main()
//{
// int i = 0, a = 1, b = 2, c = 3, d = 4;
// i = a++ && ++b && d++;
// printf("a=%d\n b=%d\n c=%d\n d=%d\n", a, b, c, d);
// return 0;//2 3 3 5
//}
//------
//int main()
//{
// int i = 0, a = 1, b = 2, c = 3, d = 4;
// i = a++ || ++b || d++;//a=1为真||后面的不计算，然后自加一
// printf("a=%d\n b=%d\n c=%d\n d=%d\n", a, b, c, d);
// return 0;//2 2 3 4
//}
//****条件操作符****
//int main()
//{
// int a = 0;
// int b = 0;
// if (a > 5)
// b = 3;
// else
// b = -3;
// //用条件操作符来表示
// b = (a > 5 ? 3 : -3);
// return 0;
//}
//****逗号表达式*****
//a = get_val();
//count_val(a);
//while (a > 0)
//{
// //业务处理
// a = get_val();
// count_val(a);
//}
//----逗号表达式优化---
//while (a = get_val(), count_val(a), a > 0)
//{
// //业务处理
//}
//****结构体类型***
//创建一个结构体类型：struct Stu
//struct Stu
//{
// char name[20];//成员变量
// int age;
// char id[20];
//};
//int main()
//{
// int a = 10;
// //使用struct Stu这个类型创建了一个学生对象s1，并初始化
// struct Stu s1 = {"张三",20,"2019010305"};
// printf("%d\n", s1.age); //结构体变量.成员名//.操作符可以访问成员
// printf("%s\n", s1.id);
// struct Stu* ps = &s1;
// printf("%d\n", (*ps).age);
// printf("%d\n", ps->age);//结构体指针->成员名
// return 0;
//}
//********隐式类型转换***
//int main()
//{
// char a = 3;
// //00000000000000000000000000000011 正常一个整数所占32位
// //00000011这就是char a //但char只能存放一个字节，要发生截断，取低位一个字节
// char b = 127;
// //00000000000000000000000001111111 同理
// //01111111这就是char b
// char c = a + b;//计算时进行整型提升
// //00000000000000000000000000000011 //整型提升：高位补符号位
// //00000000000000000000000001111111 //整型提升：高位补符号位
// //00000000000000000000000010000010 a+b得到c，因为c是char类型要截断
// //10000010就是char c
// printf("%d\n", c);//要打印整型//整型提升：高位补符号位
// //11111111111111111111111110000010 - 补码//因为是负数，所以要求原码
// //11111111111111111111111110000001 - 反码
// //10000000000000000000000001111110 - 原码//-126
// return 0;
//}
//----应用---
//int main()
//{
// char a = 0xb6;//十六进制的b6，即10110110
// short b = 0xb600;
// int c = 0xb6000000;
// if (a == 0xb6)//运算要整型提升，提升之后就不等于0xb6
// printf("a\n");//不打印
// if (b == 0xb600)//同理
// printf("b\n");
// if (c == 0xb6000000)
// printf("c\n");
// return 0;
//}
//-----
//int main()
//{
// char c = 1;
// printf("%u\n", sizeof(c));//1
// printf("%u\n", sizeof(+c));//4//因为参与运算了所以提升成了整型
// printf("%u\n", sizeof(!c));//1
// return 0;
//}
//****自加和自减******
//int main()
//{
// int c = 2;
// int b = 0;
// b = c + --c;
// printf("%d %d\n", b,c);
// /*运行b = c + --c; 分析优先级：--c最高，所以b = --c + c
// 运算之前：因为--c，在运算之前使得变量c减一(2 - 1 = 1);此时c=1
// 运算之中：加c，因为c=1，所以1+1=2赋给b
// 运算之后：无*/
// return 0;//b=2 c=1
//}
//int main()
//{
// int i = 0;
// int j = i++ + ++i;//++i优先级高于i++，所以相当于int j=++i + i++; //此时i=0,1(此时i=1)+1(此时i=2)=2
// int k = --i + i--;//此时i=2,(此时i=1)1+1(此时i=0)=2
// printf("%d %d %d\n", i, j, k);
// /*当运行int j = i++ + ++i;
// 分析优先级：自加高于 + ，两个自加同级从左向右计算；其中++i的优先级比i++高，即变为
// int j = ++i + i++
// 运算之前：因为++i, 在运算之前使得变量i加一(0 + 1 = 1)；此时i = 1
// 运算之中：加上i++，因为是后置++，所以此时i仍然是1，所以为1 + 1 = 2赋值给j
// 运算之后：因为i++，在运算之后使得变量i加一(1 + 1 = 2)；此时i = 2
// 当运行int k = --i + i--;
// 运算之前：因为--i, 在运算之前使得变量i减一(2 - 1 = 1)；此时i = 1
// 运算之中：加上i--，因为是后置--，所以此时i仍然是1，所以为1 + 1 = 2赋值给j
// 运算之后：因为i--，在运算之后使得变量i减一(1 - 1 = 0)；此时i = 0*/
// return 0;//i=0 j=2 k=2
//}
//int main()
//{
// int i = 0;
// int j = i + i++;//此时i=0,0+0(此时i=1)=0
// printf("%d %d\n", i, j);
// /*运行int j = i + i++;
// 运算之前：无
// 运算之中：加上i++，因为是后置++，所以此时i仍然是0，所以为0 + 0 = 0赋值给j
// 运算之后：因为i++，在运算之后使得变量i加一(0 + 1 = 1)；此时i = 1*/
// return 0;//i=1 j=0
//}
//int main()
//{
// int i = 0;
// int j = i + ++i;//此时i=0,1+(此时i=1)1=2
// printf("%d %d\n", i, j);
// /*运行 int j = i + ++i;
// 分析优先级：自加高于 + ，即变为int j = ++i + i；
// 运算之前：因为++i, 在运算之前使得变量i加一(0 + 1 = 1)；此时i = 1
// 运算之中：加上i，此时i仍然是1，所以为1 + 1 = 2赋值给j
// 运算之后：无*/
// return 0;//i=1 j=2
//}
//****指针*****
//编号即为地址即为指针，存放指针的变量成为：指针变量
//int main()
//{
// int a = 10;
// int* pa = &a; //拿到的是a的四个字节中的第一个字节的地址
// *pa = 20;
// return 0;
//}
//int main()
//{
// printf("%d\n", sizeof(char*));//4
// printf("%d\n", sizeof(short*));//4
// printf("%d\n", sizeof(int*));//4
// printf("%d\n", sizeof(double*));//4
// return 0;
//}
//------
//int main()
//{
// int arr[10] = { 0 };
// int* p = arr;
// char* pc = arr;
// printf("%p\n", p);//004FFC40
// printf("%p\n", p+1);//004FFC44//加了一个整型4个字节
//
// printf("%p\n", pc);//004FFC40
// printf("%p\n", pc+1);//004FFC41//加了一个字符型1个字节
// return 0;
//}
//-------指针未初始化
//int main()
//{
// int* p;//p是一个局部的指针变量，局部变量不初始化的话，默认时随机值
// int* p = NULL;//不知道该初始化什么地址时先初始化为NULL，和int a=0；类似
// *p = 20;//非法访问内存了
// return 0;
//}
//-----指针访问越界
//int main()
//{
// int arr[10] = { 0 };
// int *p = arr;
// int i = 0;
// for (i - 0; i <= 11; i++)
// {
// //当指针指向的范围超过数组arr的范围时，p就是野指针
// *(p++) = i;
// }
// return 0;
//}
//------指针指向的内存空间释放
//int* test()
//{
// int a = 10;
// return &a;
//}
//int main()
//{
// int* p = test();
// *p = 20;
// return 0;
//}
//-----指针使用之前检查有效性
//int main()
//{
// int* p = NULL;
// /**p = 10;*///会报错，指针置为NULL时的内存用户不能对其进行操作
// //修改
// if (p != NULL)
// {
// *p = 10;
// }
// return 0;
//}
//
////*****指针的运算*****
//int main()
//{
//#define N_VALUES 5
// float values[N_VALUES];
// float *vp; //指针的关系运算
// for (vp = &values[0]; vp < &values[N_VALUES];)
// {
// *vp++ = 0;//指针+-整数
// }
// //************************
// for (vp = &values[0]; vp > &values[0];)
// {
// *--vp = 0;
// }
// //----------------
// for (vp = &values[N_VALUES-1]; vp >= &values[0];vp--)
// {
// *vp = 0;
// }
// return 0;
//}
// // 第二种写法应该尽量避免，不符合标准规定
// //标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的内存位置的指针比较，
// //但是不允许指向第一个元素之前的那个内存位置的指针进行比较。
////-----指针+-数字
//int main()
//{
// int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// int* p = arr;
// int*pend = arr + 9;
// while (p <= pend)
// {
// printf("%d\n", *p);
// p++;
// }
// return 0;
//}
////-----指针-指针----
// //指针相减的前提：两个指针指向同一块空间
//int main()//指针-指针得到的两个指针之间的元素个数
//{
// int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// printf("%d\n", &arr[9] - &arr[0]);
// return 0;
//}
//*******指针和数组**************
//int main()
//{
// int arr[10] = { 0 };
// int* p = arr;
// int i = 0;
// for (i = 0; i < 10; i++)
// {
// printf("%p <==> %p\n", &arr[i], p + i);//arr是首元素的地址，所以p+i就是这个数组下标为i的元素的地址
// }
// return 0;
//}
//-----打印出来
//int main()
//{
// int arr[10] = { 0 };
// int* p = arr;
// int i = 0;
// for (i = 0; i < 10; i++)
// {
// *(p + i) = i;
// }
// for (i = 0; i < 10; i++)
// {
// printf("%d", *(p + i));
// }//0 1 2 3 4 5 6 7 8 9
// return 0;
//}
//---拓展---
//int main()
//{
// int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
// int* p = arr;
// //[]是一个操作符 2和arr是两个操作数 a+b=b+a加法交换律
// //arr[2]<==>*(arr+2)<==>*(p+2)<==>*(2+p)<==>*(2+arr)==2[arr]
// //2[arr]<==>*(2+arr)
// printf("%d\n", 2[arr]);
// printf("%d\n", arr[2]);
// //本质arr[2]-->*(arr+2)-->*(2+arr)-->2[arr]
// return 0;//实际上都是地址
//}
//*****二级指针*****
//int main()
//{
// int a = 10;
// int* pa = &a;//pa是指针变量，一级指针//*表明是指针，int表明目标的类型
// //ppa就是一个二级指针变量
// int** ppa = &pa;//pa也是个变量，&pa取出pa在内存中起始地址//*表示是指针，int*表明目标的类型
// return 0;
//}
//********指针数组****
//int main()
//{
// int arr[10];//整型数组 - 存放整形的数组就是整型数组
// char ch[5];//字符数组 - 存放的是字符
// //指针数组 - 存放指针的数组
// int* parr[5];//整型指针的数组
// char* pch[5];//字符型指针的数组
// return 0;
//}
//
////****结构体****
//struct Stu //是个类型
//{
// //成员变量
// char name[20];
// int age;
// char id[20];
//}s1,s2;//这里创建的s1，s2也是结构体变量，是全局变量
//int main()
//{
// struct Stu s;//由struct Stu类型创建的s对象//s是局部变量
//
// return 0;
//}
//---------成员为其他结构体---------
//struct B
//{
// char c;
// short s;
// double d;
//};
//struct Stu //是个类型
//{
// //成员变量
// struct B sb;
// char name[20];
// int age;
// char id[20];
//}s1, s2;//这里创建的s1，s2也是结构体变量，是全局变量
//int main()
//{
// struct Stu s;//由struct Stu类型创建的s对象//s是局部变量
// struct Stu s = { { 'w', 20, 3.14 }, "张三", 30, "202005034" };//初始化
// //用.和->操作符访问成员
// printf("%c\n", s.sb.c);//打印W
//
// struct Stu* ps = &s;
// printf("%c\n", (*ps).sb.c);
// printf("%c\n", ps->sb.c);//ps是指针可以直接用->访问成员，sb不是指针所以要用.访问成员
// return 0;
//}
//----传值调用和传址调用的对比------
//struct B
//{
// char c;
// short s;
// double d;
//};
//struct Stu //是个类型
//{
// //成员变量
// struct B sb;
// char name[20];
// int age;
// char id[20];
//}s1, s2;//这里创建的s1，s2也是结构体变量，是全局变量
//void print1(struct Stu t)
//{
// printf("%c %d %lf %s %d %s\n", t.sb.c, t.sb.s, t.sb.d, t.name, t.age, t.id);
//}
//void print2(struct Stu* ps)
//{
// printf("%c %d %lf %s %d %s\n", ps->sb.c, ps->sb.s, ps->sb.d, ps->name, ps->age, ps->id);
//}
//int main()
//{
// struct Stu s = { { 'w', 20, 3.14 }, "张三", 30, "202005034" };//初始化
// //写一个打印函数打印s的内容
// print1(s); //传值调用 传参是会开辟空间，造成浪费性能下降
// print2(&s); //传址调用 仅仅传输地址，效率高 首选
// return 0;
//}
欢迎大家来到IT世界,在知识的湖畔探索吧!
免责声明：本站所有文章内容,图片，视频等均是来源于用户投稿和互联网及文摘转载整编而成，不代表本站观点，不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益，请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权，请联系删除，如若转载，请注明出处：https://itzsg.com/36949.html
