C语言小结

Set_angle

于 2023-08-04 08:46:13 发布

阅读量277

点赞数 7

文章标签： c语言

本文链接：https://blog.csdn.net/m0_52182466/article/details/132096114

版权

12.1特殊的运算符单目运算符... 11

C基础

1 C的基本结构

#include <stdio.h> // 注释头文件引入库

int main() // 主函数一个c程序的入口

{

printf("hello world\n"); // 调用输入函数在终端输入字符 "hello world\n"

return 0; // 退出主函数程序结束了

}

2编译器

编译c文件为可执行程序

gcc hello.c 编译hello.c 文件生成可执行文件 a.out

gcc hello.c -o hello 编译hello.c 文件生成可执行文件 hello

运行程序:

程序路径/程序名

./a.out

3词法符号

关键字: 由编译器约定的具体特定功能的单词或字符

标识符: 有编程者自己命名的

运算符: 一些用于表示某种运算的符号

分隔符: 用于对书写排版的符号对编译没有影响

标点符号: 用于组成语法的特定符号, 必须严格按照要求使用

4关键字

32个关键字

类型: char、double、float、struct、short、signed、unsighed、void、int、long、enum、union；

存储: auto、const、extern、register、static；

结构: break、case continue、default 、do、else、for、if、goto、return、while、switch；

特殊功能: sizeof、typedef、volatile；

5计算机中数据的表示

0、1

数值数据: 具体的某个值 3 5.5 -2

非数值数据: 自然语言不是单纯的数值,通常是将自然语言进行后表示

英文字符：ASCII码'a'一个字符97 、"abc" 表示字符串一句自然语言

6计算机的二级制表示方法

十进制: 0-9 逢十进一

123 数码1 * 进制10^位置

= 1 * 10^2 + 2 * 10 ^ 1 + 3 * 10^0

100 20 3

二进制: 0,1 逢二进一

100 = 4 = 1 * 2^2 + 0* 2^1 + 0*2^0

8 1个4 + 0个 2 + 0个1

...

123 十进制: 二进制短除法 0111 1011 (0-15)

16进制: 逢16进一 0-9,a-f

0111 1011

7 b

书写上 0x7b 二进制数 0b01111011

32个1的二进制数 : 0x FFFF FFFF

8进制数 3个二级制位 0-7 文件的权限在Linux中以 8进制方式表示

示例: 有100瓶药水其中有1瓶有毒毒需要1小时发作

现有 8只小白鼠如何在最短的时间内测试出哪瓶有毒?

假设除毒发外, 其他操作均不消耗时间

6.1课间练习:进制转换

十进制二进制 16进制

100 0110 0100 0x64

156 1001 1100 0x9c

152 1001 1000 0x98

8个1 的二进制 255 0xff

7个1 127 0x7f

9个1 511 0x1ff

10个 1023 0x3ff

16个1 65535

7数据类型

7.1整型

二进制对整型数的表示与存储

...-2 -1 0 1 2 3 ....

C语言中的基本数据类型: 由编译器预先定义

char 字符类型表示整数由8个bit 即一个字节存储 0-255

无符号类型正整数

unsigned char 无符号字符类型 0-255

signed char 有符号字符类型 -128 .. 0 .. +127

7.2有符号数与无符号数

负数的表示 1bit 符号 7bit 补码表示

short 半指类型短整型有16bit 存储 0-65535

int 整型 32bit 存储 0- 4,294,967,295

long 长整型 64bit 存储 0- 18,446,744,073,709,551,614

7.3浮点类型

二进制对小数的表示 2.5 非精确表达

0.0000000001123 1.123 * 10^-10

1241235123412343.0001 1.241235 * 10^15

在计算机中使用指数形式存储有效数 + 指数形式存储

float a = 4.5; 4.99999 <= a <= 5.00000;

float 单精度浮点型 32bit 存储有效位数23位有效10进制位数 7位

double 双精度 64bit 存储有效10进制位数 16位

bool 布尔类型: 表示逻辑真和假的类型

C语言中没有专门的布尔类型但当需要进行布尔运算是

