码迷,mamicode.com
首页 > 编程语言 > 详细

c语言-函数

时间:2020-04-02 22:28:16      阅读:92      评论:0      收藏:0      [点我收藏+]

标签:组成   core   不能   编写   void   函数类型   根据   最小数   重叠   

一、概述

1、函数的概念(c程序的结构)

(1)一个C程序可以分为若干个函数

(2)每个程序有且只能有一个主函数(main),其他函数都是“子函数”

(3)子函数可以互相调用,但主函数不能被调用

(4)一个C源程序由一个或多个文件构成,一个源程序文件是一个编译单位

技术图片

2、说明

(1)c程序的执行从main函数开始,调用其他函数后人回到main函数,程序在main函数结束时结束

(2)所有子函数都是平行的,任何子函数都不属于其他函数

(3)从用户的角度看,函数可分为:标准函数,即库函数;自定义函数

(4)从函数形式看,可分为:

无参数函数:主调函数无数据传送给被调函数,可带或不带返回值。如:printstar();

有参数函数:主调函数与被调函数间有参数传递,主调函数可将实参传送给被调函数的形参, 被调函数的数据可返回主调函数。如:printf()。

#include <stdio.h> 
void main(  ) 
{void printstar(  ); 
  void print_message(  ); 
  printstar(  );
  print_message(  );
  printstar(  );
} 
void printstar(  ) 
{printf (“***********************\ n” ); }     
void print_message(  ) 
{printf (“_ _ _ _ _How_do_you_do!\n”) ;}   
/*
运行结果:
****************************
How do you do!
****************************
*/

二、函数的定义

1、函数定义的一般形式:

  类型说明 函数名 ([形式参数说明])

  { 函数体 } ——>{  [ 局部变量说明 ]  ——> 局部变量:函数体内定义的变量,其有效范围仅限于所在函数的内部,离开函数体则无意义。

                      语句

          }

形式参数说明方法:类型说明 变量名 [, 类型说明 变量名 ]……

【1】无参函数的定义形式 

  类型说明 函数名 ()

  { 函数体 }

【2】有参函数的定义形式

  类型说明 函数名 (形式参数说明)

  { 函数体 }

【3】空函数的定义形式

  类型说明 函数名 ([形式参数说明])

  {  }

三、函数参数和函数的值

  一个C程序由若干个函数组成,各函数调用时经常需要传递一些数据。即调用函数把数据传递给被调用函数,经被调用函数处理后,得到一个确定的结果,在返回调用函数时,把这个结果带回调用函数。各函数间的信息的往来是有参数传递和返回语句实现的。

(1)形式参数和实际参数

函数参数:用于函数间数据的传递

形式参数:定义函数时使用的参数(函数名后面括号中的变量名)

实际参数:调用函数时使用的参数(函数名后面括号中的表达式)

说明:

【1】定义参数时,必须说明形参的类型。形参只能是变量数组

【2】函数被调用前,形参不占用内存;函数调用结束后,形参所占用的内存也将被回收。

【3】实参可以是常量、变量表达式

【4】实参与形参的类型必须一致。字符型和整型可以互相匹配。

【5】C语言中实参对形参的数据传递是“值传递”,即单向传递。它仅由参数的对应位置确定,与名字无关。

 (2)函数的返回值

【1】返回函数值的方法

函数的返回值也就是函数值,是一个确定的值

1)> 如果一个函数有返回值,就必须使用return语句。

2)> 一个函数中可以有一个以上的return语句,但不论执行到哪个return都将结束函数的调用返回主调用函数

3)> return语句中的括号可以省略;return后面的值可以是一个表达式。

【2】函数值的类型

1)>函数的类型即函数值的类型,如函数是 int 型,函数值也是 int 型。

2)>省略了类型说明的函数是 int 型的。

3)>return 用中表达式的值一般应与函数类型一致。

4)>如果不一致,则需要进行类型转换。只有数值型的数据可以进行自动类型转换,以函数类型为准。

【3】不需要返回值的函数

1)>如果函数中没有使用 return 语句,函数返回值是一个不确定的数值。

2)>如果一个函数不需要返回值(表示一个过程),可以用 void 做类型说明。

3)>如果一个函数被声明为 void 类型,就不允许再引用它的返回值(即只能用函数语句形式调用)。

四、函数的调用

1、函数调用的一般形式

一般形式: 函数名(实参列表)

