C语言-内联函数、递归函数、指针函数

1. 前言

这篇文章介绍C语言的内联函数、递归函数、函数指针、指针函数、局部地址、const关键字、extern关键字等知识点；这些知识点在实际项目开发中非常常用，非常重要。

下面就以小章节的流程介绍每个知识点。

2. 函数返回局部空间的地址问题

子函数: 在调用结束后空间会被释放—被系统回收。

总结：子函数不能返回局部变量的地址。

示例1:

#include 
char *func(void);
int main()
{
	printf("%s\n",func());  //打印不出来。
	return 0;
}

char *func(void)
{
	char buff[]="1234567890";
	return buff;
}

示例2:

#include 
char *func(char *p);
int main()
{
	char buff[]="1234567890";
	printf("%s\n",func(buff)); //可以打印
	return 0;
}

char *func(char *p)
{
	return p;
}

示例3:

#include 
char *func(void);
int main()
{
	printf("%s\n",func());  //可以打印
	return 0;
}

char *func(void)
{
	static char buff[]="1234567890";
	return buff;
}

3. const 只读关键字（常量）

(1) const关键字—修饰变量

#include 
int main()
{
	//const int a; //初始化不赋值，这行代码就没有意义
	const int a=100;
	a=200; //错误的代码--无法对常量赋值--只读变量赋值
	printf("a=%d\n",a);
	return 0;
}

(2) const关键字—修饰指针

#include 

//指针: 数据域、指针(地址)域

int main()
{
	int a=100;
	int b=200;
	//const常用4种修饰指针的方法
	const int *p1=&a; //指向空间值无法修改，指向的地址可以改变
	int const *p2=&a; //指向空间值无法修改，指向的地址可以改变
	int *const p3=&a; //指向空间值可以修改，指向的地址无法改变
	const int *const p4=&a;  //向空间值无法修改，指向的地址无法改变
	//int *p5 const; 语法是错误的
	
	//*p1=666; 错误的
	//p1=&b;   正确的
	//*p2=666;错误的
	//p2=&b;正确的
	//*p3=666;正确的
	//p3=&b;错误的
	//p4=&b;错误的
	//*p4=666;错误的
	return 0;
}

4. 内联函数

内联函数: 在调用的时候不会进行压栈出栈（不会经历保存地址的过程和恢复地址的过程）。

内联函数相当于一个替换的过程。

内联函数设计要注意：内联函数里只能写简单的代码—不能写复杂代码。

函数里的局部变量存放在栈空间里的。栈空间：是由系统管理的。

#include 
void func(void);
int main()
{
	int a;
	func();
	printf("12345\n");
	return 0;
}

//inline 声明-定义内联函数
inline void func(void)
{
	printf("hello\n");
}

5. extern 外部引用声明

extern 多用于多文件编程里变量、函数、其他数据类型的引用声明。

外部引用声明的时候，不能赋值。

#include 
//引用声明
extern int a;
extern char buff[];
extern void func();

int main()
{
	printf("%d\n",a);
	printf("%s\n",buff);
	func();
	return 0;
}

int a=100;
char buff[]="1234567890";
void func()
{
	printf("hello\n");
}

6. 字符串数组和字符串常量定义问题

#include 
int main()
{
	//p1指向的字符串是在程序编译的时候赋值
	char *p1="1234567890"; //指针指向字符串常量
	//p2数组是程序运行的时候赋值
	char p2[]="abcdefg";
	//p1[0]='A'; 错误的
	printf("%s\n",p1);
	printf("%s\n",p2);
	return 0;
}

示例2：

#include 

int main()
{
	//p1指向的字符串是在程序编译的时候赋值
	char *p1="1234567890"; //指针指向字符串常量
	//p2数组是程序运行的时候赋值
	char p2[]="abcdefg";
	int a;
	int b;
	int c;
	printf("a=%#x\n",&a);
	printf("b=%#x\n",&b);
	printf("c=%#x\n",&c);
	printf("p1=%#x\n",p1);
	printf("p2=%#x\n",p2);
	return 0;
}
/*
a=0xbf9f93e0
b=0xbf9f93dc
c=0xbf9f93d8
p1=0x8048524
p2=0xbf9f93e4
*/

7. 标准main函数形参语法

#include 
/*
int argc :传入的参数数量(包括可执行文件本身)
char **p :保存传入的数据地址
main传入的参数数据都是字符串类型。
传参数的方式:  ./a.out 123 456 789
*/
int main(int argc,char **p)
//int main(int argc,char *p[]) p[0] p[1] p[2]
{
	int i;
	for(i=0;i

8. 指针函数与函数指针

数组指针: 本身是指针，指向二维数组的指针（一维数组指针）。int (*p)[5];

指针数组: 本身是数组，数组里存放的是地址。int *p[5]; (相当于定义了5个指针)

数组的名称本身就是数组元素的首地址—数组名称就是地址。

**函数指针: **本身是指针，指向函数的指针。语法：int (*p)(int,int); 不支持++和—运算符。

指针函数: 本身是函数，表示函数的返回值是指针类型。语法: int *func(int a,int b){}

函数名称就是地址。

示例1：

#include 
int func(int a,int b);
int main(int argc,char **argv)
{
	int (*p)(int,int); //指向函数的指针
	p=func;
	printf("%d\n",func(10,20)); //通过函数名称调用函数
	printf("%d\n",p(10,20)); //通过指针调用函数--写法1
	printf("%d\n",(*p)(10,20)); //通过指针调用函数--写法2
	return 0;
}

int func(int a,int b)
{
	return a+b;
}

示例2： 函数指针当做函数形参

#include 
int func1(int a,int b);
int func2(int (*p)(int,int),int a,int b);

int main(int argc,char **argv)
{
	printf("%d\n",func2(func1,100,200));
	return 0;
}

int func1(int a,int b)
{
	return a+b;
}

int func2(int (*p)(int,int),int a,int b)
{
	return p(a,b);
}

9. 递归函数

什么是递归函数？ 子函数直接或者间接的方式调用自己的过程叫做递归。

函数自己调用自己的过程—递归。

递归函数注意事项：必须有终止条件。

示例1：

#include 
int func(int a);
int main(int argc,char **argv)
{
	printf("%d\n",func(1)); //10
	return 0;
}

int func(int a)
{
	a++;
	if(a==10)
	{
		return a;
	}
	else
	{
		func(a);
	}
}

示例2：计算字符串的长度—使用递归

#include 
int func(char *p);
int main(int argc,char **argv)
{
	printf("%d\n",func("1234567890")); //10
	return 0;
}

//计算字符串长度
int func(char *p)
{
	if(*p=='\0')
	{
		return 0;
	}
	return 1+func(p+1);
}

/*
演示递归函数的返回过程：
a(); //3

int a()
{
	
	return 1+b();
}

int b()
{
	return 1+c();
}

int c()
{
	return 1;
}
*/