C语言一招教你搞定所有基础函数知识（上）

1.前言

Hello，大家好，我是小陈，新年快乐呀！马上就龙年了，今天是大年30，祝各位新的一年更上一层楼，今天小陈为大家带来了C语言的函数基础知识，希望大家仔细看完。

2.函数的概念

何为函数呢？我们在之前的数学学习中知道，例如y=kx+b，y=x^等这样的函数，因变量与自变量，当然在C语言的函数中也是这样，求解一些复杂的简单的编程问题，我们可以用函数去解决，比如计算很大的数字，大数据的处理，其实就是C语言中的函数就是一个完成某项特定的任务的一小段代码，为子程序。

3.库函数与自定义函数

3.1标准库与头文件

库函数就是C语言仓库里的函数，内置函数，而标准库可以通俗的解释为为程序员提供用的函数。
库函数相关头文件：https://zh.cppreference.com/w/c/header

3.2库函数的使用方法

C/C++官方的链接:https://zh.cppreference.com/w/c/header
cplusplus.com:https://legacy.cplusplus.com/reference/clibrary
举例:sqrt

double sqrt (double X);
//sqrt是函数名
//x 是函数的参数，表示调用sqrt函数需要传递一个double的类型的值
//double 是返回值类型 - 表示函数计算的结果是double类型的值
//总的来说就是函数返回类型+函数名+函数参数的类型+传参的值。
//这个函数的功能就是计算平方根和返回平方根
//在使用库函数的时需要包含头文件
//这个函数的实践
#include <stdio.h>
int main()
{ 
 double d =16.0;
 double r = sqrt(d);
 printf("%lf\n",r);

  return 0
}

3.3库函数文档的一般格式

1.函数原型
2.函数功能介绍
3.参数和返回类型说明

3.4自定义函数

语法形式

ret_type fun_name(形式参数)
{
}

ret_type 是函数返回类型
fun_name 是函数名
括号中放的是形式参数
{}括起来的是函数体

在这个图中我们可以清晰的知道自定义函数如何使用，但是要注意以下两点:
1.尽量起有意义的函数名字，比如加法Add
2.函数返回类型要确定好，接受的参数类型和传参的参数类型要相同。

函数举例：

写⼀个加法函数，完成2个整型变量的加法操作。

#include <stdio.h>
int main()
{
 int a = 0;
 int b = 0;
 //输⼊
 scanf("%d %d", &a, &b);
 //调⽤加法函数，完成a和b的相加
 //求和的结果放在r中
 //to do
 
 //输出
 printf("%d\n", r);
 return 0;
}

写出Add函数

#include <stdio.h>
int Add(int x, int y)
{
 int z = 0;
 z = x+y;
 return z;
}
int main()
{
 int a = 0;
 int b = 0;
 //输⼊
 scanf("%d %d", &a, &b);
 //调⽤加法函数，完成a和b的相加
 //求和的结果放在r中
 int r = Add(a, b);
 //输出
 printf("%d\n", r);
 return 0;
}

//可以简化为:
int Add(int x, int y)
{
 return x+y;
}

4.形参和实参

4.1实参

实参可以理解为它在main函数里的参数，因为如果想调用一个子程序，也就是函数我们通常会把函数写在main函数外，这样可以在main函数里写实参，传递给子程序。

4.2形参

在上面的代码里，如果只是定义了 Add 函数，⽽不去调⽤的话， Add 函数的参数 x 和 y 只是形式上存在的，不会向内存申请空间，不会真实存在的，所以叫形式参数。形式参数只有在函数被调⽤的过程中为了存放实参传递过来的值，才向内存申请空间，当实参已经确定，字母是不可以发生变化，参数类型也是，而传递过去的实参，参数类型必须和形参一样，否则就会引起类型不兼容问题，这个过程就是形式的实例化。

4.3 实参和形参的关系

虽然我们提到了实参是传递给形参的，他们之间是有联系的，但是形参和实参各⾃是独⽴的内存空间。

#include <stdio.h>
int Add(int x, int y)
{
 int z = 0;
 z = x + y;
 return z;
}
int main()
{
 int a = 0;
 int b = 0;
 //输⼊
 scanf("%d %d", &a, &b);
 //调⽤加法函数，完成a和b的相加
 //求和的结果放在r中
 int r = Add(a, b);
 //输出
 printf("%d\n", r);
 return 0;
 }

我们可以理解为形参是实参的一份临时拷贝。

5. return 语句