说明:

(1)如果调用无参函数,实参列表可以忽略,但括号不能省。

(2)实参的各数和形参一般相等。

(3)实参与形参的类型应一 一对应,必要时使用类型转换。

注意:不同系统中,实参的计算顺序不同。微机上一般是从右到左。为避免由此引起的混乱,一般应在调用函数前计算出实参的值。

 2、函数的调用方式

(1)函数语句

形式:函数名 (实参列表);

以独立的语句去调用函数。不要求有返回值,仅完成一定的操作。

例 printstar(); printf(“Hello,World!\n”);

 (2)函数表达式

函数返回一个确定值,以参加表达式的运算。不可用于void

例 m=max(a,b)*2;

(3)函数参数

函数调用作为另一个函数的参数。

例 printf(“%d”,max(a,b));  /*输出大数*/

  m=max(a,max(b,c));  /*三数比大小*/

3、函数调用的执行过程

【1】按从右向左的顺序,计算实参中各表达式的值

【2】按照位置,将实参的值一一对应的传送给形参

【3】执行被调用函数

【4】当遇到 return(表达式)语句时,计算表达式的值,并返回主调函数

技术图片

4、函数的原形说明(函数声明)

C语言中函数声明称为函数原型(形)。函数定义与函数声明不同,声明只与函数定义的第一行相同。声明可以不写形参名,只写形参类型。

函数说明位置:程序的数据说明部分(函数内或外)

作用:告诉编译系统函数类型、参数个数及类型,以便检验

在程序中调用函数需满足以下条件:

(1)被调用函数必须存在,且遵循“先定义后使用”的原则。

(2)如果被调用函数的定义在主调函数之后(位置),可以先给出原形说明。

原形说明的形式:类型说明 函数名(参数类型,参数类型,……);

其他说明:

库函数的原形说明存放在头文件(.h)中,通过使用 include 预处理命令将这些原形说明插入程序中。

旧版本C中函数声明不采用函数原型,只声明函数名函数类型。如: float add( )

函数调用之前,如果未对函数作声明,则编译系统把第一次遇到的函数形式作为函数声明,并默认为int型。即:函数类型是 int 型可以不作函数声明,最好作声明

被调用函数的定义(程序)在主调函数之前,可以不加函数声明。 在所有函数定义前,已在函数外部做了函数声明,则在各主调函数中可以不加函数声明。

五、函数的嵌套调用

函数调用是指在一个函数的函数体内有调用了其他函数。

技术图片

技术图片
#include <stdio.h>
int fun1(int x,int y);
void main(void)
{ int a,b;
   scanf(“%d%d”,&a,&b);
   printf(“The result is:%d\n”,fun1(a,b) );
}

int fun1(int x,int y)
{ int fun2(int m);
   return ( fun2(x)+fun2(y) );
}

int fun2(int m)
{ return (m*m);
}
/*
输入: 3  4
输出: The result is: 25
*/
输入两个整数,求平方和
技术图片
#include <stdio.h>
 int dif(int x,int y,int z);            //函数声明
 int max(int x,int y,int z);
 int min(int x,int y,int z);
void main()
{
       int a,b,c,d;
       scanf("%d%d%d",&a,&b,&c);
       d=dif(a,b,c);
       printf("Max-Min=%d\n",d);
}

int dif(int x,int y,int z)            //求最大值与最小值差的函数
}           
       return max(x,y,z)-min(x,y,z); 
}

int max(int x,int y,int z)         //求最大值函数
{ 
       int r;
       r=x>y?x:y;
       return(r>z?r:z);
}

int min(int x,int y,int z)          //求最小值函数
{
       int r;
       r=x<y?x:y;
       return(r<z?r:z);
}
      
求三个数中最大数和最小数的差值

六、函数的递归调用

1、递归:在函数调用过程中,直接或间接的调用自身。

2、递归调用方式

【1】直接递归调用:在函数体内又调用自身

技术图片

【2】间接递归调用:当函数1去调用另一函数2时,而另一函数2反过来又调用函数1自身。

技术图片

注:解决无终止递归调用必须要确定好结束递归的条件。

技术图片

3、例题

技术图片
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>

int age(int n)
{
    int  c;
    if (n == 1)   c = 10;
    else  c = 2 + age(n - 1);
    return(c);
}

