函数

函数概述

函数(Function)是一段可以重复使用的代码,这是从整体上对函数的认识。
C语言本身带了很多库函数,并分门别类地放在了不同的头文件中,使用时只要引入对应的头文件即可。
除了C语言自带的函数,我们也可以编写自己的函数,称为自定义函数(User-Defined Function)。自定义函数和库函数没有本质的区别,表现形式和使用方法一样,只是开发者不同而已。
 
这一章我们就来讲解如何编写和使用自己的函数。
 
参数 
函数的一个明显特征就是使用时带括号( ),必要的话,括号中还要包含数据或变量,称为参数(Parameter)。参数是函数需要处理的数据,例如:
strlen(str1)用来计算字符串的长度,str1就是参数。
puts("C语言中文网")用来输出字符串,"C语言中文网"就是参数。
 
返回值
既然函数可以处理数据,那就有必要将处理结果告诉我们,所以很多函数都有返回值(Return Value)。所谓返回值,就是函数的执行结果。例如:
char str1[] = "C Language";
int len = strlen(str1);
strlen() 的处理结果是字符串 str1 的长度,是一个整数,我们通过 len 变量来接收。
 
函数返回值有固定的数据类型(int、char、float等),用来接收返回值的变量类型要一致。


自定义函数

函数是一段可以重复使用的代码,用来独立地完成某个功能,它可以接收用户传递的数据,也可以不接收。
 
 无参函数的定义
 如果函数不接收用户传递的数据,那么定义时可以不带参数。如下所示:
返回值类型  函数名()
{
    函数体
}
说明:
返回值类型可以是C语言中的任意数据类型,例如 int、float、char 等。
函数名是标识符的一种,命名规则和标识符相同。函数名后面的括号( )不能少。
函数体是函数需要执行的代码。即使只有一个语句,也要由{ }包围。
在函数体中使用return语句返回数据。
 例如,定义一个函数,计算1加到100的结果:
int sum()
{
    int i, sum=0;
    for(i=1; i<=100; i++)
    {
        sum+=i;
    }
    return sum;
}
计算结果保存在变量sum中,通过return语句返回。sum为int型,所以返回值类型也必须为int,要一一对应。
return是C语言中的一个关键字,只能用在函数中,用来返回处理结果。
将上面的代码补充完整:
#include <stdio.h>
 
int sum()
{
    int i, sum=0;
    for(i=1; i<=100; i++){
        sum+=i;
    }
    return sum;
}
 int main()
{
    int a = sum();
    printf("The sum is %d\n", a);
    return 0;
}
运行结果:
The sum is 5050
 
函数不能嵌套定义,main 也是一个函数定义,要将 sum 放在 main 外面。函数必须先定义后使用,所以 sum 只能在 main 前面。
注意:main 是函数定义,不是函数调用。当可执行文件加载到内存后,系统从 main 函数开始执行,也就是说,系统会调用我们定义的 main 函数。
 
 无返回值函数
有的函数不需要有返回值,或者返回值类型不确定(很少见),那么用void表示,例如:
void hello(){
    printf ("Hello,world \n");
    //没有返回值就不需要 return 语句
}
void是C语言中的一个关键字,表示空类型或无类型,绝大部分情况下也就意味着没有 return 语句。
 
 有参函数的定义
 如果函数需要接收用户传递的数据,那么定义时就要带参数。如下所示:
返回值类型  函数名(参数列表)
{
    函数体
}
 用户数据通过“参数列表”传递给函数,供函数处理。例如,定义一个函数求两个数中的最大值:
 int max(int a, int b){
    if (a>b){
        return a;
    }else{
        return b;
    }
}
 参数(Parameter)本质上也是变量,定义时要指明参数类型和参数名称。参数列表中可以定义一个或多个参数,多个参数之间用逗号,分隔。参数列表中给出的参数可以在函数体中使用。
调用 max() 函数时可以直接传递整数:
int n = max(10, 20);
也可以传递变量:
int a = 10, b = 20;
int n = max(a, b);
也可以整数和变量一起传递:
int a = 10;
int n = max(a, 20);
变量 n 得到的值都是20
 
