嵌入式day09

数组在函数间传参

全局数组传递方式

复制传递方式

​ 实参为数组的指针，形参为数组名（本质是一个指针变量）

地址传递方式

​ 实参为数组的指针，形参为同类型的指针变量

编写函数，计算一个一维整型数组的所有元素的和

#include<stdio.h>
int array_sum(int data[], int n);
int main(int argc, char *argv[])
{
        int a[] = {1, 3, 7, 9};
        int sum = 0;
        int n;
        n = sizeof(a) / sizeof(int);
        sum = array_sum(a, n);
        printf("%d\n", sum);
        return 0;       
}
int array_sum(int data[], int n)
{
        int ret = 0;
        int i;
        for(i = 0;i < n;i++){
                ret +=data[i];
        }
        return ret;
}

结果：

删除字符串中空格

#include<stdio.h>
void del_space(char *str);
int main(int argc, char *argv[])
{
        char s[] = "h  el       h";
        puts(s);
        del_space(s);
        puts(s);
        return 0;
}

void del_space(char *str)
{
        char *s2;
        s2 = str;
        while(*str){
                if(*str ==' '){
                        str++;
                }
                else{
                        *s2 = *str;
                        str++;
                        s2++;
                }
        }
        *s2 = '\0';
}

结果：

指针函数

指针函数是指一个函数的返回值为地址量的函数

一般形式：

<数据类型> * <函数名称>(<参数说明>){
	语句序列;
}

返回值：全局变量的地址/static变量的地址/字符串常量的地址

编写一个指针函数删除字符串空格

#include<stdio.h>
#include<string.h>
char *del_space(char *s);
int main(int argc, char *argv[])
{
        char *r; 
        char str[] = "how are you ";
        r = del_space(str);

        puts(str);
        return 0;    
}

char  *del_space(char *s) 
{
        char *p = s;
        char *r = s;

        while(*s){
                if(*s ==' '){
                        s++;    
                }   
                else{
                        *p = *s; 
                        s++;
                        p++;
                }   
        }           
        *p = '\0';
        return r;  
}

结果：

编写一个指针函数，实现字符串连接

#include<stdio.h>
#include<string.h>
char *pstrcat(char *dest, const char *src);
int main(int argc, char *argv[])
{
        char dest[30] = "ghhhhhb";
        char src[] = "ljghg";
        strcat(dest, src);
        puts(strcat(dest, src));
        puts(dest);

        return 0;
}

char *pstrcat(char *dest, const char *src)
{
        char *r = dest;
        while(*dest){
                dest++;
        }
        while(*src){
                *dest = *src;
                dest++;
                src++;
        }
        *dest = '\0';
        return r;
}

结果：

用函数指针来编写将一个整形转换成字符串

#include<stdio.h>
#include<string.h>
char *itoa(int n);
int main(int argc, char *argv[])
{
        int n;
        char *s;
        printf("input:");
        scanf("%d", &n);
        s = itoa(n);
        puts(s);

        return 0;       
}
char *itoa(int n)
{
        int r, i = 0, j;
        static char p[30];
        while(n){
                r = n % 10;
                n /= 10;
                p[i] = r + '0';
                i++;
        }       
        p[i] = '\0';
        j = i-1;
        i = 0;
        while(i < j){
                r = p[i];
                p[i] = p[j];
                p[j] = r;
                i++;
                j--;

        }
        return p;
}

结果：

递归函数

递归函数是指一个函数的函数体中直接调用了该函数自身

递归函数调用的执行过程分为两个阶段：

​ 递归阶段：从原问题出发，按递归公式递推从未知到已知，最终达到递归终止条件

​ 回归阶段：按递归终止条件求出结果，逆向逐步代入递归公式，回归原问题求解

编写一个递归函数ｎ的阶乘

#include<stdio.h>
int fun(int n);
int main(int argc, char *argv[])
{
        int n;
        int s=0;

        printf("Please input n:");
        scanf("%d", &n);
        s = fun(n);
        printf("%d\n", s);
        return 0;
}
int fun(int n)
{
        if( n==0 || n==1){
                return 1;
        }
        return n * fun(n-1);
}       

结果：

写一个递归函数，计算斐波拉契数列

#include<stdio.h>
int fun(int n);
int main(int argc, char *argv[])
{
        int n = 0;
        while(n <= 10){
                printf("%d ", fun(n));
                n++;
        }
        printf("\n");
        return 0;
}
int fun(int n)
{
        if( n==0 || n==1){
                return 1;
        }
        return fun(n-2) + fun(n-1);
}

结果：

函数指针

函数指针用来存放函数的地址，这个地址是一个函数的入口地址

函数名代表了函数的入口地址

函数指针变变量说明的一般形式如下：

<数据类型> (*<函数指针名称>) (<参数说明列表>);

<数据类型>是函数指针指向的函数的返回值类型

<参数说明列表>应该与函数指针所指向函数的形参说明保持一致

(*<函数指针名称>)中，*说明为指针()不可缺省，表明为函数的指针

函数指针数组

函数指针数组是一个保存若干个函数名的数组

一般形式：

<数据类型> (*<函数指针数组名称>) [<大小>])(<参数说明列表>)

排序函数

ainclude<stdio.h>
int compare(const void *, const void *);
int main(int argc, char *argv[])
{
        int s[] = {89, 23, 4, 7, 23, 3};
        int n, i;
        n = sizeof(s) / sizeof(int);
        qsort(s, n, sizeof(int), compare);
        for(i=0;i<n;i++)
                printf("%d ", s[i]);
        puts("");

        return 0;
}
int compare(const void *p, const void *q)
{       
        return (*(int *)p - *(int *)q);
}

结果：