【初级】3. 函数

夏日晴风

已于 2023-08-15 17:21:09 修改

阅读量61

点赞数

分类专栏： C语言文章标签： c语言算法开发语言

于 2023-08-07 09:15:44 首次发布

本文链接：https://blog.csdn.net/the_bad/article/details/132133943

版权

C语言专栏收录该内容

16 篇文章 0 订阅

订阅专栏

文章说明：该文章的知识点源于B站上比特鹏哥的C语言课程，结合鹏哥上课的讲义、课堂代码以及自己的理解整理形成。

1. 函数是什么

维基百科中对函数的定义：子程序

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

2. C语言中函数的分类

库函数
自定义函数

2.1 库函数

库函数的作用：定义出来频繁大量使用到的功能，不用再去实现了，统一起来，更加标准。

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

库函数学习网站：

cplusplus.com

cppreference.com（英文版）（C/C++官网）

cppreference.com（中文版）

C语言常用的库函数：

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

怎么使用文档来学习库函数：

进入该网址后cplusplus.com，点击[Legacy version]，即可在搜索栏搜素函数名称

或者直接进入进入该网址：cplusplus.com - The C++ Resources Network

如何阅读函数：

英文很重要。最起码得看懂文献。

2.2 自定义函数

更加重要的是自定义函数，因为函数名，返回值类型和函数参数都是我们自己来设计。

函数的组成：

ret_type fun_name(para1, * )
{
    statement;//语句项
} //{}里面的内容为函数体

//ret_type 返回类型
//fun_name 函数名
//para1    函数参数

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

//正确的版本
void Swap(int *px, int *py)
{
    int tmp = 0;
    tmp = *px;
    *px = *py;
    *py = tmp;
}

int main()
{
    int num1 = 1;
    int num2 = 2;
    Swap(&num1, &num2); //址传递
    printf("Swap2::num1 = %d num2 = %d\n", num1, num2);
    return 0;
}

交换函数常见错误 -> 值传递：

a 和 b 的地址与 x 和 y 的地址不一样，只交换了 x 和 y 的值，没有改变 a 和 b 的值。

值传递和址传递的判断依据：函数的功能会修改函数外部的参数内容时要使用址传递。

3. 函数的参数

函数原型：void Swap(int a, int b); 函数调用： Swap(a, b);

3.1 实际参数（实参）

传给函数的参数，叫实参。实参可以是：常量、变量、表达式、函数等。

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

上面函数调用 Swap(a, b); 中的 a 和 b 就是实参。

3.2 形式参数（形参）

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

**形参其实相当于实参的一份临时拷贝。**所以改变形参，是不会改变实参的。

上面函数原型 void Swap(int a, int b); 中的 a 和 b 就是形参。

4. 函数的调用

4.1 传值调用

函数原型：void Swap(int a, int b); 函数调用： Swap(a, b);

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

4.2 传址调用

函数原型：void Swap1(int *a, int *b); 调用： Swapa(&a, &b);

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

//不建议这样写代码 -> 其添加了打印功能，函数的功能不单一

//判断是否是素数函数
int is_prime(int n) 
{
	//2->n-1 之间的数字
	int j = 0;
	for (j = 2; j < n; j++)
	{
		if (n % j == 0)
		{
			//printf("%d 不是素数\n", n);
			return 0;
		}
	}
	printf("%d 是素数\n", n);
	return 1;
}

一个函数如果不写返回类型，默认返回 int 类型。

数组传参，实际传递的不是数组的本身，仅仅传过去了数组首元素的地址。

