C语言基础之函数

最新推荐文章于 2024-09-27 19:15:27 发布

冰淇淋加点糖

最新推荐文章于 2024-09-27 19:15:27 发布

阅读量1.2k

点赞数 21

文章标签： c语言

本文链接：https://blog.csdn.net/weixin_56559434/article/details/141813987

版权

哈喽！大家好，我是冰淇凌加点糖，今天我们来讲讲C语言中的函数。

函数的概念

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

C语言中函数的分类

C语言函数主要分为两种：1.库函数 2.自定义函数。

库函数

C语言中把常用的功能，进行了封装，封装成函数，提供出来大家都可以使用，这种封装可以直接调用的函数就称之为库函数。如：scanf，printf，strlen，rand，srand，time，strcmp等。

当然C语言并不直接去实现库函数，而是提供了C语言的标准和库函数的约定。如：scanf函数规定其功能、名字、返回值、参数等，在调用时满足这些约定即可直接使用。

注：1.使用库函数，必须包含 #include 对应的头文件。
2.库函数的实现一般是由编译器去实现的。

为什么会有库函数

1. 我们知道在我们学习C语言编程的时候，总是在一个代码编写完成之后迫不及待的想知道结果，想把这个结果打印到我们的屏幕上看看。这个时候我们会频繁的使用一个功能：将信息按照一定的格式打印到屏幕上（printf）。

2. 在编程的过程中我们会频繁的做一些字符串的拷贝工作（strcpy）。

3. 在编程是我们也计算，总是会计算n的k次方这样的运算（pow）。

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

如何学习库函数

这里提供一个学习各种函数的网址：cplusplus.com - The C++ Resources Network

这个网站可自己进行搜索学习函数、关键字等知识，类似于MSDN。下图是C语言中库函数对应的一些头文件。

C语言中常用的库函数

1. IO函数 —— 输入/输出函数(scanf、printf、putchar、getchar...)
2. 字符串操作函数 —— strlen、strcmp、strcpy...
3. 字符操作函数 —— islower(判断字符小写)、isupper(判断字符大写)...
4. 内存操作函数 —— memset、memcmp...
5. 时间/日期函数 —— time...
6. 数学函数 —— sqrt、pow...
7. 其他库函数

举个栗子

strcmp函数学习

strcpy，是字符串拷贝函数，将源地址(source)的字符串拷贝到目的地址(destination)，要求目的地址的空间足够拷贝。strcpy返回目的空间的起始地址，在使用时需要调用头文件<string.h>。见如下代码：

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

自定义函数

自定义函数和库函数一样，有函数名，返回值类型和函数参数。但是不一样的是这些都是我们自己来设计。这给程序员一个很大的发挥空间。自定义函数的组成为：

ret_type fun_name ( para1 , * )
{
    statement ;     // 语句项
}
ret_type          返回类型
fun_name          函数名
para1             函数参数

举个栗子

1.写一个实现两个数相加的函数。

#include<stdio.h>
int ADD(int a, int b)
{
	return a + b;
}
int main()
{
	int sum = 0;
	sum = ADD(5, 6);
	printf("sum = %d\n", sum);
	return 0;
}

2.实现两个数的交换

