嵌入式C语言复习——Day4

嵌入式C语言复习——Day4

C语言函数的使用

1、 函数概述：一堆代码的集合，用一个标签去描述它，复用化；
函数三要素：1、函数名（地址） 2、输入参数 3、返回值
例如：int fun(int, char){xxx}
用指针保存函数：int (*p)(int, int, char);
例如：

int (*p[7])(int,int); //指向函数的指针
p[0] = fun1 ; //函数名为地址
p[1] = fun2 ;
...

int main()
{
    int(*myshow)(const char *,...);
    printf("the printf is %p\n",printf);
    myshow = printf;
    myshow ("=========\n");
    return 0;
}

定义函数和调用函数

int fun(int a, char b) //定义一个函数
{
	xxx;
}
int main()
{
	fun(10,2);  //调用函数
}

指针函数
指针函数： 顾名思义，它的本质是一个函数，不过它的返回值是一个指针。其声明的形式如下所示：

ret *func(args, ...);

其中，func是一个函数，args是形参列表，ret *作为一个整体，是 func函数的返回值，是一个指针的形式。
下面举一个具体的实例来做说明：

# include <stdio.h>
# include <stdlib.h>

int * func_sum(int n)
{
    if (n < 0)
    {
        printf("error:n must be > 0\n");
        exit(-1);
    }
    static int sum = 0;
    int *p = &sum;
    for (int i = 0; i < n; i++)
    {
        sum += i;
    }
    return p;
}

int main(void)
{
    int num = 0;
    printf("please input one number:");
    scanf("%d", &num);
    int *p = func_sum(num); 
    printf("sum:%d\n", *p);
    return 0;
}

在func_sum中，变量sum使用的是静态局部变量，因为一般的局部变量是存放于栈区的，当函数结束，栈区的变量就会释放掉，如果我们在函数内部定义一个变量，在使用一个指针去指向这个变量，当函数调用结束时，这个变量的空间就已经被释放，这时就算返回了该地址的指针，也不一定会得到正确的值。上面的示例中，在返回该指针后，如果我们等待一会儿再去访问该地址，很有可能该地址已经被其他的变量所占用，这时候得到的就不是我们想要的结果。甚至更严重的是，如果因此访问到了不可访问的内容，很有可能造成段错误等程序崩溃的情况。
因此，在使用指针函数的时候，一定要避免出现返回局部变量指针的情况。
使用了static去修饰变量，那么该变量就变成了静态变量。而静态变量是存放在静态存储区的，它的生命周期存在于整个程序运行期间，只要程序没有结束，该变量就会一直存在，所以该指针就能一直访问到该变量。
因此，还有一种解决方案是使用全局变量，因为全局变量也是放在数据段的，但是并不推荐使用全局变量。

函数指针
与指针函数不同，函数指针 的本质是一个指针，该指针的地址指向了一个函数，所以它是指向函数的指针。
我们知道，函数的定义是存在于代码段，因此，每个函数在代码段中，也有着自己的入口地址，函数指针就是指向代码段中函数入口地址的指针。
其声明形式如下所示：

ret (*p)(args, ...);

以一个简单的例子来具体说明一下函数指针的应用：

int (*p[7])(int,int); //指向函数的指针
p[0] = fun1 ; //函数名为地址
p[1] = fun2 ;

2、 函数的输入参数：承上启下的功能
调用者：函数名(要传递的数据) //实参
被调者：函数的具体实现：

函数的返回值类型  函数名(接受的数据)   //形参
{
	xxx;
}

实参传递给形参，可分为值传递和地址传递
传递的形式：拷贝
值传递：上层调用者保护自己空间不被修改的能力
例如：

void Swap(int a, int b)
{
	int tmp = a;
	a = b;
	b = tmp;
        //a=a+b;
        //b=a-b;
        //a=a-b;
}
 
int main()
{
	int a = 10;
	int b = 20;
	printf("%d %d\n", a, b);
	Swap(10, 20);
	printf("%d %d\n", a, b); //a b的值不会改变
 
	return 0;
}

