嵌入式学习笔记十一——C语言数组作为函数参数和标识符的作用域和可见性问题

数组作为函数参数

1.数组本身作为函数参数 

在函数中无法计算数组的长度，需要将长度作为参数 传入函数
      形参  --写成数组形式  还需要数组长度 
      实参  --数组名,数组长度

printArrray(int a[],int len) //形参 
//printArrray (int *a,int len) ---编译器最终理解的形式 
//调用
printArray(a,len); 

2.一维字符型数组做函数参数
一维字符型数组

用来存放字符串 

因为处理的是字符串数据，字符串操作的 依据，主要看结束标志 '\0'而不是 数组长度

所以： 一维字符型数组做函数参数，

1.   形参  数组形式
2.   实参  数组名 

练习：写Gets(char s[])，Strlen(char s[])，Strcat(char dest[],char src[])，Strcpy(char dest[],char src[])，Strcmp(char s1[],char s2[])函数，实现相对应的功能

#include <stdio.h>
 
void Puts(char s[])
{
	int i = 0;
	while (s[i] != '\0')
	{
		printf ("%c",s[i]);
		++i;
	}
	putchar('\n');
}
 
void Gets(char s[])
{
	int i = 0;
	while ((s[i] = getchar()) != '\n') //s[i] = getchar()须括起来 
                                       //关系运算 != 比 = 优先级高。
	{
		++i;
	}
	s[i] = '\0';
}
 
int Strlen(char s[])
{
    int i;
	while (s[i] != '\0')
		++i;
	return i;
}
 
void Strcpy(char dest[],char src[])
{
	int i = 0;//记得一定要初始化
	while (src[i] != '\0')
	{
		dest[i] = src[i];
		++i;
	}
	dest[i] = '\0';
}
 
void Strcat(char dest[],char src[])
{
	int i = 0;
	int j = 0;
	while (dest[i] != '\0')
		++i;
	while (src[j] != '\0')
	{
		dest[i] = src[j];
		++i;
		++j;
	}
	dest[i] = '\0';
}
 
int Strcmp(char s1[],char s2[])
{
	int i = 0;
	int ret;
	while (s1[i] == s2[i] && s1[i] != '\0' && s2[i] != '\0')
	{
		++i;
	}
	ret = s1[i]-s2[i];
	return ret;
}
 
 
int main(void)
{
	char s[100];
	char ss[100] = "hello";
	Gets(s);
	Puts(s);
    printf("%d\n",Strlen(s));
//	Strcpy(ss,s);
//	Strcat(ss,s);
//	Puts(ss);
    printf("%d\n",Strcmp(s,ss));
	return 0;
}

3.二维数组做函数参

总结:
    形参   --- 二维数组形式 + 行数    //本质 一维数组 + 长度
    实参   --- 数组名       + 行数    //

练习:实现一个函数，1.求二维数组元素的和 2.找出二维数组中主对角上最大值 

#include <stdio.h>
 
void printArray(int (*a)[4],int row)
{
	int i = 0;
	int j = 0;
	for (i = 0;i < row;++i)
	{
		for (j = 0;j < 4;++j)
		{
			printf("%d ",a[i][j]);
		}
		putchar('\n');
	}
}
 
