#include <stdio.h>

int main() {

int* p;//p是变量的名字，int*表示变量p存放的是int类型变量的地址

//int* 是p的数据类型，p是变量的名字。所谓的int*类型，就是可以存放int类型变量的地址的变量的类型

int i = 3;

/*

  i是整型int类型的变量，可以把变量i的地址放到变量p里

  &i表示i的地址，&是取址符，表示获取一个变量的地址

 */

p = &i;//把int类型的变量放到int*类型中

/*

  类似的，double* p只能存放double类型的变量的地址，

  而不能存放int类型的变量的地址

 */

 /*

   关于对p=&i的理解：

   p存放了i的地址，所以根据p可以知道i的位置，进而找到i。

   所以说，p指向i。

   p不是i，i也不是p；修改i的值不会改变p的值，修改p的值也不会影响i的值

   举个例子：[小明]（指针变量p）手里拿了一张写了[小红家庭地址]（变量）的[纸条]（指针变量p存储的i地址&i），

   小红的家庭发生任意改变，比如小红家新买了一辆汽车、丢了一袋垃圾，小明手中的纸条都不会发生改变

   （变量i的值发生任意改变，+1或者-1，都不会影响指针变量p里存放的值）

   小明在手里原本写着小红家庭地址的纸条上进行任意修改，小红的家的位置也不会发生任何变化

   （原本存放变量i的地址的指针变量p的值发生任意变化也不会影响变量i的值）

  */

  /*

int* p;int i;

p和i都是变量，p是能存放其他类型的变量的地址的指针变量，i是只能存放其相应类型的值的普通的整型变量。

指针和地址是一个概念，指针变量也可以叫做地址变量

指针变量p存放了变量i的地址---指针变量p指向了变量i

   */

printf("%d", *p == i);//1-->说明*p和i的值是一样的

/*

  如果一个指针指向了某个变量，则：

  *指针变量<---等价于--->普通变量

  如：

  如果p是指针变量，p存放了普通变量i的地址，则p指向i

  *p<---等价于--->i

  *p和i可以彼此之间相互替换使用

 */

 /*

  *p表示的是以p的内容为地址的变量

  */

return 0;

}

两个指针相减的结果是一个整数值，表示两个指针之间相隔的元素个数或者内存单元的数目。

在数组中，如果两个指针指向同一个数组的元素，那么它们相减的结果就是它们之间相隔的元素个数。这个结果是一个整数，表示两个指针之间有多少个元素。例如，如果一个指针指向数组的第i个元素，另一个指针指向数组的第j个元素，那么它们的差值就是j-i，表示它们之间相隔的元素个数。

同样地，在内存中，如果两个指针指向不同的内存单元，那么它们相减的结果就是它们之间相隔的内存单元数目。这个结果是一个整数，表示两个指针之间有多少个内存单元。例如，如果一个指针指向内存地址A，另一个指针指向内存地址B，那么它们的差值就是B-A，表示它们之间相隔的内存单元数目。

需要注意的是，两个指针相减的结果是一个整数值，而不是地址量。这个整数值表示两个指针之间相隔的数据个数，而不是它们的内存地址差值。因此，在计算两个指针相减的结果时，应该将它们的地址值进行整数相减，而不是将它们的内存地址直接相减。

总之，两个指针相减的结果是一个整数值，表示两个指针之间相隔的元素个数或者内存单元的数目。这个结果是根据指针所指向的数据类型和内存布局来确定的。通过计算指针之间的差值，程序员可以方便地进行数组遍历、内存管理和其他相关操作。

指针与整数的加减表示指针在内存空间中向下或向上移动整数个单位。这个单位的大小取决于指针所指变量的类型。例如，如果是指向short型变量的指针，那么每次移动2个字节；如果是指向double型变量的指针，那么每次移动8个字节。当指针变量增加1时，其增加的值等于指向的类型占用的内存字节数。

指针与整数的加减运算在数组中位置的移动和内存地址的偏移中有实际应用。例如，通过将指针变量增加1，可以使其指向下一个数组元素，从而实现数组的遍历。同样地，通过指针与整数的加减运算，可以方便地访问和操作内存中的不同位置，实现动态内存分配、函数参数传递和数据结构实现等功能。

需要注意的是，指针与整数的加减运算是有单位的，以它所指向数据类型的字节数为单位进行加减。在C语言中，指针加法是以所指向数据类型的大小为单位的，例如int类型的指针加1就意味着偏移4个字节（假设int类型占用4个字节）。

总之，指针与整数的加减运算表示指针在内存空间中的移动。这种运算在数组索引、指针移动和内存访问等操作中具有重要意义，使程序员能够灵活地操作内存和数据结构，实现高效的数据处理和内存管理。

#include <stdio.h>

int main(){
    int* p;
    int i=5;
    *p=i;
    printf("%d",*p);
    return 0;
}

#include <stdio.h>

int main() {

int i = 5;

int* p;

int* q;

p = &i;

//*q=p;

/*

  错误：*q是int类型的变量，p是int*类型的变量，类型不一样，不能进行赋值

 */

 //*q=*p;

 /*

   错误：*q没有进行定义就给他赋值

  */

  //p=q;

  /*

错误：q没定义，q变量存储的是int*类型的数据，但是是不确定的、随机的、垃圾值

把q存储的垃圾值赋值给p，p存储的东西也变成了垃圾值

   */

return 0;

}

#include <stdio.h>

