首页 > C语言专题 > 函数 阅读:445

C语言函数完全攻略

pk10开户推出辅导班啦,包括「C语言辅导班、C++辅导班、算法/数据结构辅导班」,全部都是一对一教学:一对一辅导 + 一对一答疑 + 布置作业 + 项目实践 + 永久学习。QQ在线,随时响应!

C 语言强调模块化编程,这里所说的模块就是函数,即把每一个独立的功能均抽象为一个函数来实现。从一定意义上讲,C 语言就是由一系列函数串组成的。

在本章之前,我们的程序只有一个 main 函数,把所有代码都写在 main 函数中,这样虽然程序的功能正常实现,但显得杂乱无章,代码可读性、可维护性较差。学完本节之后,应把每个具体的独立功能单位均抽象为一个函数,在 main 函数中调用各个函数。

C 语言函数大概包括两种,一种是编译系统提供的库函数,如字符串处理复制函数 strcpy,这是 C 编译系统提供的库函数,该函数定义在 string.h 头文件中,在使用时必须包含对应的头文件,即需加上 #include<string.h> 预处理包含命令;另一种是程序设计者自定义的函数。

每一个 C 语言程序都含有一个 main 函数,操作系统调用 main 函数,main 函数调用各个库函数或自定义函数。

函数的定义

函数是用户与程序的接口,在定义一个函数前,首先要清楚以下三个问题。

1) 函数的功能实现及算法选择。算法选择会在后续文章详细讲解,本节重点关注函数的功能实现。一般选取能体现函数功能的函数名,且见名知意,如求和函数的函数名可取为 add,求最大值的函数名可取为 max,排序函数可取名为 sort 等。

2) 需要用户传给该函数哪些参数、什么类型,即函数参数。

3) 函数执行完后返回给调用者的参数及类型,即函数返回值类型。

函教定义格式

函数定义的一般格式为:

返回类型 函数名 (类型参数1,类型参数2,…)
{
    函数体
}


例如,定义一个求两个整数之和的函数,返回该和值。其函数实现代码为:
int add (int x,int y)
{
    return (x+y) ; //括号可省略
}
说明:
1) 一个函数定义包含函数头和函数体两部分。函数名、参数表和返回类型这三部分一般称为函数头。一对大括号 {} 括起来的为函数体。

2) 函数名:符合标识符的命名规则,最好见名知意。如使用 add 作为求和函数的函数名,sort 作为排序函数名。

3) 参数表:函数定义时的参数又称为形式参数,简称形参。可以含有一个或多个参数,多个形参用逗号隔开。如下格式是错误的。
int add (int x;int y) //错误。函数各形参间用逗号隔开,而非分号
{
    return x+y;
}
各形式参数对应类型均不能省略,如下格式也是错误的。
int add (int x,y) //错误。形参y的类型不能省略
{
    return x+y;
}
也可以不含参数,不含参数时,参数表中可写关键字 void 或省略,为规范起见,教程中对没有参数的函数,参数表中统一写 void。例如:

类型 函数名 ()
{
    函数体
}

等价于:
类型 函数名 (void) //建议的书写方式
{
    函数体
}
4) 在函数定义中,参数表后不能加分号,如下函数定义格式是错误的。
float add (float x, float y); //错误。函数定义时,函数头后不能有分号
{
    return x+y;
}
5) 函数体:即函数的功能实现代码部分。用一对大括号 {} 括起来,函数体也可以为空,即函数体内不含任何代码,便于以后扩充。例如:
void fun ()
{

}
6) 返回类型:也称为函数类型,即给调用者返回值的类型。要求显式指定返回类型。可以是基本数据类型如 int、char、float 等,也可以是复合数据类型,如数组类型、指针类型,或者是自定义类型(结构体类型)。

如果返回类型省略,一般默认为 int 型,但不推荐这种不规范的写法。

如果该函数没有返回类型,则为 void 类型。例如:
void add (int x,int y)
{
    printf ("sum=%dn", x+y);
}
除了 void 类型外,在函数体中,均需要显式使用 return 语句返回对应的表达式的值。

