C语言基础09 函数

函数

函数是什么？

C语言中的函数，维基百科中给出的定义是：子程序

• 在计算机科学中，子程序，是一个大型程序中的某部分代码，由一个或多个语句块组成。它负责完成某项特定任务，而且相较于其他代码，具备相对的独立性。
• 一般会有输入参数并有返回值，提供对过程的封装和细节的隐藏。这些代码通常被集成为软件库。

C语言中函数的分类：

1. 库函数
2. 自定义函数

库函数：

为什么会有库函数？

1. 我们知道在我们学习C语言编程的时候，编写完一个代码之后，打印到屏幕上看结果，会频繁的用一个功能：将信息按照一定的格式打印到屏幕上（printf）。
2. 在编程的过程中，我们会频繁的做一些字符串的拷贝工作（strcpy）。
3. 在编程中，我们计算时总会遇到n的次方这样的运算（pow）。

像上面我们描述的一些基础工程，它们不是业务性的代码，在开发过程中所有程序员都能用的到，为了支持可移植性和提高程序的效率，所以C语言的基础库中提供了一系列类似的库函数。方便程序员使用，进行软件开发。

一些常见的库函数

• IO函数 printf scanf getchar putchar
• 字符串操作函数 strcmp strlen
• 内存操作函数 toupper
• 时间/日期函数 time
• 数学函数 sqrt pow
• 其他库函数

常见库函数的使用

strcpy

strcpy的作用：拷贝一个字符串

int mian()
{
    char arr1[20] = {0};
    char arr2[] = "hello";
    strcpy(arr1,arr2); //把arr2拷贝到arr1
    printf("%s",arr1);  //打印arr1这个字符串 %s -以字符串的格式打印

    return 0;
}

Console:
hello

memset

memset的作用：把前n个元素设置成x。

int mian()
{
    char arr[] = "hello";
    mesmset(arr,'x',5);

    printf("\s\n",arr);
    
    return 0;
}

Console:
xxxxx hello

自定义函数的使用

自定义函数和库函数一样，有函数名、返回值类型以及函数参数，和库函数不一样的是，自定义函数的函数名和函数内容，是可以自己定义的。

例如：计算20和30的和。

通常方法计算：

int main()
{
  int num1=0;
  int num2=0;
  scanf("%d%d",&num1,&num2);
  int sum =num1+num2;
  
  return 0;
}

若输入的值为20,30
则控制台打印:
50

用函数的方法来解决：

int Add(int a,int b)  //定义一个函数add,用来计算两个数的和
{
   int c = 0;    
   c = a + b;
   return c;
}

int main()
{
  int num1=0;
  int num2=0;
  scanf("%d%d",num1,num2);

  int sum = Add(num1,num2);
  printf("%d\n",sum);

  return 0;
}

若是输入的值为20,30
则控制台打印:
50

函数的组成

返回类型 函数名(函数参数)
   |      |      |
  int    Add   (int x)
{
     x++;  语句项
}

例如：

1. 求两个函数的最大值

int get_max(int x,int y) //定义get_max函数
{
    int num;
    if(x > y){
       num = x;
    }else{
       num = b;
    }
    return num; //返回最大值
}


int mian()
{
    int a = 10;
    int b = 20;
    int max = get_max(a,b);

    printf("max = %d\n",max);
    
    return 0;
}

2. 写一个函数可以交换两个整型变量的内容

//函数返回类型的地方写成 void ,表示这个函数不返回任何值,也不需要返回
void change_int(int x,int y)
{
   int temp;
   temp = x;
   x = y;
   y = temp;
}

int mian()
{
    int a = 10;
    int b = 20;
    
    printf("交换前:a=%d b=%d\n",a,b);
    change_int(a,b);
    printf("交换后:a=%d b=%d\n",a,b);
    
    return 0;
}

Console:
交换前:a=10 b=20
交换后:a=10 b=20

这里要注意一个地方，可以看到这个程序打印出来的交换前和交换后的ab值一样，这是因为change函数里面的ab和main函数里面的ab地址值不一样，改变change函数的ab值并没有改变main函数的地址，所以不论在change函数中做了什么，反馈给main的依旧是原始的ab值。

改善方法：使用指针变量

void change(int* pa,int* pb)
{
     int temp =0;
     temp =*pa;
     *pa = *pb;
     *pb = temp;
}

int mian()
{
    int a =10;
    int b =20;

    printf("交换前: a=%d b=%d\n",a,b);
    change(&a,&b);
    printf("交换后: a=%d b=%d\n",a,b);

    return 0;
}

Console:
交换前: a=10 b=20
交换后: a=20 b=10

函数的参数

在上一个例子中，main函数中有一行代码：change（&a，&b），被调用的change函数括号里跟着的参数 &a 与 &b，是真实传递给change函数的参数，这里就进入了一个概念：函数的参数类型。像这种被真实传递的参数被称为实际参数（实参），而自定义的change函数，void change(int* pa,int* pb)中的*pa 和 *pb是用来接收的参数，称为形式参数（形参）。