地址传递：上层调用者让下层 子函数修改自己空间中的值的方式
例如：
为了解决在Swap函数中修改主函数中的参数，我们引入指针变量：

void Swap2(int *p1, int *p2)
{
        //p1->a,p2->b
	int tmp = *p1; //接收p1地址里的数据
	*p1 = *p2;
	*p2 = tmp;
}
 
int main()
{
	int a = 10;
	int b = 20;
	printf("%d %d\n", a, b);
	Swap2(&a, &b);  //利用地址的唯一性进行地址传递
	printf("%d %d\n", a, b);
	return 0;
}

3、 连续空间的传递：考虑地址传递
（1）数组
数组名——标签

//实参，需要传递的数据
int abc[10];
fun(abc); //以地址传递，abc为地址名
//形参, 需要接收的数据
void fun(int *p);

（2）结构体
结构体变量
例如：

struct abc{int a;int b; int c;};
struct abc buf;
//实参，需要传递的数据
fun(&buf)
//形参 ，需要接收的数据
void fun(struct abc *a1)//使用地址传递更节约空间，一般都使用指针传递

3、 返回值
基本语法

返回类型 函数名称(输入列表)
{
	return
}

调用者：
xxx = fun();
被调者：

int fun()
{
	return num;
}

例如：

int fun(void)
{
	int a = 0x100;
	int *p = &a;
	int buf[10];
	return buf[10]; //错误，不能返回一个数组
}
int main()
{
	int ret;
	ret = fun();
	printf("the ret is %x\n",ret);
	return 0;
}

返回类型：
基本数据：char、int等
指针（空间）
不能返回数组

返回连续空间类型：指针作为空间返回的唯一数据类型
要注意地址指向空间的合法性，作为函数的设计者，必须保证函数的返回地址所指向的空间是否合法（即不是局部变量）
一般的来说，函数是可以返回局部变量的。 局部变量的作用域只在函数内部，在函数返回后，局部变量的内存已经释放了。因此，如果函数返回的是局部变量的值，不涉及地址，程序不会出错。
但是如果返回的是局部变量的地址(指针)的话，程序运行后会出错。因为函数只是把指针复制后返回了，但是指针指向的内容已经被释放了，这样指针指向的内容就是不可预料的内容，调用就会出错。准确的来说，函数不能通过返回指向栈内存的指针(注意这里指的是栈，返回指向堆内存的指针是可以的)。

例如：

char *fun(void)
{
	char buf[] = "hello world!"; //buf是局部变量
	return buf;
}
int main()
{
	char *p;
	p = fun();
	printf("the p is %s\n",p); //输出p为空，指向的地址不合法
	return 0;
}

1、 可以将数组空间静态处理，将局部变量变为全局变量，即加上关键字static

char *fun(void)
{
	static char buf[] = "hello world!"; //buf存放在静态存储区
	return buf;
}
int main()
{
	char *p;
	p = fun();
	printf("the p is %s\n",p); //输出为the p is hello world!
	return 0;
}

2、只读区：字符串常量，不太常用
3、堆区：malloc，free

char *fun(void)
{
	//static char buf[] = "hello world!"; //buf存放在静态存储区
	char *s = (char *)malloc(100); //在堆上分配一个空间 
	strcpy(s,"hello world"); //将字符串复制到s所指向的地址空间内

	return s;
}
int main()
{
	char *p;
	p = fun();
	printf("the p is %s\n",p); //输出为the p is hello world!
	free(p);//需要释放掉p的空间
	return 0;
}

位操作
例如：嵌入式系统中总是需要用户对变量或寄存器进行位操作，给定一个整型变量a，写两段代码，第一个 set 设置 a的bit 3，第二个 reset 清除 a 的bit 3。在以上两个操作中，保持其他位不变

unsigned int a;
a |= (0x01<<3);
a &= ~(0x01<<3);

访问固定内存位置
例如：在某工程中，要求设置一绝对地址为0x67a9的整型变量的值为0xaa66。编译器是一个纯粹的ANSI编译器，编写代码完成操作

int *p = (int *)0x67a9; //p指到绝对地址
p[0] = 0xaa6;
或者：
*((int*)0x67a9) = 0xaa66;