指针：

java中没有指针

java运行在JYM（虚拟机）上，底层c++，在JDK上

1、为什么要指针：

地址，内存空间

解决跨区域（不同作用域  不同代码块）之间的数据交互

2、形参：传值

     实参：传址

     野指针

3、‘*’：（1）.声明/定义变量的时候，表示一个指针变量

Float b=20;

Int c=10;

      Int *a;  //定义一个指针变量 指向的内存空间只能放整数

注意：定义指针变量一定要给初值                不确定就给NULL；

          Int *a=b; 不行，指针变量只能存地址 不能存具体值

          Int *a=&b;  不行  整形指针只能存整形地址。

          Int *a=&c; 正确

    Float *d=NULL；NULL指向内存的起始地址  0x00

（2）除了定义指针变量之外 都是访问某个地址的值

Int *temp =&c;//定义指针变量1

*temp=21；访问temp地址里面的数据  赋值为21

指针变量占8个字节内存空间

4、数组和指针的关系：

数组名并不是一个变量，没有分配内存空间，指针变量有内存空间

定义一个数组，系统会分配内存空间，可以存值

定义一个指针变量，因为变量本身分配8个字节内存空间，无法存值，无法存值，未分配内存空间

如果想给指针指向的区域赋值

5、%p是打印地址的, %x是以十六进制形式打印, 完全不同！另外在64位下结果会不一样, 所以打印指针老老实实用%p .

实战

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

// *

int a = 0;

int *p = &a;

*p = 30;

//8

int num[5] =  {};

num[0] = 1;

int *p1 = num;

*(p1 + 3) = 30;

p1[2] = 2;

int *p2 = malloc(10 * sizeof(int));

p2[0] = 1;

p2[1] = 2;

p2 = realloc(p2, 2 * sizeof(int));

free(p2);

struct Person {

int a;

double age;

char d;

};

struct Person xw = {};

xw.age =20;

//打开文件

//右键 - 运行 - cmd - 终端 - 拖一个文件到终端

//win + r

//C:\Users\pxd\Desktop\abc.txt

///Users/pengxiaodong/Desktop/abc.txt

//mode 文件的操作模式

// r 只读 文件不存在就报错 从头开始读

//w  只写 文件不存在就创建 从头开始写

//a  只写 从末尾开始写

//r+  w+ a+ 可读可写

FILE *fp = fopen("/Users/pengxiaodong/Desktop/abc.txt", "r");

//写入数据

//音频  视频  图片 -> 二进制数据

//fputs("abc", fp);

struct Student{

char name[10];

int age;

};

//struct Student xw1 = {"xiaowang", 20};

//将结构体写到文件里面去

//fwrite(&xw1, sizeof(struct Student), 1, fp);

//读取数据

//char temp[20] = {};

//fgets(temp, 5, fp);

//printf("%s\n",temp);

struct Student xw1;

fread(&xw1, sizeof(struct Student), 1, fp);

printf("name: %s\n", xw1.name);

printf("age: %d\n", xw1.age);

//关闭文件

fclose(fp);

return 0;

}

我的手机 2019/8/5 8:31:04

#import 

#include 

/*

c指针：为什么要指针

地址 内存空间

解决跨区域(不同作用域  不同代码块)之间的数据交互

野指针

‘*’ ：

1.声明/定义变量的时候 表示一个指针变量

float b = 20;

int c = 10;

int *a;定义一个指针变量 指向的内存空间只能存放整数

注意：定义指针变量的时候一定要给初值 不确定就给NULL

int *a = b;不行 指针变量只能存地址 不能存具体值

int *a = &b;不行 整形指针只能存整形数据的地址

int *a = &c;正确

float *d = NULL;NULL指向内存的起始地址 0x00

2.除了定义指针变量之外 都是访问某个地址的值

int *temp = &c;//定义指针变量l

*temp = 21; 访问temp地址里面的数据 赋值为21

‘&’ 取某个变量的地址

指针变量本身在内存里面占据8个字节内存空间

*/