void main()
{
    printf("%d\n", age(5));
    system("pause");
}
有5个人,第5个人比第4个人大2岁,第4个人比第3个人大2岁,……第2个人比第1个人大2岁,第1个人10岁,问第5个人多大?

有些问题,可以用递推,也可以用递归的方法解决。

递推:从一个已知的事实出发,按一定规律推出下一个事实,再从已知的新的事实,推出下一个新的事实。

技术图片
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void main()
{
    int  i, s = 1;
    for (i = 1; i <= 5; i++)
        s = s* i;
    printf("s = %d\ n", s);
    system("pause");
}
用递推法求n! ,即从1开始, 乘2, 乘3....一直到n
技术图片
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void main()
{
    float fac(int n);
    int n;
    printf("Input a integer number:");
    scanf("%d", &n);
    //y = fac(n);
    printf("%d! = %d", n, int(fac(n)));    //注意:fac(n)为float类型,前面对应%f,若用%d,则后面要转成int型
    system("pause");
}

float fac(int n)
{
    float f;
    if (n<0)  printf("n<0,data error!");
    else if (n == 0 || n == 1)  f = 1 ;
    else  f = (fac(n - 1)*n);
    return f;
}
用递归方法求n!

七、数组作为函数的参数

1、数组元素做函数实参

与变量做实参一样,数组元素做实参是“值传递”。

技术图片
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
float max(int x,int y)
{
    return (x>y?x:y);
}
void main()
{
    int a[10],i,m;
    printf("enter 10 integer:\n");
    for (i = 0; i < 10; i++)
        scanf("%d", &a[i]);
    m = a[0];
    for (i = 1; i < 10; i++)
        m = max(m, a[i]);
    printf("max is %d", m);

    system("pause");
}
求10个任意整数中的最大数
技术图片
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
void main()
{
    float average(float array[10]);
    float score[10], aver;
    int i;
    printf("Input 10 scores: \n");
    for (i = 0; i<10; i++)
        scanf("%f", &score[i]);
    printf("\n");
    aver = average(score);
    printf("Average is: %5.2f", aver);
    system("pause");
}
float  average(float array[10])
{
    int i;
    float aver, sum = array[0];
    for (i = 1; i<10; i++)
        sum = sum + array[i];
    aver = sum / 10;
    return (aver);
}
求学生的平均成绩

 2、一维数组与函数参数

若函数的形参是数组,对应的实参一定是数组名

说明:

【1】实参数组与形参数组的类型必须一致

【2】用数组名做参数时,传递的是数组的首地址,因此形参数组也可以不指定大小。但需另设一个参数,传递数组元素的个数。

技术图片
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
int max(int x[10])
{
    int i, m;
    m = x[0];
    for (i = 1; i < 10; i++)
        if(m < x[i])
            m = x[i];
    return m;
}
void main()
{
    int a[10], i;
    printf("enter 10 integer:\n");
    for (i = 0; i < 10; i++)
        scanf("%d", &a[i]);
    printf("max is %d", max(a));
    system("pause");
}
求10个任意整数中的最大数
技术图片
#include <stdio.h>
#include <stdlib.h>
void main()
{
    float average(float array[], int n);
    float score_1[5] = { 98.5, 97, 91.5, 60, 55 };
    float score_2[10] = { 67.5, 89.5, 99, 69.5, 77, 89.5, 76.5, 54, 60, 99.5 };
    printf("The average of clase A is %6.2f\n", average(score_1, 5));
    printf("The average of clase B is %6.2f\n", average(score_2, 10));
    system("pause");
}
float average(float array[], int n)    //另设一个参数,传递需要处理的数组元素个数
{
    int i;
    float aver, sum = array[0];
    for (i = 1; i<n; i++)
        sum = sum + array[i];
    aver = sum / n;
    return (aver);
}
/*
运行:
The average of class A is 80.40
The average of class B is 78.20
*/
求两组学生的平均成绩,形参数组长度缺省

【3】数组做函数参数时,形参数组和和实参数组共享同一个存储单元

如果形参数组的元素的值被修改,实参数组元素的值也就被修改了。

技术图片
#include <stdio.h>
#include <stdlib.h>
void main()
{
    void sort(int array[], int n);
    int a[10], i;
    printf("enter the array\n");
    for (i = 0; i<10; i++)
        scanf("%d", &a[i]);
    sort(a, 10);
    printf("the sorted array: \n");
    for (i = 0; i<10; i++)
        printf("%d ", a[i]);
    printf("\n");
    system("pause");
}

