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

1.前言

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

2.函数的概念

何为函数呢?我们在之前的数学学习中知道,例如y=kx+b,y=x^等这样的函数,因变量与自变量,当然在C语言的函数中也是这样,求解一些复杂的简单的编程问题,我们可以用函数去解决,比如计算很大的数字,大数据的处理,其实就是C语言中的函数就是一个完成某项特定的任务的一小段代码,为子程序。
C语言一招教你搞定所有基础函数知识(上)_第1张图片

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 
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 是函数名
括号中放的是形式参数
{}括起来的是函数体

C语言一招教你搞定所有基础函数知识(上)_第2张图片
在这个图中我们可以清晰的知道自定义函数如何使用,但是要注意以下两点:
1.尽量起有意义的函数名字,比如加法Add
2.函数返回类型要确定好,接受的参数类型和传参的参数类型要相同。

函数举例:

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

#include 
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 
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 
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 
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

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 
int main()
{
 int len = strlen("abcdef");//1.strlen求⼀个字符串的⻓度
 printf("%d\n", len);//2.打印⻓度 
 printf("%d\n", strlen("abcdef");
 return 0;
 }

有趣的代码?

include 
int main()
{
 printf("%d", printf("%d", printf("%d", 43)));
 return 0;
}

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

8. 函数的声明和定义

8.1 单个⽂件

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

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

#include 
//判断⼀年是不是闰年
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 
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 
#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)是程序设计概念,通常来说,⼀段程序代码中所⽤到的名字并不总是有效(可⽤)
的,⽽限定这个名字的可⽤性的代码范围就是这个名字的作⽤域。

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

8.3.1 static 修饰局部变量:

//代码1
#include 
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 
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 
extern int g_val;
int main()
{
 printf("%d\n", g_val);
 return 0;
 }

代码2

static int g_val = 2018;

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

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

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

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

小结:

谢谢大家的支持,如有错误及时指出。

你可能感兴趣的:(C语言初阶,c语言,开发语言)