C语言知识点笔记及代码实现

#include<stdio.h>
#include<stdbool.h>
#include<malloc.h>
#include<time.h>
#include<string.h>
/*
int main() {
	int arry[1001] = { 0 };
	for (int i = 2; i <= 1000; i++) {
		if (arry[i] == 0) {
			printf("%d\n", i);
			for (int j = i + i; j <= 1000; j += i) {
				arry[j] = 1;
			}
		}
	}
}
*/
//for循环的break,continue
/*
int main() {
	int a, b;
	scanf("%", &a);
	for (b = 1; b <= 10; b++)
	{
		if (a > 8)
			break;//返回到第32行	printf("a=%d\n",a);
		if (a % 2 == 1)
		{
			a += 5;
			continue;//返回到第20行b++
		}
		a -= 3;
	}


	printf("a=%d\n",a);
	printf("b=%d",b);
}

*/


//------------------------------------------------------------------------------------------------数组 为了解决大量同类型的数据
//i从0开始
/*
int main()
{
	int a[5] = { 1,2,3,4,5 };
	int i;
	for (i = 0;i < 5; i++)
	{
		printf("%d\n", a[i]);


	}
	return 0;
}

*/
//完全初始化   int a[2]={1,2}   只有在定义数组的时候才可以整体赋值 
//错误;int a[5];
//    a[5] = { 1,2,3,4,5 };  就没有a[5]  不能把一组数赋值给一个变量呀
//不完全初始化  未被初始化的自动为0
//不初始化  所有元素是垃圾值
//清零  interesting a[2]={0}


//把a数组中的数全赋给b数组(有问题）
/*
int main() {
	int a[3] = { 1,2,3 };
	int b[3];
	int i;
	for ( i = 0; i < 3; i++)
	{
		b[i] = a[i];
	}
	printf("%d", b[i]);

}
*/


//倒置数组
/*
int main()
{
	int a[5] = { 1,2,3,4,5 };
	int i = 0;
	int j = 4;
	int t;
	while (i < j)
	{
		t = a[i];
		a[i] = a[j];
		a[j] = t;

		i++;
		j--;
	}
	for (i = 0; i < 5; i++)
	{
		printf("%d\n", a[i]);
		}

	return 0;

}
*/


//----------------------------------------------------------------------------------二维数组
//初始化  int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}三行四列

//输出二维数组的内容
/*
int main()
{
	int a[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
	int i, j;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 4; j++)
		{
			printf("%5d", a[i][j]);
		}
		printf("\n");
	}
}
*/

//多维数组，不存在多维，因为内存是线性一维的，n维数组可以当作每个元素是n-1维数组的一维数组

//-------------------------------------------------------------------------------------函数
/*
			避免了重复性操作
			有利于程序的模块化
什么叫函数：逻辑上：能够完成特定功能的独立的代码块
            物理上：能够接收数据（也可以不处理）
			        能够对数据进行处理
					能够将数据处理的结果返回（也可以不返回任何值)
		函数是一个工具，它是为了解决大量类似的问题而设计的

如何定义函数
			函数的返回值 函数名字（函数的形参列表）
			{
			函数的执行体
			}
    1.函数定义的本质是详细描述函数之所以能够实现某个特定功能的具体方法
	2.return的含义：
			终止被调用的函数，向主调函数返回表达式的值
			如果表达式为空，则只终止函数，不向主调用函数返回任何值
			break是用来终止循环和switch，return终止函数
			例子：
			void f()
			{
			return ;//终止函数  有void return后面就不加任何值

			}
			int f()
			{
			return 10//向主调函数返回表达式的值
			}
	3.函数返回值的类型称为函数的类型，最终函数返回值的类型以函数名前的返回值类型为准
	例子：
	int f()
	{
		return 10.5;//函数的返回值类型是int,所以返回的值是10而不是10.5；

	}


*/


/*
void max1(int i, int j)
{
	if (i > j)
	{
		printf("%d\n", i);
	}
	else
	{
		printf("%d\n", j);
	}

}
int max2(int i,int j)
{
	if(i>j)
	return i;
	else 
	return j;
}

int main()
{
	int a = 1, b = 2, c = 3, d = 4;
	max1(a, b);
	max1(c, d);
	printf("%d\n", max2(a, b));
	printf("%d\n", max2(c, d));
	return 0;
}
*/


//----------函数的分类
 //      有参函数   无参函数
