一、指针的指针
指针的指针，即指针的地址
定义了一个指针变量，指针变量本身占4个字节，指针变量也有地址编号
例：
int a=0x12345678;
假设a的地址为：0x0000 2000
int *p;
p=&a;
则p中存放的是a的地址编号为0x0000 2000
因为p也占4个字节，有自己的地址编号，即指针变量的地址，即指针的指针
假设p的地址编号为0x0000 3000,这个地址是指针p的地址
定义一个变量去存放p的地址编号，这个变量就是指针的指针
int **q;
q=&p;//q就保存了p的地址，也可以说q指向了p
则q里存放的就是0x00003000
p和q都是指针变量，都占4个字节，都是存放地址编号，只是类型不一样
#include<stdio.h>
void main()
{int a=0x12345678;int *p;int **q;int ***m;p=&a;printf("&a=%p\n",&a);printf("p=%p\n",p);q=&p;printf("&p=%p\n",&p);printf("q=%p\n",q);m=&q;printf("&q=%p\n",&q);printf("m=%p\n",m);printf("*p=%#x\n",*p);printf("**q=%#x\n",**q);printf("***m=%#x\n",***m);}
/*
&a=0xbf9bde30
p=0xbf9bde30
&p=0xbf9bde34
q=0xbf9bde34
&q=0xbf9bde38
m=0xbf9bde38
*p=0x12345678
**q=0x12345678
***m=0x12345678*/二、字符串和指针
字符串的概念：
字符串就是’\0’结尾的若干的字符的集合：”hello”
字符串的地址：是第一个字符的地址，字符串”hello”的地址，其实就是字符串中’h’的地址，即我们可以定义一个变量保存字符串的地址：char *s=”hello”;
字符串的存储形式：数组、文字常量区、堆
1.字符串存在数组中
其实就是在内存（栈、静态全局区）中开辟了一段空间存放字符串。
char str[100]=”hello”;
定义了一个字符数组str，用来存放多个字符，并且用hello给str数组初始化，字符串”hello”,存放在str中
注意：普通全局数组，内存分配在静态全局区
普通局部数组，内存分配在栈区
静态数组（静态全局数组、静态局部数组），内存分配在静态全局区
2.字符串存放在文字常量区
在文字常量区开辟了一段空间存放字符串，将字符串的首地址赋给指针变量
char *str=”helloworld”;
定义了一个字符指针变量str，只能存放字符地址编号，
“helloworld”这个字符串中的字符不是存放在str指针变量中
str只是存放了字符’h’的地址编号，“helloworld”存放在字符常量区
3.字符串存放在堆区
使用malloc等函数在堆区申请空间，将字符串拷贝到堆区
char *str=(char *)malloc(100*sizeof(char));//动态申请了100个字节的存储空间
首地址给str赋值
strcpy(str,”helloworld”);//将字符串”helloworld”拷贝到str指向的内存中
字符串的可修改性：
字符串的内容是否可以被修改，取决于字符串存放在哪里
（1）存放在数组中的字符串的内容是可以修改的
char str[100]=”helloworld”;
str[0]=’y’;//正确的，可以修改
注：数组没有被const修饰（只要被const修饰的变量都不可以改）
（2）文字常量区里面的内容是不可以修改的
char *str=”helloworld”;
str[0]=’y’;//错误的，h是存放在文字常量区，不可修改
注：str指向文字常量区的时候，它所指向的内容不可以被修改
str是指针变量，可以指向别的地方，即可以给str重新赋值
（3）堆区的内容是可以修改的
char *str=(char*)malloc(100);
strcpy(str,”helloworld”);
*str=’y’//正确，堆区的内容可以被修改
注意：str指向堆区的时候，它所指向的内容可以被修改
str是指针变量，可以指向别的地方，即可以给str重新赋值
总结：
（1）字符串的内容是否可以被修改，取决于字符串存放在哪里
（2）str指向文字常量区的时候，内存里面的内容不可以被修改
（3）str指向数组（非const修饰）、堆区，它指向的内存里面的内容是可以被修改的
例1:
#include<stdio.h>
void main()
{char str[100]="hello world!!";printf("str=%s\n",str);str[0]='y';printf("str=%s\n",str); //str=hello world!!//str=yello world!!
} 例2：
#include<stdio.h>
void main()
{char *str="hello world!!";printf("str=%s\n",str);//str=hello world!!*str='y';printf("str=%s\n",str); //Segmentation fault (core dumped)//改不了，出现段错误
} 例3：
#include<stdio.h>
#include <stdlib.h>
#include <string.h>
void main()
{char *str=(char*)malloc(100);strcpy(str,"helloworld!!");//str=helloworld!!printf("str=%s\n",str); *str='y';printf("str=%s\n",str); //str=yelloworld!!
} 字符串的初始化
1.字符数组初始化：
char buf[100]=”hello world”;
2.指针指向文字常量区，初始化
char *buf=”hello world”;
3.指向堆区、堆区存放字符串
不能一来就初始化，先给指针赋值，让指针指向堆区，再使用strcpy、scanf等方法把字符串拷贝到堆区
char *buf;
buf=(char *)malloc(100);
strcpy(buf,”helloworld”);
scanf(“%s”,buf);
字符串使用时赋值
1.字符数组：使用scanf或者strcpy
char buf[20]=”hello world”;
buf=”hellokitty”;错误，因为字符数组的名字是个常量，不能用等号给常量赋值
strcpy(buf,”hellokitty”);正确，数组的内容是可以被修改的
scanf(“%s”,buf);正确，数组的内容是可以被修改的
2.指针指向文字常量区
char *buf=”hello world”;
buf=”hellokitty”;正确，buf指向另外一个字符串
strcpy(buf,”hellokitty”);错误，buf指向的文字常量区，内容是只读的，不可修改的，不能通过指针区修改文字常量区的内容
3.指针指向堆区，堆区存放字符串
char *buf;
buf=(char *)malloc(100);
strcpy(buf,”helloworld”);
scanf(“%s”,buf);
字符串和指针总结
（1）指针可以指向文字常量区
1）指针指向的文字常量区的内容不可以修改
2）指针的指向是可以改变的，重新赋值，让它指别的地方
（2）指针指向堆区
1）指针指向的堆区的内容可以修改
2）指针的指向是可以改变的，重新赋值，让它指别的地方
（3）指针指向数组（非const修饰）
char buf[20]=”hello world”;
char *str=buf;
- 可以修改buf数组的内容
- 可以通过str修改str指向的内存的内容，即buf的内容
- 不能给buf赋值，是常量
- 可以str赋值，让它指向别处
三、数组指针
1.二位数组
二维数组，有行有列。二维数组可以看成由多个一维数组构成的，是多个一维数组的集合，可以认为二维数组的每个元素是一维数组
例：int a[3][5];
定义了一个3行5列的二维数组
可以认为二维数组a由3个一维数组构成，每个元素是一个一维数组（这个一维数组有五个元素）
思考：数组的名字是数组的首地址，即第0个元素的地址，是个常量，数组名字加1指向下一个元素。
二维数组a中，a+1指向下一个元素，即下一个一维数组，即下一行
一维数组a[10];---------->a是a[0]的地址即&a[0],a+1-------->&a[1];
二维数组a[3][5];-------->a是a[0]的地址即&a[0],a+1--------->&a[1];
a[3][5]={
{1,2,3,4,5},
{ 6,7,8,9,0},
{5,4,3,2,1}
}
2.数组指针的概念
本身是一个指针，指向一个数组，加1跳一个数组，即下一个数组
3.数组指针的定义方法
指向的数组的类型 (* 指针变量名) [元素个数]
int ( * a)[5];//定义了一个数组指针变量a,a指向的是整型的有5个元素的数组a+1往下指5个整型，跳过一个有5个元素的一维数组
void main()
{int a[3][5];//定义了一个3行5列的数组int (*p)[5];//定义了一个数组指针变量p，P+1跳一个有5个元素的整型数组printf("a=%p\n",a);//第0行的地址printf("a+1=%p\n",a+1);//第1行的地址，a与a+1差20个字节p=a;printf("p=%p\n",p);printf("p+1=%p\n",p+1);printf("&a[0]=%p\n",&a[0]);//第0行的地址printf("&a[1]=%p\n",&a[1]);//第1行的地址printf("&a[0][0]=%p\n",&a[0][0]);//第0行首元素地址printf("&a[0][0]+1=%p\n",&a[0][0]+1);//第0行第2个元素地址
}数组指针的用法1
例子：
void fun(int(*p)[5])
{p[1][4]=10;
}
void main()
{int a[3][5]={ {1,2,3,4,5},{6,7,8,9,0},{0,0,0,0,0} };//定义了一个3行5列的数组//fun()int i,j;fun(a);for(i=0;i<3;i++){for(j=0;j<5;j++){ printf("%d ",a[i][j]);}printf("\n");}
} 4.各种数组指针的定义
（1）一维数组指针，加1后指向下个一维数组
int (*p)[5];
配合每行有5个int型元素的二维数组来用
int a[3][5]
int b[4][5]
int c[5][5]
int d[6][5]
...
p=a;
p=b;
p=c;
p=d; 都是可以的
（2）二维数组指针，加1后指向下个二维数组
int (*p)[4][5];
配合三维数组来用，三维数组中由若干个4行5列的二维数组构成的
int a[3][4][5]
int b[4][4][5]
int c[5][4][5]
int d[6][4][5]
...
p=a;
p=b;
p=c;
p=d; 都是可以的
void main()
{int a[3][4][5];printf("a=%p\n",a);printf("a+1=%p\n",a+1);//a和a+1地址编号相差80个字节int (*p)[4][5]; //验证了a+1跳一个4行5列的二维数组p=a;printf("p=%p\n",p);printf("p+1=%p\n",p+1);//p和p+1地址编号相差80个字节
} （3）三维数组指针，加1后指向下一个三维数组
int(*p)[4][5][6]
配合四维数组使用
int a[8][4][5][6]
多维数组指针以此类推......
5.容易混淆的概念
指针数组：是个数组，有若干个相同类型的指针构成的集合
int *p[10];
数组p有10个int *类型的指针变量构成，分别是p[0]~p[9]
数组指针：是个指针，指向一个数组，加1跳一个数组
int (*p)[10];
p是个指针，是个数组指针，p加1指向下一个数组，跳10个整型
指针的指针：
int **p;//p是指针的指针
int *q;
p=&q;
6.数组名字取地址，变成了数组指针
一维数组名字取地址，变成了一维数组指针，即加1跳一个一维数组
int a[10];
a+1跳一个整型元素，即a[1]的地址;
a和a+1相差了一个元素，4个字节
&a就变成了一维数组指针，是int(*p)[10]类型
(&a)+1和&a相差一个数组即10个元素即40个字节
拓展：&有升级功能 *有降级功能 &*相遇抵消
void main()
{int a[10];printf("a=%p\n",a);//a[0]的地址即&a[0]，a=0xbfc00de8;printf("a+1=%p\n",a+1);//&a[1],a+1=0xbfc00dec与a相差4个字节printf("&a=%p\n",&a);//int(*p)[10]类型的，&a=0xbfc00de8printf("&a+1=%p\n",&a+1);//数组指针加1，跳一个数组，即跳10个元素//即40个字节 &a+1=0xbfc00e10
} 总结：a是int *类型的指针，即a[0]的地址
&a变成了数组指针int(*p)[10]类型，加1跳10个元素的一维数组
注意：
在运行程序时，发现a和&a所代表的地址编号时一样的，即它们指向同一个存储单元，但是a和&a的指针类型不一样
void main()
{int a[4][5];printf("a=%p\n",a);//int (*p)[5]一维数组指针printf("a+1=%p\n",a+1);//与a相差多少个字节，5*4=20printf("&a=%p\n",&a);//int (*p)[4][5] 取地址后升级变成了二维数组指针printf("&a+1=%p\n",&a+1);//与&a相差多少个字节，4*5*4=80
}
/*a=0xbfd624e0
a+1=0xbfd624f4
&a=0xbfd624e0
&a+1=0xbfd62530*/9.数组名字和指针变量的区别
int a[5];
int *p;
p=a;
相同点：a是数组的名字，是a[0]的地址，即p=a即p保存了a[0]的地址，即a和p都是指向的a[0],所以在引用数组元素的时候，a和p是等价的
引用数组元素回顾：
a[2]、*(a+2)、*(p+2)、p[2]都是对数组a中a[2]元素的引用
void main()
{int a[5]={0,1,2,3,4};int *p;p=a;printf("a[2]=%d\n",a[2]);printf("p[2]=%d\n",p[2]);printf("*(a+2)=%d\n",*(a+2));printf("*(p+2)=%d\n",*(p+2));
} 不同点：（1）a是常量，p是变量
可以用’=’给p赋值，不能用等号给a赋值
（2）对a取地址，和对p取地址不一样
因为a是数组的名字，对a取地址结果是数组指针int (*p)[5]类型
&a+1-->5*4=20字节
p是指针变量，所以对p取地址结果为指针的指针
为int **类型
&p+1---->4个字节
往后指向一个int *类型的指针
void main()
{int a[5];int *p;p=a;printf("a=%p\n",a);//a是int *类型的指针，即a[0]的地址printf("&a=%p\n",&a);//&a变成了数组指针int(*p)[5]类型printf("&a+1=%p\n",&a+1);//与&a相差5*4=20printf("p=%p\n",p);//p是int *类型的指针printf("&p=%p\n",&p); //int **类型printf("&p+1=%p\n",&p+1); //与&p相差4个字节
} 
