（保姆级）函数基本内容-阿里云开发者社区

1.函数是什么

C语言中的函数被称为子程序。

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

独立性：每个函数之间的功能是独立的，printf 只负责打印，scanf 只负责输入，Add函数只负责加法。

2.函数的分类

库函数
自定义函数

2.1库函数

C语言本身是没有库函数的，由于一些功能被我们常常使用，

求字符串长度-strlen

比较2个字符串的大小-strcmp

打印数据-printf

为了提高我们的效率，就提供了平常可能会用到的函数。我们使用时只要包含头文件就可以直接使用。

可以查询库函数的网站

1.https://cplusplus.com/reference/

C语言常用的库函数都有：

IO函数（输入输出函数）头文件：<stdio.h>
字符串操作函数头文件：<string.h>
字符操作函数
内存操作函数
时间/日期函数
数学函数头文件：<math.h>
其他库函数

strcpy 函数参数描述：char* strcpy(char* destination, const char* source)

我们通过刚刚的网站来学习一下库函数strcpy

strcpy(目的地，来源) 将来源的字符串复制到目的地，目的地的数组长度要足够长，装得下来源的字符串。包括null字符，也就是\0一并复制。

看实现代码：

#include<stdio.h>
#include <string.h>
int main()
{
    char arr1[20] = {0};
    char arr2[] = "hello bit";
    strcpy(arr1,arr2);
    printf("%s\n",arr1);
    return 0;
}

我们接着来学一下库函数memset

ptr是指针，也就是地址，从一个地址开始，往后的num个字节，变成value

实现代码：

#include<stdio.h>
#include <string.h>
int main()
{
  char arr[] = "hello world";
  memset(arr, 'x', 5);
  printf("%s\n",arr);
  return 0;
}

代码结果：

将指针ptr改变，就是地址改为arr+6.

实现代码：

#include<stdio.h>
#include <string.h>
int main()
{
  char arr[] = "hello world";
  memset(arr+6, 'x', 5);
  printf("%s\n",arr);
  return 0;
}

结果：

库函数的使用必须包含它的头文件，#include 头文件

2.1.1 库函数的查询

库函数的查询网站：

我们不需要记住所有的库函数，只要会查询就可以了

1. https://cplusplus.com/reference/

2. https://en.cppreference.com/w/（英文）

3.https://zh.cppreference.com/w/（中文）

2.2 自定义函数

库函数只是比较常用的功能，其他功能好需要我们自定义函数。

自定义函数和库函数一样，有函数名，返回值类型和函数参数。

ret_type fun_name(paral,*)
{                                 //
    statement;//语句项            //函数体：函数的实现
}                                //
ret_type 返回类型
fun_name 数组名
paral    函数参数

a,b是参数，get_max是函数名，结果为返回值。

题目：写一个函数可以找出两个整数中的最大值

//函数的定义
int get_max(int x,int y)
{
    return (x > y ? x : y);//比较大小的函数实现
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d %d",&a,&b);
    //求较大值
    int m = get_max(a,b);
    printf("%d\n",m);
    return 0;
}

你也可以写成

int get_max(int x,int y)
{
    if(x>y)
        return x;
    if(x<y)
        return y;
}

3.函数的参数

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

#include <stdio.h>
void swap(int x,int y)
{
    int z = 0;
    z=x;
    x=y;
    y=z;
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d%d",&a,&b);
    //交换
    printf("交换前:a=%d b=%d\n",a,b);
    swap(a,b);
    printf("交换后:a=%d b=%d\n",a,b);
    return 0;
}

按照这样的代码我们发现，结果并没有进行转换。

x,y能够接收到a,b的值。

x和y的值确实发生了改变，但是并不会影响到a,b的值。

这里的x，y就是形式参数，a,b就是实际参数

形参是实参的一份临时拷贝，但是形参有自己的独立空间，因为有自己的独立空间，所以修改形参不会改变实参

想要实现这个函数，我们就要使形参和实参建立联系。

当形式参数x,y为指针指向实际参数a,b时,x,y就可以直接通过地址来改变a,b的值。

#include <stdio.h>
void swap(int* px, int* py)
{
    int z = *px;//z=a
    *px = *py;//a=b
    *py = z;//b=a
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d%d",&a,&b);
    //交换
    printf("交换前:a=%d b=%d\n",a,b);
    //swap(a,b);
    swap(&a,&b);
    printf("交换后:a=%d b=%d\n",a,b);
    return 0;
}