在函数的设计中，函数中经常会出现return语句，这⾥讲⼀下return语句使⽤的注意事项。
• return后边可以是⼀个数值，也可以是⼀个表达式，如果是表达式则先执⾏表达式，再返回表达式的结果。
• return后边也可以什么都没有，直接写 return; 这种写法适合函数返回类型是void的情况。
• return返回的值和函数返回类型不⼀致，系统会⾃动将返回的值隐式转换为函数的返回类型。
• return语句执⾏后，函数就彻底返回，后边的代码不再执⾏，如果一个程序写完了，把return 0;放在最前面则这个程序会直接退出，后面的代码不会去运行。
• 如果函数中存在if等分⽀的语句，则要保证每种情况下都有return返回，否则会出现编译错误。

6.数组做函数参数

#include <stdio.h>
int main()
{	
    int arr[]={1,2,3,4,5,6,7,8,9,10};
    set_arr();
    print_arr();
  return 0;
}

set_arr函数要能对够数组内容进行设置，就得把数组作为参数传递给参数，同时函数内部设置数组每个元素的时候进行遍历数组，print_arr也是这样。

函数传参的重点知识：
• 函数的形式参数要和函数的实参个数匹配
• 函数的实参是数组，形参也是可以写成数组形式的
• 形参如果是⼀维数组，数组⼤⼩可以省略不写
• 形参如果是⼆维数组，⾏可以省略，但是列不能省略
• 数组传参，形参是不会创建新的数组的
• 形参操作的数组和实参的数组是同⼀个数组

void set_arr(int arr[], int sz)
{
 int i = 0;
 for(i=0; i<sz; i++)
 {
 arr[i] = -1;
 }
 }
void print_arr(int arr[], int sz)
{
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d ", arr[i]);
 }
 printf("\n");
 }

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

7.1 嵌套调⽤

嵌套调用就是函数之间的互相调用，多个函数调用起来才能实现强大的功能，实现程序的调动

例如：
假设我们计算某年某⽉有多少天？如果要函数实现，可以设计2个函数:

• is_leap_year()：根据年份确定是否是闰年
• get_days_of_month()：调⽤is_leap_year确定是否是闰年后，再根据⽉计算这个⽉的天数

int is_leap_year(int y)
{
 if(((y%4==0)&&(y%100!=0))||(y%400==0))
 return 1;
 else
 return 0;
}
int get_days_of_month(int y, int m)
{
 int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 int day = days[m];
 if (is_leap_year(y) && m == 2)
 day += 1;
 
 return day;
 }
 int main()
{
 int y = 0;
 int m = 0;
 scanf("%d %d", &y, &m);
 int d = get_days_of_month(y, m);
 printf("%d\n", d);
 return 0;
}

这⼀段代码，完成了⼀个独⽴的功能。代码中反应了不少的函数调⽤：

• main 函数调⽤ scanf 、 printf 、 get_days_of_month
• get_days_of_month 函数调⽤ is_leap_year

我们这里看到几个函数调用后实现了强大的功能，但是函数是不能被嵌套定义的！！！

7.2 链式访问

所谓链式访问就是将⼀个函数的返回值作为另外⼀个函数的参数，像链条⼀样将函数串起来就是函数的链式访问。

