一、指针的指针

指针的指针,即指针的地址

定义了一个指针变量,指针变量本身占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;

  1. 可以修改buf数组的内容
  2. 可以通过str修改str指向的内存的内容,即buf的内容
  3. 不能给buf赋值,是常量
  4. 可以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个字节       }