void sort(int array[], int n)
{
    int i, j, k, t;
    for (i = 0; i < n - 1; i++)
    {
        k = i;
        for (j = i + 1; j < n; j++)
        if (array[j] < array[k])
            k = j;
        t = array[i];
        array[i] = array[k];
        array[k] = t;
    }
}
用选择法对数组中的10个整数按由小到大排序

3、用多维数组名作函数参数

【1】多维数组可以作为函数的参数

【2】如果形参是多维数组,可以省略第一维的大小,但不能省略其他维的大小。

技术图片
#include <stdlib.h>
#include <stdio.h>
void main()
{
    int  max_value(int array[][4]);
    int a[3][4] = { { 1, 3, 5, 7 }, { 2, 4, 6, 8 }, { 15, 17, 34, 12 } };
    printf("max value is %d\n", max_value(a));
    system("pause");
}
int max_value(int array[3][4])    //多维形参数组第一维维数可省略, 第二维必须相同
{
    int i, j, max;
    max = array[0][0];
    for (i = 0; i<3; i++)
    for (j = 0; j<4; j++)
    if (array[i][j]>max)
        max = array[i][j];
    return max;
}
求3×4矩阵中各元素的最大值

八、局部变量与全局变量

1、局部变量

什么是局部变量?(内部变量)

【1】在一个函数内部定义的变量

【2】函数的形式参数

【3】在某个复合语句中定义的变量

说明:

【1】局部变量只在自己的范围内有效

【2】如果局部变量的有效范围有重叠,则有效范围小的优先

【3】不同函数中同名变量,占不同内存单元

2、全局变量

在函数之外定义的变量(外部变量)是全局变量

有效范围:从定义变量的位置开始到原文件结束

说明:(习惯上,全局变量名的第一个字母用大写 )

【1】利用全局变量可以在函数间传递数据,使用全局变量可以减少函数的实参和形参个数。

技术图片
#include <stdio.h>
#include <stdlib.h>
float max = 0, min = 0;
float average(float score[], int n)
{
    int i;
    float sum = score[0];
    max = min = score[0];
    for (i = 0; i < n; i++)
    {
        sum = sum + score[i];
        if (max < score[i])
            max = score[i];
        if (min > score[i])
            min = score[i];
    }
    return sum / n;
}
void main()
{
    float avg, score[10];
    int i;
    for (i = 0; i < 10; i++)
        scanf("%f", &score[i]);
    avg = average(score, 10);
    printf("max:%f  min:%f  average:%f\n", max, min, avg);
    system("pause");
}
有10个学生的学习成绩,求平均分、最高分和最低分

【2】应尽量少使用全局变量

1)>全局变量在程序执行的全过程都占用存储单元。

2)>不利于程序的移植。程序的可读性变差。

【3】如果全局变量与局部变量同名,则局部变量优先

技术图片
#include <stdlib.h>
#include <stdio.h>
int a = 3, b = 5;
void main()
{
    int max(int a, int b);    
    int a = 8;                             // 局部变量a=8将外部变量a=3屏蔽
    printf("max=%d\n", max(a, b));
    system("pause");
}
int max(int a, int b)
{
    int c;
    c = a>b ? a : b;
    return(c);
}
//运行结果:max=8
外部变量与局部变量同名

九、变量的存储类别

1、变量的动态存储和静态存储

全局变量与局部变量 ——> 变量的作用域

静态存储变量和动态存储变量 ——> 变量的存储类别,即生存期

【1】生存期:

静态变量:从程序开始执行到程序结束

动态变量:从包含该变量定义的函数开始执行至函数执行结束

【2】内存中供用户使用的存储空间包括:

1.程序区

2.静态存储区:程序运行期间(编译时)分配固定的存储空间。

3.动态存储区:程序运行期间(执行时)根据需要动态分配存储空间。

【3】变量或函数的属性:

存储类别:自动型  auto

     静态型 static

       寄存器型  register

       外部型  extern

2、局部变量的存储类别

【1】自动变量 —— 存储在动态存储区,用 auto 说明

函数内部无static声明的局部变量均为动态存储类别,被分配在动态区 。

存储类别为自动时,声明符auto可省;自动变量被 分配在动态区,未赋初值时,其值未定义,每次调用重新赋值。