3.1实际参数（实参）：

真实传给函数的参数，叫实参。

实参可以是：常量、变量、表达式、函数等。

无论函数是什么类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

int b = 3;
int c = Add(Add(1,3),b);//Add有返回值，即使Add作为实参也是可以的

3.2形式参数（形参）：

形式参数是指函数名括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（当这个函数被调用后，我们的形式参数才会开辟内存空间），所以叫形式参数，形式参数当函数调用完之后就会自动销毁，因此形式参数只有在函数中有效。

4.函数的调用

4.1 传值调用

传值调用: swap(a,b)我们直接把变量的值，传给函数，函数也用变量来接收void swap(int x,int y)

不可以改变原来变量a,b的值

#include <stdio.h>
void swap(int x,int y)
{
    int z = 0;
    z=x;
    x=y;
    y=z;
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d%d",&a,&b);
    //交换
    printf("交换前:a=%d b=%d\n",a,b);
    swap(a,b);
    printf("交换后:a=%d b=%d\n",a,b);
    return 0;
}

4.2 传址调用

传址调用: swap(&a,&b)我们直接把变量的地址，传给函数，函数用指针来接收

void swap(int* x,int* y)，可以通过指针来改变变量a,b的值

#include <stdio.h>
void swap(int* px, int* py)
{
    int z = *px;//z=a
    *px = *py;//a=b
    *py = z;//b=a
}
int main()
{
    int a = 0;
    int b = 0;
    scanf("%d%d",&a,&b);
    //交换
    printf("交换前:a=%d b=%d\n",a,b);
    //swap(a,b);
    swap(&a,&b);
    printf("交换后:a=%d b=%d\n",a,b);
    return 0;
}

5.练习

练习1

写一个函数可以判断一个数是不是素数，范围：100~200

解题思路：素数只能被1和它本身整除的数

1.产生100到200的数进行判断

2.用 2~ i-1 的数字去除i,如果都不能被整除，那么这个数字就为素数

#include <stdio.h>
int main()
{
    int i = 0;
    for(i=100;i<=200;i++)
    {
        //判断i是否为素数
        //如果为素数，我们就打印
        int flag = 1;//flag=1，就说明为素数
        int j = 0;
        for(j=2;j<=i-1;j++)
        {
            if(i%j==0)
            {
                flag = 0;//如果一个数不是素数，就会进到这里，改变flag的值。
                break;
            }
        }
        if(flag==1)
            printf("%d ",i);
    }
    return 0;
}

优化思路：原来：用 2~ i-1 的数字去除i,如果都不能被整除，那么这个数字就为素数

改：如果一个数不是素数，就一定能被（除了1和它本身）2个数整除，而这两个数一定一个大于这个数的平方，一个小于这个数的平方

因此for循环中，j<=sqrt(i),sqrt为头文件<math.h>的库函数，作用就是算术平方根。

#include <stdio.h>
#include <math.h>
int main()
{
    int i = 0;
    for(i=100;i<=200;i++)
    {
        //判断i是否为素数
        //如果为素数，我们就打印
        int flag = 1;//flag=1，就说明为素数
        int j = 0;
        for(j=2;j<=sqrt(i);j++)
        {
            if(i%j==0)
            {
                flag = 0;//如果一个数不是素数，就会进到这里，改变flag的值。
                break;
            }
        }
        if(flag==1)
            printf("%d ",i);
    }
    return 0;
}

通过函数的表达，实现代码

#include <stdio.h>
#include <math.h>
int is_prime(int n)
{
     int j = 0;
     for(j=2;j<=sqrt(n);j++)
     {
        if(n%j==0)
       {
               return 0;//不是素数返回0
       }
     }
    return 1;//素数返回1
}
int main()
{
    int count = 0;
    int i = 0;
    for(i=100;i<=200;i++)
    {
        //判断i是否为素数
        //如果为素数，我们就打印
       if(is_prime(i))//素数返回1，为真，打印
       {
            printf("%d ",i);
            count++;
       }
    }
    printf("\ncount = %d\n",count);
    return 0;
}

练习2

写一个函数判断一年是不是闰年范围：1000~2000

解题思路：闰年指的是1.能被4整除但不能被100整除的数

2.或者能被400整除的数