//       有返回值     无返回值
//       库函数和用户自定义函数
//	    值传递函数和地址传递函数
//      普通函数和主函数（main)
//                一个程序必须有且只有一个主函数
//                主函数可以调用普通函数    普通函数不能调用主函数
//                普通函数可以相互调用
//                主函数是程序的入口，也是程序的出口

//     判断是否是素数
/*
int sushu(int i)
{
	int j;
	for (j = 2; j < i; j++)
	{
		if (i%j == 0)
		{
			break;
		}
		
	} 
	if(i==j)
		{
			printf("yes\n");
		}
		else
		{
			printf("no\n");
		}
}
int main()
{
	int a;
	scanf("%d", &a);
	sushu(a);
	return 0;
}
*/
/*
bool IsPrime(int i)//加头文件#include<stdbool.h>
{
	int j;
	for (j = 2; j < i; j++)
	{
		if(i%j==0)
		{
			break;
		}
	}
	if (i == j)
		return true;
	else
		return false;
	
}
int main(void)
{
	int a;
	scanf("%d", &a);
	if(IsPrime(a))
		printf("yes\n");
	else
	{
		printf("no\n");
	}
	return 0;
}

*/

//函数声明
//如果函数写在了函数定义的前面，则必须加函数前置声明

/*
void g(void)
{
	f();//这样不对，因为函数f的定义放在了调用f语句的后面，因此需要声明f
}
void f(void)
{
	printf("%哈哈\n");

}
int main(void)
{
	g();

}
*/
//函数声明：
//1.告诉即将可能出现的若干个字母代表的是一个函数
//2.告诉即将出现若干个字母所代表的函数的形参和返回值的类型
//3.对库函数的声明是通过#include<库函数所在的文件的名字.h>所实现的
//4.函数声明是一个语句，必须加分号；

//形参和实参
/*例子；
void f(int i, float j)//形参
{
	printf("hhh");

  }
int main()
{
	f(5, 4.5);//实参
	return 0;
}
	
//void f(void);// 加上函数声明
*/

//如何合理设计函数

//求1到某个数之间所有的素数
     //可重用性不高
/*
bool  TotalPrime(int i)
{
	int j;

	for (j = 2; j < i; j++)
	{
		if (i%j == 0)
		{
			break;
		}
	}
	if (i == j)
		{
			return true;
		}
		else
		{
			return false;
		}

}
int main()
{
	int n;
	int i, j;
	scanf("%d", &n);
	for (i = 2; i< n; i++) {
		if (TotalPrime(i))
		{
			printf("%d\n",i);
		}
	}
}

*/


//把函数模块化
/*
bool  TotalPrime(int i)//判断是否是素数
{
	int j;

	for (j = 2; j < i; j++)
	{
		if (i%j == 0)
		{
			break;
		}
	}
	if (i == j)
	{
		return true;
	}
	else
	{
		return false;
	}

}

void Travel(int m)//把1到n之间所有素数在显示器上输出
{
	int i;
	for (i = 2; i < m; i++) {
		if (TotalPrime(i))
		{
			printf("%d\n", i);
		}
	}

}

int main()
{
	int n;
	scanf("%d", &n);
	Travel(n);
}


*/
//常用的系统函数：
/*
double sqrt(double x);//求x的平方根
int abs(int x);//绝对值
double fabs(double x);//绝对值
*/
//变量的作用域和存储方式
//			按作用域分：
//			全局变量:在所有函数外部定义的变量叫全局变量
//          全局变量使用范围：从定义位置开始到整个程序结束
//			局部变量：在一个函数内部定义的变量或者函数的形参
				/*
				void f(int i)
				{
				int j=10;
				}
				i,j都是局部变量
		   局部变量使用范围：只能在本函数内部使用
				*/
//全局变量和局部变量命名冲突的问题:
//			在一个函数内部如果定义的变量名和全局变量名一样，那么局部变量会屏蔽全局变量


