指针2
==========
指针二
==========
1、认识指针
地址 编号 常量
指针 变量
2、定义指针
所指类型 * 变量名
3、给指针变量进行初始化【&】
【注】给指针变量进行初始化只可以赋值地址。
4、指针所占的字节数
64位系统下面都是8字节。
5、为什么使用指针？
为了跨栈访问数据。
【补充】当函数被调用时，cpu会在栈区给该函数开辟一块空间。当函数 结束调用时，该空间被摧毁。
6、指针与数组
指针 + 1 所指类型的字节
数组名 + 1 数组元素的字节数
数组名—代表着数组首元素的地址； int a[10]; a == &a[0]
*(a+1)—>*&a[1]—>a[1]
int * p = &a[0] *(p+1)—>*&a[1]—>p[1]
【结论】
1、数组名代表着数组首元素的地址。是一个常量。
int a[10]; a++; 常量不可以加加 数组名是一个常量
2 、指针指向数组首元素时，可以使用下标法遍历数组。
int *p = a(=&a[0]) p[i] 3、a代表着数组首元素的地址；&a代表着数组的地址。
这两个地址的值是一样的，但是a+1的结果与 &a+1的结果是不一 样的。
为什么要使用指向数组的指针？有指向数组首元素的指针不是就完全可 以吗？
对于指向数组的指针，主要是用在二维数组传参时。
二维数组的首元素是一个数组。所以将二维数组的数组名作为实参，那 么形参需要是一个指向数组的指针。
7、定义一个指向数组的指针
int (*p）[10]
8、指向指针的指针
int * q;
int **p = &q;
9、指向函数的指针
返回值类型 (*p)（形参列表） = 函数名；
【见代码 指针函数的应用】
【目标】
1、定义一个指向函数的指针；
2、给函数指针进行初始化；赋值的是函数名。
3、通过函数名可以调用函数；通过指向函数的指针也可以调用函数。
4、函数名代表着函数的入口地址。
【扩展】函数的入口地址
我们编辑的文件，在编译之后会变成二进制文件，保存在硬盘上，当程 序运行的时候，会将该二进制文件读取到常量区中。二进制文件就是 cpu的使用说明书。函数的入口地址就相当于是这个说明中该函数所在 的页数（地址）。当发生函数调用的时候，cpu会根据函数名找到到函 数的地址，然后读取指令，进行操作。
【注】函数名代表着入口地址，并不是函数在运行阶段发生调用时候的 函数栈的地址。
一个程序经历编辑（coding）、编译（command+b）、运行的过 程。
10、返回指针的函数
【见代码 函数指针的应用】
11、认识复杂的类型
【如何辨别与指针相关的妖魔鬼怪？】
1、先找到变量名，
2、然后观察左右两边的运算符，() [] *
3、根据优先级去确定这到底是个什么鬼；优先级最高的运算符如果是，说明这是一个 指针；优先级最高的是[],说明这是一个数组；优先级最高的是（），说明这是一个 函数的声明。
4、如果是数组，我们要看数组元素是什么类型，遮住数组名与数组的大小剩余部分就 是数组元素的类型；
如果是指针，我们要看指针指向什么类型，遮住变量名与剩余部分就所指向的类 型。
如果是函数，我们要看函数的返回值类型与形参列表。函数名前半部分都是返回值 类型，函数名后面都是形参列表；
【课堂练习】
int (p[10])[10] 数组
int (p[10])[10] 数组元素是指针
int (*p[10])[10] 指针是指向数组的
这是一个数组，数组元素是指向数组的指针
int (p[10])(int) 数组
int (p[10])(int)数组元素是指针
int (*p[10])(int)指向函数
这是一个数组，数组元素是指向函数的指针
int （p）[10]; 指针
int （p）[10] 指向数组
int （p）[1 数组元素是指针
int (func[10])(int,int); 数组
int (func[10])(int,int);数组元素是指针
int (func[10])(int,int);指向的是函数，函数的返回值int * 形参列表（int,int）;
int (p[10])(int) 数组
int (p[10])(int)数组元素值指针
int (*p[10])(int)指向函数 函数返回值int 形参int
int （p）[10]; 指针，
int （p）[10];指向数组
int （p）[10];数组元素是指针
int (func[10])(int,int);数组
int (func[10])(int,int);数组元素是指针
int (func[10])(int,int);指向函数，函数返回值int *,形参 （int,int）
12、特殊的指针—空指针 与 野指针
当我们声明一个指针变量时，不给指针变量赋值，那么此时这个指针就 是一个野指针，他的指向是不明确的。在程序使用野指针是非常危险 的。
当我们暂时无法给一个指针变量进行赋值时，我们可以将其置为NULL, 即：int * p = NULL;
13、const常量修饰符与指针的关系
int * const p = &b;
p = &c;//错误！
//const放在*后面，修饰的是指针，即指针的指向不允许发生改变。
const int * p = &b; int const * p = &b;
// *p = 100; 错误！
//const放在*前面，修饰的是指针的指向。也就是说不能通过指针去修改所指变 量的内容。
指针的复习
#include <stdio.h>
int main(int argc, const char * argv[]) {
int a[10];
//数组首元素的地址
printf("%p\n",a);
//数组的地址
printf("%p\n",&a);
//数组首元素地址+1 4个字节
printf("%p\n",a+1);
//数组地址+1 40个字节
printf("%p\n",&a+1);
return 0;
}
返回指针的函数
#include <stdio.h>
#include <stdlib.h>
int * func();
int main(int argc, const char * argv[]) {
int * p = func();
int * r = (int*)malloc(sizeof(int)*10);
for(int i = 0;i<10;i++){
r[i] = i*1111;
printf("%p\n",&r[i]);
}
//func函数调用结束之后，func栈空间被摧毁，数组a也就不存在了。
for (int i = 0; i < 10; i++) {
printf("%d ",p[i]);
}
return 0;
}
int * func(){
//在堆上开辟4*10个字节的空间，malloc是程序员手动开辟空间的方法。返回值是一个地址。
//在堆上开辟的空间需要程序员手动去释放，只有调用free函数才会被摧毁。
int * p = (int*)malloc(sizeof(int)*10);
for(int i = 0;i<10;i++){
p[i] = i*10;
printf("%p\n",&p[i]);
}
// free(p);
return p;
//a在func函数栈开辟空间
// int a[10] = {1,2,3,4,5,6,7,8,9,10};
// return a;
}
函数指针应用
#include <stdio.h>
int test(int (*p)(int a,int b),int a,int b);
int gcd(int a,int b);
int lcm(int a,int b);
int main(int argc, const char * argv[]) {
int a,b,c;
printf("请输入a,b,c的值\n");
scanf("%d%d%d",&a,&b,&c);
if (c>0) {
//求a与b的最大公约数
printf("%d\n",test(gcd,a,b));
}else{
//求a与b的最小公倍数
printf("%d\n",test(lcm,a,b));
}
//函数名代表着函数的入口地址
printf("+++++%p\n",test);
printf("+++++%p\n",&a);
// 【oc阶段】回调。
// [btn addtarget:withSelector:]
return 0;
}
int test(int (*p)(int a,int ),int a,int b){
return p(a,b);
}
int gcd(int a,int b){
if (a<b) {
int temp = a;
a = b;
b = temp;
}
int c;
while (1) {
c = a%b;
if (c == 0) {
//返回最大公约数
return b;
}else{
a = b;
b = c;
}
}
}
int lcm(int a,int b){
return a*b/gcd(a, b);
}
野指针与空指针
#include <stdio.h>
int main(int argc, const char * argv[]) {
//在Xcode编译器中会将没有初始化的数据，初始化为默认的值。
//int初始化为0，float初始化为0.0 指针初始化为NULL
//当我们声明一个指针，暂时没有办法为其初始化，我们将置为NULL.
//否则的话就是野指针。
int * p = NULL;
printf("%p\n",p);
return 0;
}
const修饰符
#include <stdio.h>
int main(int argc, const char * argv[]) {
//const常量修饰符 被const修饰变量是只读变量
int const a = 10;
int b = 20;
int c = 33;
int * const p = &b;
//const放在*后面，修饰的是指针，即指针的指向不允许发生改变。
// p = &c;
// const int * p = &b; int const * p = &b;
//const放在*前面，修饰的是指针的指向。也就是说不能通过指针去修改所指变量的内容。
// *p = 100;
return 0;
}