1.创造1000到2000的数

#include <stdio.h>
int main()
{
    int year = 0;
    for (year = 1000; year <= 2000; year++)
    {
        if (year % 4 == 0)
        {
            if (year % 100 != 0)
                printf("%d ", year);
        }
        if (year % 400 == 0)
            printf("%d ", year);
    }
}

优化：使代码更加简洁

#include <stdio.h>
int main()
{
  int year = 0;
  for (year = 1000; year <= 2000; year++)
  {
        //判断year是不是闰年
  if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
  {
    printf("%d ", year);
  }
  }
  return 0;
}

将代码写入函数

#include <stdio.h>
int is_leap_year(int y)
{
  if (((y % 4 == 0) && (y % 100 != 0)) || (y % 400 == 0))
    return 1;//闰年返回1
  else
    return 0;//不是闰年返回0
}
int main()
{
  int year = 0;
  for (year = 1000; year <= 2000; year++)
  {
    //判断year是不是闰年
    if (is_leap_year(year))//闰年返回1，表达式为真，执行语句
    {           //不是闰年返回0，跳过语句，进入下一个循环        
      printf("%d ", year);
    }
  }
  return 0;
}

练习3

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

解题思路：arr[]={1,2,3,4,5,6,7,8,9} , 我们通过比较这个数组的中间元素的大小，

二分查找：

1.如果比我们找的数要大，我们直接从中间开始，往左边找就可以了。

2.如果比我们找的数要小，我们直接从中间开始，往右边找就可以了。

实现代码：

#include<stdio.h>
int binary_search(int arr[], int k, int sz)
{
  int left = 0;//左边的下标
  int right = sz - 1;//右边的下标
  while (left<=right)
  {
    int mid = left + (right - left) / 2;
    if (arr[mid] < k)
    {
      left = mid + 1;//如果中间元素小于我们要找的元素，将left改变为mid+1,就可以开启新的                   
                             一轮二分查找
      }
    else if (arr[mid] > k)
    {
      right = mid - 1;//如果中间元素大于我们要找的元素，将right改变为mid-1,就可以开启
                              新的一轮二分查找                   
    }
    else
    {
      return mid;//找到了返回下标
    }
  }
  return -1;//找不到返回-1
}
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  //            0 1 2 3 4 5 6 7 8 9 
  int k = 17;
  int sz = sizeof(arr) / sizeof(arr[0]);
  //找到了，返回下标
  //找不到，返回-1
  int ret = binary_search(arr, k, sz);
  if (ret == -1)
  {
    printf("找不到\n");
  }
  else
  {
    printf("找到了，下标是:%d\n", ret);
  }
  return 0;
}

形式参数和实际参数的名字可以相同，也可以不同

错误示范：

数组传参实际上传递的是数组首元素的地址，如果你想要在函数里面，求元素个数

int sz = sizeof(arr) / sizeof(arr[0])

那么这时就会发生错误

#include<stdio.h>
int binary_search(int arr[], int k)
{
  int sz = sizeof(arr) / sizeof(arr[0]);  
    int left = 0;//左边的下标
  int right = sz - 1;//右边的下标
  while (left<=right)
  {
    int mid = left + (right - left) / 2;
    if (arr[mid] < k)
    {
      left = mid + 1;//如果中间元素小于我们要找的元素，将left改变为mid+1,就可以开启新的                   
                             一轮二分查找
      }
    else if (arr[mid] > k)
    {
      right = mid - 1;//如果中间元素大于我们要找的元素，将right改变为mid-1,就可以开启
                              新的一轮二分查找                   
    }
    else
    {
      return mid;//找到了返回下标
    }
  }
  return -1;//找不到返回-1
}
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  //            0 1 2 3 4 5 6 7 8 9 
  int k = 7;
  //找到了，返回下标
  //找不到，返回-1
  int ret = binary_search(arr, k);
  if (ret == -1)
  {
    printf("找不到\n");
  }
  else
  {
    printf("找到了，下标是:%d\n", ret);
  }
  return 0;
}

练习4

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

#include <stdio.h>
void set(int* n)
{
  (*n)++;
}
int main()
{
  int num = 0;
  set(&num);
  printf("%d\n", num);
  set(&num);
  printf("%d\n", num);  
  set(&num);
  printf("%d\n", num);
  set(&num);
  printf("%d\n", num);
  return 0;
}