例如:
int
f(int a) /*定义f函数,a为形参*/ {auto int b,c=3; /*定义b、c为自动变量*/ … } 又如:
auto
int b,c=3; int b,c=3; /*两者等价*/

【2】局部静态变量 —— 占用静态存储区,用 static 说明

若希望函数调用结束后,局部变量的值保留,则指定该变量为静态局部变量,用static对变量加以声明。

技术图片
#include <stdlib.h>
#include <stdio.h>
void main()
{
    void increment(void);
    increment();
    increment();
    increment();
    system("pause");
}
void increment(void)
{
    int x = 0;                 //结果:1 1 1 
    //static int x = 0;     //结果:1 2 3
    x++;
    printf("%d\n", x);
}
局部静态变量值具有可继承性
技术图片
#include <stdlib.h>
#include <stdio.h>
void main()
{
    int f(int);
    int  a = 2, i;
    for (i = 0; i<3; i++)
        printf(" %d ", f(a));    //结果:7 8 9
    system("pause");
}
int f(int a)
{
    auto b = 0;
    static int c = 3;
    b = b + 1; c = c + 1;
    return(a + b + c);
}
考察静态局部变量的值

说明:

1)>局部静态变量属于静态存储类别。在程序整个运行期间都不释放存储空间,程序运行结束后才释放存储单元。

2)>局部静态变量在编译时赋初值(仅赋一次值),前次结果保留。

3)>如果局部动态变量若未赋初值,其值不确定;局部静态变量时没有赋初值,编译时会自动赋初值,其值为0或‘\0’(字符变量)。

4)>局部静态变量只能在定义它的函数内被引用(调用结束后存在但不能被其他函数使用)。

使用局部静态变量的场合

1)>需要保留上一次调用结束时的值

技术图片
#include <stdlib.h>
#include <stdio.h>
void main()
{
    int  fac(int n);
    int  i;
    for (i = 1; i <= 5; i++)
        printf("%d != %d\n", i, fac(i));
    system("pause");
}
int  fac(int n)
{
    static int f = 1;
    f = f*n;
    return(f);
}
/*
运行结果:
1 != 1
2 != 2
3 != 6
4 != 24
5 != 120
*/
打印1到5的阶乘值

2)>初始化后变量只被引用而不改变其值,则用静态局部变量较方便,以免每次调用时重新赋值,但会一直占用内存浪费系统资源。

【3】寄存器变量 —— 占用动态存储区,用 register 说明

CPU内有寄存器可用来存放数据,若把数据声明为寄存器类型,则将该类型的数据存放在寄存器中,其优点是:减少数据与内存之间的交换频率,提高程序的效率和速度。

寄存器类型变量的几点说明:

1. 寄存器变量对寄存器的占用是动态的,局部自动变量类型和形参可定义为寄存器变量,局部静态变量不能定义为寄存器变量。

2.计算机的寄存器的个数有限, 不同C系统对寄存器的使用个数,对register变量的处理方法不同,对寄存器变量的数据类型有限制。

3.有的系统将寄存器变量转化为自动变量处理,而有的系统会自动设置寄存器变量。

4. long,double,float不能设为register型,因为超过寄存器长度。

3、全局变量的存储类别

【1】全局变量都是静态的

【2】用 extern 说明一个在其他原文件中定义的全局变量

外部变量也称全局变量,在函数外部定义,其作用域是从变量的定义处开始,到本程序文件的未尾。在定义的作用域内,全局变量可为程序中各个函数所引用。 可以用extern声明外部变量,以扩展外部变量的作用域。

一个文件内声明外部变量 外部变量没在文件开头定义,其作用域为定义处到文件结束。定义处之前的函数要使用,则在引用前用关键字extern作“外部变量声明”。

技术图片
#include <stdio.h>
#include <stdlib.h>
int max(int x, int y)
{
    int z;
    z = x>y ? x : y;
    return(z);
}
void main()
{
    extern int A, B;                //可以省略为:extern A,B;
    printf(" %d ", max(A, B));    //结果:13
    system("pause");
}
int  A = 13, B = -8;
用extern声明外部变量,扩展作用域
技术图片
#include <stdio.h>
#include <stdlib.h>
void main()
{
    void gx(), gy();
    extern int X, Y;
    printf("1: x = %d\ty = %d\n", X, Y);
    Y = 246;
    gx();
    gy();
    system("pause");
}
void gx()
{
    extern int X, Y;
    X = 135;
    printf("2: x = %d\ty = %d\n", X, Y);
}
int X, Y;
void gy()
{
    printf("3: x = %d\ty = %d\n", X, Y);
}
//1 : x = 0        y = 0
//2 : x = 135      y = 246
//3 : x = 135      y = 246
用extern扩展作用域

