函数

1.什么是函数?

1.1 函数的分类

C 程序是由函数组成的，我们写的代码都是由主函数 main()开始执行的。函数是 C 程序的基本模块，是用于完成特定任务的程序代码单元。
从函数定义的角度看，函数可分为系统函数和用户定义函数两种：

1. 系统函数，即库函数：这是由编译系统提供的，用户不必自己定义这些函数，可以直接使用它们，如我们常用的打印函数printf()。
2. 用户定义函数：用以解决用户的专门需要。

1.2 函数及其作用

函数:将在main(){}函数中的代码块移植到其他地方

1. 方便移植,可以重复使用
2. 函数的使用可以省去重复代码的编写，降低代码重复率
3. 函数可以让程序更加模块化，从而有利于程序的阅读，修改和完善

// 求两数的最大值
int max(int a, int b)
{
	if (a > b){
		return a;
	}
	else{
		return b;
	}
}

int main()
{
	// 操作1 ……
	// ……
	int a1 = 10, b1 = 20, c1 = 0;
	c1 = max(a1, b1); // 调用max()

	// 操作2 ……
	// ……
	int a2 = 11, b2 = 21, c2 = 0;
	c2 = max(a2, b2); // 调用max()

	// ……

	return 0;
}

2. 函数的定义

• 函数定义不能定义在函数的代码块{}中
• 函数名()代表一个函数
  函数定义的一般格式:

	返回类型 函数名(形式参数列表)
	{
		数据定义部分;
		执行语句部分;
        }

2.1 函数名

理论上是可以随意起名字，最好起的名字见名知意，应该让用户看到这个函数名字就知道这个函数的功能。注意，函数名的后面有个圆换号()，代表这个为函数，不是普通的变量名。

2.2 形参列表

在定义函数时指定的形参，在未出现函数调用时，它们并不占内存中的存储单元，因此称它们是形式参数或虚拟参数，简称形参，表示它们并不是实际存在的数据，所以，形参里的变量不能赋值。

void max(int a = 10, int b = 20) // error, 形参不能赋值
{
}

在定义函数时指定的形参，必须是，类型+变量的形式：

//1: right, 类型+变量
void max(int a, int b)
{
}

//2: error, 只有类型，没有变量
void max(int, int)
{
}

//3: error, 只有变量，没有类型
int a, int b;
void max(a, b)
{
}

在定义函数时指定的形参，可有可无，根据函数的需要来设计，如果没有形参，圆括号内容为空，或写一个void关键字：

// 没形参， 圆括号内容为空
void max()
{
}

// 没形参， 圆括号内容为void关键字
void max(void)
{
}

2.3 函数体

花括号{ }里的内容即为函数体的内容，这里为函数功能实现的过程，这和以前的写代码没太大区别，以前我们把代码写在main()函数里，现在只是把这些写到别的函数里。

2.4 返回值

函数的返回值是通过函数中的return语句获得的，return后面的值也可以是一个表达式。

a)尽量保证return语句中表达式的值和函数返回类型是同一类型。

int max() // 函数的返回值为int类型
{
	int a = 10;
	return a;// 返回值a为int类型，函数返回类型也是int，匹配
}

b)如果函数返回的类型和return语句中表达式的值不一致，则以函数返回类型为准，即函数返回类型决定返回值的类型。对数值型数据，可以自动进行类型转换。

double max() // 函数的返回值为double类型
{
	int a = 10;
	return a;// 返回值a为int类型，它会转为double类型再返回
}

注意：如果函数返回的类型和return语句中表达式的值不一致，而它又无法自动进行类型转换，程序则会报错。
c)return语句的另一个作用为中断return所在的执行函数，类似于break中断循环、switch语句一样。

int max()
{
	return 1;// 执行到，函数已经被中断，所以下面的return 2无法被执行到
	return 2;// 没有执行
}