函数定义时给出的参数称为形式参数,简称形参;函数调用时给出的参数(传递的数据)称为实际参数,简称实参。函数调用时,将实参的值传递给形参,相当于一次赋值操作。注意:实参和形参的类型、数目必须一致。
将上面的代码补充完整:
#include <stdio.h>
int max(int a, int b){
    if (a>b){
        return a;
    }else{
        return b;
    }
}
int main(){
    int num1, num2, maxVal;
    printf("Input two numbers: ");
    scanf("%d %d", &num1, &num2);
    maxVal = max(num1, num2);
    printf("The max number: %d\n", maxVal);
 
    return 0;
}
 
运行结果:
Input two numbers: 100 200
The max number: 200
 
定义max时,变量a、b的值都是未知的;调用max时,分别将num1、num2的值传递给a、b,类似于:
a=num1;
b=num2;
return 语句可以有多个,可以在函数体的任意位置。在max中,根据 if 的判断结果来执行不同的 return 语句。
 
函数一旦遇到 return 语句就返回(停止执行),后面的所有语句都不会被执行到,例如:
 int max(int a, int b){
    int n = (a>b) ? a : b;
    return n;
    printf("Function is performed\n");
}
第4行代码是多余的,永远没有执行的机会。

函数参数和函数返回值

如果把函数比喻成一台机器,那么参数就是原材料,返回值就是最终产品;函数的作用就是根据不同的参数产生不同的返回值。
 
函数的参数 
在函数定义中出现的参数可以看做是一个占位符,它没有数据,只能等到函数被调用时接收传递进来的数据,所以称为形式参数,简称形参。
 
函数被调用时给出的参数包含了实实在在的数据,会被函数内部的代码使用,所以称为实际参数,简称实参。
 
形参和实参的功能是作数据传送,发生函数调用时,实参的值会传送给形参。
 
形参和实参有以下几个特点:
1) 形参变量只有在函数被调用时才会分配内存,调用结束后,立刻释放内存,所以形参变量只有在函数内部有效,不能在函数外部使用。
 
2) 实参可以是常量、变量、表达式、函数等,无论实参是何种类型的数据,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参,所以应该提前用赋值、输入等办法使实参获得确定值。
【示例】计算 1+2+3+...+(n-1)+n 的值。
#include <stdio.h>
int sum(int n){
    int i;
    for(i=n-1; i>=1; i--){
        n+=i;
    }
    printf("The inner n = %d\n",n);
    return n;
}
int main(){
    int m, total;
    printf("Input a number: ");
    scanf("%d", &m);
    total = sum(m);
    printf("The outer m = %d \n", m);
    printf("1+2+3+...+%d+%d = %d\n", m-1, m, total);
    return 0;
}
运行结果:
Input a number: 100↙
The inner n = 5050
The outer m = 100
1+2+3+...+99+100 = 5050
 
通过 scanf 输入 m 的值,作为实参,在调用 sum 时传送给形参 n。
从运行情况看,输入 m 值为100,即实参 m 的值为100,把这个值传给函数 sum 时,形参 n 的初值也为100,在函数执行过程中,形参 n 的值变为 5050。函数运行结束后,输出实参 m 的值仍为100,可见实参的值不随形参的变化而变化。
 
3) 实参和形参在数量上、类型上、顺序上必须严格一致,否则会发生“类型不匹配”的错误。
 
函数调用中发生的数据传送是单向的,只能把实参的值传送给形参,而不能把形参的值反向地传送给实参。 因此在函数调用过程中,形参的值发生改变,而实参中的值不会变化。
 
函数的返回值
函数的返回值是指函数被调用之后,执行函数体中的程序段所取得的值,可以通过return语句返回。
return语句的一般形式为:
return 表达式;
或者:
return (表达式);
例如:
return max;
return a+b;
return (100+200);
函数中可以有多个 return 语句,但每次调用只能有一个return 语句被执行,所以只有一个返回值。
一旦遇到 return 语句,不管后面有没有代码,函数立即运行结束,将值返回。例如:
int func(){
    int a=100, b=200, c;
    return a+b;
    return a*b;
    return b/a;
}
返回值始终 a+b 的值,也就是300。
 
没有返回值的函数为空类型,用void进行说明。例如:
void func(){
    printf("Hello world!\n");
}
一旦函数的返回值类型被定义为 void,就不能再接收它的值了。例如,下面的语句是错误的:
int a = func();
为了使程序有良好的可读性并减少出错, 凡不要求返回值的函数都应定义为 void 类型。
 

函数声明和函数原型

