对指针的初步见解（1）

1.内存和地址

1.1 内存

cpu在处理数据时，需要从内存中读取，处理后数据会放回内存中。

内存也就是存放数据的结构单元，一个结构单元大小为 1个字节。

一个比特位可以存储一个2进制的1或者0

计算机中常见的单位：

bit -  比特位                                                                      1byte  = 8bit
byte - 字节                                                                        1KB    = 1024byte
KB                                                                                    1MB   = 1024KB
MB                                                                                    1GB    = 1024MB
GB                                                                                    1TB    = 1024GB
TB                                                                                    1PB    = 1024TB
PB

每个内存单元也都有⼀个编号（这个编号就相当于房间的⻔牌号），有了这个内存单元的编号，CPU就可以快速找到⼀个内存空间。

在计算机中把内存单元的编号也称为地址，C语⾔中给地址起了新的名字叫：指针。

内存单元的编号==地址==指针

 

1.2 编址

CPU访问内存中的某个字节空间，必须知道这个字节空间在内存的什么位置，⽽因为内存中字节
很多，所以需要给内存进⾏编址.

 

---

2.指针变量和地址

2.1取地址操作符（&）

在C语⾔中创建变量其实就是向内存申请空间

#include <stdio.h>
int main()
{
    int a = 10;
    return 0;
}

上述的代码就是创建了整型变量a，内存中申请4个字节，⽤于存放整数10，其中每个字节都
有地址.

而操作符(&)----取地址操作符

#include<stdio.h>
int main()
{
    int a = 10;
    &a;//取出a的地址 
    printf("%p\n", &a);
    return 0;
}

如运行上述代码则会打印处理：006FFD70

 

 

2.2指针变量和解引⽤操作符（*）

2.2.1指针变量

通过取地址操作符(&)拿到的地址是⼀个数值以上述地址为例：006FFD70，有时需要
存储起来，则将地址值存放在指针变量中。

#include <stdio.h>
int main()
{
    int a = 10;
    int* p = &a;   //取出a的地址并存储到指针变量p中 
    
    return 0;
}

上述代码中p的类型是int*    p左边写的是int*，*是在说明p是指针变量，⽽前⾯的int是在说明p指向的内容类型是整型(int)

2.2.3解引⽤操作符

使⽤地址要找到⼀个房间，在房间⾥可以使用里面的内容。

在c语言中只要拿到了地址（指针），就可以通过地址（指针）找到地址（指针）
指向的对象，其中可以使用操作符叫解引⽤操作符  (*)

3int main()
4{
5    int a = 100;
6    int* pa = &a;
7    *pa = 0;
8    return 0;
9}

上⾯代码中就使⽤了解引⽤操作符，*pa的意思就是通过pa中存放的地址，找到指向的空间，*pa其实就是a变量了；所以*pa=0，这个操作符是把a改成了0

这⾥是把a的修改交给了pa来操作，这样对a的修改，就多了⼀种的途径。

 

2.3指针变量的大小

•32位平台下地址是32个bit位，指针变量大小是4个字节
•64位平台下地址是64个bit位，指针变量大小是8个字节
•注意指针变量的大小和类型是⽆关的，只要指针类型的变量，在相同的平台下，大小都是相同的

 

 

---

3.1指针的解引用

//代码1 
#include <stdio.h>
int main()
{
    int n = 0x11223344;
    int *pi = &n; 
    *pi = 0;   
    return 0;
}

//代码2 
#include <stdio.h>

int main()
{
    int n = 0x11223344;
    char *pc = (char *)&n;  
    *pc = 0;
    return 0;
}

通过调试代码1会将n的4个字节全部改为0，但是代码2只是将n的第⼀个字节改为0

这是因为指针的类型决定了，对指针解引⽤的时候有多⼤的权限（⼀次能操作⼏个字节）
⽐如：  char*的指针解引⽤就只能访问⼀个字节，⽽int*的指针的解引⽤就能访问四个字节

 

 

3.2指针+-整数

指针的类型决定了指针向前或者向后一步有多大。

例如：char*类型的指针变量+1跳过1个字节，int*类型的指针变量+1跳过了4个字节

 

3.3void*指针

指针类型中有⼀种特殊的类型是void*类型的，为⽆具体类型的指针（泛型指
针），可以⽤来接受任意类型地址。但是也有局限性，void*类型的指针不能直接进
⾏指针的+-整数和解引⽤的运算

 

 