0值为假非0 为真

7.4程序运行中的存储

程序运行时, 在内存中存在几个存储区;

代码段: 存放编译的二级制代码CPU会读取代码执行;

常量区: 存储程序中的常量;

静态区: 存储静态变量如全局变量静态局部变量;

栈区: 存储局部变量由程序的运行情况自动分配;

堆区: 编程者可以在该内存区手动申请内存使用;

7.5常量

在代码编译时就确定的值且在程序整个运行过程中值不会改变只读

数值常量: 1 2 2.6 -7

非数值常量: 字符常量 'a' 字符串常量 "hello"

标志常量: 宏定义 #define 宏名值

#开始的语句属于预处理命令用于指示编译器如何编译

#define MAX 128

指数常量: 用于标识很大或很小的常量 3×10^-26kg C语言中 3e-26

8变量

8.1变量的定义

在程序运行过程中可以更改的量本质一段可以读写的内存

主要用于存放程序运行过程中的一些必要数据

C程序中变量必须先定义后使用

存储类型数据类型变量名 = 初始化值;

变量的赋值:给变量对应的内存空间写入一个新的值,覆盖原理的值

初始化值可以是常量、变量类型匹配, 空间足够

8.2局部变量

局部的作用域(能访问到该变量的代码区域)与局部的生命周期 (存在的时间)

在代码块内{}定义的变量局部变量存放于栈区,有程序运行过程中

代码块开始时自动分配与释放代码块结束时

8.3全局变量

全局的作用域(任何位置都可以访问)有全局的生命周期

在函数外,创建的变量 ,存放于静态区

程序开始, 就被创建直到程序结束才会释放

9存储类型

9.1存储相关

auto 自动类型(缺省值) 根据变量定义的位置来自动分配空间

const 修饰变量改变存储位置到常量区或限制变量的写权限

extern 外部引用存储

static 静态存储

9.2变量名

标识符由编程者自己命名

1. 只能由英文字符(a-z,A-Z) 数字(0-9) 下划线组成_

2. 不能数字打头x hello

3. 不能与关键字重名

4. 标识符的长度 gcc 64字节

10类型的转换

隐式类型转换:有编译器自动完成的转换

遵循低精度可以向高精度转换

短长度可以向更长的空间转换

强制(显式)类型转换:手动指定转换的类型

在变量前使用 (类型) 可以强制转换该变量中值的类型

在指针中使用强制类型转换的情况更多

示例:

(int)a; 将变量a中的值强制转换为 int类型

类型转换中的问题:

小数向整数转换舍弃小数部分

整数向浮点型转换其精确值会变为非精确值存在精度丢失问题

11运算符与表达式

11.1算数运算

运算符:表示某种数据处理方式的符号

+ - * 数值间的运算双目运算

/ 若为整型除法, 求商

若为浮点除法, 结果为浮点类型带小数

% 取模运算取余运算两数相除求余数必须要整型

math.h 数学库提供了更多的数学运算方式

11.1逻辑运算

真和假之间的 bool运算非0 为真 0 假

逻辑与: && 双目运算

真 && 真结果真

真 && 假结果假

假 && 真结果假

假 && 假结果假

如: 6 && 7 结果 1

0.25 && '0' 结果 1

逻辑或: || 双目运算

真 || 真结果真

真 || 假结果真

假 || 真结果真

假 || 假结果假

逻辑非: ! 单目运算

!真结果假

!假结果真

!0.25 = 0

!0 = 1

11.2关系运算

比较大小双目运算运算结果为 bool值真或假

C语言中 : == 相等比较 != 不相等

> < >= <=

a >= b 等同于 a > b || a == b ;

判断一个数是否在 0-5 之间 : 数学上 0< a < 5 假

C语言中 0<a && a < 5

位操作运算符: 将值按二进制方式操作

按位与 & 与0得0 与1不变

按位或 | 或1得1 或0不变

按位取反 ~ 单目运算将数按二进制形式对每一个bit进行翻转

移位操作 << 逻辑左移植 >> 算数右移植双目运算

按位亦或 ^ 相同为0 不同为1