//------------------------------------------------指针
/*
int main() 
{
	int* p;//p是变量的名字，int* 表示p变量存放的是int类型变量的地址
	int i=3;
	p = &i;
	printf("%d\n", p); //p存放了变量i的地址
	printf("%d", *p);//*p就是变量i的值，p指向了i

}
//指针就是地址，地址就是指针
//指针变量是存放地址的变量
*/
/*
int main()
{
	int* p;
	int* q;
	int i = 9;
	p = &i;
	//*q = p;//error 类型不一致不能把地址赋给int *
	p = q;//q是垃圾值，p也变为垃圾值

	//*q = *p;//error

	//*p = i;//true
	printf("%d", *q);
	return 0;
}
*/
//互换
/*
void change(int *p, int *q) 
{
	int t;
	t = *p;
	*p = *q;
	*q = t;
	return;
}
int main()
{
	int a = 2;
	int b = 3;
	change(&a, &b);
	printf("a=%d,b=%d", a, b);
	return 0;
}

*/
//* 的含义：
//	1.乘法
//	2.定义指针变量：
//              int *p;定义了一个名字叫p的变量，
//              int *表示p只能存放int变量类型的地址
//	3.指针运算符：该运算符放在已经定义好的指针变量的前面，如果p是一个已经定义好的指针变量，
//则*p表示 以p的内容为地址的变量
//改变值
/*
void alter(int*p, int* q)
{
	*p = 1;
	*q = 4;
	return;
}

int main()
{
	int a = 2;
	int b = 3;
	alter(&a, &b);
	printf("%d %d ", a, b);
	return 0;
}
*/
//指针和一维数组
//一维数组名是指针常量，存放的是一维数组第一个元素的地址
/*
int main(void)
{
	int a[5];//a是数组名     0--4
	//int b[2][3];//b[0][0]是第一个元素，b[i][j]第i+1行j+1列
	int b[5];
	///a = b;//error a是常量
	printf("%d\n%d", &a[0],a);//17825400  17825400
}
*/

//确定一个一维数组需要2个形参：首元素的地址，数组的长度

//输出一维数组的内容(指针可以快速的传送数据）

/*

void f(int* pArr,int len)
{
	int i;
	for (i = 0; i < len; i++)
		printf("%4d", *(pArr + i));//*(pArr + i)=pArr[i]=a[i]
	printf("\n");
	pArr[3] = 88;
	return;
}
int main()
{
	int a[5] = { 1,2,3,4,5 };
	int b[5] = { -1,-2,-3,-4,-5 };
	int c[100] = { 1,99,22,33 };
	f(a,5);
	f(b, 5);
	f(c, 100);
	printf("%d", a[3]);//88   a[i]=*(a+i)
	return 0;
}

*/
//指针变量只能相减（两个指针变量指向的是同一块连续空间中的不同存储单元）
/*
int main(void ) {
	int i = 3;
	int j = 9;
	int *p;
		p= &i;
	int *q;
		q= &j;
	printf("p和q所指向的单元相隔%d个单元\n", p - q);//p和q所指向的单元相隔3个单元(编译器)
	printf("&p=%d\n", &p);// &p = 11533876	
	printf("&q=%d\n", &q);//& q = 11533864
	printf("p和q所指向的单元相隔%d个单元\n",& p - &q);
	int a[5];
	p = &a[1];
	q = &a[4];
	printf("&a[0]=%d\n", &a[0]);// &a[0] = 8517384
	printf("&a[1]=%d\n", &a[1]);// &a[1] = 8517388
	printf("&a[2]=%d\n", &a[2]);// &a[2] = 8517392
	
	printf("p和q所指向的单元相隔%d个单元", p - q);//p和q 所指向的单元相隔-3个单元

}
*/
/*
一个指针变量到底占几个字节
sizeof(数据类型）：返回值是该数据类型所占的字节数
sizeof(变量名）：返回值是该变量所占的字节数
假设p指向char类型变量(1个字节)
假设d指向int类型变量(4个字节)
假设r指向double类型变量(8个字节)
p q r本身所占的字节数是否一样:是
总结：一个指针变量无论它指向的变量占几个字节，该指针本身只占4个字节（x86)     8个（x64)
无论64位还是86位，int char double 均占字节    4   1   8
*(arry+i)==arry[i];
*/


/*
int main()
{
	int a=99;//4
	char b = 'A';//1
	double c = 88.8;//8
	char* p = &b;//p指向b
	int* q = &a;
	double* r = &c;

	printf("sizeof(p)=%d   sizeof(q)=%d   sizeof(r)=%d\n", sizeof(p), sizeof(q), sizeof(r));//4  4  4
	
	char* m;
	m = &b;

	printf("sizeof(m)=%d\n", sizeof(m));//4
	
	printf(" sizeof(a)=%d   sizeof(b)=%d   sizeof(c)=%d\n", sizeof(a), sizeof(b), sizeof(c));//4   1   8

}

*/