int test(int a){

return 0;

}

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

int a = 10;

int *pa = &a;

int a2[10] = {};

int *pa2 = a2;

int(*pFunc)(int) = test;

char c = 'a';

char *pc = &c;

printf("%lu\n",sizeof(a)); //4

printf("%lu\n",sizeof(pa));//8

printf("%lu\n",sizeof(a2));//40

printf("%lu\n",sizeof(pa2));//8

printf("%lu\n",sizeof(pFunc));//8

printf("%lu\n", sizeof(pc));//8

/*

数组和指针的关系

数组名并不是一个变量 没有分配内存空间 int a = 10;

指针变量是有内存空间

*/

int score[5] = {39,32,87,58,27};

for (int i = 0; i < 5; i++) {

printf("%d ",score[i]);

}

for (int i = 0; i < 5; i++) {

printf("%d ", *(score + i));

}

//score+1 = 0x100 + 1 * 4 = 0x104;

printf("%p\n", score); //0x7ffeefbff4d0

printf("%p\n", score+1);//0x7ffeefbff4d4

printf("%d\n", *(score+1));//32

printf("%d\n", *score+1);//40

//int score[5] = {39,32,87,58,27};

//printf("%p\n", *score++);

printf("%d\n", (*score)++);//39

printf("%d\n", score[0]);//40

printf("%d\n", ++*score);//41

//定义一个数组 系统会分配内存空间 可以存值

int num[10] = {};

//定义一个指针变量 只为变量本身分配8个字节内存空间

//无法存值，因为没有为他分配可以存值的内存空间

int *p;

//如果想给指针指向的区域赋值

//1.指针变量已经指向某块区域

int a3 = 10;

int *pA = &a3;  //指向变量a的内存地址

*pA = 30;

//2.指针指向一个数组

int num2[10] = {};

int *pNum = num2; //指向数组num2的首地址

*(pNum+0) = 20;

pNum[0] = 20;

*(pNum + 1) = 30;

pNum[1] = 30;

//3.动态分配内存 malloc realloc free

//上面两种指向的内存都是别人的

//希望分配一个属于自己的内存空间

//自己分配的内存空间必须自己释放

//普通变量的内存是系统自己分配 所以系统自己负责释放

char *pName = malloc(3 * sizeof(char));

//判断分配是否成功

if(pName == NULL){

//分配失败

exit(EXIT_FAILURE);

}

pName[0] = 'j';

pName[1] = 'a';

pName[2] = 'c';

//当之前分配的内存空间不够了 就需要在之前的基础上重新分配

//realloc 必须是之前使用malloc分配过的

//如果是系统分配的内存 是不能使用realloc的

//用完了就要自己释放内存

pName =  realloc(pName, 4*sizeof(char));

pName[3] = 'k';

printf("%s\n", pName);

free(pName);

//结构体 是一种数据类型 复合数据类型

//struct

//声明一种类型 struct Person == int

struct Person {

char name[10];

char *addr;

int age;

};

//    int i1 = 10;

//    struct Person zs = {"张三", 20};

//定义结构体struct Person变量 变量名xw

int i;

i = 20;

struct Person xw;

//xw.name = "小王";//数组一旦定义 地址不能改变

//不能直接给数组赋值

xw.name[0] = 'x';//系统为这个变量分配内存了

xw.name[1] = 'w';

//xw.addr = "西南大学";//常量字符串的地址是由系统分配的

//先为addr分配内存

xw.addr = malloc(4 * sizeof(char));

xw.addr[0] = 'S';//字符指针赋值 必须要有内存

xw.addr[1] = 'o';

xw.addr[2] = 'u';

xw.addr[3] = 't';

xw.age = 30;

printf("name:%s\n", xw.name);

printf("addr:%s\n", xw.addr);

/*

定义一个学生结构体

学号 姓名 年龄 数学成绩

从终端输入学生的信息

查询

更改

删除

增加

使用文件 数据持久化 NSUserDefaults sqlite 文件

SharedPreference sqlite 文件

将结构体写入文件

从文件了里面读取结构体

*/