函数的参数类型

• 实际参数（实参）
  真是传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传给形参。

• 形式参数（形参）
  形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

回过头来看前一个例子，没有用指针变量的change函数，其实可以理解为：change再被调用的时候，实参传给形参，其实形参是实参的一份临时拷贝，改变形参，不能改变实参的值。

函数的传值调用

传值调用

函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。

传址调用

• 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
• 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。

int change(int x,int y){} //传值调用
int change(int* pa,int* pb){} //传址调用

练习：

1. 写一个函数可以判断100-200之的素数，打印并计数。
2. 写一个函数判断1000-2000年有多少闰年，打印出来。
3. 写一个函数，实现一个整型有序数组的二分查找。
4. 写一个函数，每调用一次这个函数，就会将num的值增加1。

写一个函数可以判断100-200之的素数，打印并计数。

int  prime(int x)
{  
     int j =0;
     for(j = 2; j <n; j++)
     {
        if( n % j == 0)
            return 0;
     }
     return 1;
}

int main()
{
    int i =0;
    int count = 0;
    for( i = 100; i <= 200; i++)
    {
        //判断i是否为素数
        if(prime(i) == 1)
        {
           count++;
           printf("%d",i);
        }
    }
    printf("\ncount = %d\n",count);
    return 0;
}

判断1000-2000年有多少闰年，打印出来

int year(int x)
{
    return ((x % 4 == 0 && x % 100 != 0) || (x % 400 == 0));
}

int main()
{
    int i =0
    for(i = 1000; i <=2000; i++)
    {
        if(year(i) == 1)
        {
           printf("%d",i);
        }
    }
    return 0;
}

写一个函数，实现一个整型有序数组的二分查找。

在1-10中查找7

//int search(int* a,intx,int y)
int search(int a[],int x,int y)
{
    int left = 0;
    int right = y -1;

    while(left <= right)
    {
        int mid = (left + right) /2;
        if(a[mid] > x)
        {
          right = mid - 1;
        }
        else if(a[mid] < x)
        {
          left = mid + 1;
        }
        else
        {
          return mid;
        }
    }
    return -1;
}

int mian()
{
    int arr[] = {1,2,3,4,5,6,7,8,9,10};
    int key =7;
    //数组arr传参，实际传递的不是数组本身，仅仅传过去了数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    int num = search(arr,key,sz);
    if( -1 == num)
    {
       printf("查无此数\n");
    }
    else
    {
       printf("查找的数下标为:%d\n",num);
    }
    
    return 0;
}

写一个函数，每调用一次这个函数，就会将num的值增加1。

int Add(int* x)
{
   (*x)++;
}

int main()
{
    int num =0;
    Add(&num);
    printf("%d\n",num); //1

    Add(&num);
    printf("%d\n",num); //2

    Add(&num);
    printf("%d\n",num); //3
    
    return 0;
}

函数的嵌套调用和链式访问

函数的嵌套调用

void test3()
{
     printf("红彤彤\n");
}

int test2()
{
    printf();
    return 0;
}

int main()
{
   test2();
   return 0;
}

Console:
红彤彤

• 链式访问

把一个函数的返回值作为另一个函数的参数。

例一：

int mian()
{
    char arr1[20] = {0};
    char arr2[] = "hello";
    strcpy(arr1,arr2);
    printf("%s\n",arr1);
    
    return 0;
}

Console:
hello

例二：

printf("%d",printf("%d",printf("%d",43)));

Console:
4321

printf的返回值是：函数返回的是打印在屏幕上的字符的个数。

最内层的printf打印出的数是43，个数为2，所以最内层返回的值为2，控制台紧接着打印2，又因为打印了2，个数为1，所以中间那层的返回值为1，最外层接收到1，打印1，加在一起就是4321。

函数的声明和定义

• 函数声明

  1. 告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但具体是不是存在，无关紧要。
  2. 函数的声明一般出现在函数的使用之前。要满足先声明后使用。
  3. 函数的声明一般要放在头文件中。

• 函数定义
  函数的定义是指函数的具体实现，交代函数的功能实现。

例如：

int mian()
{
    int a =10;
    int b =20;
    int c =Add(a,b);

    printf("%d\n",c);
    return 0;
}

//函数的定义
int Add(int x,int y)
{
    return x+y;
}

Console:
报错:"Add"未定义;假设外部返回 int

报错是因为，程序是从上到下执行的，而进入到了main函数之后，发现Add函数并没有被定义，所以会报错。所以我们一般会把定义的函数放在main函数之前，若是想把函数放在main函数之后，我们可以使用函数的声明，来帮助我们完成这个想法，例如：

int main()
{
    int a =10;
    int b =20;
    //函数声明
    int Add(int, int);

    int c = Add(a,b);
    printf("%d\n",c);
    return 0;
}

int Add(int x,int y)
{
    return x + y;
}

Console:
30