#include <stdio.h>
int main()
{
 int len = strlen("abcdef");//1.strlen求⼀个字符串的⻓度
 printf("%d\n", len);//2.打印⻓度 
 printf("%d\n", strlen("abcdef");
 return 0;
 }

有趣的代码？

include <stdio.h>
int main()
{
 printf("%d", printf("%d", printf("%d", 43)));
 return 0;
}

这三层最里面的一层先打印43，然后43被确定为两个字符，再打印2，然后2被确定为1个字符，再打印为1

8. 函数的声明和定义

8.1 单个⽂件

⼀般我们在使⽤函数的时候，直接将函数写出来就使⽤了。⽐如：我们要写⼀个函数判断⼀年是否是闰年。

函数的定义在函数调⽤之前

#include <stido.h>
//判断⼀年是不是闰年
int is_leap_year(int y)
{
 if(((y%4==0)&&(y%100!=0)) || (y%400==0))
 return 1;
 else
 return 0;
}
int main()
{
 int y = 0;
 scanf("%d", &y);
 int r = is_leap_year(y);
 if(r == 1)
 printf("闰年\n");
 else
 printf("⾮闰年\n");
 return 0;
 }

函数的定义在函数的调⽤之后

#include <stido.h>
int main()
{
 int y = 0;
 scanf("%d", &y);
 int r = is_leap_year(y);
 if(r == 1)
 printf("闰年\n");
 else
 printf("⾮闰年\n");
 return 0;
}
//判断⼀年是不是闰年
int is_leap_year(int y)
{
 if(((y%4==0)&&(y%100!=0)) || (y%400==0))
 return 1;
 else
 return 0;
 }

我们发现会报错，因为函数需要先声明后使用，函数的调⽤⼀定要满意，先声明后使⽤；函数的定义也是⼀种特殊的声明，所以如果函数定义放在调⽤之前也是可以的。

8.2 多个⽂件

⼀般情况下，函数的声明、类型的声明放在头⽂件（.h）中，函数的实现是放在源⽂件（.c）⽂件中。

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

//函数的声明
int Add(int x, int y);

#include <stdio.h>
#include "add.h"
int main()
{
 int a = 10;
 int b = 20;
 //函数调⽤
 int c = Add(a, b);
 printf("%d\n", c);
 return 0;
}

8.3 static 和 extern

static 和 extern 都是C语⾔中的关键字。

static 是静态的的意思，可以⽤来：
• 修饰局部变量
• 修饰全局变量
• 修饰函数
extern 是⽤来声明外部符号的。

作⽤域和⽣命周期
作⽤域（scope）是程序设计概念，通常来说，⼀段程序代码中所⽤到的名字并不总是有效（可⽤）
的，⽽限定这个名字的可⽤性的代码范围就是这个名字的作⽤域。

局部变量的作⽤域是变量所在的局部范围。
全局变量的作⽤域是整个⼯程（项⽬）。
⽣命周期指的是变量的创建(申请内存)到变量的销毁(收回内存)之间的⼀个时间段。
局部变量的⽣命周期是：进⼊作⽤域变量创建，⽣命周期开始，出作⽤域⽣命周期结束。
全局变量的⽣命周期是：整个程序的⽣命周期。

8.3.1 static 修饰局部变量：

//代码1
#include <stdio.h>
void test()
{
 int i = 0;
 i++;
 printf("%d ", i);
}
int main()
{
 int i = 0;
 for(i=0; i<5; i++)
 {
 test();
 }
 return 0;
}

//代码2
#include <stdio.h>
void test()
{
 //static修饰局部变量
 static int i = 0;
 i++;
 printf("%d ", i);
}
int main()
{
 int i = 0;
 for(i=0; i<5; i++)
 {
 test();
 }
 return 0;
}

对⽐代码1和代码2的效果，理解 static 修饰局部变量的意义。
** 代码1**的test函数中的局部变量i是每次进⼊test函数先创建变量（⽣命周期开始）并赋值为0，然后 ++，再打印，出函数的时候变量⽣命周期将要结束（释放内存）。

代码2中，我们从输出结果来看，i的值有累加的效果，其实 test函数中的i创建好后，出函数的时候是不会销毁的，重新进⼊函数也就不会重新创建变量，直接上次累积的数值继续计算。

**结论：**static修饰局部变量改变了变量的⽣命周期，⽣命周期改变的本质是改变了变量的存储类型，本来⼀个局部变量是存储在内存的栈区的，但是被 static 修饰后存储到了静态区。存储在静态区的变量和全局变量是⼀样的，⽣命周期就和程序的⽣命周期⼀样了，只有程序结束，变量才销毁，内存才回收。但是作⽤域不变的。

8.3.2 static 修饰全局变量

代码1

int g_val = 2018;

#include <stdio.h>
extern int g_val;
int main()
{
 printf("%d\n", g_val);
 return 0;
 }

代码2

static int g_val = 2018;

#include <stdio.h>
extern int g_val;
int main()
{
 printf("%d\n", g_val);
 return 0;
}

extern是⽤来声明外部符号的，如果⼀个全局的符号在A⽂件中定义的，在B⽂件中想使⽤，就可以使⽤ extern 进⾏声明，然后使⽤。
代码1正常，代码2在编译的时候会出现链接性错误。

结论： ⼀个全局变量被static修饰，使得这个全局变量只能在本源⽂件内使⽤，不能在其他源⽂件内使⽤。本质原因是全局变量默认是具有外部链接属性的，在外部的⽂件中想使⽤，只要适当的声明就可以使⽤；但是全局变量被 static 修饰之后，外部链接属性就变成了内部链接属性，只能在⾃⼰所在的源⽂件内部使⽤了，其他源⽂件，即使声明了，也是⽆法正常使⽤的。

使⽤建议：如果⼀个全局变量，只想在所在的源⽂件内部使⽤，不想被其他⽂件发现，就可以使⽤ static修饰。