C语言代码由上到下依次执行,原则上函数定义要出现在函数调用之前,否则就会报错。但在实际开发中,经常会在函数定义之前使用它们,这个时候就需要提前声明。
 
所谓声明(Declaration),就是告诉编译器我要使用这个函数,你现在没有找到它的定义不要紧,请不要报错,稍后我会把定义补上。
 
函数声明的格式非常简单,相当于去掉函数定义中的函数体再加上分号;,如下所示:
返回值类型  函数名( 类型 形参, 类型 形参… );
也可以不写形参,只写数据类型:
返回值类型  函数名( 类型, 类型…);
函数声明给出了函数名、返回值类型、参数列表(参数类型)等与该函数有关的信息,称为函数原型(Function Prototype)。
 
函数原型的作用是告诉编译器与该函数有关的信息,让编译器知道函数的存在,以及存在的形式,即使函数暂时没有定义,编译器也知道如何使用它。
 
有了函数声明,函数定义就可以出现在任何地方了,甚至是其他文件、静态链接库、动态链接库等。
 
上节给出了计算sum = 1! + 2! + 3! + ... + (n-1)! + n!的代码,这节我们稍作修改,将 factorial() 和 sum() 函数的定义放到 main() 函数后面,请看下面的代码:
#include <stdio.h>
 
// 函数声明
long factorial(int n);  //也可以写作 long factorial(int);
long sum(long n);      //也可以写作 long sum(long);
 
int main(){
    printf("1!+2!+...+9!+10! = %ld\n", sum(10));
    return 0;
}
 
//求阶乘
long factorial(int n){
    int i;
    long result=1;
    for(i=1; i<=n; i++){
        result *= i;
    }
    return result;
}
 
// 求累加的和
long sum(long n){
    int i;
    long result = 0;
    for(i=1; i<=n; i++)
    {
        //嵌套调用
        result += factorial(i);
    }
    return result;
}
运行结果:
1!+2!+...+9!+10! = 4037913
 
我们知道,使用 printf()、puts()、scanf()、getchar() 等函数要引入 stdio.h 这个头文件,很多初学者认为 stdio.h 中包含了函数定义(也就是函数体),只要有了头文件程序就能运行。其实不然,头文件中包含的都是函数声明,而不是函数定义,函数定义都在系统库中,只有头文件没有系统库在链接时就会报错,程序根本不能运行。
 
最后再补充一点,函数原型给出了使用该函数的所有细节,当我们不知道如何使用某个函数时,需要查找的是它的原型,而不是它的定义,我们往往不关心它的实现。
 
 

递归函数

一个函数在它的函数体内调用它自身称为递归调用,这种函数称为递归函数。执行递归函数将反复调用其自身,每调用一次就进入新的一层。
 
【示例】用递归计算 n!。阶乘 n! 的计算公式如下:


根据公式编程:
long factorial(int n){
    long result;
    if(n==0 || n==1){
        result = 1;
    }else{
        result = factorial(n-1) * n;  // 递归调用
    }
    return result;
}
 
这是一个典型的递归函数。调用factorial后即进入函数体,只有当 n==0 或 n==1 时函数才会执行结束,否则就一直调用它自身。
 
由于每次调用的实参为 n-1,即把 n-1 的值赋给形参 n,所以每次递归实参的值都减 1,直到最后 n-1 的值为 1 时再作递归调用,形参 n 的值也为1,递归就终止了,会逐层退出。
 
例如求 5!,即调用factorial(5)。当进入factorial函数体后,由于 n=5,不等于0或1,所以执行result = factorial(n-1) * n;,即result = factorial(5-1) * 5;,接下来也就是调用factorial(4)。这是第一次递归。
 
进行四次递归调用后,实参的值为 1,也就是调用factorial(1)。这时递归就结束了,开始逐层返回。factorial(1) 的值为 1,factorial(2) 的值为 1*2=2,factorial(3) 的值为 2*3=6,factorial(4) 的值为 6*4=24,最后返回值 factorial(5) 为 24*5=120。
注意:为了防止递归调用无终止地进行,必须在函数内有终止递归调用的手段。常用的办法是加条件判断,满足某种条件后就不再作递归调用,然后逐层返回。
递归调用不但难于理解,而且开销很大,如非必要,不推荐使用递归。很多递归调用可以用迭代(循环)来代替。
 
