指针day01

指针==地址

访问变量一般通过两种的方式，分别是变量名（直接访问）和地址（间接访问）

指针变量== 存放地址的变量

如何定义一个指针变量-

*的标识作用--只产生在指针变量定义或声明的时候

如何使用一个指针变量-

*的运算作用        

既然指针变量是存放别人地址的变量，那为什么要声明类型？

①决定指向空间的大小

如 int *pint

    char *pchar

#include <stdio.h>
int main(){
	int a = 0x1234;
	int *p = &a;
	char *c = &a;
	
	printf("p = %p\n",p);
	printf("c = %p\n",c);
	
	printf("a = %x\n",*p);
	printf("a = %x\n",*c);
	
	
	return 0;
}

②决定增量

通过指针引用数组

可以用一个指针变量指向一个数组元素，数组的首地址是数组中第零个元素的地址（下标为0）

int a[10] = {1,2,3,4,5,6,7,8,9,10}; //定义a为包含10个整形数据的数组
int * p;                            //定义p为指向整型变量的指针变量
p = &a[0];                          //把a[0]元素的地址赋给指针变量p

表示数组得的另一种方式是数组名，在C语言中，数组名代表数组首元素的地址（即序号为0的元素的地址） ，因此，下列两个语句等价

p = &a[0];     //p的值是a[0]的地址

p = a;          //p的地址是数组a首元素(即a[0])的地址

#include <stdio.h>
int main(){
	int arr[] = {1,2,3};
	int *p;
	
	//p = &arr[0];
	p = arr;
	
	printf("第一个元素是：%d",*p);
	
	return 0;
}

对地址里面的数据进行访问是 * 运算符。

指针增量和数组的关系

指针+1，并不是地址+1，而是指针的偏移，偏移之后它还是这个地址，+1是指该类型增加字节，之前有定义类型，是整型数，就增加4个字节，是char型，就偏移一个字节

#include <stdio.h>
int main(){
	int arr[] = {1,2,3};
	int *p;
	
	//p = &arr[0];
	p = arr;
	
	printf("第0个元素是：%d",*p);
	printf("第1个元素是：%d",*(p+1));
    printf("第2个元素是：%d",*(p+2));
   
	return 0;
}

//通过指针的方式来遍历整个数组，是一种更好的方法
for(i=0;i<3;i++){
    printf("%d",*(p+i));    
}

 

 

#include <stdio.h>
int main(){
	int arr[] = {1,2,3};
	int *p;
	int i;
	p = &arr[0];	//下标法
	p = arr;		//指针法
	
	for(i=0;i<3;i++){
    printf("address: 0x%p,%d\n",(p+i),*(p+i));    
	}
	return 0;
}

 通过指针引用数组元素

 关于下标法和指针法的效率对比：

对于使用指针和数组下标的选择：

系统在使用数组下标对数组成员变量进行访问时，开销比较大，指针的访问效率是远远大于数组名的访问效率的

但是只有在指针正确访问时，才能比下标法更有效率

下标法更容易理解，在可读性方面，也更加的具有优势，具体怎么选择，也没有一定的说法、

关于见怪不怪的数组名

指针偏移的另一种方式：

for(i=0;i<3;i++){

        printf("%d ",*p++);//这里涉及到一个优先级的问题*和p先结合，然后运行之后p++

}
    或者
for(i=0;i<3;i++){

        printf("%d ",*p);
        p++;
}

但是p++这种情况有时会连续使用，需要连续遍历时，要先让p回到原来的初始值（在次给p赋值），然后在开始自增，否则p会承接上一次自增的结果，导致最后运行紊乱。如：

p = arr;
for(i=0;i<3;i++){

        printf("%d ",*p);
        p++;
}
p = arr;
for(i=0;i<3;i++){

        printf("%d ",*p);
        p++;
}

①见怪不怪：指针当作数组名，下标法访问

指针指向一个数组，可以把指针当作一个数组名来使用，同样也可以通过for循环

#include <stdio.h>
int main(){
	int arr[] = {1,2,3};
	int *p = arr;
	
	printf("%d ",p[2]);
	
	return 0;
}

 ②见怪不怪：数组名拿来加,下面这两种都可以

p = arr;
for(i=0;i<3;i++){

        printf("%d ",*(p+1));
        p++;
}
p = arr;
for(i=0;i<3;i++){

        printf("%d ",*(arr+1));
        p++;
}

既然可以p++，那么可不可以arr++呢？

并不行

p是一个指针变量，它是一个保存地址的变量，它保存的地址是可改的

而数组是一个常变量，如arr[3] = {1,2,3},1,2,3它的地址是确定的，数组名代表内存空间的开头位置，所以数组名不能拿来加

（指针常量不允许++，但指针变量可以++）

关于sizeof的使用

printf("sizeof arr is %d\n",sizeof(arr));//3*4=12
printf("sizeof arr is %d\n",sizeof(p));//os用8个字节表示一个地址
printf("sizeof int is %d\n",sizeof(int));//4个字节
printf("sizeof pointer is %d\n",sizeof(int *));//os用8个字节表示一个地址
printf("sizeof pointer is %d\n",sizeof(char *));//os用8个字节表示一个地址

指针变量都是用八个字节来存放一个地址

在gcc demo.c之后加一个-g使得程序进入可调式状态

之后在a.exe前加上gdb

回车后输入r之后回车，使得程序开始运行，os会告诉你哪里出现了错误

退出需要按q

1、 p：p是一个指针变量的名字，表示此指针变量指向的内存地址，如果使用%p来输出的话，它将是一个16进制数

2、 *p：*p表示此指针指向的内存地址中存放的内容，一般是一个和指针类型一致的变量或者常量。

3、 &p：&是取地址运算符，&p就是取指针p的地址。

顺序输入，倒序输出

#include <stdio.h>

void getArry(int *parry,int len){		//数据输入
	int i;
	for(i=0;i<len;i++){
		printf("请输入第%d个数\n",i+1);
		scanf("%d",parry++);
	}
	puts("\n");
}

void revangeArry(int *parry,int len){	//实现两个数的翻转
	int temp;
	int i,j;
	for(i=0;i<len/2;i++){
		j = len-1-i;
		temp = *(parry+i);
		*(parry+i) = *(parry+j);
		*(parry+j) = temp;
	}
}

void putArry(int *parry,int len){
	for(int i = 0;i<len;i++){
		printf("%d ",*parry++);
	}
	puts("\n");
}

int main(){
	int arry[5];
	int len;
	len = sizeof(arry)/sizeof(arry[0]);
	getArry(arry,len);//实际参数，数组的首地址：名，首个元素的地址
	putArry(arry,len);
	revangeArry(&arry[0],len);//传递的是数组元素的首地址，()中有两种写法。一种是&arry[0],另一种是arry
	putArry(arry,len);
	return 0;
}

putArry(arry,len);
	revangeArry(&arry[0],len);//传递的是数组元素的首地址，()中有两种写法。
                                //一种是&arry[0],另一种是arry

这里scanf用到的是parry++，而下面printf用到的是*parry++

arry++是地址，*arry++是值（*arry++是先*arry然后++）