循环的计算和选择

循环的起点终点对结果都有影响
有固定次数，明确起点与终点：for
至少执行一次:do while
可能一次不执行：while

循环控制

设定判定变量isprime=1;
如果出现可以整除，isprime=0;break;
break:结束循环
continue:可以跳过此循环剩下的部分，进入下一轮循环

嵌套的循环

如：输出100内的素数，for里有for（第一个for遍历1~100，第二个检验该数是不是素数）

int x;//再scan x
int isprime=1;
for(int i=2;i<x;i++){
	if(x%i==0){
		isprime=0;
		break;
	}
}//再根据isprime是不是1判断x是不是素数
1
2
3
4
5
6
7
8

除了特别设计，每一层循环的控制变量应该不一样（i），要注意。所以在第一层循环每层开始的时候重新赋值或定义int i，免得上次循环完的i这次拿来接着用，乱套了。
/t可以对齐，具体以后再讲

从嵌套的循环中跳出

凑硬币：用1,2,5元凑出100
如果我们想，发现了一种合适的就结束：在if内加break跳出（下图是错误示例）

for(one=1;one<x*10;one++)
{
	for(two=1;two<x*10/2;two++)
	{
		for(five=1;five<x*10/5;five++)//break跳出的是这层循环，而没有跳出上面的两层循环
		{
			if(one+two*2+five*5==x*10)
			{
				printf("可以用%d个一角加%d个两角加%d个五角得到%d元\n",one,two,five,x);
				break;
			}
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

但是图中的break只跳出了第三层for循环；接着又进到了第二层for循环（图中蓝色位置），Break和continue都只能在他那一层循环里做；
如何一直跳出呢？

方法一：连环跳
加一个判定变量exit=0;
if内写 exit=1;
在两个for后面都写上if(exit)break;

//接力break
int x,one,two,five,x;
int exit=0;
scanf("%d",&x);
for(one=1;one<x*10;one++)
{
	for(two=1;two<x*10/2;two++)
	{
		for(five=1;five<x*10/5;five++)
		{
			if(one+two*2+five*5==x*10)
			{
				printf("可以用%d个一角加%d个两角加%d个五角得到%d元\n",one,two,five,x);
				exit=1;
				break;
			}
		}
		if(exit==1)break;
	}
	if(exit==1)break;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

方法二：goto out

//goto
int x,one,two,five,x;
int exit=0;
scanf("%d",&x);
for(one=1;one<x*10;one++)
{
	for(two=1;two<x*10/2;two++)
	{
		for(five=1;five<x*10/5;five++)
		{
			if(one+two*2+five*5==x*10)
			{
				printf("可以用%d个一角加%d个两角加%d个五角得到%d元\n",one,two,five,x);
				goto out;
			}
		}
	}
}
out:
return 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

（除了这种多重break的结构建议使用goto，别的地方不建议。）

补充：PTA 例题

前n项和

求1+1/2+1/3+……+1/n.
在这个循环里，起点数字1，终点数字n都是明确的

#include
int main()
{
	int n;
	double sum=0.0;
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		sum+=1.0/i;
	}
	printf("f(%d)=%f",n,sum);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

例2：1-1/2+1/3-1/4+……
解决方案：定义一个sign=1;

sum+=sign*1.0/i;
sign=-sign;
1
2

技巧：如果我们double sign=1.0，算式中就出现小数了，就不用*1.0了。

整数分解

比如输入：12345
输出：1 2 3 4 5
考虑之前逆序输出的方法，我们可以先把这个数逆过来之后再逆序输出（鬼才）
即：

1. 先求x的逆序数t
2. 逆序逐位输出t

这种方法的缺陷在于：对于末尾有0出现的数字（如700）只能得到7
我们可以回想3位数的题，我们用三位数/100得到最高位数字。
所以我们知道位数之后，可以正序逐位得到每一位的数字。

可以先一个while循环求出x的位数和mask（位数），（还是记得提前把x保存下来）然后正序输出。
123456 / 100000 = 1
123456%100000 = 23456
23456 / 10000 = 2
……

求最大公约数

算法1：枚举。

循环t++
if(u/t==0&&v/t==0)gcd=t;//不断刷新gcd
if(t==u||t==v)break;//并输出gcd;
1
2
3

效率更高的算法2：辗转相除

1. 如果b=0，计算结束，a就是最大公约数；
2. 否则，让a=b，b=a%b；
3. 回到第一步
   （可以使用之前提到过的变量表格法来人工运行）

求符合给定条件的整数集

给定<=6的正整数A，从A开始的连续四个数字，请输出所有由它们组成的无重复数字的三位数。
输出满足条件的三位数，从小到大，且每行6个整数，行末无多余空格。
如：输入A=2
234 235 243 245 253 254
324 325 342 345 352 354
423 425 432 435 452 453
523 524 532 534 542 543

int i,a,j,k,cnt=0;
   scanf("%d",&a);
   i=a;
   //思路：i,j,k都从a开始，从小到大逐渐增加到a+3，三者不能相等
   
   while(i<=a+3){
       j=a;
       while(j<=a+3){
           k=a;
           while(k<=a+3){
              if(i!=j&&j!=k&&i!=k){
                  printf("%d%d%d",i,j,k);
                  cnt++;
                  if(cnt==6){
                      printf("\n");
                      cnt=0;
                  }
                  else printf(" ");
              }
              k++;
           }
           j++;
       }
       i++;
   }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

水仙花数

水仙花数指一个N位正整数（N>=3)，它的每位上的数字的N次幂之和等于它自己。如：153=1³+3³+5³;
给定一个N（3<=N<=7），按顺序输出所有N位水仙花数。
输入：3
输出：
153
370
371
第一个循环：遍历所有N位数。
第二个循环来求和，循环里面第三个循环来求每一位的N次幂（N次循环），最后if判断是否==sum。

打印乘法口诀表

a*b，a、b两重循环。
还要注意对齐问题。如果结果是一位数，输出两个空格；两位数输出一个空格。

统计素数并求和

给定M和N区间内的素数的个数并对它们求和。

读题后得知:包含两头[M,N]
先定义isprime=1;当可以被比他小的数整除的时候就isprime=0。
这道题很好做。注意特殊情况，如m=1时，循环直接不判断，isprime=1
可以在m~n循环开始前判断，if(m==1)m++;

猜数游戏

输入要猜的数字和猜的最大次数，大了输出too big,小了输出too small，直到猜对或者次数用光或者用户输入负数为止
还有就是注意不同次数猜到的输出结果也有区别。
一次猜到：BINGO！
两次猜到：LUCKY YOU！
三次以上猜到：GOOD GUESS!
//也不难，1.考的是语文的阅读理解；2.你是否有足够的耐心。（文中条件太多）

n项求和

2/1+3/2+5/3+8/5+……的前n项之和（从第二项开始，每一项的分子是前一项的分子和分母之和，分母是前一项的分子）

dividend=2;//分母
divisor=1;//分子
for(i=1;i<=n;i++){
	sum+=dividend/divisor;
	t=dividend;
	dividend+=divisor;
	divisor=t;
}
printf("%.2f/n",sum);
1
2
3
4
5
6
7
8
9

因为分子分母变大的相当快，所以出于范围考虑，也建议使用double储存dividend（分子）和divisor（分母）
(inf是越界，即无穷；nan是无效数字)

约分最简分式

输入一个分式，如32/45，输出最简形式。

1. scanf(“%d/%d”)这样处理输入
2. 辗转相除法寻找最大公约数；
   念数字：比如输入-12：fu yi er
   先判断-的情况之后switch case很好办。以后学会数组之后会有更优解。

求a的连续和

输入a,n，计算a+aa+aaa+……+n个a的和
循环的每一轮a1=a1*10+a。

6. 数据类型

C语言是有类型的语言。C语言的变量，必须：
1.在使用前定义;
2.确定类型.
如果我们一开始直接说a=6:使用了未定义的标识符a。

C语言之后语言朝着两个方向发展：

1. C++和Java更强调类型，对类型的检查更加严格
2. JavaScript、Python、PHP不着重类型，甚至不需要事先定义。
   支持强类型的观点认为明确的类型有助于尽早发现程序中的简单错误；
   反对强类型的观点认为过于强调类型，迫使程序员面对底层，实现而非事务逻辑

总的来说，早期语言、面向底层的语言强调类型。
C语言需要类型，但是对类型的安全检查并不足够：
（以下斜体的是c99类型）
整数：char、short、int、long、long long；
浮点数：float,double,long double；
逻辑：bool；
指针；
以及自定义类型。
类型的不同之处在于：

1. 类型名称：int,long,double……
2. 输入输出时的格式化（占位符）：%d,%ld,%lf……
3. 所表达的数的范围：char
4. 内存中占据的大小：1~16个字节

内存中的表达形式：二进制数（补码）、编码（浮点是编码形式）
编码形式不能直接进行运算，而两个整数可以。
Sizeof()是一个运算符，给出某个类型或变量在内存中所占据的字节数。如：
sizeof(int)
sizeof(i)
(1个字节是8个比特，所以int4个字节32个比特)
sizeof是一个静态运算符，在编译时其结果就已经决定了
比如上一行写sizeof(a++),但输出a之后会发现a其实没有++。

整数类型

sizeof(char)=1;//char1字节（8比特）
sizeof(short)=2;//short2字节
sizeof(int)=4;//由编译器决定，通常代表“1个字”
sizeof(long)=4;//由编译器决定，通常代表“1个字”
sizeof(long long)=8;//long long 8字节
1
2
3
4
5

说一台计算机的字长的时候，我们指的是寄存器RAM是多少字长（比特）的。
每一次从CPU中取数据取32个比特
所以说int就是用来表达寄存器的，不同计算机可能得到不一样的sizeof(int)。

整数的内部表达

计算机内部，一切都是二进制的，只是说我们以不同的方式去看待它。
十进制：18→二进制：00100010
十进制用负号来表示负数，运算一般在结果上再加负号。
而二进制怎么表示负数呢？
一个字节（8位）可以表达的数：00000000 ~ 11111111（0~255）

三种方案：

1. 像十进制一样，有一种特殊的标志（类似符号）来表示负数（缺陷：计算机做加减法的时候，要像判断十进制的负号一样，我们需要一个东西去控制加号还是减号。不过每次计算机都要特别地去判断这个符号的正负，这样就会比较复杂。）

2. 从0000 0000到1111 11111，取中间的数为0，如1000 0000表示0，比他小的是负数，比他大的是正数，各一半（缺陷：所有数都要和这个数做减法来计算其值，会比较复杂）

3. 补码
   思路：本质上来看，（互为相反数的）负数+正数=0。这是提供思路的一种方法。
   比如我们希望-1+1→0，如何能够做到？
   如0→0000 0000，1→0000 0001，我们让一个数+1得到0。这个数字选谁？
   全1的数字1111 1111。因为0000 0001+1111 1111→1 0000 0000多出来的一位（溢出）那一位被丢掉了，相加结果即是00000000。妙啊
   或者换个角度：-1=0-1=(1)0000 0000-0000 0001→1111 1111
   （1111 1111被当作纯二进制看待时是255，被当做补码看待时是-1）
   所以对于-a来说，他的补码就是0-a，实际就是2ⁿ-a，n是该种类型的位数
   补码的意义就是拿补码和原码可以加出一个溢出的0。
   另一个好处是这样我们做计算的时候，不需要调整加减，全部都是加法（+补码就是-原码）。

整数的范围：如何推算整数类型所能表达的数的范围，越界了会怎样？

一个字节（8位）：0000 0000~1111 1111
其中0000 0000→0
0000 0001 ~ 0111 1111→1~127（纯二进制数）
1000 0000 ~ 1111 1111→-128 ~ -1（用补码表示的数）
还是那句话，关键在于我们以什么样的方式去看待这个数。当成纯二进制数，1111 1111就是255；当成整数，就是-1

char c=255;
int i=255;
printf("%d%d",c,i);
1
2
3

输出结果：c=-1,i=255。
因为对于字符c来说，255→1111 1111
而对于整形变量i来说，266→0000 0000 0000 0000 0000 0000 1111 1111

比如char长度256，会被分成三部分：-128~-1,0,1~127
所有整数类型范围都是-2^(n-1)~2^(n-1)-1
如果我们希望一个数据从计算机中拿出来时我们将其视为纯二进制看待，我们要在其前面加上一个关键字unsigned.

unsigned char c=255;
1

unsigned使得这个类型在正整数表达部分范围扩大一倍，但是不能表达负数了。
如果一个字面量常数想要表达自己是unsigned，可以在后面加u/U：255U
Similarly,想表达自己是个long,后面加l
unsigned的初衷不是为了扩展数能表达的范围，而是为了做纯二进制运算，主要是为了移位。
整数是以纯二进制方式进行运算的。

补码就是顺时针-，逆时针+

char c=127;
c++;
1
2

然后c变成了-128。
Similarly，-128-1变成了127。
unsigned（无符号）则是直接加减。
但是

unsigned char c=255;
c++;
1
2

并不像预想中的得到256，我们得到c=0，因为256在8比特里是全0，第九位是1被丢掉。

c=0;
c--;
1
2

得到255。
所以对于unsigned，也是顺时针-，逆时针+

int a=0,b=1;
while(++a>0);
printf("int数据类型的最大数是：%d\n",a-1);
while((a/=10)!=0)b++;
printf("int数据类型最大的数的数位是:%d",b);
1
2
3
4
5

可以用这种方法推算int 的最大范围。while(++a>0)使得a加到127→-128越界后变成负数，然后printf("%d",a-1);再返回到127，得到int可以表达的最大数
同理，如果想得到unsigned的最大范围，参考上面的表，while(a!=0);

整数的格式化：如何格式化地输入输出整数，如何处理8进制/16进制

整数的输入输出只有两种形式：int和long long
%d：int
%u: unsigned
%ld: long long
%lu: unsigned long long
若int i=-1;储存在计算机中是二进制形式，即全1，若以%u即unsigned形式输出，得到的结果就是int 型的最大值（4294967295）
如此仍然可见，重点在于我们以什么样的正确的方式去看待这个结果。
8进制（octal）：一个以0开始的数字字面量
16进制（Hexadecimal）：一个以0x开始的数字字面量

 char c=012;
 int i=0x12;
 printf("c=%d,i=%d\n",c,i);
1
2
3

得到结果（%d转化为十进制）：c=10,i=18
（计算机内部同样还是二进制的形式）
想要输出8进制：%o或%O
想输出16进制:%x或%X,小写的x输出小写的字母，大写的输出大写的
(但是这样输出的结果前面是没有0和0x的。所以可以写printf(“c=0%o,i=0x%x\n”,c,i);
8进制和16进制只是如何把数字表达为字符串，与内部如何表达数字无关。
scanf中也可以用%o，表示读进来的数我们把其当做8进制来读。
16进制很适合表达二进制数据，因为4位二进制正好是一个16进制位（0001 0010→1 2）
八进制的一个数字正好表达3位二进制，因为早期计算机的字长是12的倍数，并非8。

整数类型的选择

char,short,int,long,long long
每种类型有不同大小，不同范围，内部是什么样，表达出来是什么样，……
C语言这些又多又复杂的原因：1.C语言的严谨性，为了准确表达内存，做底层程序的需要
2.C语言要和硬件打交道，要准确表达计算机里的东西（内存、寄存器、接口……）
建议：没有特殊需要，就选择int
原因 ：

1. 现在CPU字长（CPU和内存之间的通道。如果char可能会从32位中先挑出来8个，可能会花费时间）普遍是32位/64位，一次内存读写、一次计算都是int，选择更短的类型不会更快，甚至可能会更慢
2. 现代编译器一般会设计内存对齐，（比如这个东西虽然占据8bit，在内存中仍然占据了一个int。这个事等到结构再讲）所以更短的类型实际在内存中也可能占据一个int的大小。除非在做顶层的硬件，告诉你硬件多大你就要用多大去运算
   至于Unsigned与否，只是输出的形式不同，内部的计算还是一样的

浮点类型

float，double
32位，64位
10³⁸,10³⁰⁸
7位有效数字，15
但是float靠近0的部分（0~10³⁸）有很小一部分不能表达（这应该是之前的题目为什么if判断浮点数不写做差==0，而是写做差<1e-6）
float还能表达0，±inf（无穷），nan（非有效数字）
%e/%E:科学计数法
1234.56789输出得到：1.234567e+03
-5.67E+16，科学计数法可选的有：±号，e或E，小数点，E后面的符号±
Double ff=1E-10；
输出精度：%.数字f可以指定输出小数点后几位，这样输出的结果是做四舍五入的
%.3f,-0.0045→-0.004
%.30f→后面输出30位，-0.0049→-0.00489999……（计算机最终只能用离散的数字来表示数字，这就是浮点数的误差。Double更准确，但可能依然不精确）
%.3f，-0.00049→-0.000

浮点数的范围和精度

Inf无穷，nan输出不存在的浮点数
正数除0.0→inf
负数除0.0→-inf
0.0/0.0→nan
(如果是整数，12/0编译不过)
浮点数范围不包括无穷大，但它可以表示。

float a,b,c;
a=1.345f;
b=1.123f;
c=a+b;
if(c==2.468)printf("相等");
else printf("不相等，c=%.10f，或%f",c,c);
1
2
3
4
5
6

加f:表明身份，让它是float
结果：不相等！c=2.4679999352，或2.468000
f1==f2不一定成功，应该写fabs(f1-f2)<1e-12
所以浮点数不能做精确计算，最后误差会累积起来的。只能在一定范围内相信小数点

Android计算器低级错误？都是二进制惹的祸！
而传统计算器直接用整数做运算
而浮点数内部是编码形式

从左到右分别表示正数负数、指数、小数
如果没有特殊需要，就用double
现代cpu能直接对double做硬件计算，性能不会比float差，而且在64位的机器上数据存储的速度也不会比float慢

字符类型：char是整数也是字符

char是整数，也是字符。（character）
原因1：我们可以用单引号表示字符的字面量'a','1'
''也是字符
我们可以在printf和scanf里用%c来输入和输出字符。
计算机内部每一个值都有一个字符去表达它（ASCII）如1对应的码是49
输入1给计算机的方法：scanf("%c",&c);输入1
或者scanf("%d",&c);输入49
输出同样，因为49=='1'
注意空格的问题。

scanf("%d%c",&i,&c);
scanf("%d %c",&i,&c); 
1
2

这样中间几个空格回车都没关系，中间的空格会全部被读掉
从A到Z的ASCII码都是连着的
一个字符加一个数字可以转到后面那个对应ASCII码的字符处
int i='Z'-'A';//两个字符相减，得到它们在表中的距离
字母在ASCII表中顺序排列，且大小写字母分开排列
'a'-'A'可以得到小写字母与大写字母之间的距离，所以'a'+('A'-'a')可以转小写为大写

逃逸字符

用来表达无法印出来的控制字符或特殊字符，由一个反斜杠\开头，后面跟着一个字符

printf("请分别输入身高的英尺和英寸，""如输入\"5 7\"表示5英尺7英寸：");
1

（作业时就会有最后结尾多个空格，使用/b来删掉的情况，但其实应该说是覆盖了吧，总之这样运行的时候是不正确的，还是要想办法控制输出的空格等的格式正确）
例子

printf("123\b\n456\n"); 
1

得到结果：

但是到了其他程序那边运行
123
456
原因：dev c++那个黑框框，是别人写的程序(shell)来帮助我们运行的；部分东西是经过它处理的，比如\b\n，不同shell对此处理不一样。如dev c++用BS字符来表示。
\b\n都是控制字符
BS是回到上一格，没输出东西就什么结果都没有，输出了就把他盖住了
也不能否认有的程序，输出的时候把\b翻译成删除
\t:到下一个表格位（在每一行中有一些固定的位置，\t代表输出的固定的位置）
比如

printf("123\t456\n");
printf("12\t456\n");
1
2

\n换行\r回车，源自打字机的动作
一直敲键盘，打字机的轴就往左移
敲一下回车就回到右边，这叫回车
然后往上调一下纸，这叫换行。
不过dev c++把回车就当做回车+换行了。

类型转换

自动类型转换：当运算符两边出现不一样的类型时，会自动转成较大的类型，即能表达的数范围更大的类型。
char->short->int->long->long long
int->float->double
对于printf，任何小于int的类型都会被转换成int；float会被转换成double。所以printf输出double的时候写%f就也行。
但scanf不会，想输入short时，需要%hd。
强制类型转换：(类型)值
如：

(int)10.2;
(short)32;
1
2

但是注意安全性，小的变量不总能表达大的量。如(short)32768，因为short最大范围是32767，所以会被转化为-32768
只是从那个变量计算出了一个新类型的值，他并不改变那个变量的值或类型。

int i=32768;
short s=(short)i;
printf("%d\n",i);
1
2
3

i输出仍然是32768。强制类型转换不会改变这个变量自身的类型或值。

如果想计算a，b的int型相除得到的i的int型的值：

double a=1.0;
double b=2.0;
int i=(int)a/b;
1
2
3

实际上是先int a，再/浮点数b,强制类型转换的优先级高于四则运算。
所以正确的写法是

int i=(int)(a/b);
(double)(a/b);
1
2

逻辑类型：表示关系运算和逻辑运算结果的量

bool类型
首先要包含头文件#include，然后可以使用bool，true,false。

bool b=6>5;
1

只要bool量不是0，都=1.

逻辑运算：对逻辑量进行与、或、非运算

逻辑运算是对逻辑量进行的运算，结果只有0或1。
逻辑量是关系运算或逻辑运算的结果。

例：表达数学区间时，(4,6)或[4,6]：
同样像之前if一样，不可以写4 x>4&&x<6或x>=4&&x<=6
判断一个字符是大写字母：c>='A'&&c<='Z'
优先级：!>&&>||
例：!done&&(count>MAX)：done是0且count>MAX时结果为1

所有的优先级

短路：逻辑运算自左向右，如果左边足以决定结果，就不会进行右边的计算了
a==6&&b==1如果左边a!=6就终止了。
即：&&左边false就不做右边了；||左边是true就不做右边了。就算右边是赋值的话右边也不会做了。

int a=-1;
if(a>0&&a++>1){
	printf("OK\n");
}printf("%d\n",a);
1
2
3
4

这样输出结果a=-1，没有进行右边的a++。
所以不要把赋值和复合赋值组合进表达式！

条件运算符

条件运算符1：问号

cnt=(cnt>20)?cnt-10:cnt+10;
//格式：条件?条件满足时的值:条件不满足时的值
1
2

相当于

if(cnt>20)cnt-=10;
else cnt+=10;
1
2

这种条件运算符?的优先级高于赋值运算符，但是低于其他运算符，但是这样会很麻烦。
条件运算符自右向左，先计算右边的分支
不建议使用嵌套的条件表达式！太复杂，太难理解

条件运算符2：逗号
逗号是个运算符，连接两个表达式，并且以右边的表达式的值作为其结果。
逗号的优先级是最低的，所以两边的表达式会先运算，而右边的表达式的值留下来作为运算的结果。

i=3+4,5+6;//编译时会提示warning。因为赋值的优先级也要高于逗号，该式子其实是
(i=3+4),(5+6);//右边编译错误,i=7
如果写作i=(3+4,5+6);//编译时同样会warning，因为3+4没有用到;i=11
1
2
3

逗号表达式主要在for中使用

for(i=0,j=10;i<j; i++,j--)
1

目前来说，逗号表达式只有这一个用处。

7. 函数

初见函数

回想起区间[m,n]内素数求和的例子，对于每个数我们定义isPrime=1，如果最后仍然=1的话sum+=i.
这样让这一层循环显得很大，而这一层代码的功能很单纯
我们可以以函数的形式把这一堆代码取出来

int isPrime(int i)
{
	int ret=1;
	int k;
	for(k=2;k<i-1;k++){
		if(i%k==0){
			ret=0;
			break;//有1~i-1间的因数就可以判断i不是素数了，break节约时间
		}
	}
	return ret;
}
1
2
3
4
5
6
7
8
9
10
11
12

我们之前从第一个程序printf开始就是在用函数。只不过这次我们在自己定义了一个函数。
这样main里面很简洁，而且isPrime可以很方便地多次使用
PS: 程序中出现几段几乎完全相似的代码（除了字母不同），“代码复制”是程序不良的表现。因为将来做修改、维护的时候要维护很多处。
（吓得我立刻就去改大作业了）我们用函数替换，可以把重复的代码提出。

//闭区间内所有数求和的函数
void sum(int begin,int end)
{
	int i,sum=0;
	for(i=begin;i<=end;i++){
		sum+=i;
	}
	printf("%d到%d的和是%d\n",begin,end,sum);
}

int main()
{
   sum(1,10);
   return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

函数的定义和调用

函数是一块代码，接收0个/多个参数做一件事情，并返回0个/1个值。
可以先想象成数学中的函数y=f(x)。
调用函数时要写出 函数名(参数值);
（）起到了表示函数调用的重要作用，即使没有参数我们也需要（）。
不给括号的话，会给warning，而且函数不会被调用。
如果有参数，参数的数量、顺序都必须正确。而且函数知道每一次是哪里调用它，还会返回到正确的地方。

从函数中返回

int函数会有返回值return
return停止函数的执行，并返回一个值
return;
return 一个值;
可以写 c=函数()；这样c=函数的返回值。
可以把这个值赋给变量/传给函数/丢掉。
没有返回值的函数:void，不能使用带值的return ，可以没有return 。调用的时候也不可以做返回值的赋值。

函数原型：用来告诉编译器这个函数长什么样

使用函数的先后顺序：先写函数再调用。
可以先想象成数学函数y=f(x)
C的编译器自上而下分析你的代码，它会记住函数sum()长什么样子要几个参数，每个参数的类型如何，返回什么类型
如果把函数放在后面，C语言可能会猜，你在main函数里使用的这个函数是什么类型。如果后面发现后面的函数类型和它猜测的不符，就输出error 。
因此也可以先不用写完函数，光把一句函数头放到前面编译也能通过。
（事先声明了函数的样子）
下面函数还会判断一下和你之前的声明是否一致

void sum(int begin,int end);//声明

int main()
{
	//略去不表，其中用到了sum(a,b)
}

void sum(int begin,int end)//定义
{
	int i,sum=0;
 	for(i=begin;i<=end;i++){
 		sum+=i;
 	}
 	printf("%d到%d的和是%d\n",begin,end,sum);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

函数头以分号结尾，就构成了函数的原型；
在函数里定义的参数类型与输入的变量的类型不一样，会发生自动类型转换。

double max(double a,double b);
1

在以前是把函数原型写在调用它的函数(main())里面的。
函数的原型里可以不写参数名，但一般仍然写上。

Void sum(int ,int)
1

不过对于人类读者，一般来说写上会更好理解。

参数传递：调用哪个函数的时候，是用表达式的值来初始化函数的参数

传递给函数的值可以是表达式的结果(max(a+b,c))
包括字面量、变量、函数返回值（函数调用里有函数）、计算结果
当调用函数的值与参数类型不匹配：编译器总是悄悄替你把类型转换好，但是这很可能不是你所期望的。这是C语言传统上最大的漏洞。
后续语言如c++/java在这方面会很严格。
这样的函数代码能交换a,b的值吗？

 void swap(int a,int b)//形参

int main()
{
   int a=5;
   b=6;
   swap(a,b);//实参
}
void swap(int a,int b)//形参
{
	int t=a;
	a=b;
	b=t;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

不能。
C语言在调用函数时，永远只能传值给函数。
每个函数有它自己的变量空间，参数也位于这个独立的空间中，和其他函数没有关系。
后面递归还会再提。
过去对于函数参数表中的参数叫做形式参数。调用函数时给的数值叫做实际参数。
（见上图）
由于易误会，我们不再这么称呼。我们把参数表中叫做参数，调用函数的叫做值。

本地变量：定义在函数内部的变量是本地变量，参数也是本地变量

函数每次运行都会产生一个独立的变量空间，其中的变量是函数这一次运行所独有的。（本地变量）
所有我们定义在函数内部的变量就是本地变量。（我们现在学过的都是定义在函数内部的）我们写在函数参数表里的参数也是本地变量。

变量的生存期和作用域

生存期：这个变量出现和消亡的时间
作用域：在（代码的）什么范围内可以访问这个变量（这个变量可以起作用）
对于本地变量，这两个答案都是：大括号内（块）

void swap(int a,int b)//形参

int main()
{
  int a=5;
  b=6;
  swap(a,b);//实参
}
void swap(int x,int y)//形参
{
  int t=x;
  x=y;
  y=t;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

比如仍然是上例，进入swap函数之后（离开了自己的变量空间）a,b就没了。还在生存，但是不在当前的作用域了（显示：Not found in current context)
而回到原函数中之后，x,y,t就不存在了
所以在swap函数里交换a,b不会影响到原函数
本地变量的规则

1. 本地变量定义在块内。可以是函数的块内，语句的块内，如：
   if (a 离开if语句之后未定义使用i编译错误。（没声明）
   程序运行进入这个块前，其中的变量不存在。离开后就消失了。
   如果在块里定义了块外已经定义过的变量，就把块外的变量掩盖了；出来之后又回到块外的值。（C语言）
   但是不能在块里面定义同名变量（多次定义）
   本地变量不会被默认初始化，不会得到一个初始值。而参数进入函数的时候被初始化了。

函数庶事：一些细节，main()的解释

函数没有参数的时候写void f(void)。而写void f()在传统C语言中表示f的函数的参数表未知，并不表示没有参数。（编译器可能会猜测什么类型）
所以不要写空的括号
调用函数时的逗号和逗号运算符怎么区分？再加一层括号就是逗号运算符f((a,b))
C语言不允许函数嵌套定义。
（也最好不要写return (i);虽然意思上没变，但是会让人误会return 是个函数）
int main(void)也是个函数，所以return 0;也是有意义的。

8. 数组

初试数组

之前提到过如何计算用户输入的数字的平均数？
之前的做法：每读到一个数（!=-1）加到sum里，cnt++,最后sum/cnt
这样我们不需要记录每一个数
如果题目还要求：输出所有大于平均数的数？这样就必须记录每一个数了，因为我们是最后才计算平均数的，要最后再用每个数和平均数做判断
如何记录很多数？int num1,num2……？不好。这样下去无穷无尽。

使用数组

int number[100];//定义数组，表示数组可以放100个int
scanf(“%d”,&x);
while(x!=-1){
	number[cnt]=x;//对数组中的元素赋值
	cnt++;
	scanf(“%d”,&x);
}
1
2
3
4
5
6
7

最后再加个cnt长度的循环，判断每一个数与平均数比较大小

if(cnt>0){
	int i;
	double average=sum/cnt;
	for(i=0;i<cnt;i++){
		if(number[i]>average){//使用数组中的元素
			printf("%d ",number[i]);//遍历数组
		}
	}
}
1
2
3
4
5
6
7
8
9

这个程序的安全隐患在于没有考虑使用的数组下标是否会超过100.定义的时候注意要求。

数组的使用：如何定义和使用数组，数组的下标和下标的范围

定义数组：
<类型>变量名称[元素数量];//方括号表示这是个数组

int grades[100];
double weight[20];
1
2

元素数量必须是整数。在c99之前，元素数量必须是编译时确定的字面量。(a[n]不行)vscode中好像就不行，提示variable-sized object may not be initialized
数组是一种容器，特点是：
其中所有元素具有相同的数据类型；
一旦创建，不能改变大小；
其中元素在内存中连续依次排列（从0开始）；
如：定义十个单元a[10]→a[0]~a[9]

每个单元就是一个int类型的变量。像普通变量一样可以出现在赋值的左边或右边。左边的叫左值，右边的叫右值。
数组的每个单元就是数组类型的一个变量。使用数组时[]中的数字/变量叫下标或索引，从0开始计数
（要习惯数数从0开始到n-1）
但编译器和运行环境不会检查数组下标是否越界，无论读、写数组单元。
不过数组越界时可能出问题:segmentation fault，运气好的话不会造成严重的后果。
所以这是程序员的责任来保证程序只适用有效的下标值（范围：[0,数组大小-1]）

防止读入数字超过100个的方法：
方法一：cnt=100之后停止读数；
方法二：利用c99数组大小可以是动态的的特性，定义number[cnt];//用户先输入cnt

可不可以int a[0];?
可以，但是没用。

数组的例子：统计个数

不停输入0~9范围内的整数，读到-1停止，统计每种数字出现的次数。
和上一道题不同的是，不用记录每次输入的数字，我们需要记录的是每种数字出现的次数。
学到了定义数组为0的方法：

for(int i=0;i<10;i++)count[i]=0;
1

和打印方法：

for(int i=0;i<10;i++)printf(“%d\n”,count[i]);
1

该题中出现多次数字10。根据之前学到的方法，我们可以定义const number=10（c99才能用）;每一个10用number代替。

通常用到数组的程序都需要的环节：

1. 确定数组大小；
2. 定义数组；
3. 初始化数组；
4. 数组参与运算；
5. 遍历数组输出。

数组运算

搜索：在一组给定数据中，怎样找出某个数据是否存在？
（往函数中传数组：int sum(a[])）
数组的集成初始化：

int a[]={2,4,6,7,1,3,5,9}
/*直接用大括号给出数组所有元素的初始值；
不需要给出数组的大小，编译器替你数了。*/
1
2
3

依次初始化数组的每一个单元
如果a[13]={2};只有a[0]是2，后面的单元都是0
所以如果想定义一个数组全为0：a[13]={0};
C99还可以在大括号里给指定的位置赋值。
用[n]在初始化数据中给出定位，没有定位的数据接在前面的位置后面；其他位置的值补0.

int a[0]={[0]=2,[2]=3,6};
这个例子里，a[0]=2，a[2]=3，a[3]=6
我们也可以不给出数组大小，让编译器计算。比如上例可写为：
int a[]={[0]=2,[2]=3,6};
这样会根据大括号里最大的数字下标来算数组的大小。即下标最大为3
这样特别适合初始数据稀疏的数组。

数组的大小

sizeof给出整个数组所占据的内容的大小，单位是字节。（n*4，sizeof(a)/sizeof(a[0])就能得到数组元素个数）
不能直接把一个数组赋给另一个数组b[]=a;
数组变量本身不能被赋值。如果想把一个数组的值全部交给另一个数组，必须遍历。

遍历数组

通常使用for循环，从0开始到 常见错误：1.循环结束条件是<=数组长度
2.离开循环之后继续使用i作为数组元素下标。

数组作为函数参数时，往往需要另一个参数来传递数组大小。
原因：1、数组传入函数之后我们不能用sizeof来计算数组的元素个数；
2.不能在[]中给出数组的大小。
具体原因后面再说。

数组例子：素数

之前找素数的例子。我们可以定义isPrime()函数来判断一个数是否是素数。
isPrime()函数：我们从2到x-1都拿去除x，循环要走很多遍，重复执行的次数很多（程序很差）。
优化：当x是!=2的偶数，一定不是素数，就直接不用判断。
因为剩下需要判断的书都是奇数，肯定%2=1，这样我们判断接下来的数时for循环除数就可以从3开始的奇数判断。

for(int i=3;i<x;i+=2)
1

再次优化：我们不需要走到x。我们只要走到sqrt(x)就够了。

for(int i=3;i<=sqrt(x);i+=2)
1

引入：当我们想了解一个函数时，在编译器中输入man 函数名称（man sqrt）就能得到其相关信息。（man:manual手册）
Windows用户：打开浏览器搜索。
再再次优化：我们不需要拿比x小的数字来测试x是不是素数，我们只需要拿比x小的素数就够了。

int isPrime(int x,int knowsPrimes[],int numberofKnownPrimes)
int main()
{
	const int number=100;
	int prime[number]={2};
	int count=1;
	int i=3;
	while(count<number){
		if(isPrime(i,prime,count)){
			prime[count++]=i;
		}
		i++;
	}//prime数组装着所有素数
	for(i=0;i<number;i++){
		printf("%d",prime[i]);
		if((i+1)%5)printf("\t");
		else printf("\n");
	}
	return 0;
}
 int isPrime(int x,int knowsPrimes[],int numberofKnownPrimes)
 {
 	int ret=1;
 	int i;
 	for(i=0;i<numberofKnownPrimes;i++){
 		if(x%knownPrimes[i]==0){
 			ret=0;
 			break;
 		}
 	}
 	return ret;
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

一边构造素数表，一边利用表来证明素数。
其中prime[cnt++]=i;一举两得，cnt++的同时还把i的值放到了对应的数组位上。

while(count<number){
	if(isPrime(i,prime,count)){
		prime[count++]=i;
	}
	{
		printf("i=%d \tcnt=%d\t",i,count);
		int i;
		for(i=0;i<number;i++){
			printf("%d\t",prime[i]);
		}
		printf("\n");
	}
	i++;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

这样加个括号在里面int i之后，我们使用i就不会影响到外面的i的值了（但是我宁愿重新定义个变量j=i。因为太绕了）

同样的方法，我们可以先输出一个表头。

{
	int i;
	printf("\t\t\t\t");
	for(i=0;i<number;i++){
		printf("%d\t",i);
	}
	printf("\n");
}
1
2
3
4
5
6
7
8

换一个思路，使得最后这张表里留下来的数都是素数。
欲构造n以内的素数表：

1. 令x=2
2. 将2x,3x……直到ax
3. 令x为下一个没有被标记为非素数的数，重复2；直到所有的数都已经被尝试完毕。
   （从2,3,4,5,6,7,8……删掉2的所有倍数，再删掉3的所有倍数，再删掉5的所有倍数……）
4. 先开辟数组prime[n]，初始化其所有元素为1，prime[x]=1表示x是素数，prime[x]=0表示x不是素数
5. 令x=2
6. 如果x是素数，则for(int i=2;x*i令prime[i*x]=0
7. x++，重复3直到x==n，否则结束。

int main()
{
	const int maxNumber=25;
	int isPrime[maxNumber];
	int i,x;
	for(i=0;i<maxNumber;i++)
	{
		isPrime[i]=1;
	}
	for(x=2;x<maxNumber;i++)
	{
		if(isPrime[x])
		{
			for(i=2;i*x<maxNumber;i++) isPrime[i*x]=0;
		}
	}
	printf("\n");
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

int a[][5]={
	{0,1,2,3,4},
	{2,3,4,5,6},
};
1
2
3
4

const int size = 3;
int board[size][size];
int i,j;
int num0fX;//X是一方
int num0fO;//O是一方
int result=-1;//-1：平局，1：X方赢，0:O方赢

//读入矩阵
for(i=0;i<size;i++){
	for(j=0;j<size;j++){
		scanf("%d",&board[i][j]);
	}
}

//检查行
for(i=0;i<size&&result==-1;i++){
	num0fO=num0fX=0;
	for(j=0;j<size;j++){
		if(board[i][j]==1)num0fX++;
		else num0fO++;
	}
	if(num0fO==size)result=0;//O方赢
	else if(num0fX==size)result=1;//X方赢
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

printf("0x%x",&i);//%x是以16进制输出；&i是一个地址

printf("%p",&i);

p=(int)&i;
printf("0x%x",p);
1
2
3
4
5
6

int a;
int b;
1
2

int i;
int *p=&i;//（p指向了i）*p理解为指向p指针地址所存在的值=i的地址。
int* p,q;
int  *p,q;
1
2
3
4

void f(int*p);
int main()
{
   int i=6;
   printf("&i=%p\n",&i);
   f(&i);
   return 0;
}
void f(int *p)
{
   printf("p=%p\n",p);
}//该函数在被调用的时候得到了某个变量的地址
1
2
3
4
5
6
7
8
9
10
11
12

//我们调用的时候可以这么写：
int i=0;f(&i);
1
2

void swap(int *pa,int *pb)
{
	int t=*pa;
	*pa=*pb;
	*pb=t;
}
1
2
3
4
5
6

写一个求最大值最小值的函数，要返回最大值和最小值两个值。
int a[10],min,max;
minmax(a,sizeof(a)/sizeof(a[0]),&min,&max);


void minmax(int a[],int len,int *min,int *max)
/*
sizeof(a)/sizeof(a[0])是数组元素个数。
函数内部：一个len次的循环来比较每一个a[i]和*min,*max大小，然后令*min,*max不断改变主函数中min和max的值
1
2
3
4
5
6
7
8
9

给你两个数做除法，当分母等于0时返回0，分母不等于0的时候要返回1和除法的结果。
int divide(int a,int b,int *result)
{
	int ret=1;
	if(b==0)ret=0;
	else{
		*result=a/b;
	}
	return ret;
}
如果返回1再输出a/b结果。
1
2
3
4
5
6
7
8
9
10
11

int sum(int *ar,int n);
int sum(int *,int);
int sun(int ar[],int n);
int sum(int [],int);
1
2
3
4

pritnf("min=%d,max=%d\n",min,max);
int *p=&min;
printf("*p=%d\n",*p);
printf("p[0]=%d\n",p[0]);//得到的是一样的结果。
1
2
3
4

int * const q=&I;//q是const
*q=26//可以改变i的值
q++//error

const int *p=&I;
*p=26;//error!(*p)是const，不能通过p做赋值。
I=26;//可以直接改i
P=&j;//改变p指向的地址，可以
1
2
3
4
5
6
7
8

int I;
const int*p1=&I;
int const*p2=&I;
int *const p3=&I;
1
2
3
4

void f(const int*x);
int a=15;
f(&a);//可以
const int b=a;
f(&b);//可以
b=a+1;//不行！
1
2
3
4
5
6

char a[]={0,1,2,3,4,5,6}
char *p=ac;
printf("p的地址是%p\n",p);
printf("p+1的地址是%p\n",p+1);
1
2
3
4

p=ac;
while(*p!=-1)
{
	printf("%d\n",*p++);
}
1
2
3
4
5

int *p=&i;void*q=(void*)p;
1

int *a=(int*)malloc(n*sizeof(int));
1

#include
{
	int n;
	int *a;
	scanf("%d",&n);
	a=(int*)malloc(n*sizeof(int));
	//用完之后
	free a;
}
1
2
3
4
5
6
7
8
9

char word[]={'H','e','l','l','o','!'};
1

char *str="Hello";//一个指针指向了一个字符数组
char word[]="Hello";//字符数组，结尾0
char line[10]="Hello";//字符数组，结尾0
1
2
3

printf("123456789"
"10111213");
1
2

printf("123456789\
10111213");
1
2

char *s="Hello";
s[0]='B';//尝试把H替换为B，然后输出s[0]
1
2

int i=0;
char *s="Hello";
char*s1="Hello";//两个一样的字符串变量
printf("i的地址是%p\n",&i);
printf("s的地址是%p\n",s);
printf("s1的地址是%p\n",s1);
1
2
3
4
5
6

char s[]="Hello!";
1

char *t="title";
char *s;
s=t;
1
2
3

char string[8];
scanf("%s",string);
printf("%s",string);
1
2
3

scanf("%s",str1);
scanf("%s",str2);
printf("%s%s",str1,str2);
1
2
3

char str1[8],str2[8];
scanf("%s",str1);
scanf("%s",str2);
1
2
3

char zero[100]="";
1

char a[][10]={
	"hello",
	"world"
};//每个字符串长度不要超过n，即10
1
2
3
4

for(i=0;i<argc;i++){
	printf("%d:%s\n",i,argv[i]);
}
1
2
3

int ch;
while((ch=getchar())!=EOF){
	putchar(ch);
}
printf("EOF\n");//这样来看读入什么会EOF
return 0;
1
2
3
4
5
6

char line[]="Hello";
printf("%lu\n%lu",strlen(line),sizeof(line));
1
2

int cnt=0;
while(s[cnt]!='\0'){
	cnt++;
}
return cnt;
1
2
3
4
5

s1[]="abc";
s2[]="bbc";
1
2

s1[]="abc";
s2[]="Abc";
1
2

s1[]="abc";
s2[]="abc ";//多了个空格
1
2

while(s1[idx]!='\0'&&s1[idx]==s2[idx])//当出现不相等的字符或者字符串到了末尾时，返回差值
	idx++;
return s1[idx]-s2[idx];
1
2
3

*s1==*s2
s1++;
s2++;
return *s1-*s2;
1
2
3
4

char *dst=(char*)malloc(strlen(src)+1);//不包含结尾的\0，所以+1
strcpy (dst,src);
1
2

char *mycpy(char*dst,const char*src)
{
	int idx=0;
	while(src[idx]!='\0')
	{
		dst[idx]=src[idx];
		idx++;
	}
	dst[idx+1]='\0';
	return dst;
1
2
3
4
5
6
7
8
9
10

char *ret=dst;
while(*src!='\0')
{
	*dst=*src;
	*dst++;
	*src++;
}
*dst='\0';
return ret;
1
2
3
4
5
6
7
8
9

while(*src)*dst++ = *src++;
1

while(*dst++ = *src++);
1

char*strncpy(char* restrict s1,const char* restrict s2,size_t n);
char*strncat(char* restrict s1,const char* restrict s2,size_t n);
char*strncat(const char* s1,const char* s2,size_t n);
1
2
3

char *s="hello";
char *p=strchr(s,'l');
printf("%s",p);
1
2
3

p=strchr(p+1,'l');
1

char *t=(char*)malloc(strlen(p)+1);
strcpy(t,p);
free(t);
1
2
3

char c=*p;
*p='\0';//把l的位置改成'\0'
char *t=(char*)malloc(strlen(s)+1);
strcpy(t,s);//只拷贝了第一个l前面的部分。
1
2
3
4

const int red=0;
const int yellow=1;
const int green=2;

int main()
{
	int color=-1;
	char *colorname=NULL;
	printf("请输入你喜欢的颜色的代码");
	scanf("%d",&color);
	switch(color){
	case red:colorname="red";break;
	case yellow:colorname="yellow";break;
	case green:colorname="green";break;
	default:colorname="unknown";break;
	}
	printf("%s",colorname);
	return 0;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

enum COLOR{RED,YELLOW,GREEN};
int main(){
	int color=-1;
	char *colorname=NULL;
	printf("输入你喜欢的颜色代码：");
	scanf("%d",&color);
	switch(color){
	case RED:colorname="red";break;//在case处就可以直接使用RED YELLOW和GREEN来取代0,1,2
	case YELLOW:colorname="yellow";break;
	case GREEN:colorname="green";break;
	default:colorname="unknown";break;
	}
	printf("你喜欢的颜色是%s\n",colorname);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

enum color {red,yellow,green};
void f(enum color c);
int main()
{
	enum color t= red;
	scanf("%d",&t);
	f(t);
	return 0;
}

void f(enum color c)
{
	printf("%d\n",c);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

enum COLOR{RED,YELLOW,GREEN,numcolors};//结尾的numcolors表示数组的结尾，同时也可以表示enum中元素的个数。
int main()
{
	int color=-1; 
	char *ColorNames[numcolors]={
		"red","yellow","green",
	};
	char *colorname=NULL;
	printf("请输入你喜欢的颜色的代码");
	scanf("%d",&color);
	if(color>=0&&color<numcolors) colorname=ColorNames[color];
	else colorname="unknown";
	printf("你喜欢的颜色是%s",colorname);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int main()
{
	struct date{
		int day;
		int month;
		int year;
	};//声明时，结尾有个分号！！
	struct date today;//像枚举一样不要忘记开头，struct
	today.day=12;
	today.month=3;
	today.year=2021;
	printf("Today's date is %i-%i-%i.",today.year,today.month,today.day);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

struct{
	int x;
	int y;
}p1,p2;
1
2
3
4

struct point{
	int x;
	int y;
}p1,p2;
1
2
3
4

struct date={12,3,2021};//注意顺序
struct thismonth={.month=3,.year=2021};//剩下没有被赋值的部分都是0，和数组一样
1
2

p1=(struct point){5,10};
p1=p2;
1
2

struct date today,day;
today=(struct date){12,3,2021};
day=today;
1
2
3

struct date *pdate=&today;
1

int numberofdays(struct date d)
1

struct point p={0,0};
gtestruct(p);

void getstruct(struct point p){
	scanf("%d",&p.x);
	scanf("%d",&p.y);
}
1
2
3
4
5
6
7

struct point getstruct(void)
{
struct point p;
	scanf("%d",&p.x);
	scanf("%d",&p.y);
	return p;
}
//main函数中：y=getstruct();
1
2
3
4
5
6
7
8