//--------------------------------动态内存分配
/*
一、传统数组的缺点：
  1.数组长度必须事先确定，且只能是常整数，不能是变量
		  例子：
		  int a[5];//ok
		  int len=5;inta[len];//error
  2.传统形式定义的数组，该数组的内存无法手动释放
  数组一旦定义，系统为该数组分配的存储空间就会一直存在，直到该函数运行完毕时，数组的空间才会被系统释放
  3.数组的长度不能再函数运行的过程中动态的扩充或缩小
    数组的长度一旦被定义，长度就不能被改变了
  4.A 函数定义的数组，在A函数运行期间可以被其他函数使用，
    但A函数运行完毕后，A函数中的数组将无法再被其他函数使用

    
二、为什么需要动态分配内存
		动态数组很好的解决了传统数组（静态数组）的4个缺陷
		int main()
{
	int i = 5;//分配4个字节，静态
	int* p = (int *)malloc(4);
	p = &i;

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

		//1.要使用malloc函数，必须添加malloc.h头文件
		//2.malloc函数只有一个形参，并且形参是整形
		//3.4表示请求系统为本程序分配4个人字节
		//4.malloc 函数只能返回第一个字节的地址
		//5.一共分配了8个字节,p变量占4，p指向的内存也占4
		//6.p本身所占的内存是静态分配的，p所指向的内存是动态分配

	free(p);//表示把p所指向的内存给释放掉,p本身的内存是静态的，p本身的内存只能在p变量所在的函数运行终止时由系统自动释放
	printf("%hello world");//error
}

例子：改变动态数组定义的数值

void f(int *q)
{
	*q = 200;
	//free(q);//error必须注释掉，不然会导致printf("%d\n", *p);出错
	return;
}
int main()
{
	int* p = (int *)malloc(sizeof(int)); //sizeof(int)的返回值是int所占的字节数
	*p = 10;
	printf("%d\n", *p);//10
	f(p);
	printf("%d\n", *p);//200
	return 0;

}
三、动态内存分配举例，动态数组的构造
int main()
{
	//int a[5];//该数组包含20个字节

	//动态构造一维数组
	int len;
	int* pArr;
	printf("%请输入要存放的元素的个数：");
	scanf("%d", &len);
	pArr = (int *)malloc(4 * len);//***动态的构造了一个一维数组，长度len,每个元素是int ,类似与int pArr[len]
	//动态的对一维数组赋值

	int i;
	for (i = 0; i < len; i++)
	{
		scanf("%d",& pArr[i]);
	}
	//输出一维数组
	printf("%一维数组的内容为：\n");
	for (i = 0; i < len; i++)
	{
		printf("%d\n", pArr[i]);

	}
	int n;
	scanf("%d", &n);


	//重新分配空间
	realloc(pArr, n);
	int j;
	for (j = 0; j< n; j++)
	{
		scanf("重新分配空间=%d", &pArr[j]);
	}
	//输出一维数组
	printf("%一维数组的内容为：\n");
	for (j = 0; j < n; j++)
	{
		printf("%d\n", pArr[j]);

	}
	//free(pArr);//释放掉动态分配的数组
	return 0;
}

四、静态内存和动态内存的比较
  静态内存是由系统自动分配，由系统自动释放
  静态内存是在栈分配的

  动态内存是由程序员手动分配，手动释放
  动态内存是在堆分配的

五、跨函数使用内存的问题
//静态

void f(int** q)
{
	int i = 5;
	*q = &i;  //*q=&i;等价于  p=&i
}
int main()
{
	int *p;
	f(&p);
	printf("%d\n", *p);//语法没错，但逻辑有问题
}



//动态
void  f(int** q)
{
	*q = (int*)malloc(sizeof(int));
	**q = 5;
}
int main()
{
	int * p;
	f(&p);
	printf("%d", *p);
	return 0;
}

*/

//多级指针
/*
int f(int **ppp)
{
	//*q就是p
	**ppp = 100;
	
	return;
}
int  g(int *pp)
{
	int **n = &pp;
	f(n);
}
int main()
{
	int i = 10;
	int* p = &i;
	printf("%d\n", *p);//10
	g(p);
	printf("%d\n", *p);//100
	return 0;
	
}

*/
//627求s = 1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)的值
/*
int main()
{
	int i;
	int sum = 0;
	int total=0;
	int n;
	scanf("%d", &n);
	for (i = 1; i <= n; i++)
	{
		
		sum = sum + i;
		total = sum + total;
		
	}
	printf("%d\n", total);
	return 0;
}
*/


//625质数（prime number）又称素数，有无限个。质数定义为在大于1的自然数中，除了1和它本身以外不再有其他因数，这样的数称为质数。
/*
int main()
{
	int n;
	scanf("%d", &n);
	int i;
	for (i = 2; i < n; i++)
	{
		if(n%i==0)
		{
			break;
		}
	}
	if (n == i)
	{
		printf("1");
	}
	else
	{
		printf("0");
	}
}


*/
//631股神：假设买入1元股票，股票的变化规律是第一天不变（0），第二天涨1元（1），第三天跌1元（ - 1），

