数组在函数间传参

全局数组传递方式

复制传递方式

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

地址传递方式

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

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

#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);
}

结果：

函数指针

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

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

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

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

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

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

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

函数指针数组

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

一般形式：

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

排序函数

#include<stdio.h>
#include<stdlib.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);
}

结果：