5 & 7 == 5

0101

0111

0101

5 | 7 == 7

0101

0111

~0 == -1

a << b 将数a 按二进制方式向左移动 b bit位高位溢出丢弃低位空位补0

a >> b 将数a 按二进制方式向右移动 b bit位低位溢出丢弃高位空位补符号位

5 ^ 7 = 2

0101 1001 0110

0111 0000 1111

^0010 1001 1001

作用了解:

有一个数 a = ??

需要将数a 的最低4bit 设置为 0 其他位不能变

a & ~ 0b1111

有一个数 a = ??

需要将数a 的最低4bit 设置为 1 其他位不能变

a | 0b1111

有一个数 a = ??

需要将数a 的最低4bit 仅对这4bit取反其他位不能变

a ^ 0b1111

有一个数 int num 得到第 cnt[31:0]位是0还是1 ???

if( num & (1<<cnt)) num数中第cnt位为1

else num数中第cnt位为0

(num & (1<<cnt)) >> cnt; // 得到 num数的第cnt位的值

1 0000 0000 0000 0000 0000 0000 0000 0001 <<cnt

两变量 a,b 交换 a,b的值

使用亦或方式

a = a ^ b; // a ^= b;

b = b ^ a; // b ^= a;

a = a ^ b;

a = a + b; // a += b;

a = a - b; // a -= b;

a = b - a; // 不能结合

12表达式

由运算符与值合理顺序构成的一个式子

3+2-5*0 = 5;

C语言中的表达式运算模型:

3+2-5*0 = 5;

5-5*0

5-0

设 a= 0

0< a < 5:

0 < 5

0<a && a < 5:

0 && a < 5

0 && 1

12.1特殊的运算符单目运算符

++ 自增运算符

-- 自减运算符

四个:

前缀++ 运算符

后缀++ 运算符

前缀-- 运算符

后缀-- 运算符

设有 int a =5;

a++; 先用后+ a++表达式的值a; 然后 a= a+1;

++a; 先+后用先执行 a= a+1; 然后表达式的值a;

a--; 先用后- a--表达式的值a; 然后 a= a-1;

--a; 先-后用先执行 a= a-1; 然后表达式的值a;

12.2三目运算符

条件表达式 ? 语句1或表达式 : 语句2或表达式 ;

条件表达式为真则运算语句1或表达式且整个3目表达的值即语句1或表达式的值

条件表达式为假则运算语句2或表达式且整个3目表达的值即语句2或表达式的值

//示例: 将 a,b中大的那个数赋值给c

c = a>b ? a : b;

12.3逗号运算符

用于在一行连接多个表达式, 多个表达式相互独立,

整个表达式的值由最后一个表达式的值决定

表达式1 , 表达式2, ...表达式n;

表达式1 ;

表达式2 ;

...表达式n;

int a,b,c;

12.4 sizeof()

用于计算变量类型对应的内存大小单位字节类型无符号长整型

sizeof(a) = 4

sizeof(int) = 4

sizeof(long) = 8

sizeof(float) = 4

sizeof(double) = 8

() 优先级提升运算符优先级最高

3+(2-5)*0

C语言优先级:

提升运算符

单目运算符！、++、-、&、sizeof、~、–、 +、* 、（类型）

算数运算符

移位与关系运算

逻辑运算

吊车尾 3兄弟三目运算符赋值运算符 = ,运算符

思考?:

设下列表达式中int a 开始时都 = 5; 求下列表达式的值

-5 + ++a; 表达式的值为 1 , a的值为 6;

a++ - 7 * 6; 表达式的值为 -37, a的值为 6;

5 > a++ || 6 > a; 表达式的值为 0, a的值为 6;

~a >> 2 + 8 > 6 && 7;

a++ > 5 && (a = 20);

-5 + ++a;

-5 + 6;

a++ - 7 * 6;

5 -7 * 6; a=6;

5-42;

-37; a=6;

5 > a++ || 6 > a;

5 > 5 || 6 > a;

0 || 6 > 6;

0 || 0

~a >> 2 + 8 > 6 && 7;

