函数

定义

c 语言函数设计：早前模块化设计理念的具体应用；

将一个复杂问题解决程序的代码，根据功能不同我们给它划分成若干多个简单模块，然后对每个模块进行程序设计；实现对复杂问题解决；

模块在每个语言上称呼：在 c program 叫做函数；有的语言叫做过程，在面向对象的语言中：方法();

格式:

1
2
3
4
5
6


函数类型 函数名(参数系列)        // 函数的数据类型和函数返回处理结果的数据类型一致的；
{
    sentence;
    ...
    return 函数处理的结果；
}

如果函数没有 return 语句，那么函数类型就是 void 类型；

函数名：调用的依据；函数名的命名和普通变量的规则相同；

参数系列：参数提供给函数加工处理的数据；系列是可以提供多个参数

int x,y 如果作为参数变量，需要分开表达：int x, int y;

在函数中，一旦执行 return，语句所有执行都全部停止；

Q1 定义一个函数，求三个数的最大值；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


int FindMax(int x,int y,int z){            // 函数的默认类型是 int
    int max;
    max = x<y?y:x;
    max = max<z?z:max;
    return max;
}

main(){
    int x;
    x = fun(12,36,4);
    printf("%d",x);
}

调用就是通过一个函数调用另一个函数，在考试范围内，都是通过 main() 函数调用；

Q2 定义一个函数，求阶乘；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


int fun(int n){
    int s = 1;
    for(int i=1; i<=n; i++)
        s = s*i;
    return s;
}
main()
{
    int m,n,s;
    printf("input m,n:");
    scanf("%d,%d",&m,&n);
    s = fum(m) / (fun(n) * fun(m-n));
    printf("%d",s);
}

将指针作为函数参数

指针参数传递的只能是地址

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void fun(int pa, int pb){
    int t;
    t = pa; pa = pb; pb = t;   // 函数内是局部变量，即改变后的值不会传输给main函数；
}

main(){
    int a,b,c;
    a = 3, b= 1;
    c = fun(a,b);                // 传值进入函数，对原来的函数没有任何影响
    printf("%d\n",c);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


void fun(int *pa, int *pb){
    int t;
    t = *pa; *pa = *pb; *pb = t;    
}

main(){
    int a,b,c;
    a = 3, b= 1;
    fun(&a,&b);                      // 传地址，即直接修改该变量
    printf("%d\n",c);
}

Q3 指针作为参数，定义函数求两个数的最小公倍数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


int fun(int *pa, int *pb){
    int t,r;
    t = *p1 * (*p2);
    // 求最大公约
    while(*pa%*pb!=0){
        t = *pa % *pb;
        *pa = *pb;
        *pb = t;  
    }
    // 求最小公倍数    return t/(*p2);
}

main(){
    int m,n;
    printf("input m,n:");
    scanf("%d %d",&a,&b);
    printf("%d\n",fun(&a,&b));
}

以数组名作为参数

1
2
3
4


int fun(int a[],int n);        // a是数组名，n是元素个数
int fun(int *p, int n);        // 与前者等同，p是指向数组的首地址，n为元素个数

// 无论如何，参数为数组的传递的实参，肯定是地址；通常传递的是数组的首地址；

Q4 定义一个数组，求数组元素的次最大值；

解题思路：次最大值，它是由最大值反应出来的，在求解过程中，要求出最大值，比自己值大，且比最大值小肯定就是次最大值；如果有比最大值大的，此时最大值就是次最大值；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


int fun(int a[],int n){
    int i,j,max,xmax;
    if(a[0]>a[1]){
        max1 = a[0];
        max2 = a[1];
    }
    else{max1 = a[1];
     max}
    for(i=0; i<n; i++){
        if(xmax<a[i]){
            max = xmax;
            xmax = a[i];
        }
        else if(max<a[i])
            max = a[i];
    }
    return max;       
    // 只能返回一个 对象，只能执行一个 return；
    // 若要返回多个数，必须返回数组，问：数组是地址，修改过后还需要返回吗？
    //答：没有必要，除非该数组是在函数内定义的局部变量，返回后空间释放，数组丢失……
}

main(){
    int a[] = {12,98,6,35,78,21};
    int n = 6;
    int i;
    for(i=0; i<10; i++){
        scanf("%d",&a[i]);
    }
    k = fun(a,n);
    printf("%d",k);
}

**Q5 设计一个函数，删除非前导的 ***

字符串作为函数的参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


void fun(char st[]){                // 字符串有 \0 作为结束，故此无须传入元素个数
    int i=0,j;
    while(st[i]=='*') i++;
    while(st[i]!='\0')
    {
        if('*' == st[i])
            for(j=i+1; j<strlen(st); j++)
                st[j-1] = st[j];
    
        if(st[i] != '*') i++;
    }
}

int main(){
    char st[] = "****sa**def***zffd";
    fun(st);
    printf("%s\n",st);
    return 0;
}

Q6 以指针作为函数子串的参数；设计函数，将一句话的每个单词前面第一个字母变成大写；

how are you -> How Are You

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


void fun(char *p);
{
    int i,j;
    *p -= 32;
    for(i=1; *(p+i) != '\0'; i++){
        while(*(st+i) == ' ') i++;
        if(*(st+i-1) == ' '){
            *(st+i) -= 32;
        }
    }    
}

main(){
    char st[] = "how are you";
    fun(st);
    printf("%s\n",st);
}

补充：

当函数非空型，必须有return返回值，函数没有return 语句时，默认函数类型为 void
若是没有定义函数的类型，默认为int整型
形参与实参占据不同的单元