【示例】用迭代法求 n!。
long factorial(int n){
    int i;
    long result=1;
    if(n==0 || n==1){
        return 1;
    }
    for(i=1; i<=n; i++){
        result *= i;
    }
    return result;
}

    递归函数的定义,不应出现无终止的递归调用。而应定义为有限次数、有终止的递归调用函数。
       对于一个问题,只要能够知道递归定义式,及边界条件(即递归终止的条件),就可以编写一个递归函数。



例题见上一篇

文章


局部变量和全局变量

在 C语言函数的参数和返回值 中提到,形参变量要等到函数被调用时才分配内存,调用结束后立即释放内存。这说明形参变量的作用域非常有限,只能在函数内部使用,离开该函数就无效了。所谓作用域(Scope),就是变量的有效范围。
不仅对于形参变量,C语言中所有的变量都有自己的作用域。决定变量作用域的是变量的定义位置。
 
局部变量
定义在函数内部的变量称为局部变量(Local Variable),它的作用域仅限于函数内部, 离开该函数后就是无效的,再使用就会报错。例如:
int f1(int a){
    int b,c;  //a,b,c仅在函数f1()内有效
    return a+b+c;
}
int main(){
    int m,n;  //m,n仅在函数main()内有效
    return 0;
}
几点说明:
1) 在 main 函数中定义的变量也是局部变量,只能在 main 函数中使用;同时,main 函数中也不能使用其它函数中定义的变量。main 函数也是一个函数,与其它函数地位平等
2) 形参变量、在函数体内定义的变量都是局部变量。实参给形参传值的过程也就是给局部变量赋值的过程。
3) 可以在不同的函数中使用相同的变量名,它们表示不同的数据,分配不同的内存,互不干扰,也不会发生混淆。
4) 在语句块中也可定义变量,它的作用域只限于当前语句块。
 
全局变量
 在所有函数外部定义的变量称为全局变量(Global Variable),它的作用域默认是整个程序,也就是所有的源文件,包括 .c 和 .h 文件。例如:
int a, b;  //全局变量
void func1(){
    //TODO:
}
 
float x,y;  //全局变量
int func2(){
    //TODO:
}
 
int main(){
    //TODO:
    return 0;
}
a、b、x、y 都是在函数外部定义的全局变量。C语言代码是从前往后依次执行的,由于 x、y 定义在函数 func1() 之后,所以在 func1() 内无效;而 a、b 定义在源程序的开头,所以在 func1()、func2() 和 main() 内都有效。
 
局部变量和全局变量的综合示例
 #include <stdio.h>
 
int n = 10;  //全局变量
void func1(){
    int n = 20;  //局部变量
    printf("func1 n: %d\n", n);
}
void func2(int n){
    printf("func2 n: %d\n", n);
}
void func3(){
    printf("func3 n: %d\n", n);
}
int main(){
    int n = 30;  //局部变量
    func1();
    func2(n);
    func3();
    //代码块由{}包围
    {
        int n = 40;  //局部变量
        printf("block n: %d\n", n);
    }
    printf("main n: %d\n", n);
 
    return 0;
}
运行结果:
func1 n: 20
func2 n: 30
func3 n: 10
block n: 40
main n: 30
 
代码中虽然定义了多个同名变量 n,但它们的作用域不同,在内存中的位置(地址)也不同,所以是相互独立的变量,互不影响,不会产生重复定义(Redefinition)错误。
1) 对于 func1(),输出结果为 20,显然使用的是函数内部的 n,而不是外部的 n;func2() 也是相同的情况。
当全局变量和局部变量同名时,在局部范围内全局变量被“屏蔽”,不再起作用。或者说,变量的使用遵循就近原则,如果在当前作用域中存在同名变量,就不会向更大的作用域中去寻找变量。
2) func3() 输出 10,使用的是全局变量,因为在 func3() 函数中不存在局部变量 n,所以编译器只能到函数外部,也就是全局作用域中去寻找变量 n。
3) 由{ }包围的代码块也拥有独立的作用域,printf() 使用它自己内部的变量 n,输出 40。
4) C语言规定,只能从小的作用域向大的作用域中去寻找变量,而不能反过来,使用更小的作用域中的变量。对于 main() 函数,即使代码块中的 n 离输出语句更近,但它仍然会使用 main() 函数开头定义的 n,所以输出结果是 30。
【示例2】根据长方体的长宽高求它的体积以及三个面的面积。
#include <stdio.h>
 