-6 >> 2 + 8 > 6 && 7;

-6 >> 10 > 6 && 7;

-1 > 6 && 7;

0 && 7;

a++ > 5 && (a = 20);

5 > 5 && (a = 20); a=6;

0 && (a = 20); 编译器优化 (a = 20) 不执行

可能编译器优化的结构

真 || (....);

假 && (....);

13 C语言中的输出

putchar('a'); 输出一个字符

puts("hello"); 输出字符串

printf 格式化输出函数

printf( "格式控制字符串", 填充量1, 填充量2, .... );

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

格式控制字符串: "a=%d\n"

原样输出的字符 a= \n

格式控制占位符

%开头的

第一个字符

%d 以有符号整数 10进制方式输出到填充位置处

%f 以 float形式输出默认6位小数到填充位置处

%x 无符号整数以16进制方式输出

%u 以无符号整数 10进制方式输出到填充位置处

%c 以字符方式输出一个字符

%s 以字符串形式输出到填充位置处

%e 以科学计数法显示数

%% 显示%本身

%p 输出地址

可选控制字符

%8d 输出宽度为 8个字符右对齐

%-8d 输出宽度为 8个字符左对齐

控制小数点位数

%.2f 保留2位小数, 四舍五入

printf("a=%d, %f %x\n", a, b,c);

fprintf(buf,"a=%d, %f %x\n", a, b,c)

14 输入

程序阻塞等待用户输入

fgetc(); 从终端得到一个字符

fgets(buf, size, stdin); 从终端读取一行字符 \n

gets(buf, stdin); 淘汰了

字符串由多个字符组成

char buf[20]; // 定义了一个连续的内存空间buf, 大小20个字节

字符串: 有最后一个字节存放的一个结束符 '\0' ascii值为 0

fgets(buf, 20, stdin);

若: 终端输入的一行字符串没有超过 buf大小即可得到这一行字符

若超过buf的长度取前面 buf大小-1 个字符存放于 buf中

多余的字符残留在了输入终端,

若程序结束了残留在输入终端的数据将会被清除

scanf(); 与 printf对应格式化输入函数

scanf("格式控制字符串", 容器地址1, 容器地址2, ....);

输入一个整数 : %d

int ret = scanf("%d,%d", &a,&b); // 将输入内容以整数形式存放到a中

ret 存放的是 scanf的返回值 0 没有一个输入成功 >0 有对应个数的数据得到了

输入的数据必须按照格式控制串指定的格式书写否则将导致数据的提取与转换失败

%f 输入浮点数

练习: 输入两个数输出最大的那个

多个数据连续输入 "%d%d" , 使用默认分隔空格回车 table

scanf的输入提取:

输入身份证号码输出你的生日 510502202205050016

scanf("%*6c%4d%2d%2d", &y, &m, &d);

sscanf(buf,"%*6c%4d%2d%2d", &y, &m, &d); // 从buf中进行字符匹配与提取

了解:

scanf("%[1234567890]",strings); 它的作用是：

如果一经发现输入的字符属于方括号内字符串中某个字符，那么就结束提取；

scanf() : 注意事项, 每次scanf() 都会存在残留,会影响下一次的输入

可以在每次输入scanf后进行一次fgets() 吸收残留

作业:

1. 输入两个数求和

2. 提取电话号码在下列输入字符串中

豪华单间出租,联系电话:13888888888

3. 求下列表达式的值

假设 int x=1,y=2,z=5;

x>0 && ! (y==3) || z>5 结果为 1

== 1 && ! (y==3) || z>5

== 1 && 1 || z>5

== 1 || z>5

== 1

! (x+1>0) && y==0 || z>0 结果为 1

== ! (2>0) && y==0 || z>0

== 0 && y==0 || z>0

== 0 && 0 || z>0

== 0 || z>0

== 0 || 1

x<0 || y==0 && z>0

== 0 || y==0 && z>0

== 0 || 0 && 1

== 0 || 0

== 0

int x=1,y=2,z=5;

x = y>z ? z >0 ? 5: y: 10;

x = 0 ? 1?5:y : 10;

