您现在的位置是：首页 >其他 >C语言，指针详解网站首页其他

1. 指针是什么？

1. 指针是内存中一个最小单元的编号

2. 口头上的“指针”，指的是指针变量

#include<stdio.h>

int main()
{
    int a=10;
    int * pa=&a;// pa 是一个指针变量,用来存放 a 的地址
    //int ——> pa 所指向对象的类型
    //* 代表 pa是个指针变量
    
    return 0;
}

3. 编址

4. 指针变量大小

//32位机器上，地址是32个0/1组成的二进制序列，地址要用4个字节的空间来储存


//指针在32位平台上，占4个字节
//在64位平台上，占8个字节

2. 指针和指针类型

1. 内存中的信息

2. 指针类型的意义

2.1[

//指针的类型，决定了指针解引用时，访问多少个字节 —— 指针的访问权限

//short* ——> 2
//int* ——> 4
//float* ——> 4
//double* ——> 8
//...

#include<stdio.h>

int main()
{
    int a=0x11223344;
    //在内存中开辟四个字节的空间；
    //放入44 33 22 11
    //"44" 所占空间的地址 就是 a 的地址
    char* pa=&a;
    *pa=0;
    //将 44 33 22 11 ——> 00 33 22 11
    return 0;
}

2.2

//指针的类型决定了 指针+1 操作时的步长
//
//char* 类型的指针 +1时，跳过 1  个字节
//int* 类型的指针 +1时，跳过 4 个字节
//

//type* p ,p +/- n
//跳过 n* sizeof(type) 个字节

3. 野指针

3.1

1. 指针未初始化

#include<stdio.h>

int main()
{
    int* pa;
    *pa=10;
    //局部变量指针未初始化，为随机值
    return 0;
}

2. 指针越界访问

#include<stdio.h>

int main()
{
    int arr[10]={0};
    for(int i=0;i<11;i++)
    {
        *(p++)=i;
        //i=10,指针的指向超出了数组范围 ，此时为野指针
    }
    return 0;
}

3. 指针所指向的空间释放

#include<stdio.h>

int* test()
{
    int a=10;
    return &a;
}

int main()
{
    int* p=test();
    printf("%d
",*p);
    //出test()后，a所在空间还给操作系统了
    //此时 p 为野指针
    return 0; 
}

3.2 规避野指针

1. 指针初始化

#include<stdio.h>

int main()
{
    int a=0;
    int* pa=&a;
    
    int* pc=NULL;//如果不知道指针初始化为何值，暂时初始化为 NULL
    return 0;
}

2. 指针指向的空间释放，及时置 NULL

#include<stdio.h>

int* test()
{
    int a=10;
    return &a;
}

int main()
{
    //避免返回局部变量的地址
    int* p=test();
    
	p=NULL;    
    return 0; 
}

3. 指针使用之前检查有效性

#include<stdio.h>

int main()
{
    int a=10;
    int* pa=&a;
    
    int* ptr=NULL;
    
    if(ptr != NULL)
    {
    	//使用ptr    
	}
    return 0;
}

4. 指针运算

1. 指针加减整数

//利用指针访问数组中的元素
//1

#include<stdio.h>

int main()
{
    int arr[10]={0};
    int* p=arr;
    
    for(int i=0;i<10;i++)
    {
        *p=i;
        p++;
        //指针不断向后移
    }
    return 0;
}

注意：

//2
#include<stdio.h>

int main()
{
    int arr[10]={0};
    int* p=arr;

    for(int i=0;i<10;i++)
    {
        *(p+i)=i;
        //指针不移动，利用i++ 对数组中的元素进行访问
	}
    return 0;
}

补充：

" int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };"

arr ——> 数组名 ——> 首元素地址

#include<stdio.h>

int main()
{
    int arr[10]={0,1,2,3,4,5,6,7,8,9};
    int* p=arr;
    for(int i=0;i<10;i++)
        printf("%d ",p[i]);
	return 0;
}

" arr[i] == *(arr + i) == *(i + arr) == i[arr] "

//[] ——> 操作符 arr[i] == i[arr]
// + ——> 操作符 a+b == b+a

2. 指针减指针

#include<stdio.h>

int main()
{
    int arr[10]={0};
    printf("%d
",&arr[9]-&arr[0]);
    return 0;
}

//&arr[9] ——> arr+9
//&arr[0] ——> arr

//结论:

//1. 指针 - 指针 得到数值的绝对值，是指针与指针之间的元素个数
//2. 指针 - 指针 运算的前提条件是：指针和指针指向了同一块空间

补充：

//my_strlen() 的多种实现方式

#include<stdio.h>

int my_strlen(char ch[])
{
    int len=0;
    while(*ch)
    {
        len++;
        ch++;
    }
    return len;
}

#include<stdio.h>

int my_strlen(char ch[])
{
    int i=0;
    while(*(ch+i))
    {
        i++;
    }
    return i;
}

#include<stdio.h>

int my_strlen(char ch[])
{
    char* start=ch;
    while(*ch)
    {
        //判断 *ch！='', ch++
        ch++;
	}
    return ch-start;
}

//err
//while(*ch++)

3. 指针关系运算

//指针是有大小的
//指针关系运算就是比较指针大小

#include<stdio.h>

int main()
{
    int arr[5]={0};
    for(int* p=arr;p<&arr[5];)
        *p++=1;
    
    for(int i=0;i<5;i++)
        printf("%d ",arr[i]);
    return 0;
}

C语言标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置进行比较；

但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

5. 指针和数组

1. 指针和数组的联系

//数组中，数组名是数组首元素地址
//数组是连续存放的

//当我们知道数组首元素地址时，可以通过指针访问数组

6. 二级指针

//可以通过修改 **ppa ——> 修改 a 

7. 指针数组

1. 指针数组 ——> 用来存放指针的数组

#include<stdio.h>

int main()
{
    int arr1[]={1,2,3,4,5};
    int arr2[]={2,3,4,5,6};
    int arr3[]={3,4,5,6,7};
    
    int* parr[]={arr1,arr2,arr3};
    return 0;
}

//parr[] 就是一个指针数组

通过指针数组 打印字符串

2. 指针数组模拟二维数组

真实的二维数组是连续的