void jiaohuan(int a,int b){
    int t=a;
    a=b;
    b=t;
}
int main(){
    int a=3;
    int b=5;
    jiaohuan(a,b);
    printf("%d,%d",a,b);//3,5
    return 0;
}

#include <stdio.h>

void jiaohuan(int* p,int* q){
    int * t=p;
    p=q;
    q=t;
}
int main(){
    int a=3;
    int b=5;
    jiaohuan(&a,&b);
    printf("%d,%d",a,b);//3,5
    return 0;
}

#include <stdio.h>

void jiaohuan(int* p,int* q){
    int  t=*p;
    *p=*q;
    *q=t;
}
int main(){
    int a=3;
    int b=5;
    jiaohuan(&a,&b);
    printf("%d,%d",a,b);//5,3
    return 0;
}

int* p;

*p = a;

#include <stdio.h>

void f(int* p,int* q){
    *p=1;
    *q=2;
}
int main(){
    int a=3;
    int b=5;
    f(&a,&b);
    printf("%d,%d",a,b);//1,2
    return 0;
}

#include <stdio.h>

int main(){
    int a[5];
    printf("%#x\n",&a[0]);
    printf("%#x\n",a);
    return 0;
}

#include <stdio.h>

void f(int *pArr,int len){
    for(int i=0;i<len;i++){
        printf("%d ",*(pArr+i));
    }
}
int main(){
    int a[5]={1,2,3,4,5};
    f(a,5);
    return 0;
}

#include <stdio.h>

void f(int *pArr,int len){
    pArr[3]=999;
}
int main(){
    int a[5]={1,2,3,4,5};
    f(a,5);
    printf("%d",a[3]);//999
    return 0;
}

#include <stdio.h>

int main(){
    char ch='a';
    int w=1;
    double d=1.2;
    
    char* p=&ch;
    int* q=&w;
    double* r=&d;
    
    printf("%d\n",sizeof(p));//8
    printf("%d\n",sizeof(q));//8
    printf("%d\n",sizeof(r));//8
    
    return 0;
}

#include <stdio.h>

#include <malloc.h>//使用malloc函数需要这个头文件

int main() {

int i = 5;//分配了4个字节 静态分配

int* p = (int*)malloc(4);

/*

* 对于这句代码，有以下理解：

1、malloc函数只有一个形参，这个形参是整型

2、malloc（4）是请求系统分配4个字节的内存，

这个函数会返回系统所分配的内存的起始地址。

malloc（4）会返回系统分配的这4个字节的第一个字节的地址

3、(int*)malloc(4) 强制类型转换，将 malloc 返回的 void* 类型转换为 int* 类型。

malloc函数会返回一个 void* 类型的指针[地址]，这个指针指向分配的内存的起始地址。

由于 void* 是一个泛型指针类型，它不包含任何关于所指向数据类型的信息，因此在使用前需要进行类型转换。

在 (int*)malloc(4) 中，将 malloc 返回的 void* 指针转换为 int* 类型。

这意味着我们告诉编译器，我们希望这块内存能够存储整数类型的变量。

4、int* p 定义了一个名为 p 的指针变量，所以p用于存放int类型的数据的地址[指针]

5、最后p指向了4个字节，但本质上p里面只保存了这4个字节中的第一个字节的地址。

这4个字节在用的时候是作为一个整体来用的

6、int* p = (int*)malloc(4);

一共分配了12个字节：其中系统为指针变量p分配了8个字节（64位系统）

还分配了4个字节的空间，这4个字节被p指向（本质上p指向的是这4个字节的第一个字节的地址）

其中，p本身的8个字节是静态分配的，p指向的4个字节是动态分配的

7、p本身的8个字节p具有拥有权，而他指向的4个字节只具有使用权

8、*p不是变量，是表达式。但是*p可以作为变量来使用。*p所指向的内存是通过动态分配的

如果int a=*p; 则可以使用变量a代替表达式*p来使用

*/

free(p);

//表示把p所指向的内存给释放掉而不会把p本身所占用的内存释放，所谓释放内存，就是系统收回这段内存的使用权，而不会清空这块内存中的数据。被释放后，整个程序都失去了对这段内存的使用权而不仅仅是某个变量

return 0;

}

#include <stdio.h>

#include <malloc.h>//使用malloc函数需要这个头文件

void f(int* q) {

*q = 200;

//free(q);

}

int main() {

int* p = (int*)malloc(sizeof(int));

*p = 10;

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

f(p);

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

return 0;

}

#include <stdio.h>

#include <malloc.h>//使用malloc函数需要这个头文件

int main() {

int a[5];//int占4个字节，则本数组总共包含20个字节，每4个字节被当做一个int变量来使用

//把系统所分配的20个字节的前4个字节当做a[0]来使用，第5~8个字节当做a[1]来使用……

//只有所在的函数终止的时候这20个字节才会被释放

int len;

printf("请输入要创建的数组长度：\n");

scanf("%d", &len);

int* p = (int*)malloc(sizeof(int) * len);

//在使用上，和静态数组的使用是一样的，相当于int p[len]，只是静态定义的数组不能用len这个变量

/*

这句代码分配了20个字节的内存，p指向了因为是强转成了int*类型，

所以p表示前4个字节，p+1表示第5~8个字节，p+2表示第9~12个字节……

*p等价于p[0],*(p+1)等价于p[1]，*(p+2)等价于p[2]……

类似的，对于静态定义的数组，也可以有这样的写法

*/

return 0;

}