一、指针的指针
指针的指针,即指针的地址
定义了一个指针变量,指针变量本身占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个字节,都是存放地址编号,只是类型不一样
#includevoid 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=0xbf9bde30p=0xbf9bde30&p=0xbf9bde34q=0xbf9bde34&q=0xbf9bde38m=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:#includevoid 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:#includevoid 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#include #include 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=0xbfc00de8 printf("&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=20 printf("&a=%p\n",&a);//int (*p)[4][5] 取地址后升级变成了二维数组指针 printf("&a+1=%p\n",&a+1);//与&a相差多少个字节,4*5*4=80 } /*a=0xbfd624e0a+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=20 printf("p=%p\n",p);//p是int *类型的指针 printf("&p=%p\n",&p); //int **类型 printf("&p+1=%p\n",&p+1); //与&p相差4个字节 }