函数传参、进程映像

一、函数传参
1、形参变量、函数内定义的变量都只是属于它所在的函数，出了该函数
就不能再用
2、普通实参与形参之间是通过赋值的方式传递数据的（单行值传递），函数
之间不能共享同名变量
3、return其实是把数据存放到一个公共区域（函数都可以访问），如果
不写return语句，那么就会读取该区域原来的数值，就得到一个垃圾数据
4、数组作为函数的参数时，中括号中的长度就会丢失，需要额外增加
一个参数传递数组的长度
5、数组作为函数参数传递时，传递的是数组的首地址，叫做"址传递"，
函数和函数的调用者可以共享同一个数组

练习1：实现函数，找出数组的最大值

#include <stdio.h>
int func(int arr[],int len);
int main(int argc,const char* argv[])
{
int max=0;
int arr[10]={11,3,2,4,8,6,7,5,9,10};
max=func(arr,sizeof(arr)/sizeof(arr[0]));
printf(“max:%d”,max);
}
int func(int arr[],int len)
{
int max=arr[0];
for(int i=0;i<len;i++)
{
if(max<arr[i])
{
max=arr[i];
}

}
return max;

}

练习2：实现函数，对数组进行升序排序
#include <stdio.h>

void sort(int arr[],int len);

int main(int argc,const char* argv[])
{
int arr[]={4,2,6,5,7,10};
int len=sizeof(arr)/sizeof(arr[0]);
sort(arr,len);
for(int i=0;i<len;i++)
{
printf("%d ",arr[i]);
}
}
void sort(int arr[],int len)
{
for(int i=0;i<len-1;i++)
{
for(int j=i+1;j<len;j++)
{
if(arr[i]>arr[j])
{int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
}

练习3：实现一个函数，查找数组中是否存在某个值，如果存在则返回该值
的下标
#include <stdio.h>

int find_arr(int arr[],int len,int key);
int main(int argc,const char* argv[])
{
int arr[]={2,4,6,3,4,7,99,4};
int len=sizeof(arr)/sizeof(arr[0]);
printf(“index:%d\n”,find_arr(arr,len,7));

}
int find_arr(int arr[],int len,int key)
{
for(int i=0;i<len;i++)
{
if(key==arr[i])

        return i;
    
}
return -1;

}

设计函数的建议：
    1、一个函数就解决一个问题，降低错误率，提高可读性
    2、尽量减少函数之间的依赖层数（降低耦合度）
    3、数据由调用者提供，结果返回给调用者（提高通用性）
    4、考虑函数的非法参数，可以通过返回值的方式告诉调用者
    参数有误，也可以通过注释方式写明情况（提高函数的健壮性）

二、进程映像
程序：存储在磁盘上的可执行文件（二进制文件、脚本文件）
进程：在系统中运行中的程序 数据加载到内存运行
进程映像：指的是进程内存的分布情况
text 代码段 存储二进制的指令、常量数据、被const修饰
过初始化过的全局变量、静态局部变量 权限是只读的，强制修改
会产生段错误
data 数据段 初始化过的全局变量，初始化过的静态局部变量
bss 静态数据段 未初始化的全局变量，未初始化过的静态局部
变量，进程运行前该段内存会自动清理为0
heap 堆 由程序员手动管理，使用麻烦 优点：足够大
stack 栈 局部变量、块变量 由操作系统管理，
，会在进程运行过程中自动申请、释放内存 使用简单 内存小

局部变量和全局变量：
    全局变量：定义在函数外的变量
        存储位置：data（初始化） 或者 bss（未初始化）
        生命周期：程序开始到程序结束
        作业范围：在程序的任意位置都可以使用
    局部变量：定义在函数内的变量
        存储位置：stack 栈内存
        生命周期：从函数调用开始到函数结束
        作业范围：只能在函数内使用
    块变量：定义在语句块内的变量 if\for\while
        存储位置：stack 栈内存
        生命周期：从函数调用开始到函数结束
        作业范围：只能在语句块内使用
    注意：局部变量可以和全局变量同名，在函数内局部变量会屏蔽
    同名的全局变量，块变量在语句块内屏蔽同名的全局变量、局部变量
    ，因此建议全局变量首字母大写，局部、块全部小写

三、类型限定符
auto 用于定义自动分配内存、释放内存的变量（局部变量），不加
就代表了加
注意：全局变量不能用auto修饰的
在C11中用于自动识别类型
auto num=10；

    extern
        声明变量  extern 类型名 变量名；
        告诉编译器此变量已经在别处定义过了，请放心使用
        但是只能临时让编译通过，但是在链接时如果找不到该变量
        的定义，依然会报错
        不能在声明变量时赋值
        在多文件编程中，假设a.c中定义全局变量N，想要在b.c中使用
        N，需要在使用前声明该变量

    static
        改变存储位置：
            改变局部变量的存储位置，从stack改为data或者bss（取决于是否
            初始化）
            被它修饰的局部变量叫做静态局部变量
        延长生命周期：
            延长了局部变量的生命周期，函数结束后不会被销毁，直到进程结束
        限制作用范围：
            限制全局变量、函数的作用范围，只能在本文件内使用
            可以防止全局变量、函数命名冲突，也可以防止被别的文件
            使用

    const
        “保护”变量的值不能被显示地修改
        但是可以通过访问内存的方式来修改值
        但是如果修饰的是初始化过的全局变量、初始化后的静态局部
        变量，则该变量会从data改为text，变成了“常量”，不能
        强制修改

    volatile
        如果变量的值没有被显示地修改，那么在使用该变量时变化从内存
        中读取，而是继续使用上次读取的结果，这个结果叫做取值优化，
        一般变量都会进行。
        变量被volatile修饰后，编译器不对该变量进行取值优化，每次都从
        内存中重新读取
        一般硬件编程时、多线程编程时会使用到

存储介质:硬盘->内存->高级缓存->寄存器
    register
        申请把变量的存储介质由内存改为寄存器，由于寄存器数量有限
        不一定能够申请成功
        注意：寄存器变量不能取地址

    typedef
        类型重定义
        定义变量时，如果在类型名前面加typedef，那么变量名就
        变成了这个类型的新的类型名
        注意：typedef不是替换关系

    小项目：五子棋
        需要数据：
            1、定义字符数组的棋盘 15*15
            2、定义变量用于记录落子的位置
            3、定义一个变量记录棋子角色 黑棋'@'     白棋'$'

        业务逻辑：
            定义需要的数据
            是否需要对数据进行初始化
            for（；；）
            {
                1、清理屏幕、显示棋盘
                2、落子
                    坐标要合法、该位置不能有棋子
                    否则继续重新落子
                3、 检查是否五子连珠
                    是，结束游戏
                4、交换角色
            }

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <getch.h>
//棋盘数组
char board[15][15];;
//棋子坐标
//char key_x,key_y;
//棋子角色 黑’@‘白’$’
char role=‘@’;
int key_x=7,key_y=7;

//初始化棋盘
void init_board(void);
//显示棋盘
void show_board(void);
//落子
void get_key(void);
bool is_win(void);
int main(int argc,const char* argv[])
{
init_board();
for(;😉
{
show_board();
get_key();
if(is_win())
{
show_board();
printf(“%c胜利”,role);
return 0;
}
//交换角色
role=‘@’==role?‘$’:‘@’;
}

}
void init_board(void)
{
for(int i=0;i<15;i++)
{
for(int j=0;j<15;j++)
{
board[i][j]=‘*’;
}
}
}
void show_board(void)
{
system(“clear”);
for(int i=0;i<15;i++)
{
for(int j=0;j<15;j++)
{
printf(" %c",board[i][j]);
}
printf(“\n”);
}
}
void get_key(void)
{
printf(“请%c落子”,role);
for(;😉
{
printf(“\33[%d;%dH”,key_x+1,(key_y+1)2);
switch(getch())
{
case 183:key_x>0 && key_x–; break;
case 184:key_x<14 && key_x++; break;
case 186:key_y>0 && key_y–; break;
case 185:key_y<14 && key_y++; break;
case 10: if(''==board[key_x][key_y])
{
board[key_x][key_y]=role;
return;
}
break;
}
}
}

//	printf("请%c输入棋子坐标:",role);
//	scanf("%hhd%hhd",&key_x,&key_y);
	//检查坐标是否合法
//	if(key_x<0||key_x>14||key_y<0||key_y>14)
//	{
//		printf("坐标不合法，请重新输入\n");
//		continue;
//	}
	//检查是否有棋子
//	if('*'!=board[key_x][key_y])
//	{
//		printf("该位置已有棋子，请重新输入\n");
//		continue;
//	}

// board[key_x][key_y]=role;
// return;
// }
//}
bool is_win(void)
{
//左上+右下
int cnt=0;
//左上
for(int x=key_x-1,y=key_y-1;x>=0&&y>=0;x–,y–)
{
if(board[x][y]==role)
{
cnt++;
}
else
{
break;
}
}
for(int x=key_x+1,y=key_y+1;x<=14&&y<=14;x++,y++)
{
if(board[x][y]==role)
{
cnt++;
}
else
{
break;
}
}
if(cnt>=4)
{
return true;
}
cnt=0;

for(int x=key_x-1,y=key_y;x>0;x--)
{
	if(board[x][y]==role)
	{
		cnt++;
	}
	else
	{
		break;
	}
}
for(int x=key_x+1,y=key_y;x<=14;x++)
{
	if(board[x][y]==role)
	{
		cnt++;
	}
	else
	{
		break;
	}
}
if(cnt>=4)
{
	return true;
}
cnt=0;
for(int x=key_x,y=key_y-1;y>0;y--)
{
	if(board[x][y]==role)
	{
		cnt++;
	}
	else
	{
		break;
	}
}
for(int x=key_x,y=key_y+1;y<=14;y++)
{
	if(board[x][y]==role)
	{
		cnt++;
	}
	else
	{
		break;
	}
}
if(cnt>=4)
{
	return true;
}
cnt=0;
for(int x=key_x+1,y=key_y-1;x<=14&&y>0;x++,y--)
{
	if(board[x][y]==role)
	{
		cnt++;
	}
	else
	{
		break;
	}
}
for(int x=key_x-1,y=key_y+1;x>0&&y<=14;x--,y++)
{
	if(board[x][y]==role)
	{
		cnt++;
	}
	else
	{
		break;
	}
}
if(cnt>=4)
{
	return true;
}
cnt=0;
return false;

}