C语言（一级指针）

指针

本质：

地址

一级指针

一级指针变量名：存储普通变量的地址

格式：

存储类型         数据类型         *指针变量名

                                int                 *p

int a=5;

int *p=&a;

--------------------------------------------------

char b='q';

char *p1=&b;

访问：

int a=5;

int *p=&a;

printf("%d %d\n",a,*p);

printf("%p %p\n",p,&a);

指针操作符

*：取地址里边的内容

&：取地址符:取变量的地址

int a=5; int *p=&a;

*&（变量）a==（变量）a； *&（地址）p==（地址）p； （*&一起出现会抵消，从右向左）

&*a：错误 &*（地址）p==（地址）p；

初始化

指针在使用前要先定义，同时初始化，未初始化的指针变量不能随便使用，会产生野指针

1）int a=5;

int *p=&a; //定义指针的同时，直接初始化

2）int *p=NULL; //先定义一个空指针，后边可以重新赋值

指针p指向变量a,*p可以访问到a的值，

可以通过*p间接修改变量a的值

把数组的首地址赋值给指针变量

int a[5]={2,3,4,5,6};

int *p=a;

--------------------------------------------------------

// int a[5]={2,3,4,5,6};

// int *p=a; === *p==2

char c[]="hello";

char *p=c; === *p=='h'

printf("%c\n",*p);

一维数组：数组名也是数组的首地址，是地址常量，不能为左值(=左边)，不能被重新赋值。

指针运算

算术运算

int a[5]={2,13,4,5,6};

// char a[]="hello";

int *p=a;

printf("%p\n",p);

printf("%d\n",*p);

p++;//p=p+1 //指针向高地址方向移动一个数据单位(int 4字节；char 1字节)，指针的指向发生改变

printf("%p\n",p);

printf("%d\n",*p);

int a[5]={2,13,4,5,6};

// char a[]="hello";

int *p=a;

printf("%p\n",p);

printf("%p\n",p+2); //指针访问高地址方向第n个元素，指针的指向不发生改变

printf("%p\n",p);

p++ //指针向高地址方向移动一个数据单位(int 4字节；char 1字节)，指针的指向发生改变

p+2 //指针访问高地址方向第n个元素，指针的指向不发生改变

验证：同一个数组，两个地址之间的差值=相差元素个数

int a[5]={2,13,4,5,6};

int *p=&a[2];

int *q=a;

printf("%d\n",p-q);

………………………………………………………………

printf("%p\n",5); //0x5 %p打印是十六进制格式，会把数字5转成十六进制格式

int m = 100;

double n = 200;

int *p=NULL;

double *q=NULL;

p= &m;

q = &n;

printf(“m=%d &m=%p\n”, m, &m);

printf(“p=%p p+2=%p\n”, p, p+2);

printf(“n=%lf &n=%p\n”, n, &n);

printf(“q=%p q+2=%p\n”, q, q+2);

关系运算

< > ==

同一个数组下比较，才有意义

高地址>低地址

指针的大小

int a=3;

int *p1=&a;

printf("%d\n",sizeof(p1));

char b='q';

char *p2=&b;

printf("%d\n",sizeof(p2));

getconf LONG_BIT 查看操作系统位数

32位操作系统 ，指针大小为4字节 1字节==8位

8位16进制 4*8=32位二进制 =4字节

64位操作系统 ，指针大小为8字节

字符串倒序输出，用指针hello--->olleh

#include<stdio.h>

#include<string.h>

int main(int argc, char const *argv[])

{

char a[]="hello",temp;

char *p=a;

char *q=p+strlen(a)-1;

while(p<q)

{

temp=*p;

*p=*q;

*q=temp;

p++;

q--;

}

puts(a);

return 0;

}

循环输入一个五位数，判断是否是回文数，当输入0时结束。12321

char *p=a;

char *q=p+strlen(a)-1;

int test=1;

while(p<q)

{

if(*p!=*q)

test=0;

p++;

q--;

}

if(test==1)

printf("yes\n");

else

printf("no");

指针修饰

const void

const 常量化 read-only（只读）

修饰普通变量,不能直接通过变量名进行修改

const int a=5; //int const a=5;

a+=6; //error

通过指针修改

const int a=5;

int *p=&a;

*p=88;

printf("%d %d\n",a,*p);

修饰指针

int const *p; （const int *p）//const修饰*p指针指向的内容不能修改；但是指针的指向可以修改

int a=5;

const int *p=&a;

1）*p=33; //error

2)int b=33;

p=&b; //正确

修饰p

int * const p=&a; //const修饰p指针的指向不能改，指针指向的内容可以改

int a=5;

int * const p=&a;

// p=&b;

*p=33;

printf("%d %d\n",a,*p);

既修饰指针也修饰p

const int * const p； //const修饰p指针的指向和指针指向的内容都不能改

指针修饰

void 不能修饰普通变量，修饰指针表示任意类型的指针.

void a;//错误

void *p;//任意类型的指针

一般在函数参数或函数返回值中用到

void *p;//任意类型的指针

强转成int类型指针(int *)p

取内容*(int *)p

void *p=NULL;

int a=5;

p=&a;

printf("%p %p\n",(int *)p,&a); //强转只在当前一行有效

printf("%d %d\n",*(int *)p,a);

void *p=NULL;

---------------------------------------------------

int a=5;

int *q=(int *)p;

q=&a;

printf("%p %p\n",q,&a);

printf("%d %d\n",*q,a);

大小端

大端：低地址里边存放高字节数据，高地址里边存放低字节数据

小端：低地址里边存放低字节数据，高地址里边存放高字节数据

0x12345678

大端：0x12 0x34 0x56 0x78

小端：0x78 0x56 0x34 0x12

int a=0x12345678;

char b;

b=(char)a;

printf("%#x\n",b);//0x78

电脑：小端存储