d)如果函数带返回值，return后面必须跟着一个值，如果函数没有返回值，函数名字的前面必须写一个void关键字，这时候，我们写代码时也可以通过return中断函数(也可以不用)，只是这时，return后面不带内容( 分号“；”除外)。

void max()// 最好要有void关键字
{
	return; // 中断函数，这个可有可无
}

3.函数的调用

定义函数后，我们需要调用此函数才能执行到这个函数里的代码段。这和main()函数不一样，main()为编译器设定好自动调用的主函数，无需人为调用，我们都是在main()函数里调用别的函数，一个 C 程序里有且只有一个main()函数。

• 无参函数的调用:函数名()

3.1 函数的执行流程

#include <stdio.h>

void print_test()
{
	printf("this is for test\n");   //无参无返回值函数
}

int main()
{
	print_test();	// print_test函数的调用

	return 0;
}

1. 进入main()函数
2. 调用print_test()函数：
   a. 它会在main()函数的前寻找有没有一个名字叫“print_test”的函数定义；
   b. 如果找到，接着检查函数的参数，这里调用函数时没有传参，函数定义也没有形参，参数类型匹配；
   c. 开始执行print_test()函数，这时候，main()函数里面的执行会阻塞( 停 )在print_test()这一行代码，等待print_test()函数的执行。
3. print_test()函数执行完( 这里打印一句话 )，main()才会继续往下执行，执行到return 0, 程序执行完毕。

3.2 函数的形参和实参

• 形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。
• 实参出现在主调函数中，进入被调函数后，实参也不能使用。
• 实参变量对形参变量的数据传递是“值传递”，即单向传递，只由实参传给形参，而不能由形参传回来给实参。
• 在调用函数时，编译系统临时给形参分配存储单元。调用结束后，形参单元被释放。
• 实参单元与形参单元是不同的单元。调用结束后，形参单元被释放，函数调用结束返回主调函数后则不能再使用该形参变量。实参单元仍保留并维持原值。因此，在执行一个被调用函数时，形参的值如果发生改变，并不会改变主调函数中实参的值。

3.3 无参函数调用

如果是调用无参函数，则不能加上“实参”，但括号不能省略。

// 函数的定义
void test()
{
}

int main()
{
	// 函数的调用
	test();	// right, 圆括号()不能省略
	test(250); // error, 函数定义时没有参数

return 0;
}

3.4 有参函数调用

int func(int a,int b){
          int c = a + b;
          return c;   // 返回类型与定义时的类型一致
}

int main()
{
        int x = 20;
        int y = 30;
        int sum = 0;
        // 调用函数接收返回值,接收结果的变量类型与返回值的类型一致
        sum = func(x,y);   
        // 不接收返回值
        func(x,y)
}

• 参数的传递只能是单向传递,实参的值传递给形参
• 每个函数都有自己的内存空间,实参在调用主函数中开辟空间,形参在函数中开辟空间
• 返回值大于四个字节,返回到内存,返回值小于四个字节,返回到寄存器中
  
  note
  a) 如果实参表列包含多个实参，则各参数间用逗号隔开。

// 函数的定义
void test(int a, int b)
{
}

int main()
{
	int p = 10, q = 20;
	test(p, q);	// 函数的调用

	return 0;
}

b) 实参与形参的个数应相等，类型应匹配(相同或赋值兼容)。实参与形参按顺序对应，一对一地传递数据。
c) 实参可以是常量、变量或表达式，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。所以，这里的变量是在圆括号( )外面定义好、赋好值的变量。

// 函数的定义
void test(int a, int b)
{
}

int main()
{
	// 函数的调用
	int p = 10, q = 20;
	test(p, q);	// right
	test(11, 30 - 10); // right

	test(int a, int b); // error, 不应该在圆括号里定义变量

	return 0;
}

3.5 实参传递

void swap(int a,int b){
        int c = 0
        c = a;
        a = b;
        b = c;
        printf("a = %d  b = %d\n",a,b);  // 实参传递给a,b a,b的值进行交换
        return;
}