函教返回值

函数的值是指调用函数结束时,执行函数体所得并返回给主调函数的值。 关于函数返回值说明如下。

1) 带返回值的函数,其值一般使用 return 语句返回给调用者。其格式为:

return 表达式;

或者

return (表达式);

例如:
int add (int a, int b)
{
    return (a + b); //return 后为表达式
}
2) 函数可以含一个或多个 return 语句,但每次调用时只能执行其中一个 return 语句。

例如,求整数绝对值的函数:
int f (int n) //含多个return语句,但每次调用只执行一个
{
    if (n >= 0)
        return n;
    else
        return -n; //或为 return (-1 * n);
}
3) 不带返回值的函数,其返回类型一般显式指定为 void 类型。如 void print_99 (void); 函数,其返回类型为 void。

4) 如果没有显式指定函数的返回类型,默认为 int 型,不推荐这种不规范的写法。 例如:
add (int a, int b) //省略返回类型,默认为int型
{
    return (a + b);
}
5) return 后表达式的类型应与函数返回类型一致,如果不一致,则先将表达式的类型自动转换为函数类型后再返回。例如:
int f (void) //函数返回类型为int
{
    int n = 1;
    return (n + 2.3); //表达式为 double 型
}
上述函数中,函数类型为 int 型,return 后表达式的类型为 double 型值 3.3,两者类型不一致,故首先把表达式的类型 double 自动转换为 int 型值 3,然后再把 3 作为函数返回值返回给调用者。这种情况一般会丢失精度,可能得不到预想的结果。

函教调用格式

无参函数的调用格式

函数名();

注意:无参函数调用时,参数表空着,而不能写出 void,如下函数调用是错误的。

函数名 (void);//错误!无参函数调用时,参数表空着,不能加void

例如,设有定义好的无参函数 void print_99(void); 的调用如下。
print_99 ( ) ; //正确。调用无参函数
print_99 (void) ; //错误。实参表中不能加void

带参函数的调用格式

函数名(实参1,实参2,…);

说明:
1) 其中各实参可以是各种类型的常量、变量或表达式。例如,对定义好的带参函数 int add (int a,int b); 的调用如下。
add (2,5+1); //正确,实参可以为常量、变量或表达式 int n=7;
add(3,n); //正确,实参可以是变量
2) 调用函数时,不能写函数类型。
int add(2,3);//错误,调用时不能加返回类型

函教调用过程

函数调用的过程是:首先是实参给形参赋初值,接着函数体对形参做相应处理,最后把处理结果作为函数值返回给调用者。

未被调用时的函数形参并不占用内存空间,在函数调用时为形参变量分配空间,把实参的值赋给对应形参变量的空间,函数调用结束时,收回分配给形参的内存空间。即形参仅在函数调用的过程中占有内存空间。

通过如下 add 函数来说明函数调用过程。
//函数定义
int add (int a, int b)
    int s;
    s=a+b;
    return s;
}
说明:
1) 以上是 add 函数的定义,a 和 b 为形参,s 为函数内定义变量,a、b、s 这三个变量均为局部变量,作用域为该函数,不能在 add 函数外使用。

2) 未调用 add 函数时,a、b 和 s 均不占用内存空间。函数调用时,即执行如下语句。
int x=2, y=3, sum;
sum=add(x,y);
该函数调用语句中,有两个实参,第一个实参为 x,其值为 2,第二个实参为 y,其值为 3。在函数调用时,为形参 a 和 b 及函数内变量 s 这三个整型局部变量分配存储空间,在 VC++ 6.0 里各占 4 个字节。函数调用时,实参与形参的关系如图 1 所示。


图 1

函数调用过程也就是实参给形参赋初值的过程,即:
a=x;
b=y;
函数体中,对形参 a 和 b 求和的结果赋给 s,最后把 s 的值作为函数的值返回赋给 sum 变量。调用过程结束,函数 add 中的所有局部变量的内存空间被收回。

由于形参仅在定义函数内有效,故在函数调用时,函数的实参可以和形参变量同名,互不影响。