x = 0 ? 5 : 10;

x = 10

使用三目运算符求 x,y,z中的最大值

max = x>y? x>z?x:z : y>z?y:z;

x>y?(x>z?x:z):(y>z?y:z);

逗号运算符: ,

用于在一行连接多个表达式,多个表达式相互独立,整个表达式的值由，由最后一个表达式的值决定

表达式1 , 表达式2, ...表达式n;

表达式1 ;

表达式2 ;

...表达式n;

思考:

4. 输入一个整数,输出其二进制

5. 输入一个数, 分解质因数

20 = 2*2*5

6. 输入一个数,判断是否为质数只能被1和他自身整数的数

15 结构性语句

顺序结构: 程序代码顺序执行,从上到下

分支结构: 有选择性的执行部分代码

循环结构: 有条件的重复执行部分代码

分支结构:

if分支

if( 条件表达式 )

{

语句块; //当条件表达式为真时执行

}

else

{

语句块2; //当条件表达式为假时执行

}

若没有else 可以省略

if( 条件表达式 )

{

语句块; //当条件表达式为真时执行

}

若语句块只有一行C代码, ; 时对应的{} 可以省略

if( 条件表达式 ) 一行C语句; //当条件表达式为真时执行

练习:

1.输入你的成绩输出是否及格 60

2.输入你的成绩输出优良中差

100 >=90 >=75 >=60 <60 0

vim: C代码自动排版命令模式下 ggvG=

switch case 多分支结构

switch( 整型表达式 )

{

case 整型常量表达式1: 语句块1; break;

case 整型常量表达式2: 语句块2; break;

...

case 整型常量表达式n: 语句块n; break;

default: 语句块m;

}

运行逻辑:

当整型表达式的值与 case中整型常量表达式的值相等时(匹配上)

执行对应的语句块然后退出 case

若没有任何 case命中整型常量表达式的值与整型表达式的值匹配

执行 default中的语句块m

若语句块m 为空可以省略default

当匹配命中的语句块没有 break;语句此时程序将继续向下执行下一个case中的语句块

直到遇到break; 或 switch 结束

循环结构:

示例: 打印10个'*'

printf("*");

while() 循环结构:

while( 条件表达式 )

{

循环语句块;

}

执行逻辑: 当条件表达式为真时执行循环语句块中的代码一次, 然后继续判断

条件表达式直到条件表达式为假时循环结束

若循环语句块只有一行, {} 可以省略

循环的提前退出,或多条件退出使用break; 关键字

continue; 继续可以让循环中 continue后的循环代码不执行

提前结束本次循环

示例: 打印 0-10的奇数

//打印0-10的奇数

i = 0;

while(i <= 10)

{

if( i++ % 2 == 0) continue; //排除循环中的一些情况

printf("%d ",i-1);

}

return 0;

1 % 2 == 0; i= i+1;

1; i=i+1;

for()循环结构

for( 循环初始化表达式 ; 条件表达式 ; 循迹递进表达式 )

{

循环语句块;

}

执行逻辑:

1.执行一次循环初始化表达式

2.判断条件表达式

3.若为真执行循环语句块一次执行循迹递进表达式一次回到动作2 继续

4.若为假退出循环

在for中 break; 退出本层循环

在for中 continue; 提前结束本次循环执行循迹递进表达式一次在开始下一次循环

课堂练习:

1. 循环求解 1+2+3 ... 100= ??

2. 打印图案使用循环实现

***

****

行hang 空格个数ak=4-hang *的个数mk= hang *2 -1

* 1 3 1

*** 2 2 3

***** 3 1 5

******* 4 0 7

.... ...

行hang 空格个数ak *的个数mk 空格个数ak *的个数mk

hang*2 -3

* 1 4 1 0 0

* * 2 3 1 1 1

* * 3 2 1 3 1

* * 4 1 1 5 1

********* 5 0 9 0 0

其他循环结构

do{

循环语句块;

}while(条件表达式);

逻辑: 先执行一次循环语句块; 然后再判断条件表达式

若真执行一次循环语句块

若假退出循环

goto: 程序跳转