return 0;

}

我的手机 2019/8/5 8:31:30

#import 

#include 

/*

c指针：为什么要指针

地址 内存空间

解决跨区域(不同作用域  不同代码块)之间的数据交互

野指针

‘*’ ：

1.声明/定义变量的时候 表示一个指针变量

float b = 20;

int c = 10;

int *a;定义一个指针变量 指向的内存空间只能存放整数

注意：定义指针变量的时候一定要给初值 不确定就给NULL

int *a = b;不行 指针变量只能存地址 不能存具体值

int *a = &b;不行 整形指针只能存整形数据的地址

int *a = &c;正确

float *d = NULL;NULL指向内存的起始地址 0x00

2.除了定义指针变量之外 都是访问某个地址的值

int *temp = &c;//定义指针变量l

*temp = 21; 访问temp地址里面的数据 赋值为21

‘&’ 取某个变量的地址

指针变量本身在内存里面占据8个字节内存空间

*/

int test(int a){

return 0;

}

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

int a = 10;

int *pa = &a;

int a2[10] = {};

int *pa2 = a2;

int(*pFunc)(int) = test;

char c = 'a';

char *pc = &c;

printf("%lu\n",sizeof(a)); //4

printf("%lu\n",sizeof(pa));//8

printf("%lu\n",sizeof(a2));//40

printf("%lu\n",sizeof(pa2));//8

printf("%lu\n",sizeof(pFunc));//8

printf("%lu\n", sizeof(pc));//8

/*

数组和指针的关系

数组名并不是一个变量 没有分配内存空间 int a = 10;

指针变量是有内存空间

*/

int score[5] = {39,32,87,58,27};

for (int i = 0; i < 5; i++) {

printf("%d ",score[i]);

}

for (int i = 0; i < 5; i++) {

printf("%d ", *(score + i));

}

//score+1 = 0x100 + 1 * 4 = 0x104;

printf("%p\n", score); //0x7ffeefbff4d0

printf("%p\n", score+1);//0x7ffeefbff4d4

printf("%d\n", *(score+1));//32

printf("%d\n", *score+1);//40

//int score[5] = {39,32,87,58,27};

//printf("%p\n", *score++);

printf("%d\n", (*score)++);//39

printf("%d\n", score[0]);//40

printf("%d\n", ++*score);//41

//定义一个数组 系统会分配内存空间 可以存值

int num[10] = {};

//定义一个指针变量 只为变量本身分配8个字节内存空间

//无法存值，因为没有为他分配可以存值的内存空间

int *p;

//如果想给指针指向的区域赋值

//1.指针变量已经指向某块区域

int a3 = 10;

int *pA = &a3;  //指向变量a的内存地址

*pA = 30;

//2.指针指向一个数组

int num2[10] = {};

int *pNum = num2; //指向数组num2的首地址

*(pNum+0) = 20;

pNum[0] = 20;

*(pNum + 1) = 30;

pNum[1] = 30;

//3.动态分配内存 malloc realloc free

//上面两种指向的内存都是别人的

//希望分配一个属于自己的内存空间

//自己分配的内存空间必须自己释放

//普通变量的内存是系统自己分配 所以系统自己负责释放

char *pName = malloc(3 * sizeof(char));

//判断分配是否成功

if(pName == NULL){

//分配失败

exit(EXIT_FAILURE);

}

pName[0] = 'j';

pName[1] = 'a';

pName[2] = 'c';

//当之前分配的内存空间不够了 就需要在之前的基础上重新分配

//realloc 必须是之前使用malloc分配过的

//如果是系统分配的内存 是不能使用realloc的

//用完了就要自己释放内存

pName =  realloc(pName, 4*sizeof(char));

pName[3] = 'k';

printf("%s\n", pName);

free(pName);

return 0;

}

感悟

愿历尽艰辛仍然值得！

、