函教原型声明

函数原型包括返回类型、函数名、参数列表等函数定义的基本信息。一般用于告知调用者该函数的基本信息,便于调用。

函数原型声明通常有以下两种形式。

无参函数原型声明格式为:

返回类型 函数名 (void);

或者

返回类型 函数名 ();

带参函数原型声明通常有如下两种形式。

1) 返回类型 函数名 (类型参数 1,类型参数 2,…);

这种写法是把函数定义时的函数头直接复制过来加分号即可,在编程时,操作方便,较节省时间,例如:
int add (int a, int b); //正确,函数头后面直接加分号

2) 返回类型 函数名 (类型,类型,…);

这种写法在第一种写法的基础上,去掉了各个形参名,只保留各个形参类型。这种写法比较专业,但可能多花费些时间。例如:
int add (int, int);//正确,只指明有两个整型形参即可
如果把函数定义的代码写在了调用语句之前,在这种情况下,虽然不加函数原型声明,也可以正常调用函数。但为了规范起见,要求所有定义函数,在函数调用前必须加函数原型声明语句。

比较常见规范的函数使用方式是:先函数原型声明,再调用,一般函数定义在程序的后面。

说明:函数原型声明,原则上只要在函数调用前声明都可以,但为了不让 main 函数显得臃肿,一般不放在main函数里面,比较规范的做法是把其放在 main 函数前面。本书采用这种方式。

函教调用举例

【例 1】带参函数调用举例。设计一个求两个整型数之和的函数。

问题分析:
1) 欲求两个整型数之和,调用者必须传递给该函数两个整型数,故函数需要两个整型类型的“容器”即形参,用于接收调用者传来的两个整型数。因实现功能为求和运算,函数名可取为 add,把求和的结果(整型)返回给调用者,即返回值类型也为整型。

2) 函数调用之前必须声明函数原型,一般放在 main 函数前面。

3) 函数调用时,把欲求和的被加数和加数作为实参传递给函数形参。

4) 函数的返回值即求和的结果,可以直接输出,或保存到某变量中参与其他运算或输出。

实现代码:
#include<stdio.h>
int add (int a, int b); //函数声明
int main (void)
{
    int a=2,b=3, s;
    s=add(a,b); //函数调用,返回值赋给s
    printf("%d+%d=%dn",a,b,s);
    return 0;
}
int add (int a, int b) //函数定义
{
    int s;
    s=a+b;
    return s;
}
运行结果为:
2+3=5

【例 2】无参函数调用举例,编写一个打印九九乘法表的函数。

分析:该函数根据实现的功能可取名为 Print_99,该函数不需要调用者(main 函数)向其传递任何参数,该函数就可以正常打印九九乘法表,故该函数可以定义为无参类型。

实现代码:
#include<stdio.h>
void print_99 (void);//函数声明
int main (void)
{
    print_99();//无参函数调用
    return 0;
}
void print_99 (void) //无参函数定义
{
    int i, j;
    for(i=1;i<=9;i++)
    {
        for (j=1; j<=i; j++)
            printf("%d*%d=%dt",i,j,i*j);
        printf ("n");
    }
}
运行结果:
1*1=1
2*1=2   2*2=4
3*1=3   3*2=6   3*3=9
4*1=4   4*2=8   4*3=12  4*4=16
5*1=5   5*2=10  5*3=15  5*4=20  5*5=25
6*1=6   6*2=12  6*3=18  6*4=24  6*5=30  6*6=36
7*1=7   7*2=14  7*3=21  7*4=28  7*5=35  7*6=42  7*7=49
8*1=8   8*2=16  8*3=24  8*4=32  8*5=40  8*6=48  8*7=56  8*8=64
9*1=9   9*2=18  9*3=27  9*4=36  9*5=45  9*6=54  9*7=63  9*8=72  9*9=81

函数的嵌套调用