int s1, s2, s3;  //面积
 
int vs(int a, int b, int c){
    int v;  //体积
    v = a * b * c;
    s1 = a * b;
    s2 = b * c;
    s3 = a * c;
    return v;
}
 
int main(){
    int v, length, width, height;
    printf("Input length, width and height: ");
    scanf("%d %d %d", &length, &width, &height);
    v = vs(length, width, height);
    printf("v=%d, s1=%d, s2=%d, s3=%d\n", v, s1, s2, s3);
 
    return 0;
}
运行结果:
Input length, width and height: 10 20 30↙
v=6000, s1=200, s2=600, s3=300
 
根据题意,我们希望借助一个函数得到三个值:体积 v 以及三个面的面积 s1、s2、s3。遗憾的是,C语言中的函数只能有一个返回值,我们只能将其中的一份数据,也就是体积 v 放到返回值中,而将面积 s1、s2、s3 设置为全局变量。全局变量的作用域是整个程序,在函数 vs() 中修改 s1、s2、s3 的值,能够影响到包括 main() 在内的其它函数。



整体上理解函数

从整体上看,C语言代码是由一个一个的函数构成的,除了定义和说明类的语句(例如变量定义、宏定义、类型定义等)可以放在函数外面,所有具有运算或逻辑处理能力的语句(例如加减乘除、if else、for、函数调用等)都要放在函数内部。
 
例如,下面的代码就是错误的:
#include <stdio.h>
int a = 10;
int b = a + 20;
int main(){
    return 0;
}
int b = a + 20;是具有运算功能的语句,要放在函数内部。
 
但是下面的代码就是正确的:
#include <stdio.h>
int a = 10;
int b = 10 + 20;
int main(){
    return 0;
}
int b = 10 + 20;在编译时会被优化成int b = 30;,消除加法运算。
 
在所有的函数中,main() 是入口函数,有且只能有一个,C语言程序就是从这里开始运行的。
 
C语言不但提供了丰富的库函数,还允许用户定义自己的函数。每个函数都是一个可以重复使用的模块,通过模块间的相互调用,有条不紊地实现复杂的功能。可以说C程序的全部工作都是由各式各样的函数完成的,所以也把C语言称为函数式语言。
 
标准C语言(ANSI C)共定义了15 个头文件,称为“C标准库”,所有的编译器都必须支持,如何正确并熟练的使用这些标准库,可以反映出一个程序员的水平。
合格程序员:<stdio.h>、<ctype.h>、<stdlib.h>、<string.h>
熟练程序员:<assert.h>、<limits.h>、<stddef.h>、<time.h>
优秀程序员:<float.h>、<math.h>、<error.h>、<locale.h>、<setjmp.h>、<signal.h>、<stdarg.h>
 
以上各类函数不仅数量众多,而且有的还需要硬件知识才能使用,初学者要想全部掌握得需要一个较长的学习过程。我的建议是先掌握一些最基本、最常用的函数,在实践过程中再逐步深入。 
还应该指出的是,C语言中所有的函数定义,包括主函数 main() 在内,都是平行的。也就是说,在一个函数的函数体内,不能再定义另一个函数,即不能嵌套定义。但是函数之间允许相互调用,也允许嵌套调用。习惯上把调用者称为主调函数,被调用者称为被调函数。函数还可以自己调用自己,称为递归调用。
 
main() 函数是主函数,它可以调用其它函数,而不允许被其它函数调用。因此,C程序的执行总是从 main() 函数开始,完成对其它函数的调用后再返回到 main() 函数,最后由 main() 函数结束整个程序。


指针或数组名作为参数

在C语言中,函数的参数不仅可以是整数、小数、字符等具体的数据,还可以是指向它们的指针。用指针变量作函数参数可以将函数外部的地址传递到函数内部,使得在函数内部可以操作函数外部的数据,并且这些数据不会随着函数的结束而被销毁。
 
像数组、字符串、动态分配的内存等都是一系列数据的集合,没有办法通过一个参数全部传入函数内部,只能传递它们的指针,在函数内部通过指针来影响这些数据集合。
 
有的时候,对于整数、小数、字符等基本类型数据的操作也必须要借助指针,一个典型的例子就是交换两个变量的值。
有些初学者可能会使用下面的方法来交换两个变量的值:
 #include <stdio.h>