//第四天涨1元（1），第五天涨1元（1），第六天跌1元（ - 1），第七天涨1元（1），第八天涨1元（1），
//第九天涨1元（1），第十天跌1元（ - 1）...求N天后的股票剩余价格
/*
int main()
{
	int n = 0;
	scanf("%d", &n);
	int x = 0;
	int s = 3;
	int i = 3;
	while (s <= n)
	{
		x++;
		s += i++;

	}
	printf("%d", n - 2 * x);
	return 0;
}
*/

//
/*
632一条长廊里依次装有n(1 ≤ n ≤ 65535)盏电灯，从头到尾编号1、2、3、…n-1、n。

每盏电灯由一个拉线开关控制。开始，电灯全部关着。

有n个学生从长廊穿过。第一个学生把号码凡是1的倍数的电灯的开关拉一下；

接着第二个学生把号码凡是2的倍数的电灯的开关拉一下；

接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；

如此继续下去，最后第n个学生把号码凡是n的倍数的电灯的开关拉一下。

n个学生按此规定走完后，长廊里电灯有几盏亮着。

注：电灯数和学生数一致
*/
/*
int main()
{
	int n;
	scanf("%d",&n);
	int i = 1;
	while (i*i <= n)
	{
		i++;
	}
	printf("%d", i - 1);
	return 0;
}
*/

//打印随机数
/*
void printfArray(int arr[], int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d", arr[i]);
	}
	printf("\n");
}



int main()
{
	srand(time(0));
	int arry[11] = { 0 };
	for(int i=0;i<11;i++)
	{
		arry[i] = i + 1;
	}
	for (int i = 0; i < 11; i++)
	{
		int r = rand() % 11;
		int t = arry[i];
		arry[i] = arry[r];
		arry[r] = t;
	}
	printfArray(arry, 5);
	return 0;
}
*/
//650
/*
定义一个int型的一维数组，包含10个元素，分别赋值

1)然后将数组中的元素都向前移一个位置，最后一个位置放的是第一个元素

2)然后将数组中的元素都向后移一个位置，第一个位置放的是最后一个元素
1 2 3 4 5 6 7 8 9 10


2 3 4 5 6 7 8 9 10 1
1 2 3 4 5 6 7 8 9 10
*/
/*
void printfArry(int *arry, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arry[i]);
	}
	printf("\n");
}
int main()
{
	//定义一个数组
	int arry[10];
	int i;
	for (i = 0; i < 10; i++)
	{
		scanf("%d", &arry[i]);

	}
	//每一个向前移一位
	int t = arry[0];
	for (i = 0; i < 9; i++)
	{
		arry[i] = arry[i + 1];
	}
	arry[9] = t;//第一个赋给第10个

	printfArry(arry, 10);//打印
	//每一个向后移一位
	for (i = 8; i >= 0; i--)
	{
		arry[i + 1] = arry[i];

	}
	arry[0] = t;//第十个赋给第一个
	printfArry(arry, 10);//打印
	return 0;
}
*/

//654求1000以内的素数