在 C 语言中,函数不能嵌套定义,即不能在一个函数中定义其他函数。例如,在 main 函数中嵌套定义函数 fun,为错误语法。
int main (void)
{
    int fun(void)//错误,不能嵌套定义
    {
         //fun函数体
    }
    //...
    return 0;
}
此代码就属于函数的嵌套定义,是错误的语法。

C 语言虽然不支持函数的嵌套定义,但支持函数的嵌套调用,即在一个函数中可以调用其他函数,在前面已经涉及函数嵌套调用,就是在main函数中调用其他自定义函数。自定义函数之间也可以相互嵌套调用。

【例 3】编程实现求 12+22+32+42+52+...+102 的值

实现代码为:
#include<stdio.h>
int pow(int , int);
int sum(int);
int main(void)
{
    int r;
    r=sum(10);
    printf("result=%dn",r);
    return 0;
}
int sum(int n)
{
    int i,s=0;
    for(i=1;i<=n;i++)
    {
        s+=pow(i,2);
    }
    return s;
}
int pow(int m,int n)
{
    int i,p=1;
    for(i=1;i<=n;i++)
    {
        p*=m;
    }
    return p;
}
运行结果为:
result=385

程序说明:该程序的执行过程是,操作系统调用 main 函数,main 函数调用 sum 函数,sum 函数调用 pow 函数,pow 函数执行完后,返回到其调用者 sum 函数,接着往下执行,sum 函数执行完,返回调用处 main 函数,接着往下执行,执行完 main 函数,return 0; 后返回给操作系统,整个程序执行结束。

另外,sum 函数及 pow 函数中均含有相同名字的变量 n 和 i。因为它们都是局部变量,作用域仅局限于各自的函数体中,故它们互不相干,互不影响。

传值调用和传址调用

C 语言中函数调用方式可分为传值调用传址调用两大类。

传值调用

函数调用时,把实参的值传递给对应形参变量。这种调用形式,相当于形参复制了实参的一个副本,函数体内对形参(实参的副本)操作,形参变量的变化并不会影响到实参的值。即函数调用过程中,数据的传递是单向的。

传值调用时,传入的实参是普通变量(包括数组的某个元素)和常量及常量表达式。

例如,分析如下程序。
#include<stdio.h>
void swap (int, int);
int main (void)
{
    int a=3, b=5;
    swap(a,b);
    printf ("a=%d,b=%dn",a,b);
    return 0;
}

void swap (int x, int y)
{
    int t;
    t=x;
    x=y;
    y=t;
}
【运行结果】
a=3,b=5

程序分析:

形参为普通变量(整型),实参为普通变量(整型变量 a 和 b),故该函数调用为传值调用。形参相当于复制了实参的一个副本,函数内对形参的操作,均是对实参副本的操作,不会对实参变量产生任何影响。

另外,swap 函数中借助于变量 t,把形参 x 和 y 的值进行交换,由于 x、y 和 t 均属于 swap 函数内的局部变量,函数调用结束后,三个变量的空间全收回,对实参变量 a 和 b 没有任何影响。故调用该函数后,a 和 b 的值并未发生交换。

传址调用

实参是某个空间的地址,把该地址赋给形参变量,函数内对该地址操作,可间接对该地址所指的空间进行操作。即传址调用过程,函数可以通过传入的地址值,改变该地址空间的值。数组作为函数参数和指针作为函数参数均可实现址调用。

传址调用时,实参为地址(一维数组名被看成数组首元素的地址)。形参一般为数组类型或指针类型。如果形参为数组类型,则实参为同类型数组的数组名或首元素的地址。

例如,用数组类型作函数形参,编程实现求斐波那契数列的前 n 项的程序。实现代码为:
#include<stdio.h>
#define N 10
void Fib (int x[], int n);
int main (void)
{
    int i,a[N] = {0,1};
    Fib(a,N);
    for(i=0;i<N;i++)
        printf ("%-4d",a[i]);
    printf ("n");
    return 0;
}

void Fib (int x[], int n)
{
    int i;
    for(i=2;i<n;i++)
        x[i]=x[i-1]+x[i-2];
}
运行结果:
0   1   1   2   3   5   8   13  21  34