void swap(int a, int b){
    int temp;  //
    temp = a;
    a = b;
    b = temp;
}
int main(){
    int a = 66, b = 99;
    swap(a, b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}
运行结果:
a = 66, b = 99
 
从结果可以看出,a、b 的值并没有发生改变,交换失败。这是因为 swap() 函数内部的 a、b 和 main() 函数内部的 a、b 是不同的变量,占用不同的内存,它们除了名字一样,没有其他任何关系,swap() 交换的是它内部 a、b 的值,不会影响它外部(main() 内部) a、b 的值。
 
改用指针变量作参数后就很容易解决上面的问题:
 #include <stdio.h>
void swap(int *p1, int *p2){
    int temp;  //
    temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}
int main(){
    int a = 66, b = 99;
    swap(&a, &b);
    printf("a = %d, b = %d\n", a, b);
    return 0;
}
运行结果:
a = 99, b = 66
 
调用 swap() 函数时,将变量 a、b 的地址分别赋值给 p1、p2,这样 *p1、*p2 代表的就是变量 a、b 本身,交换 *p1、*p2 的值也就是交换 a、b 的值。函数运行结束后虽然会将 p1、p2 销毁,但它对外部 a、b 造成的影响是“持久化”的,不会随着函数的结束而“恢复原样”。
 
需要注意的是临时变量 temp,它的作用特别重要,因为执行*p1 = *p2;语句后 a 的值会被 b 的值覆盖,如果不先将 a 的值保存起来以后就找不到了。
 
用数组作函数参数
数组是一系列数据的集合,无法通过参数将它们一次性传递到函数内部,如果希望在函数内部操作数组,必须传递数组指针。下面的例子定义了一个函数 max(),用来查找数组中值最大的元素:
#include <stdio.h>
 
int max(int *intArr, int len){
    int i, maxValue = intArr[0];  //假设第0个元素是最大值
    for(i=1; i<len; i++){
        if(maxValue < intArr[i]){
            maxValue = intArr[i];
        }
    }
   
    return maxValue;
}
 
int main(){
    int nums[6], i, maxValue;
    int len = sizeof(nums)/sizeof(int);
    //读取用户输入的数据并赋值给数组元素
    for(i=0; i<len; i++){
        scanf("%d", nums+i);
    }
    printf("Max value is %d!\n", max(nums, len));
 
    return 0;
}
运行结果:
12 55 30 8 93 27↙
Max value is 93!
 
参数 intArr 仅仅是一个数组指针,在函数内部无法通过这个指针获得数组长度,必须将数组长度作为函数参数传递到函数内部。数组 nums 的每个元素都是整数,scanf() 在读取用户输入的整数时,要求给出存储它的内存的地址,nums+i就是第 i 个数组元素的地址。
 
用数组做函数参数时,参数也能够以“真正”的数组形式给出。例如对于上面的 max() 函数,它的参数可以写成下面的形式:
int max(int intArr[6], int len){
    int i, maxValue = intArr[0];  //假设第0个元素是最大值
    for(i=1; i<len; i++){
        if(maxValue < intArr[i]){
            maxValue = intArr[i];
        }
    }
    return maxValue;
}
 
int intArr[6]好像定义了一个拥有 6 个元素的数组,调用 max() 时可以将数组的所有元素“一股脑”传递进来。
 也可以省略数组长度,把形参简写为下面的形式:
int max(int intArr[], int len){
    int i, maxValue = intArr[0];  //假设第0个元素是最大值
    for(i=1; i<len; i++){
        if(maxValue < intArr[i]){
            maxValue = intArr[i];
        }
    }
    return maxValue;
}
 int intArr[]虽然定义了一个数组,但没有指定数组长度,好像可以接受任意长度的数组。
 
实际上这两种形式的数组定义都是假象,不管是int intArr[6]还是int intArr[]都不会创建一个数组出来,编译器也不会为它们分配内存,实际的数组是不存在的,它们最终还是会转换为int *intArr这样的指针。这就意味着,两种形式都不能将数组的所有元素“一股脑”传递进来,大家还得规规矩矩使用数组指针。
 
int intArr[6]这种形式只能说明函数期望用户传递的数组有 6 个元素,并不意味着数组只能有 6 个元素,真正传递的数组可以有少于或多于 6 个的元素。
 
需要强调的是,不管使用哪种方式传递数组,都不能在函数内部求得数组长度,因为 intArr 仅仅是一个指针,而不是真正的数组,所以必须要额外增加一个参数来传递数组长度。
 
C语言为什么不允许直接传递数组的所有元素,而必须传递数组指针呢?
 
参数的传递本质上是一次赋值的过程,赋值就是对内存进行拷贝。所谓内存拷贝,是指将一块内存上的数据复制到另一块内存上。
 
对于像 int、float、char 等基本类型的数据,它们占用的内存往往只有几个字节,对它们进行内存拷贝非常快速。而数组是一系列数据的集合,数据的数量没有限制,可能很少,也可能成千上万,对它们进行内存拷贝有可能是一个漫长的过程,会严重拖慢程序的效率,为了防止技艺不佳的程序员写出低效的代码,C语言没有从语法上支持数据集合的直接赋值。
 
除了C语言,C++、Java、Python 等其它语言也禁止对大块内存进行拷贝,在底层都使用类似指针的方式来实现。

 指针变量作为函数返回值


C语言允许函数的返回值是一个指针(地址),我们将这样的函数称为指针函数。下面的例子定义了一个函数 strlong(),用来返回两个字符串中较长的一个:
#include <stdio.h>
#include <string.h>
 
char *strlong(char *str1, char *str2){
    if(strlen(str1) >= strlen(str2)){
        return str1;
    }else{
        return str2;
    }
}
 
int main(){
    char str1[30], str2[30], *str;
    gets(str1);
    gets(str2);
    str = strlong(str1, str2);
    printf("Longer string: %s\n", str);
 
    return 0;
}
运行结果:
C Language↙
HelloWorld↙
Longer string: HelloWorld↙
用指针作为函数返回值时需要注意的一点是,函数运行结束后会销毁在它内部定义的所有局部数据,包括局部变量、局部数组和形式参数,函数返回的指针请尽量不要指向这些数据,C语言没有任何机制来保证这些数据会一直有效,它们在后续使用过程中可能会引发运行时错误。请看下面的例子:
#include <stdio.h>
 
int *func(){
    int n = 100;
    return &n;
}
 
int main(){
    int *p = func(), n;
    n = *p;
    printf("value = %d\n", n);
    return 0;
}
运行结果:
value = 100
n 是 func() 内部的局部变量,func() 返回了指向 n 的指针,根据上面的观点,func() 运行结束后 n 将被销毁,使用 *p 应该获取不到 n 的值。但是从运行结果来看,我们的推理好像是错误的,func() 运行结束后 *p 依然可以获取局部变量 n 的值,这个上面的观点不是相悖吗?
 
为了进一步看清问题的本质,不妨将上面的代码稍作修改,在第9~10行之间增加一个函数调用,看看会有什么效果:
 #include <stdio.h>
 
int *func(){
    int n = 100;
    return &n;
}
 
int main(){
    int *p = func(), n;
    printf("c.biancheng.net\n");
    n = *p;
    printf("value = %d\n", n);
    return 0;
}
运行结果:
c.biancheng.net
value = -2
可以看到,现在 p 指向的数据已经不是原来 n 的值了,它变成了一个毫无意义的甚至有些怪异的值。与前面的代码相比,该段代码仅仅是在 *p 之前增加了一个函数调用,这一细节的不同却导致运行结果有天壤之别,究竟是为什么呢?
 
前面我们说函数运行结束后会销毁所有的局部数据,这个观点并没错,大部分C语言教材也都强调了这一点。但是,这里所谓的销毁并不是将局部数据所占用的内存全部抹掉,而是程序放弃对它的使用权限,弃之不理,后面的代码可以随意使用这块内存。对于上面的两个例子,func() 运行结束后 n 的内存依然保持原样,值还是 100,如果使用及时也能够得到正确的数据,如果有其它函数被调用就会覆盖这块内存,得到的数据就失去了意义。
第一个例子在调用其他函数之前使用 *p 抢先获得了 n 的值并将它保存起来,第二个例子显然没有抓住机会,有其他函数被调用后才使用 *p 获取数据,这个时候已经晚了,内存已经被后来的函数覆盖了,而覆盖它的究竟是一份什么样的数据我们无从推断(一般是一个没有意义甚至有些怪异的值)。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值