//-----------------------------------------结构体
/*
 1.为什么需要结构体
	为了表示一些复杂的事物，而普通的基本类型无法满足实际要求
2.什么是结构体
	把一些基本类型数据组合在一起组成的一个新的复合数据类型
3.如何定义结构体
					//第1种方式，只是定义了一个新的数据类型，并没有定义变量

					struct student1
					{
						int age;
						float score;
						char sex;
					};
					//第2种方式
					struct student2
					{
						int age;
						float score;
						char sex;
					}st2;//定义变量
					//第3种方式
					struct 
					{
						int age;
						float score;
						char sex;
					}st3;


4.怎样使用结构体变量
赋值和初始化
				struct student
				{
					int age;
					float score;
					char sex;
				};
				int main()
				{
					struct student st1 = { 19,100,'F' };//整体赋值
					struct student st2;//单个赋值
					st2.age = 19;
					st2.score = 99;
					st2.sex = 'M';
					printf("%d %.2f %c\n", st1.age, st1.score, st1.sex);
					printf("%d %.2f %c\n", st2.age, st2.score, st2.sex);
					return 0;
				}
如何取出结构体变量中的每一个成员
			1. 结构体变量名.成员名
			2. 指针变量名->成员名

			 pst->age 的含义：pst所指向的那个结构体变量中的age 这个成员
 

 struct student
{
	int age;
	float score;
	char sex;
};
int main()
{
	struct student st1 = { 19,100,'F' };//整体赋值
	struct student st2;//单个赋值
	st2.age =21;
	st2.score = 99;
	st2.sex = 'M';
	struct student st3;
	struct student *pst=&st3;//指针
	pst->age = 20;//pst->age会被转化成（*pst).age,等价于st1.age
	pst->score = 98;
	pst->sex = 'F';
	printf("%d %.2f %c\n", st1.age, st1.score, st1.sex);
	printf("%d %.2f %c\n", st2.age, st2.score, st2.sex);
	printf("%d %.2f %c\n", pst->age, pst->score, pst->sex);
	return 0;

}

结构体变量的运算:结构体变量不能相加减，乘除
但是可以赋值

struct Student 
{
int age;
char sex;
char name[100];
};
sturct Student st1,st2;
st1+st2 st1*st2 st1/st2//都是错的
st1=st2//是对的


结构体变量和结构体变量指针作为函数参数传递的问题

							struct Student
							{
								int age;
								char sex;
								char name[100];
							};

							void InputStudent(struct Student* stu);//声明
							void OutputStudent(struct Student ss);


							 int main(void)
							{
								struct Student st;
								InputStudent(&st);//对结构体变量输入
							//	printf("%d %c %s\n", st.age, st.sex,st.name);
								OutputStudent(st);//对结构体变量输出

								return 0;

							}

							 void InputStudent(struct Student* pstu)//pstu占4个字节
							 {
								 (*pstu).age = 22;
								 strcpy(pstu->name, "张三");
								 pstu->sex = 'F';
							 }
							void OutputStudent(struct Student ss)
							 {
								 printf("%d %c %s\n", ss.age, ss.sex, ss.name);
							 }


							 /*本函数无法修改主函数st的值
							 void InputStudent(struct Student stu)
							{
								stu.age = 10;
								strcpy(stu.name,'张三');//不能写成syu.name='张三'
								stu.sex = 'F';


							}
							 */


//通过函数完成对结构体的输入和输出
/*
指针的优点：
		快速的传递数据
		耗用内存小
		执行速度块


						struct Student
						{
							int age;
							char sex;
							char name[100];
						};

						void InputStudent(struct Student* );//声明
						void OutputStudent(struct Student* );


						 int main(void)
						{
							struct Student st;
							InputStudent(&st);//对结构体变量输入
						//	printf("%d %c %s\n", st.age, st.sex,st.name);
							OutputStudent(&st);//对结构体变量输出

							return 0;
	
						}
 
						 void InputStudent(struct Student* pstu)//pstu占4个字节
						 {
							 (*pstu).age = 22;
							 strcpy(pstu->name, "张三");
							 pstu->sex = 'F';
						 }
						void OutputStudent(struct Student* pst)
						 {
							 printf("%d %c %s\n", pst->age, pst->sex, pst->name);
						 }


						 /*本函数无法修改主函数st的值
						 void InputStudent(struct Student stu)
						{
							stu.age = 10;
							strcpy(stu.name,'张三');//不能写成syu.name='张三'
							stu.sex = 'F';


						}
						 */

//冒泡排序
/*动态冒泡

				int main()
				{
					int len;
					int* pArr;
					printf("请输入要存放的元素的个数：");
					scanf("%d", &len);
					pArr = (int *)malloc(4 * len);
					//动态的对一维数组赋值

					int i,j;
					for (i = 0; i < len; i++)
					{
						scanf("%d", &pArr[i]);
					}

	
					//输出一维数组
					printf("一维数组的内容为：\n");
					for (i = 0; i < len; i++)
					{
						printf("%d ", pArr[i]);
		
					}
					printf("\n");

					//排序
					int t;
					for ( i = 0; i < len-1; i++)
					{
						for ( j = 0; j < len - 1-i; j++)
						{
							if (pArr[j] > pArr[j + 1])
							{
								t = pArr[j];
								pArr[j] = pArr[j + 1];
								pArr[j + 1] = t;
							}
						}
					}

					printf("排序后的数组为：\n");
					for (i = 0; i < len; i++) 
					{
						printf("%d ", pArr[i]);
					}
	
					return 0;
				}
*/
					/*函数方法
					void sort(int*, int);
					int main()
					{
						int a[6] = { 12,23,21,45,6 };
						int i = 0;
						sort(a, 5);
						for (i = 0; i < 5; i++)
						{
							printf("%d ", a[i]);
						}
						printf("\n");
						return 0;
					}

					void sort(int* a,int len)
					{
						int i, j, t;
						for (i = 0; i < len - 1; i++)
						{
							for (j = 0; j < len - 1 - i; j++)
							{
								if (a[j] > a[j + 1]) {
									t = a[j];
									a[j] = a[j + 1];
									a[j + 1] = t;
								}

							}
						}
					}

					*/
