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

复制复制#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;
}

复制复制#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);
}

复制复制#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);
	}
}

复制复制#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;
}
*/