C语言-函数指针，指针与函数传参

1.函数指针

(1)函数指针的实质（还是指针变量）

->函数指针的实质还是指针，还是指针变量。本身占4字节（在32位系统中，所有的指针都是4字节）

->函数的实质是一段代码，这一段代码在内存中是连续分布的，所以对于函数来说很关键的就是函数中的第一句代码的地址，这个地址就是所谓的函数地址，函数指针就是指向这个地址。

(2)函数指针的书写和分析方法

->C语言本身是强类型语言（每一个变量都有自己的变量类型），编译器可以帮我们做严格的类型检查。

->假设我们有个函数是：void func(void);对应的函数指针：void (*p)(void); 类型是：void (*)(void);

->写一个复杂的函数指针的实例：譬如函数是strcpy函数（char *strcpy(char *dest, const char *src);），对应的函数指针是：char *(*pFunc)(char *dest, const char *src);

(3)用函数指针调用执行函数

#include <stdio.h>


void func1(void)
{
	printf("I am func1.\n");
}

int main(void)
{
    void (*pFunc)(void);
	//pFunc = func1;	 
	pFunc = &func1;		// &func1和func1做右值时是一模一样的，没任何区别
	pFunc();		   // 用函数指针来解引用以调用该函数
	
	return 0;
	
}

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

int main(void)
{
    char a[5] = {0};
	char* (*pFunc)(char *, const char *); //定义了一个函数指针pFunc，类型是char* (*) (char*,const char*)
	pFunc = strcpy;                    //把strcpy函数名赋值给函数指针
	pFunc(a, "abc");
	printf("a = %s.\n", a);   //a = abc 
	
}

---

2.指针与函数传参

(1)普通变量作为函数形参

void func1(int b)
{
	// 在函数内部，形参b的值等于实参a
	printf("b = %d.\n", b);
	printf("in func1, &b = %p.\n", &b);
}
int main(void)
{	
	int a = 4;     
	printf("&a = %p.\n", &a);     // &a = 0x7ffc3826c2f4.
	func1(a);                     //b = 4,    in func1, &b = 0x7ffc3826c2dc.

	return 0;
}

->函数传参时，普通变量作为参数时，形参和实参名字可以相同也可以不同，实际上都是用实参来替代相对应的形参的。

->在子函数内部，形参的值等于实参。原因是函数调用时把实参的值赋值给了形参。

(2)数组作为函数形参

void func2(int a[])
{
	printf("sizeof(a) = %d.\n", sizeof(a));
	printf("in func2, a = %p.\n", a);
}
int main(void)
{	
	int a[5];
	printf("a = %p.\n", a);        //a = 0x7ffc5e60ef00.
	func2(a);                    //sizeof(a) = 8.  in func2, a = 0x7ffc5e60ef00.
                                  //用到的是64位操作系统，所以sizeof(a)是8

	return 0;
}

->数组名作为形参传参时，实际传递是不是整个数组，而是数组的首元素的首地址（也就是整个数组的首地址。因为传参时是传值，所以这两个没区别）。所以在子函数内部，传进来的数组名就等于是一个指向数组首元素首地址的指针。所以sizeof得到的是8（64位操作系统）.

->数组作为函数形参时，[]里的数字是可有可无的。为什么？因为数组名做形参传递的实际只是个指针，根本没有数组长度这个信息。

(3)指针作为函数形参

void func3(int *a)
{
	printf("sizeof(a) = %d.\n", sizeof(a));
	printf("in func2, a = %p.\n", a);
}
int main(void)
{	
	int a[5];
	printf("a = %p.\n", a);
	func3(a);
	
	return 0;
}

->和数组作为函数形参是一样的.这就好像指针方式访问数组元素和数组方式访问数组元素的结果一样是一样的.

(4)结构体变量传参

struct A
{
	char a;				// 结构体变量对齐问题
	int b;				// 因为要对齐存放，所以大小是8
};

void func4(struct A a1)
{
	printf("sizeof(a1) = %d.\n", sizeof(a1));
	printf("&a1 = %p.\n", &a1);
	printf("a1.b = %d.\n", a1.b);
}


int main(void)
{	
	struct A a = 
	{
		.a = 4,
		.b = 5555,
	};
	printf("sizeof(a) = %d.\n", sizeof(a));    //sizeof(a) = 8.
	printf("&a = %p.\n", &a);                //&a = 0x7ffc93bee420.
	printf("a.b = %d.\n", a.b);             //a.b = 5555.
	func4(a);                            //sizeof(a1) = 8.
                                         //&a1 = 0x7ffc93bee400.
                                           //a1.b = 5555.
	
	return 0;
}

(5)结构体指针传参：

struct A
{
	char a;				// 结构体变量对齐问题
	int b;				
};

void func5(struct A *a1)
{
	printf("sizeof(a1) = %d.\n", sizeof(a1));		  
	printf("sizeof(*a1) = %d.\n", sizeof(*a1));		
	printf("&a1 = %p.\n", &a1);			           
	printf("a1 = %p.\n", a1);
	printf("a1->b = %d.\n", a1->b);
}


int main(void)
{	
	struct A a = 
	{
		.a = 4,
		.b = 5555,
	};
	printf("sizeof(a) = %d.\n", sizeof(a));		//sizeof(a) = 8.
	printf("&a = %p.\n", &a);                 //&a = 0x7fffdde01030.
	printf("a.b = %d.\n", a.b);               //a.b = 5555.
	func5(&a);                            // sizeof(a1) = 8.   sizeof(*a1) = 8.
	                                       //&a1 = 0x7fffdde01018.
										    //a1 = 0x7fffdde01030.    a1->b = 5555.
	return 0;                       
}