3.指针与指针类型入门

入门

#include<stdio.h>
int main(){
     // 指针其实就是代表一个地址

     // 指针
     int i=4;  // 定义了一个变量 变量的名字叫i 变量的类型是int类型
     int* p = &i;//就是取i的指针(内存地址)

     // 指针变量
     int* p; // 定义了一个变量 变量的名字叫p p的类型是一个int* 的类型
     //int* 类型是一个指针变量
     //int*的类型就是一个存放地址的类型  只能存放int类型数据的地址
     //& 符号 取地址的符号
     p =  &i;  // &i就是取i的指针(内存地址) ,取出i的地址之后 把他放到p变量里面存起来.

     printf("i变量在内存中的地址为 %#x\n", p);

     //*号操作符
     // 我们可以使用*号操作符 去操作某个内存地址里面的数据

     //*p  使用 p变量里面存放的地址 所指向的值
     printf("*p的值就是 %d\n",*p);
     *p = 888;
     //*p跟 i是同一个变量么? 指向同一块内存空间,改变*p的值i的值也会跟着改变
     printf("i的值就是 %d\n",i);
     // 更改i的值 会更改p的值么 ? 不会,但*p的值会跟着改变
     i = 999;
     printf("*p的值就是 %d\n",*p);
     printf("i变量在内存中的地址为 %#x\n", p);
     system("pause");
}

应用

#include<stdio.h>

/**
如果想在子函数中修改主函数变量的值 
1.在主函数中使用&号操作符获取要修改内容的地址
2.把地址传递给子函数，子函数使用 type* 指针变量接收地址
3.子函数中使用*号操作符修改地址所指向的变量的值
**/
√
void swap2(int* p, int* q){
     int temp;
     temp = *p;
     *p=*q;
     *q = temp;
}

X
void swap(int i, int j){  
    int temp ;
    temp = i;
    i = j;
    j = temp;
}

int main(){
    int i = 3;
    int j = 5;
    // swap(i,j);
    swap2(&i,&j);
    printf("i=%d\n",i);
    printf("j=%d\n",j);
    system("pause");   
}

需要注意的点

1. 未经过初始化的指针变量 不能被使用 。
2. 指针类型需要根据不同的变量类型 定义不同的指针类型, 不同的指针类型不能相互转化。
3. 不能使用指针去访问已经失去作用范围的变量,下面的例子就可以说明这一点。


#include<stdio.h>
void f(int** p){
     int i =5; 
     printf("f() - i 的地址为 %#x\n", &i); //与main函数打印的地址相同
     *p = &i; // 把i的地址设置给p变量   
} 


int main(){
    int* p; // 是用来存放f() 中 i的地址的  
    f(&p);  //把p变量的地址 传递给子函数  
    printf("main - i 的地址为 %#x\n", p); //与f()函数打印的地址相同
    printf("i的值=%d\n",*p); //打印的值是-1
    system("pause");   
}

*号的三种含义

1.乘法3 * 5；
2.定义指针变量int* p:定义了一个变量名为p的变量，只能够存放int数据类型的地址。
3.指针运算符，如果p是一个已经定义好的指针变量则*p表示使用p中存放的地址所指向的值。

其他

1.C语言的数据访问不检查下标。
int arr[2] = {0,1};
printf("arr[8]=%d\n",arr[8]); 
打印出来的是一个随机值，这是C语言中的缓冲区越界的问题，代码中的这些漏洞可能会被病毒利用，经典案例：MS06-040

2.数组中元素的值与地址
#include<stdio.h>
void printArr(int* arr, int len){
     int i=0;
     for(;i<len;i++){ 
        //printf("arr[%d]=%d\n", i, arr[i]); 
        printf("arr[%d]=%d\n", i, *(arr+i)); 
       //arr[i]等价于*(arr+i)
     }
}
int main(){
       // java 定义一个数组  byte arr[],  byte[] arr  
       // c语言定义一个数组 int a[4]; 
    
       int a[8]={1,2,3,4}; 
       //a[0]和 *a 其实是同一个东西，数组名就是数组的首地址，也就是数组第一个元素的地址   
       printf("数组的名字a=%#x\n",a); 
       printf("数组的第一个元素的地址%#x\n",&a[0]); 
       //打印数组中的元素
       printArr(a,8);  
       system("pause");   
}

3.指针在内存中存在几个字节
#include<stdio.h>
int main(){
           int* p1 ; 
           double* p2;
           char* p3;
           long* p4;
           short* p5;
           // sizeof();
          
           printf("int 指针的长度为%d\n",sizeof(p1));
           printf("double 指针的长度为%d\n",sizeof(p2));
           printf("char 指针的长度为%d\n",sizeof(p3));
           printf("long 指针的长度为%d\n",sizeof(p4));
           printf("short 指针的长度为%d\n",sizeof(p5)); 
           system("pause");   
}

//打印结果都是4个字节，所有指针(地址)在内存中都占用4个字节的空间