---

4.const修饰指针

4.1 const修饰变量

如果把变量的地址交给⼀个指针变量，通过指针变量可以修改这个变量

#include <stdio.h>
int main()
{
    int a = 0;
    a = 20;//a是可以修改的 
    const int b = 0;
    b = 20;//b是不能被修改的 
    return 0;
}

上述代码被const修饰后的b在语法上加了限制const致使没法直接修改b

但是使⽤b的地址，去修改b就能做到了

#include <stdio.h>
int main()
{
    const int b = 0;
    printf("b = %d\n",b );
    int*p = &n;
    *p = 20;
    printf("b = %d\n", b);
 }

如果运行上述代码，可以看到这⾥的b确实修改了,这样就打破了const的限制

 

 

4.2 const修饰指针变量

const修饰指针变量的时候
• const如果放在(*)的左边，修饰的是指针指向的内容，保证指针指向的内容不能通过指针来改变。
但是指针变量本⾝的内容可变。
• const如果放在(*)的右边，修饰的是指针变量本⾝，保证了指针变量的内容不能修改，但是指针指
向的内容，可以通过指针改变。

 

 

---

5.指针运算

指针的基本运算有三种，分别是：
• 指针+-整数
• 指针-指针
• 指针的关系运算

5.1指针+-整数

因为数组在内存中是连续存放的，只要知道第⼀个元素的地址，就能找到后⾯的所有元素。

所以我们可以有以下代码

#include <stdio.h>
//指针+- 整数 
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0];
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    for(i=0; i<sz; i++)
    {
        printf("%d ", *(p+i));//p+i 这⾥就是指针+整数 
    }
    return 0;
}

5.2指针-指针

//指针-指针 
#include <stdio.h>
int my_strlen(char *s)
{
       char *p = s;
       while(*p != '\0' )
              p++;
       return p-s;
}

int main()
{
    printf("%d\n", my_strlen("abc"));
    return 0;
}

5.3指针的关系运算

//指针的关系运算 
#include <stdio.h>

int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int *p = &arr[0];
    int i = 0;
    int sz = sizeof(arr)/sizeof(arr[0]);
    while(p<arr+sz) //指针的⼤⼩⽐较 
    {
        printf("%d ", *p);
        p++;
    }
    return 0;
}

 

 

 

---

6.野指针

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的的指针）

 

1.指针未初始化

#include <stdio.h>
int main()
{        
    int *p;//局部变量指针未初始化，默认为随机值 
    *p = 20;
    return 0;
}

2.指针越界访问

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = &arr[0];
    int i = 0;
    for(i=0; i<=11; i++)
    {
        //当指针指向的范围超出数组arr的范围时，p就是野指针 
        *(p++) = i;
    }
    return 0;
}

3.指针指向的空间释放

#include <stdio.h>

int* test()
{
    int n = 100;
    return &n;
}

int main()
{
    int*p = test();
    printf("%d\n", *p);
    return 0;
}

以上代码都会导致野指针的发生

如果不知道指针应该指向哪⾥，可以给指针赋值NULL
NULL是C语⾔中定义的⼀个标识符常量，值是0，0也是地址，这个地址是⽆法使⽤的，读写该地址会报错，因而知道有代码需要调整。

1    #ifdef __cplusplus
2        #define NULL 0
3    #else
4        #define NULL ((void *)0)
5    #endif

 

 

 

---

7. assert断⾔
assert.h头⽂件定义了宏assert()，⽤于在运⾏时确保程序符合指定条件，如果不符合，就报
错终⽌运⾏。这个宏常常被称为“断⾔”

assert(p != NULL);

用于验证变量p是否等于NULL。如果确实不等于NULL，程序继续运⾏，否则就会终⽌运⾏，并且给出报错信息提⽰。

如果已经确认程序没有问题，不需要再做断⾔，就在#include <assert.h>语句的前⾯，定义⼀个宏NDEBUG。

#define NDEBUG
#include <assert.h>

重新编译程序，编译器就会禁⽤⽂件中所有的assert()语句。如果程序⼜出现问题，可以移
除这条#define NDBUG指令（或者把它注释掉），再次编译，这样就重新启⽤了assert()语
句。