结构:

int a=5;

loop: // 跳转标记 loop 跳转标识符

语句块;

a = 20;

goto loop; //执行到该代码程序将会回到标记处重新开始执行

//但会保留内存中的数据, 变量的值会存在

goto loop;

语句块; // 该语句块将被跳过不执行

loop:

goto 只能在同一个函数中跳转, 不能超越函数跳转

3.升级版输入行数确定图案

16数组

构造数据类型

在内存中将多个相同数据类型的空间(元素)连续排列, 称为数组;

定义:

存储类型元素数据类型数组名[元素个数];

元素: 数组中的每一个数据称作元素

元素个数: 整型常量表达式 > 0

如: int arr[5]; // 定义一个有5个整型(int) 元素的数组名字为 arr;

char s[10];

数组在内存中的存储模型:

按顺序,连续,紧密排列

数组的初始化: 定义时赋值

int arr[5]= { 元素值表 };

int arr[5]= { 2,3,4,5 };

int arr[5]= { 0 }; // 定义并初始化数组为 0

元素值表: 按顺序依次给数组中的元素赋值, 不够的以0初始化 ;

元素值表中的类型应该和数组元素的类型一致

数组的初始化方式赋值仅可以在定义时使用;

char s[10];

s = {'c','b'}; //不行不能如此操作

数组的元素访问: 读写数组中的元素

使用数组名[元素下标] []数组元素访问运算符

元素下标: 起始从0开始编号

元素下标: 可以是整型表达式

int arr[5]= { 2,3,4,5 };

arr[1] ; // 访问数组arr中的 1号下标的元素

arr[1] = 10; // 将数值10 写入到数组arr的 1号下标的元素中

数组的遍历: 依次访问元素中的所有元素

for(i=0; i < sizeof(arr)/ sizeof(arr[0]); i++) arr[i];

内存拷贝: 可以用于复制数组

#include <string.h>

memcpy(目标数组名, 原数组名, 长度单位字节);

目标数组的长度 >= 原数组

字符串与字符数组:

"hello" 字符串常量

char s[] = "hello"; // 将常量字符"hello" 复制到数组 s中

有下列字符串 "hello world"; 要求将其变成全大小字符

ABC...

abc ...

字符串求长度: 通过判断结束符'\0'的位置来确定长度

'\0'

库函数 #include <stdlib.h>

int atoi(const char *nptr); //字符串转换为整数 int

long atol(const char *nptr); //字符串转换为整数 long int

double atof(const char *nptr);//字符串转换为小数 double

num = 123 ===> "123" ???

0个位数: (num / 1) % 10;

1十位数: (num /10 ) % 10;

2百位数: (num /100) % 10;

...

n 位数: (num / m ) %10;

sprintf(buf,"%d", 123);

绝对值 m = m>=0? m : -m;

16.1 一维数组

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

当做二维数组使用 2行5列 5行2列

i j arr[8]

2行5列 1行 3列的值 arr[i*5+j] 8 = i*5+j

数组名:

1. 这个数组本身 arr[0]

2. 这个数组的首地址 printf("%p",arr)

16.2 二维数组

二维数组的定义:

存储类型元素数据类型数组名[一维元素个数][元素个数];

引入: 数组中的元素是一个数组称为二维数组

数组嵌套

int arr[5]; 类型 int [5];

二维数组:

int a[3][5]; //一个a数组中有3个元素 ,每个元素都是一个数组,这个数组由5个整型元素;

二维数组初始化:

int a[3][5] = {{1,2,3,4,5}, {6,7,8,9,10}, {11,12,13,14,15}};

int a[3][5] = {{1,2,3,4,5}, {6,7}, {11,12,13}};

int a[3][5] = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};

int a[3][5] = {1,2,3,4,5,6,10,11,12,13,14,15};

访问:

a[0] 这是什么? {1,2,3,4,5} 是一个一维数组

a[0][4] 即访问 5值 ; 数组a中0号元素的4号元素

a[0][4] = 10;

a[i][j] 表示二维数组中的第i行第j列的元素的值 ij从0开始的