在多文件的程序中声明外部变量 如果一个程序由多个文件组成,而一个外部变量需要在几个文件中引用,此时,可以在任一文件中定义该外部变量,在其它文件中用extern加以声明 若在每个文件中都定义该外部变量,则系统将提示“重定义类型错”。

技术图片

技术图片
#include <stdlib.h>
#include <stdio.h>    /*文件file1.c*/
int A;
void main()
{
    int power(int);
    int b = 3, c, d, m;
    printf("Enter the number a and its power m:\n");
    scanf("%d %d", &A, &m);
    c = A*b;
    printf("%d*%d=%d\n", A, b, c);
    d = power(m);
    printf("%d**%d=%d", A, m, d);
    system("pause");
}
/*文件file2.c*/
extern int A;
int power(int n)
{
    int i, y = 1;
    for (i = 1; i <= n; i++)
        y *= A;
    return(y);
}
/*
输入:a=5,m=2
结果:5*3=15
         5**2=25
*/
     
用extern将外部变量的作用域扩展到其它文件,给定b的值,输入a和m,求a*b和a**m的值

【3】用 static 说明一个不能在其他原文件中定义引用的全局变量

如果外部变量只允许本文件使用,不允许其它文件引用,则定义时加static声明。称为“静态外部变量” 只在工程方法中有效,在文件包含中则不起作用 常用于多人编同一程序,又使用同名变量时 加或不加static声明的外部变量都是静态存储,但其作用域不同

技术图片

关于变量的声明和定义

函数:由“声明部分”和“执行语句”组成

声明部分: 对有关的标识符(变量,函数,结构体)的属性进行说明,对于函数,声明和定义区别明显,声明是函数原型,定义是函数本身,是一个独立的程序模块;

变量的声明有两种情况 定义性声明:需建立存储空间,如int a;也称定义。 引用性声明:不建立存储空间,如extern A 外部变量“定义性声明”只能一次,“引用性声明”多次。

广义地讲,声明包括定义,但并非所有的声明都是定义;

如:int A;既包含声明又包含定义; extern A;只是声明,而无定义。

约定:建立存储空间的声明称定义; 不建立存储空间的声明称声明。

 

Static定义性声明变量作用二个:

  局部变量用static定义性声明,分配的存储空间在程序执行期间始终存在,但作用域 只限定义它的函数或分程序。

  全局变量用static定义性声明,变量的作用域仅限本文件模块

Auto,register,static是在定义变量的基础上加上这些关键字,不能单独作用。

 

 

注:应尽量少用全局变量

4、存储类别小节

【1】变量的定义方法: [ 存储类别 ]  数据类型  变量名 ,……

【2】变量的划分

按作用域:局部变量 —— 自动变量;静态局部变量;寄存器变量;形式参数。

     全局变量

按生存期:动态存储 —— 自动变量;寄存器变量;形式参数。

     静态存储 —— 静态局部变量;全局变量。

按变量的存放位置:动态存储区 —— 自动变量;形式参数。

         静态存储区 —— 静态局部变量;全局变量

           寄存器 —— 寄存器变量

技术图片
//方法二:全局变量
#include <stdio.h>
#include <stdlib.h>
int x, y;
void swap(void)
{
    int t;
    t = x; x = y; y = t;
}
void main()
{
    scanf("%d %d", &x,&y);
    swap();
    printf("a=%d b=%d\n", x, y);
    system("pause");
}
//方法三:数组
#include <stdio.h>
#include <stdlib.h>
void swap(int x[2])
{
    int t;
    t = x[0];
    x[0] = x[1];
    x[1] = t;
}
void main()
{
    int x[2];
    scanf("%d %d", &x[0], &x[1]);
    swap(x);
    printf("a=%d b=%d\n", x[0], x[1]);
    system("pause");
}
编写一个函数swap用于交换两个整数的值

 

c语言-函数

标签:组成   core   不能   编写   void   函数类型   根据   最小数   重叠   

原文地址:https://www.cnblogs.com/dabj-yb/p/12589417.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!