C语言学习笔记--C函数

C函数

函数是一组一起执行一个任务的语句。每个C程序都至少有一个函数，即主函数main(),所有简单的程序都可以定义其他额外的函数。
可以把代码划分到不同的函数中。如何划分代码到不同的函数中是由自己决定的，但是在逻辑上，划分通常是根据每个函数执行一个特定的任务来进行的。
函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。
C标准库提供了大量的程序可以调用的内置函数。例如，函数strcat() 用来连接两个字符串，函数 memcpy() 用来赋值内存到另一个位置。
函数还有很多叫法，比如方法、子例程或程序，等等。

定义函数

C语言中的函数定义的一般形式如下：

return_type function_name(parameter list)
{
	body of the function
}

在C语言中，函数由一个函数偷和一个函数主体组成。下面列出一个函数的所有组成部分：

• 返回类型： 一个函数可以返回一个值。return_type是函数返回的值的数据类型。有些函数指向性所需的操作而不返回值，在这种情况下，return_type是关键字void。
• 函数名称： 这是函数的实际名称。函数名和参数列表一起构成了函数签名。
• 参数： 参数就像是占位符。当函数被调用时可以向参数传递一个值，这个值被称为实际参数。参数列表包括函数参数的类型、顺序、数量。函数是可选的，也就是说，函数可能不包含参数。
• 函数主体： 函数主体包含一组定义函数执行任务的语句。
  实例：
  以下是max() 函数的源代码。该函数有两个参数num1和num2，会返回这两个数中较大的那个数：

//函数返回两个数中较大的那个数
int max(int num1,int num2)
{
	//局部变量声明
	int result;
	if(num1>num2)
		result=num1;
	else
		result=num2;
	return result;
}

函数声明

函数声明会告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义。
函数声明包括以下几个部分：

return_type function_name(parameter list);

针对上面定义的函数max()，以下是函数声明：

int  max(int num1,int num2);

在函数声明中，参数的名称并不重要，只有参数的类型是必需的，因此下面也是有效的声明：

int max(int,int);

当在一个源文件中定义函数且在另一个文件中调用函数是，函数声明是必需的。在这种抢矿下，应该在调用函数的文件顶部声明函数。

调用函数

创建C函数时，会定义函数做什么，然后通过调用函数来完成已定义的任务。
当程序调用函数时，程序控制权会转义给被调用的函数。被调用的函数执行已定义的任务，当函数的返回语句被执行时，或到达函数的结束括号时，会把程序控制权交还给主程序。
调用函数时，传递所需参数，如果函数返回一个值，则可以存储返回值。例如：

#include 
 
/* 函数声明 */
int max(int num1, int num2);
 
int main ()
{
   /* 局部变量定义 */
   int a = 100;
   int b = 200;
   int ret;
 
   /* 调用函数来获取最大值 */
   ret = max(a, b);
 
   printf( "Max value is : %d\n", ret );
 
   return 0;
}
 