//遍历二维数组

行列遍历

for(j=0;j < 最大行数; j++) // 行循环二维数组的逻辑结构

{

for(i=0;i<最大列数 ;i++) // 列循环

//printf("a[%d][%d]=%d, ",j,i,a[j][i]);

printf("%2d ",a[j][i]);

printf("\n");

}

列行遍历

for(i=0;i<最大列数 ;i++) // 列循环二维数组的逻辑结构

{

for(j=0;j < 最大行数; j++) // 行循环

//printf("a[%d][%d]=%d, ",j,i,a[j][i]);

printf("%2d ",a[j][i]);

printf("\n");

}

逻辑结构即表示平面图像或表有行和列组成

arr[行][列]

存储结构: 每一行紧密连续存储

使用案例: 写五子棋游戏

抽象: 实物 ----> 逻辑表示

棋盘: 9*9 表示字符界面存储二维数组 char[9][9];

0 1 2 3 4 5 6 7 8

0 + + + + + + + + +

1 + + + + + + + + +

2 + + + + + + + + +

3 + + + + + X X + +

4 + + + + + + O + +

5 + + + + + + + O +

6 + + + + + + + + +

7 + + + + + + + + +

8 + + + + + + + + +

棋子: 表示黑子 X 白子 O 无子存储字符

棋盘初始化

棋盘显示

下棋:

落子: hang lie 子 sancf

交替落子仅能在无子处落子

胜负判定

17 函数

代码或代码块的集合, 或特定功能代码的集合

目的:

1.提高代码的复用性

2.方便阅读与调试提高开发速度

main函数程序的主函数或入口函数在程序中有且仅有一个

程序的运行从main函数开始

定义一个函数: 定义函数时函数不会被执行只有被调用了才会执行

返回值类型函数名(形参列表) // 函数的原型

{

功能代码的集合; // 函数体;

return 返回值类型的值; // 结束该函数

}

若函数没有返回值可以使用 void 修饰返回值类型 return ; //结束没有返回值的函数

若函数有返回值定义函数时需要给定返回值类型 int float char 基本数据类型

17.1 函数名

1.代指这个函数本身标识符

2.代表这段代码块的开始地址

函数的输入与输出

一个函数一定有输出可以没有输入 ;

17.2 函数的输入

1. 使用函数的形参列表作为输入参数

2. 使用全局变量作为输入

3. 从标准输入中获得输入 scanf fgets

17.3 函数的输出

1. 使用返回值作为输出多用于输出函数执行成功否

2. 使用标准输出输出 printf fputs ...

3. 向内存中输出向堆区内存或向调用者传递进来的的内存位置

4. 其他非数值形式的输出延时 delay();

int ret = scanf("%d",&a);

形参列表作为输入参数;

什么是形参列表: 函数开始运行时在栈区自动创建的几个局部变量

17.4 函数的调用

运行一次这段代码块

int a = 函数名(实参表); // ()函数调用运算符

// 函数的调用可以看做一个表达式

// 该表达式的值为函数的返回值

a 即赋值为函数的返回值;

17.5 形参与实参:

调用函数时实参表的值依次赋值给形参表中的变量

示例:写一个函数实现两个数求和

int add(int a,int b) // a,b形式参数多个使用','分隔称形参列表

{

return a+b; //返回一个表达式的值其中的a,b即a,b形式参数

}

调用add函数:

add(10,20); // 10,20为实际参数,依次赋值给形参a,b

函数声明:若函数的定义在调用函数之后的位置则该函数需要在调用前声明

声明即函数原型;

全局变量的引用:

extern int board[9][9];

Set_angle

关注

7
点赞
踩
1

收藏

觉得还不错? 一键收藏
3
评论
C语言小结

在程序运行过程中可以更改的量本质一段可以读写的内存主要用于存放程序运行过程中的一些必要数据C程序中变量必须先定义后使用存储类型数据类型变量名 = 初始化值;变量的赋值:给变量对应的内存空间写入一个新的值,覆盖原理的值初始化值可以是常量、变量类型匹配, 空间足够8.2。
复制链接

扫一扫