//动态构造存放学生信息的结构体数组，然后按照分数排序输出
/*
struct Students
{
	char name[100];
	int age;
	float score;
};


int main()
{
	int len;	
	printf("请输入要录入的学生的个数len: ");
	scanf("%d", &len);

	struct Students * pArr;
	pArr = (struct Students *)malloc(len*sizeof(struct Students));
	int i;
	for (i = 0; i < len; i++)
	{
		printf("请输入第%d个学生的信息:\n",i+1);
		printf("name= ");
		scanf("%s", pArr[i].name);//name是数组名，本身已经是数组首元素的地址

		printf("age= ");
		scanf("%d", &pArr[i].age);

		printf("score= ");
		scanf("%f", &pArr[i].score);

	}
	//按学生成绩升序
	int j;
	struct Students t;
	for (i = 0; i < len - 1; i++)
	{
		for (j = 0; j < len - 1 - i; j++)
		{
			if (pArr[j].score > pArr[j+1].score)
			{
				t = pArr[j];
				pArr[j] = pArr[j + 1];
				pArr[j + 1] = t;
			}
		}
	}
	//输出
	for (i = 0; i < len; i++)
	{
		printf("第%d个学生的信息是：\n",i+1);
		printf("name=%s\n",pArr[i].name);
		printf("age=%d\n", pArr[i].age);
		printf("score=%f\n", pArr[i].score);
	}

	return 0;
}


*/

/*
#pragma pack(2)
typedef struct Student
{
	int number;
	char sex;
	char res[3];

}student;
#pragma pack()
int main()
{
	student st[10] = { {1,'F','ab'},{2,'M','abc'},{3,'F',"aaa"} };
	st[0].sex = 'F';
	printf("%d %c %s", st->number, st->sex, st->res);
	return 0;
}
*/


//枚举

/*
enum Weekday
{
	Monday,Tuesday,Wednesday,Tursday,friday,saturday,sunday
};
int main()
{
	enum Weekday day = Tuesday;
	printf("%d", day);
	return 0;
}

*/

//补码
/*
原码：也叫 符号-绝对值码
	最高位0表示正，0表示负 其余二进制位是该数字的绝对值的二进制位
	原码简单易懂，但加减运算复杂
	0表示不唯一

反码：运算不便，也没有在计算机中应用

移码：表示数值平移n位，n称为移码量，主要用于浮点数的阶码的存储

补码：
	十进制转二进制
		正整数转二进制：除2取余，直到商为0，余数倒叙排序
		负整数转二进制：先求与该负数相对应的正整数的补码，然后将所有位取反，末尾加1，不够位数时，左边补1
		（-3）  011——100--101——1111111111111111111111111111 101
		int main()
		{
			int i = -3;
			printf("%#X\n", i);//FFFFFFFD
			return 0;
		}
		0转二进制:全是0
	二进制转十进制：
		如果首位是0，则表示是正整数，按普通方法来求
		如果首位是1，则表示是负整数，
			将所有位取反，末尾加1，所得数字就是该负数的绝对值
		如果全是0，则对应的十进制数字是0

int 类型的变量所能存储的最大正数用十六进制：7FFFFFFF

		

*/

/*
int main()
{
	char c = '\n';
	c = '\'';
	printf("%c", c);
	c = '\t';

	c = '\\';
	printf("%c", c);
	c = '\a';
	printf("%c", c);
	return 0;

}

*/
//"xxx"表示的是字符串首个字符的地址
//为什么char* 存储字符串
/*
int main()
{
	char* p = "abcdef";
	printf("%d ", sizeof(char));//1在遍历字符串的时候指针变量偏移一个字节

	p++;//p=p+1*sizeof(char)
	printf("%c", *p);//b
	return 0;
}
*/
//计算字符串的长度
/*
int main()
{

	char* p = "\\\a\0\n\012a0";
	printf("%d ", sizeof(p));//4
	printf("%d ", sizeof("\\\a\0\n\012a0"));//8
	//           \\  \a  \0 \n \012 1 0 \0

	char c = '/012';
	printf("%d ", c);//50

	int n = strlen(p);
	printf("%d ", n);//2



	char* q = "\\\\\a\0\n\012a0\\\a\s";
	printf("%d ", sizeof(q));//4
	printf("%s ", q);//有响声  输出\
	printf("%d ", sizeof("\\\a\0\n\012a0\\\a\s"));//11
	int m = strlen(q);
	printf("%d ", m);//3输出\,\,\a


	return 0;
}


*/