//二分查找函数
//找到了就返回找到的位置的下标，找不到返回-1
//a[]为数组，k为要找的数值，s为数组长度
int binary_search(int a[], int k, int s) 
{
	int left = 0;
	int right = s - 1;

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

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

5.1 嵌套调用

函数无法嵌套定义，但却可以嵌套调用。

#include <stdio.h>
void new_line()
{
    printf("hehe\n");
}
void three_line()
{
    int i = 0;
    for(i=0; i<3; i++)
    {
        new_line();
    }
}
int main()
{
    three_line();
    return 0;
}

5.2 链式访问

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

#include <stdio.h>
int main()
{
    //注：printf函数的返回值是打印在屏幕上字符的个数
    printf("%d", printf("%d", printf("%d", 43)));	//结果：4321
    return 0;
}

6. 函数的声明和定义

6.1 函数声明

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

6.2 函数定义

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

test.h 的内容 -> 放置函数的声明

#ifndef __TEST_H__
#define __TEST_H__
//函数的声明
int Add(int x, int y);
#endif //__TEST_H__

test.c的内容 -> 放置函数的实现

#include "test.h"
//函数Add的实现
int Add(int x, int y)
{
    return x+y;
}

静态库能实现代码库的隐藏，导入静态库（lib文件）：

#pragma comment(lib, "sub.lib");

7. 函数递归

7.1 什么是递归？

程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略。

只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的主要思考方式在于：把大事化小。

7.2 递归的两个必要条件

存在限制条件，当满足这个限制条件的时候，递归便不再继续。
每次递归调用之后越来越接近这个限制条件。

//接受一个整型值（无符号），按照顺序打印它的每一位。
#include <stdio.h>
void print(int n)
{
    if(n>9)
    {
        print(n/10);
    }
    printf("%d ", n%10);
}

int main()
{
    unsigned int num = 0;
    scanf("%d", &num);
    print(num);
    return 0;
}

递归会出现栈溢出的现象。

注意事项：

不能死递归，都有跳出条件，每次递归逼近跳出条件。
递归的层次不能太深。

//编写函数不允许创建临时变量，求字符串的长度。
#incude <stdio.h>
int Strlen(const char *str)
{
    if (*str == '\0')
        return 0;
    else 
        return 1+Strlen(str+1);
}

int main()
{
    char *p = "abcdef";
    int len = Strlen(p);
    printf("%d\n", len);
    return 0;
}

7.3 递归与迭代

迭代属于循环，循环中参与运算的变量同时是保存结果的变量，当前保存的结果作为下一次循环计算的初始值。

有一些功能可以使用迭代的方式实现，也可以使用递归。

//求n的阶乘。（不考虑溢出）
int factorial(int n)
{
    if(n <= 1)
        return 1;
    else
        return n * factorial(n-1);
}

//求第n个斐波那契数。（不考虑溢出）
int fib(int n)
{
    if (n <= 2)         
        return 1;
    else
        return fib(n - 1) + fib(n - 2);
}

递归可以求解，但是效率太低，因为在调用的过程中很多计算其实在一直重复。

提示：

许多问题是以递归的形式进行解释的，这只是因为它比非递归的形式更为清晰。
但是这些问题的迭代实现往往比递归实现效率更高，虽然代码的可读性稍微差些。
当一个问题相当复杂，难以用迭代实现时，此时递归实现的简洁性便可以补偿它所带来的运行时开销。

//编写一个函数reverse_string(char *string)（递归实现）
//实现：将参数字符串中的字符反向排列，不是逆序打印
//要求：不能使用C函数库中的字符串操作函玫。
int my_strlen(char* str)
{
	int count = 0;
	while (*str != '\0')
	{
		count++;
		str++;
	}
	return count;
}

void reverse_string(char* str)
{
	char tmp = *str; //1. 拿出第一个元素 
	int len = my_strlen(str);
	*str = *(str + len - 1); //2. 将最后一个元素移到第一个位置上
	*(str + len - 1) = '\0'; //3. 将最后一个元素赋值为'\0'
	//判断条件
	if(my_strlen(str+1)>=2)
	{
		reverse_string(str + 1); //4. 递归
	}
	*(str + len - 1) = tmp; //5. 将第一个元素移到最后一个元素上
}

int main()
{
	char arr[] = "abcdef";
	reverse_string(arr);//数组名arr是数组arr首元素的地址
	printf("%s\n", arr);//fedcba
	return 0;
}