int addArray(int (*a)[4],int row)
{
	int i = 0;
	int j = 0;
	int sum = 0;
	for (i = 0;i < row;++i)
	{
		for (j = 0;j < 4;++j)
		{
			sum += a[i][j];
		}
	}
	return sum;
}
int findMax(int a[][4],int row)
{
	int i = 0;
	int max = a[0][0];
 
	while (i < row)
	{
		if (max < a[i][i])
			max = a[i][i];
		++i;
	}
	return max;
}
 
 
int main(void)
{
	int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
	int row = sizeof(a)/sizeof(a[0]);
	printf("%d\n",addArray(a,row));
	printArray(a,row);
	printf("max = %d\n",findMax(a,row));
	return 0;

4.二维字符数组做函数参数

 与二维整型数组 使用方式相同 
    形参   --- 二维数组形式 + 行数    //本质 一维数组 + 长度
    实参   --- 数组名       + 行数    //

  注意:
      1.不要和一维字符型数组传参搞混 
        一维字符型数组，主要用来存放 字符串数据 
        而字符串数据有结束标志('\0'),故，传参时，不需要传长度 

       2.二维字符型数组，用来存储多个字符串
       要操作时，往往都是操作多个字符串，而多个字符串没有所谓结束的标志。
       看的是数组长度(行数)

练习:1. 实现一个输入多个字符串函数2.排序    //插入排序3.二分查找 

#include <stdio.h>
#include <string.h>
void printStr(char s[][10],int row)
{
	int i = 0;
	for (i = 0;i < row;++i)
	{
		puts(s[i]);
	}
}
 
 
 
void inputStr(char s[][10],int row)
{
	int i = 0;
	for (i = 0;i < row;++i)
	{
		gets(s[i]);
	}
}
 
void insertSort(char s[][10],int row)
{
	int i = 0;
	char ss[10];
    for (i = 0;i < row;++i)
	{
		strcpy(ss,s[i]);
		int j = i;
		while(j > 0 && strcmp(ss,s[j-1]) < 0)
		{
			strcpy(s[j],s[j-1]);
			j--;
		}
		strcpy(s[j],ss);
	}
}
 
int seekStr(char s[][10],int row,char s1[])
{
	int begin = 0;
	int end = row - 1;
	int mid;
	int ret = 0;
	while (begin <= end)
	{
		mid = (begin+end)/2;
		if (strcmp(s[mid],s1) < 0)
			begin = mid + 1;
		else if (strcmp(s[mid],s1) > 0)
			end = mid - 1;
		else 
		{
			ret = mid;
			break;
		}
	}
	return ret;
 
}
 
 
int main(void)
{
	char s[5][10];
	int row = sizeof(s)/sizeof(s[0]);
	char s1[10] = "hello";
	inputStr(s,row);
	insertSort(s,row);
	printStr(s,row);
	printf("s[%d] = %s\n",seekStr(s,row,s1),s[seekStr(s,row,s1)]);
	return 0;
}

  总结:

   1.一维整型数组 做函数参数
   形参 --- 数组形式 + 数组长度 
   实参 --- 数组名   + 数组长度    
   2.一维字符型数组 做函数参数
   形参 --- 数组形式  
   实参 --- 数组名   
   原型: 一维字符型数组 主要用来存储字符串数据 
   3.二维整型数组 做函数参数
   形参 --- 数组形式 + 行数 //本质 就是一维数组的长度 
   实参 --- 数组名   + 行数 
   4.二维字符型数组 做函数参数
   形参 --- 数组形式 + 行数 //本质 就是一维数组的长度 
   实参 --- 数组名   + 行数

2.标识符的作用域与可见性问题:

作用域：名字 作用的访问 
可见性 ：程序运行到某一个位置 哪些名字可以被使用(被看见)

1.作用域:

局部作用域 
        { 
        }  //花括号范围内 就叫局部作用域 
 全局作用域 
       不在 任何一个 {} 范围之内 

 （1）在局部作用域定义的变量 --- 局部变量  
   特点:局部变量 空间 一般都开栈上， 如果不初始化，局部变量中的值是随机值(垃圾值)

  （2）在全局作用域 定义的变量 --- 全局变量 
   特点:全局变量 空间  全局区， 如果不初始化，默认初始化为0

2.标识符的可见性的规则:

1.先定义，后使用 
2.同一作用域中，不能有同名标识符
3.在不同的作用域，同名标识符，相互之间没有影响 
4.如果是不同的作用域，但是作用域之间存在嵌套关系， 则内层的作用域的同名标识符，会屏蔽外层的作用域的同名标识符。 (就近原则)

3.生命周期

（1）局部变量的生命周期 

      从程序运行到定义处开始存在，到程序运行到 它作用范围结束时销毁

（2）全局变量(静态变量)的生命周期

     从程序开始运行时就存在了，直到整个程序运行结束时，销毁 
      注意:全局变量和静态变量，不能用"变量"进行初始化

4.存储类别的关键字

auto ：表示它是一个自动变量 (局部变量)  ---  自动申请 自动释放 

static：static 修饰局部变量  此时 会被放在 全局区(静态区)此时局部变量的生命周期被延长
注意:
   1.static 修饰局部变量 --只会被初始化一次 

   2.static 修饰的变量 -- 具有继承性

   3.static 修饰的变量 -- 只能用常量初始化 (不能用变量初始化)

   4.static 修饰全局变量 表示限定全局变量的作用域位本文件，别的文件不能通过extern来声明使用。用途: 保护私有数据 ， 防止被引用 。
   5.修饰函数 //声明函数 在别处的定义的 函数，static 修饰函数作用和修饰全局变量作用相同， 限定作用域为本文件，别的文件不能通过extern来声明使用 

register：寄存器  表示，把变量 存储 寄存器中 //建议性//register 修饰的变量 ，不能 做 & //(取地址) 

extern：外部的  ---表示你的变量 是存在外部的   //多文件编程 //不在当前文件中  //只能 声明 全局变量 

 static总结：

1.修饰变量 

（1）修饰局部变量 
表示将局部变量存放到静态区。 延长声明周期。
存在静态区的变量：
a.不能用变量初始化 
b.只会被初始化一次 
c.反复使用该变量时，值具有继承性。

（2）全局变量   
限定作用域为本文件，别的文件不能通过extern来声明使用 

2.修饰函数         
限定作用域为本文件，别的文件不能通过extern来声明使用