/*
void myprintf(char* p)
{
	while (*p != '\0')
	{
		putchar(*p);
		p++;
	}
}
int main()
{
	char* p = "abcdef";
	myprintf(p);//abcdef
	return 0;
}

*/











































//最大最小
/*
int main() {

		int n = 0;
		scanf("%d", &n);
		int i;
		int arry[100] = { 0 };
		for (i = 0; i < n; i++) {
			scanf("%d", &arry[i]);//35 17 2 56 2 5 30 2
		}
		int max = arry[0],min = arry[0];

		for (i = 0; i < n; i++) {
			if (max < arry[i]) {
				max = arry[i];//35 56
			}
			if (min > arry[i]) {
				 min=arry[i];//17  2
			}
		}
		printf("最大值 %d\n", max);

		printf("最小值 %d\n", min);
		return 0;
	}
	*/                
/*int main() {
	int n = 0;
	scanf("%d", &n);
	int  arry[100] = { 0 };
	int i;
	for (i = 0; i < n; i++) {
		scanf("%d", &arry[i]);
	}
	for (i = 0; i < n; i++) {
		if (arry[i] % 2 != 0) {
			printf("%d ", arry[i]);
		}

	}

}
*/
/*int main() {
	int n = 0;
	scanf("%d", &n);
	int arry[100] = { 0 };
	for (int i = 0; i < n; i++) {
		scanf("%d", &arry[i]);
	
	}
	int sum = 0;
	for (int i = 0; i < n; i++) {
		sum += arry[i];
	}
		printf("%.2f",(float)sum /n);
		return 0;
	
}*/
/*#include<stdlib.h>
#include<time.h>
void printfArray(int arry1[], int n) {
	//for (int i = 0; i < n; i++) {
		//printf("%d", arry1[i]);//arry1[i]==*(arry1+i)
	printf("%d", );

	}
}
int main() {
	srand(time(0));
	int arry1[6] = { 1,2,3,4,5,6 };
	int n = sizeof(arry1)  / sizeof(int);
	int r = rand()% 11 + 1;
	printfArray(arry1, n);
	return 0;


}*/
/*int main() {
	int n = 0;
	scanf("%d", &n);
	int i = 1;
	while (i*i < n) {
		i++;

	}
	printf("%d", i - 1);
	return 0;
}*/
/*int main() {
	int n = 0;
	scanf("%d", &n);
	int x = 0;
	int s = 3;
	int i = 3;
	while (s <= n) {
		x++;
		s += +i++;
	}
	printf("%d", n - 2 * x);
	//return 0;
}
*/
/*int main() {
	int n=0;
	scanf("%d", &n);
	int i = 0;
	for (int i = 2; i < n; i++) {
		if (n % i == 0) {
			printf("0");
			return 0;
		}
	}	
			printf("1");
			return 0;
	return 0;
}
*/
/*int main() {
	int n=0, sum=0, s=0;
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		
		sum = sum + i;
		s = s + sum;
	}
	printf("%d", s);
}*/
/*int main() {
	int n, count;
	count = 0;
	scanf("%d", &n);
	while (n != 0) {
		n = n & (n - 1);
		count++;
	}
	printf("%d", count);
	return 0;
}*/
/*int main() {
	int n;
	scanf("%d", &n);
	for (int i = 1; i <= n;i++) {
		for (int j = 1; j <= n - i; j++){
			printf(" ");
		}
		for (int k = 1; k <= i; k++) {
			printf("%d", k);
		}
		for (int m = i - 1; m >= 1; m--) {
			printf("%d", m);
		}

			printf("\n");
		}
	return 0;
}*/
/*void change(int *a, int *b) {
	int *c = *a;
	*a = *b;
	*b = c;
}
int main() {
	int a = 10;
	int b = 20;
	change(&a, &b);
	printf("%d %d", a, b);
	return 0;
}*/
/*int main() {
	int n;
	for (n = 1000; n <= 2000; n++) {

		if (((n % 4 )== 0) && (n % 100) != 0 || (n % 400 )== 0){
			printf("%8d", n);
		}

	}
	return 0;
}*///609
/*int main(){
	int n = 0;
	scanf("%d", &n);
	if ((n % 100 == 0) && (n % 400) == 0) {
		printf("1");
	}
	else {
		printf("0");
	}
	return  0;
}
*/