/* 函数返回两个数中较大的那个数 */
int max(int num1, int num2) 
{
   /* 局部变量声明 */
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

把max()函数和main()放一块，编译源代码。当运行最后的可执行文件时，会产生下列结果：

Max value is：200

函数参数

如果函数要使用参数，则必须声明接受参数值的变量。这些变量被称为函数的形式参数
形式参数就像是函数内的其他局部变量，在进入函数时被创建，退出函数时被销毁。
当调用函数时，有两种向函数传递参数的方式：

调用类型	描述
传值调用	该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数
引用调用	通过指针传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。

传值方式调用函数

向函数传递参数的传值调用方法，把参数的实际值赋值给函数的形式参数。在这种情况下，修改函数内的形式参数不会影响实际参数。
默认情况下，C语言使用传值调用方法来进行传递参数。一般来说，这意味着函数内的代码不会该表用于调用函数的实际参数。函数swap() 定义如下：

//函数定义
void swap(int x,int y)
{
	int temp;
	temp=x;	//保存x的值
	x=y;	//把y赋值给x
	y=temp;	//把temp赋值给y
	return;
}

现在，让我们通过传递实际参数来调用函数swap():

#include 
 
/* 函数声明 */
void swap(int x, int y);
 
int main ()
{
   /* 局部变量定义 */
   int a = 100;
   int b = 200;
 
   printf("交换前，a 的值： %d\n", a );
   printf("交换前，b 的值： %d\n", b );
 
   /* 调用函数来交换值 */
   swap(a, b);
 
   printf("交换后，a 的值： %d\n", a );
   printf("交换后，b 的值： %d\n", b );
 
   return 0;
}

当上面的代码被编译和执行时，会产生下列结果：

交换前，a 的值： 100
交换前，b 的值： 200
交换后，a 的值： 100
交换后，b 的值： 200

上面的实例表明了，虽然在函数内改变了a和b的值，但是实际上a和b的值没有发生变化。

引用方式调用函数

通过引用传递方式，形参为指向实参地址的指针，当对形参的指向操作时，就相当于对实参本身进行的操作。传递指针可以让多个函数访问指针所引用的对象，而不用把对象声明为全局可访问。

/* 函数定义 */
void swap(int *x, int *y)
{
   int temp;
   temp = *x;    /* 保存地址 x 的值 */
   *x = *y;      /* 把 y 赋值给 x */
   *y = temp;    /* 把 temp 赋值给 y */
  
   return;
}

现在通过引用传值来调用函数swap():

#include
//函数声明
void swap(int *x,int *y);
int main()
{
	//局部变量定义
	int a=100;
	int b=200;
	
	printf("交换前，a的值：%d\n",a)；
	printf("交换前，b的值：%d\n",b);

	/* 调用函数来交换值
    * &a 表示指向 a 的指针，即变量 a 的地址 
    * &b 表示指向 b 的指针，即变量 b 的地址 
   */
   swap(&a,&b);
	
	printf("交换后，a 的值： %d\n", a );
   	printf("交换后，b 的值： %d\n", b );
	return 0;
}

当上面的代码被编译和执行时，会产生下列结果：

交换前，a 的值： 100
交换前，b 的值： 200
交换后，a 的值： 200
交换后，b 的值： 100

上面的实例表明了，与传值调用不同，引用调用在函数内改变了a和b的值，实际上也改变了函数外a和b的值。
通常情况下，C使用传值调用来传递参数。一般来说，这意味着函数内的代码不能改变用于调用函数的实际参数。

内部函数与外部函数

根据函数能否被其他源文件调用，将函数分为内部函数和外部函数。
内部函数
如果一个函数只能被本文件中其他函数所调用，它称为内部函数。在定义背部函数时，在函数名和函数类型的前面加上static,即

static 类型名 函数名 （形参表）

例如，函数的首行：

static int max（int a，int b）

内部函数又称为静态函数。使用内部函数，可以使函数的作用域只局限于所在文件。即使在不同的文件中有同名的内部函数，也互不干扰。提高了程序的可靠性。
外部函数
如果在定义函数时，在函数的首部的最左端加关键字extern，则此函数是外部函数，可供其他文件调用。
如函数首部可以为

extern int max (int a,int b)

C语言规定，如果在定义函数时省略extern，则默认为外部函数。
在需要调用此函数的其他文件中，需要对此函数做声明（不要忘记，即使在本文件中调用一个函数，也要用函数原型来声明）。在对此函数作声明时，要加关键字extern，表示该函数是在其他文件中定义的外部函数。

内联函数

内联函数是指用inline关键字修饰的函数。在类内定义的函数被默认成内联函数。内联函数从源代码层来看，有函数的结构，而在编译后，却不具备函数的性质。
内联扩展是用来消除函数调用时的时间开销。它通常用于频繁执行的函数，对于小内存空间的函数非常受益。
使用内联函数的时候要注意：

• 递归函数不能定义为内联函数
• 内联函数一般适合于不存在while和switch等复杂的结构且只有1–5条语句的小函数上，否则编译系统将该函数视为普通函数。
• 内联函数只能先定义后使用，否则编译系统也会把它认为是普通函数。
• 对内联函数不能进行异常的接口声明。
  示例： 一个简单的交换函数

inline void swap(int *a, int *b)
{
    int t = *a;
    *a = *b;
    *b = t;
}

函数参数传递常用的三种方式：
1.值传递

#include 

void swap(int x, int y);
void swap(int x, int y)
{
    int temp;
    temp = x;
    x = y;
    y = temp;
}

int main( int argc, char *argv[] )
{
    int a = 5;
    int b = 10;
    swap(a, b); //调用交换函数
    printf("交换结果为 a = %d, b = %d\n",a,b);
    return 0;
}

由于值传递是单向传递，传递过程中只是改变了形参的数值，并未改变实参的数值，因此并不会改变a和b原有的值。
2.指针传递

#include 

void swap(int *x, int *y);
void swap(int *x, int *y)
{
    int temp;
    temp = *x;
    *x = *y;
    *y = temp;
}

int main( int argc, char *argv[] )
{
    int a = 5;
    int b = 10;
    swap(&a, &b); //调用交换函数
    printf("交换结果为 a = %d, b = %d\n",a,b);
    return 0;
}

指针传递过程中，将a和b的地址分别传递给了x和y，在函数体内部改变了a、b所在地址的值，即交换了a、b的数值。
3.引用传递

#include 

void swap(int &x, int &y);
void swap(int &x, int &y)
{
    int temp;
    temp = x;
    x = y;
    y = temp;
}

int main( int argc, char *argv[] )
{
    int a = 5;
    int b = 10;
    swap(a, b); //调用交换函数
    printf("交换结果为 a = %d, b = %d\n",a,b);
    return 0;
}

引用传递中，在调用swap(a,b);时函数会用a、b分别代替x、y，即x、y分别引用了a、b变量，这样函数体中实际参与运算的其实就是实参a、b本身，因此也能达到交换数值的目的。
注： 严格来说，C语言中没有引用传递，这是C++中语言特性，因此在.c文件中使用引用传递会导致程序编译出错。