int main()
{
        int x = 20;
        int y = 30;
        swap(x,y);
        printf("x = %d  y = %d\n",x,y); // x = 20 y = 30 值没有交换
}

• 实参传递给形参,形参的值改变,但是不会改变实参的值
• 以后如果实参是传变量本身,只会是值传递,不会把变量本身的空间传递进去

4.函数声明

//函数声明,不加函数体,而且有分号
//函数的声明extern,可以加也可以不加
//函数的声明可以不加变量名
//函数的声明就是告诉编译器这个函数在其他地方定义
extern void swap(int a,int b);
void swap(int a,int b);
void swap(int,int);


// 主函数
int main()
{
        int x = 20;
        int y = 30;
        swap(x,y);
        printf("x = %d  y = %d\n",x,y); // x = 20 y = 30 值没有交换
}

// 函数定义
void swap(int a,int b){
        int c = 0
        c = a;
        a = b;
        b = c;
        printf("a = %d  b = %d\n",a,b);  // 实参传递给a,b a,b的值进行交换
        return;
}

// 函数定义在主函数之后,会出现编译错误

• 在调用函数之前,要让编译器知道有这个函数
• 定义在主函数之前或者在调用之前声明
• 函数声明就是告诉编译器这个函数已经定义了
• 函数声明没有函数体
• 函数声明加分号
• 函数声明可以不加变量名
• 函数声明extern可以加也可以不加,extern就是告诉编译器函数在其他地方定义了

5.return和exit的区别

在main函数中调用exit和return结果是一样的，但在子函数中调用return只是代表子函数终止了，在子函数中调用exit，那么程序终止。

• return 结束当前所在的函数
• return在子函数中调用,只会结束子函数;return在main函数中会结束整个程序
• exit(0);在任何地方调用exit(0);都会结束整个程序

#include <stdio.h>
#include <stdlib.h>

void fun()
{
	printf("fun\n");
	//return;
	exit(0);
}

int main()
{
	fun();
	while (1);

	return 0;
}

6.多文件(分文件)编程

• 将代码放在其他文件中
• #include "" 在当前目录下寻找文件
• #include <> 在系统目录下寻找文件

1. main.c文件

#include <stdio.h>
#include "mymath.h"
// int my_max(int a,int b);
// int my_min(int a,int b);    // 每使用一个函数都要声明,非常麻烦,将函数声明写到头文件中

int main()
{
        int a = 10;
        int b = 20;
        // 求最大值
        printf("max=%d\n",my_max(a,b));
        // 求最小值
        printf("min=%d\n",my_min(a,b)); // 在使用之前进行函数声明
}

2. mymath.c文件

//#include <stdio.h>
int my_max(int a,int b)
{
  return a > b ? a : b;
}

int my_min(int a,int b)
{
  return a < b ? a : b;
}

3. 函数声明的头文件 mymath.h -- 头文件以.h结尾

// 如果没有定义这个宏,就进行编译
// 定义了这个宏就跳过
#ifndef MYMATH      
#define MYMATH
int my_max(int a,int b);
int my_min(int a,int b);  

#endif

• 头文件中只进行声明,定义在.c文件中
• 定义宏之后可以防止多次重复包含同一个头文件

6.1 防止头文件重复包含

当一个项目比较大时，往往都是分文件，这时候有可能不小心把同一个头文件 include 多次，或者头文件嵌套包含。

1. a.h 中包含 b.h ：

#include "b.h"

2. b.h 中包含 a.h：

#include "a.h"

3. main.c 中使用其中头文件：

#include "a.h"

int main()
{
	return 0;
}

编译上面的例子，会出现如下错误：

为了避免同一个文件被include多次，C/C++中有两种方式，一种是 #ifndef 方式，一种是 #pragma once 方式。

• 方式1

#ifndef __SOMEFILE_H__
#define __SOMEFILE_H__

// 声明语句

#endif

• 方式2

#pragma once

// 声明语句

原文地址：https://www.cnblogs.com/Icer-newer/p/17233264.html