指针

常量指针与指针常量

int x=10086;

const int*p =&x;
/*
常量指针 (指向常量的指针)
const修饰值,值变成了常量,const常量能不能改的问题别问我!
*/
p=100;
*p=100;    //这里会出错,值不可改变,测试时记得删除这行
printf("%d\n",p);
printf("%d\n",&x);
//在这里,地址可以改变,但指的是p的地址(p原先保存的是x的地址),而x的地址是不能变的

int x=10086;
int * const p=&x;
/*
指针常量
const修饰地址,地址变成了常量
*/
p=100;  //这里会出错,地址不可以改变
*p=100;
printf("%d\n",*p);
printf("%d\n",x);
//在这里,指针p所保存的地址不能改变,而值(x内存段保存的数据)可以改变,*p和x的输出一样

*个人癖好:常量指针与指针常量的区分看开头,若int 在前就是指针常量,反之则为常量指针

int x=10086;
const int* const p=&x;
//const地址和值都修饰了,都不能改

一个小问题:程序运行结果输出的数是多少?

int x=10086;	//int类型的数据占据4个字节
//10086在内存保存上形式为:
//0000 0000   0000 0000   0010 0111   0110 0110
//	   0           0 	  	  39	       102
char*p =(char *)&x;     //指定的空间大小不同  (某类型 *)这个东西是强制转换
*p=100;
printf("%d\n",x);
//这里输出结果为10084,因为char类型就一个字节,所以指定的空间只有8位,刚好与原来的那个8位小2
//为什么不是100?因为你输出的是x呀!他有4个字节,0010 0111还在呢
//想看100?输出那个只有一个字节的空间就可以嘛
printf("%d\n",*p);
//这里输出的就是100,char目光短浅只有一个字节

printf("%#X\n",p);
printf("%#X\n",&x);
//地址没动过,还是一样滴

一个小问题:我们怎么通过指针设置x的符号为负号?

int x=10086;
//0000 0000   0000 0000   0010 0111   0110 0110
//1 将第一位改成1即为负数(原反补码)
char *p=(char *)&x;				//可以不用到(char *)强制转换,但是空间,而
								//且指针效果不同
//1000 0000等于128
*(p+3)=128;	//用*p+3也是可以的
printf("%d\n",x);  

指针与数组的关系

一个变量有地址,一个数组包含若干个元素,每个元素在内存中皆有地址.

int array[5]={1,2,3,4,5}; 
int *p=array;	//第一种写法,用数组名
				//数组名的变量名就是数组的首地址
				//所以int *p=&array;这个写法是错误的,记住上面的话,不要用&!!!
int *p1=&array[0]; //第二种写法,用数组第一个元素
					//因为是元素,就和int x这种差不多,所以得用&!!!
					//与第一种所表达的是一样的,都是变量的首地址

printf("%d\n",array);
printf("%d\n",&array[0]);  //别忘记&符号,不然访问的就是值了,而不是地址
printf("%d\n",p);
printf("%d\n",p1);			//还有一点,其实用%#x比较好一点,毕竟地址都是16进制



//这里提一个问题:怎么只用p弄出array[1]元素的地址和值?

printf("%#x\n",&array[1]);
printf("%#x\n",p+1); 
//为什么是p+1?因为指针有点类似数组的 下标
//同时我们发现array[0]与array[1]的地址'相差4',其实数组元素内存空间地址上就是呆一块
//而为什么相差的不是1而是4,单纯因为int是4个字节

printf("%d\n",array[1]);
printf("%d\n",*p+1);
printf("%d\n",*(p+1)); //这和上面是一样的,都是下标嘛,p+1后再配*号,不就
						//是解引用去解array[1]嘛,而上面直接就是*p后右一位
						//,直接为解引用array[1]

恶搞程序__关机

//已知: shutdowwn -s -t 0 这个就是关机指令(-t就是时间在0秒后)
//附带: shutdown -p 强制关机(直接关机)
char s[]="tivuepxo!.t!.u!1";
char *p=s;
for(int i=0;i<strlen(s);i++)
{
    printf("%c",s[i]-1);    //这里的-1是作用在ascii码上,这里主要是为体现下面的代码作用
}							//测试时记得删除
while(*p!=NULL)
{
    *p=*p-1;
    p=p+1;  //指针往右移动一位,
}
//上面的while函数与下面的一样,写法不同
//while(*p)(*p++)--;

 system(s);    //点晶之笔;

指针运算

指针运算不是简单的整数加减法,而是指针指向的数据类型在内存中介占用字节数作为倍数的运算

char *p;
p++;		//移动了sizeof(char)这么的多字节数

int *p1;
p1++;		//移动了sizeof(int)这么多的字节数

通过指针使用数组元素

p+1代表&a[1]地址,也可以直接使用p[1]表示a[1]元素

p+5代表&a[5]地址

p++代表*p往右(后)移动一位

int array[10]={1,2,3,4,5,6,7,8,9,10};
double *p=(double *)array;  //这里可以不用(double *)强制转换
							//但最好还是要用,因为不同的数据类型占据的空间大小不一样
							//所用指针操作的效果也就不同,而缩小了空间
for(int i=0;i<5;i++)
{
    printf("%d\n",p[i]);
}
//输出结果为1 3 5 7 9
//利用doble*,指针的步长是8字节,一次跳动8个字节,而int是4字节,所以每次变
//化移动的是8字节,俩个元素

数组指针与指针数组

int array[3][5]={{1,2,3,4,5},
                 {6,7,8,9,10},
                 {11,12,13,14,15}};
int (*a)[5]=array; //数组指针(行指针)
//数组指针
//记住这个格式括号()是必带的
//数组指针就是指针 
printf("%#x\n",array);
printf("%#x\n",&array[0][0]);
printf("%#x\n",*a);
printf("%#x\n", (*a));
//上面输出全是地址




//接下来是利用数组指针来访问数组中的元素
printf("%d\n", *a[0]);
printf("%d\n", *a[1]);
printf("%d\n", *a[2]);
//输出显示为: 1 6 7

int (*b)[3][5]=array;
for(int i=0;i<3;i++)
{
    for(int j=0;j<5;j++)
    {
        printf("%d\t",(*b)[i][j]); 注意千千万万不用写成*b[i][j],数字会出错,写法错误
	}
    printf("\n");
}


总结:写数组指针,那就乖乖的写上括号!!!!没有[数字]就算带*号也只是个地址!!!!

指向二维数组的指针

int array[5]={1,2,3,4,5};
int array1[6]={1,2,3,4,5,6};
int sum=1;

int x[5]; //数组名是x  [5]表示我的x数组能够帮助我们存储5个int类型的数组
int (*x1)[5];//数组名是x1  [5]表示我的x1数组能够帮助我们存储5个int*类型的数据

int *p[5];//指针数组 指针指向的数组     (这个指针数组,所存储的指针有5个)
p[0]=array;		//第一个存储的指针是数组指针
p[1]=array1;	//第二个存储的指针也是数组指针
p[2]=∑		//第三个存储的指针是int类型的指针
for(int i=0;i<5;i++)
{
    printf("%d\t",p[0][i]);
}
printf("\n");
for(int i=0;i<6;i++)
{
    printf("%d\t",p[1][i]);
}
printf("\n");
printf("%d\n",*p[2]);