#include<stdio.h>
void swap1(int x,int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
void swap2(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
int main()
{
	int a = 5;
	int b = 3;
	printf("交换前：a = %d,b = %d\n", a, b);
	swap1(a, b);
	printf("swap1交换：a = %d,b = %d\n", a, b);
	swap2(&a, &b);
	printf("swap2交换：a = %d,b = %d\n", a, b);
	return 0;
}

为什么上面例子2中的swap1不能够实现交换两个变量的内容呢？让我们继续来了解函数参数和函数调用吧。

函数参数

函数的参数又分为实际参数(实参)和形式参数(形参)两种。

实际参数(实参)

1. 真实传给函数的参数，叫实参。
2. 实参可以是：常量、变量、表达式、函数等。
3. 无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。
4. 在上述案例1中传给swap1函数的a , b就是实际参数。

形式参数(形参)

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

注：形参实例化之后其实相当于实参的一份临时拷贝。

函数调用

传值调用

1. 函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
2. 上述案例2中的swap1(a,b)就是传值调用。

传址调用

1. 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。
2. 这种传参方式可以让函数和函数外边的变量建立起真正的联系，也就是函数内部可以直接操作函数外部的变量。
3. 上述案例2中的swap2(&a,&b)就是传址调用。

重温案例2

#include<stdio.h>
void swap1(int x,int y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
void swap2(int* x, int* y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}
int main()
{
	int a = 5;
	int b = 3;
	printf("交换前：a = %d,b = %d\n", a, b);
	swap1(a, b);
	printf("swap1交换：a = %d,b = %d\n", a, b);
	swap2(&a, &b);
	printf("swap2交换：a = %d,b = %d\n", a, b);
	return 0;
}

为什么swap1不能对两个变量的内容进行交换呢？这是因为swap1进行的是传值调用，在传值调用时，当实参传递给形参的时候，形参是实参的一份临时拷贝，也就是形参和实参并不是占用同一块内存空间(通过下图代码调试可知)，所以对形参的修改不会影响实参。

而在swap2中，swap2进行的是传址调用，虽然x、y和a、b的地址也不一样，但是在进行传址调用时，a、b会将自己内存空间的地址传递给x、y，x、y本质上就是指针，记录着a和b的地址(也可以说是指向a和b的地址空间)，对x、y进行解引用修改值时，本质上就是对a和b的值进行修改，因此能够交换两个实参变量的内容。(后续会对指针进行详细讲解)

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

嵌套调用

函数调用就是函数和函数之间根据实际需求进行组合互相调用。

#include<stdio.h>
int ADD(int a, int b)
{
	return a + b;
}
void Ans(int sum)
{
	sum = ADD(5, 6);
	printf("sum = %d\n", sum);
}
int main()
{
	int sum = 0;
	Ans(sum);
	return 0;
}

上述代码中就是在Ans()函数内部进行调用ADD()函数，在main()函数内部进行调用Ans()函数，这就是函数嵌套。
注：函数可以嵌套调用，但是不能嵌套定义(如下)。嵌套定义是不被允许的。

链式访问

链式访问就是把一个函数的返回值作为另外一个函数的参数。

举个栗子1

#include<stdio.h>
#include<string.h>

int main()
{
	char arr[20] = "hello";
	int ret = strlen(strcat(arr, "bit"));
	printf("%d\n", ret);
	return 0;
}

strcat是把源串附加到目标串后面，所以上述代码的结果是8，hellobit一共8个字符。

举个栗子2

#include<stdio.h>
int main() 
{
	// printf 的返回值是字符个数
	printf("%d ", printf("%d ", printf("%d ", 43))); // 43 3 2
	return 0;
}

printf返回输出成功的字符个数，首先最里面printf("%d ", 43)输出‘43 ’，成功输出3个字符。然后第二层printf("%d ", printf("%d ", 43))转化为printf("%d ", 3)，输出‘3 ’，成功输出2个字符。最后一层printf("%d ", printf("%d ", printf("%d ", 43)))转化为printf("%d ", 2)，输出‘2 ’。即最终结果为43 3 2.

函数的声明和定义

函数声明

1.告诉编译器有一个函数叫什么，参数是什么，返回类型是什么。但是具体是否存在，无关紧要。

2.函数的声明一般出现在函数使用之前，要满足先声明后使用。

3.函数的声明一般要放在头文件中。

函数定义

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

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

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

递归

1.接受一个整型值（无符号），按照顺序打印它的每一位。例如：输入：1234，输出 1 2 3 4.

#include<stdio.h>
void print(int n)
{
    if(n > 9)
    {
        print(n / 10);
    }
    printf("%d ",n % 10);
}
int main()
{
    int n = 1234;
    print(n);
    return 0;
}

2.编写函数不允许创建临时变量，求字符串的长度。

#include<stdio.h>
int Strlen(const char *s)
{
	if (*s == '\0')
	{
		return 0;
	}
	s++;
	return 1 + Strlen(s);
}
int main()
{
	int len = 0;
	char str[20] = "hello world";
	len = Strlen(str);
	printf("len = %d\n", len);
	return 0;
}

3.字符串逆序

非递归实现

#include<stdio.h>
#include<string.h>
void swap(char* x, char* y)
{
	char tmp = *x;
	*x = *y;
	*y = tmp;
}
void reverse(char* s)
{
	char* left = s;
	char* right = s + strlen(s) - 1;
	while (left < right)
	{
		swap(left, right);
		left++;
		right--;
	}
}
int main()
{
	char str[20] = "abcdefghijk";
	puts(str);
	reverse(str);
	puts(str);
	return 0;
}

递归实现

#include<stdio.h>
#include<string.h>
//1.交换a和g
//2.以递归的方式逆置源字符串的剩余部分，剩余部分可以看作一个有效的字符串
//3.再以类似的方式递归
void reverse(char *s)
{
	int len = strlen(s);
	char tmp = *s;
	*s = *(s + len - 1);

	*(s + len - 1) = '\0';
	if (strlen(s + 1) >= 2)
		reverse(s + 1);
	*(s + len - 1) = tmp;

}
int main()
{
	char str[20] = "abcdef";
	puts(str);
	reverse(str);
	puts(str);
	return 0;
}