C语言中指针的定义与使用

指针也就是内存地址，指针变量是用来存放内存地址的变量，不同类型的指针变量所占用的存储单元长度是相同的，而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作。

计算机中所有的数据都必须放在内存中，不同类型的数据占用的字节数不一样，例如 int 占用 4 个字节，char 占用 1 个字节。为了正确地访问这些数据，必须为每个字节都编上号码，就像门牌号、身份证号一样，每个字节的编号是唯一的，根据编号可以准确地找到某个字节。

在计算机中, 所有的数据都是存放在存储器中的, 不同的数据类型占有的内存空间的大小各不相同。内存是以字节为单位的连续编址空间, 每一个字节单元对应着一个唯一的编号, 这个编号被称为内存单元的地址。比如: int类型占两个字节, char类型占1个字节等。内存为变量分配存储空间的首个字节单元的地址, 称之为该变量的地址。地址用来标识每一个存储单元, 方便用户对存储单元中的数据进行正确的访问。在高级语言中地址形象地称为指针， CPU 访问内存时需要的是地址，而不是变量名和函数名！变量名和函数名只是地址的一种助记符，当源文件被编译和链接成可执行程序后，它们都会被替换成地址。编译和链接过程的一项重要任务就是找到这些名称所对应的地址。

需要注意的是 变量名和函数名为我们提供了方便，让我们在编写代码的过程中可以使用易于阅读和理解的英文字符串，不用直接面对二进制地址，那场景简直让人崩溃。虽然变量名、函数名、字符串名和数组名在本质上是一样的，它们都是地址的助记符，但在编写代码的过程中，我们认为变量名表示的是数据本身，而函数名、字符串名和数组名表示的是代码块或数据块的首地址。

指针相对于一个内存单元来说，指的是单元的地址，该单元的内容里面存放的是数据。在C语言中，允许用指针变量来存放指针，因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。

指针的定义与使用

变量的指针与指针变量：

在C语言中，允许用一个变量来存放指针，这种变量称为指针变量。指针变量的值就是某份数据的地址，这样的一份数据可以是数组、字符串、函数，也可以是另外的一个普通变量或指针变量

变量的指针就是变量的存储地址，指针变量就是存储指针的变量。指针变量是存放一个变量地址的变量，不同于其他类型变量，它是专门用来存放内存地址的，也称为地址变量。定义指针变量的一般形式为：类型说明符 * 变量名 *

类型说明符表示指针变量所指向变量的数据类型；* 表示这是一个指针变量；变量名表示定义的指针变量名，其值是一个地址，例如：char * p1;表示p1是一个指针变量，它的值是某个字符变量的地址

//定义指针变量与定义普通变量非常类似，不过要在变量名前面加星号*，格式为：
int *fp;//*表示这是一个指针变量，fp是一个指向int数据类型的指针
float *a,*b; //表示a和b都是指针变量，都指向一个为float数据类型的指针

指针变量的使用：

取地址运算符&：单目运算符&是用来取操作对象的地址。

例：&i 为取变量 i 的地址。对于常量表达式、寄存器变量不能取地址（因为它们存储在存储器中，没有地址）。

指针运算符 * （间接寻址符）：与&为逆运算，作用是通过操作对象的地址，获取存储的内容。

例：x = &i x 为 i 的地址，*x 则为通过 i 的地址，获取 i 的内容。

//赋值
int a = 100;//定义了一个a的整形变量
int *p_a = &a;//将一个int类型的指针p_a，p_a指向了a（也叫p_a指向了a的地址）
在定义指针变量 p_a 的同时对它进行初始化，并将变量 a 的地址赋予它，此时 p_a 就指向了 a。
值得注意的是，p_a 需要的一个地址，a 前面必须要加取地址符&，否则是不对的。

和普通变量一样，指针变量也可以被多次写入，只要你想，随时都能够改变指针变量的值:

//定义普通变量
float a = 99.5, b = 10.6;
char c = '@', d = '#';
//定义指针变量
float *p1 = &a;//P1指向a的地址
char *p2 = &c;//p2指向c的地址
//修改指针变量的值
p1 = &b;//将p1改变指向为b
p2 = &d;//将p2改变指向为a

* 是一个特殊符号，表明一个变量是指针变量，定义 p1、p2 时必须带 *。而给 p1、p2 赋值时，因为已经知道了它是一个指针变量，就没必要多此一举再带上 *，后边可以像使用普通变量一样来使用指针变量。也就是说，定义指针变量时必须带 *，给指针变量赋值时不能带 *。

//注意
不允许把一个数赋予指针变量
int *p;
p = &a;
*p = 100;//这样是错误的


或者：
int b=200;
int *a;
a=b; //这样也错误，因为没有加上取地址符&

指针变量存储了数据的地址，通过指针变量能够获得该地址上的数据：

#include 
int main(){
    int a = 66;//定义整形变量
    int *p = &a; //定义int的指针变量并指向a变量的地址
    printf("%d, %d
", a, *p);  //两种方式都可以输出a的值
    return 0;
}


//假设 a 的地址是 0X1000，p 指向 a 后，p 本身的值也会变为 0X1000，*p 表示获取地址 0X1000 上的数据，
也即变量 a 的值。所以从运行结果看，*p 和 a 是等价的。


CPU 读写数据必须要知道数据在内存中的地址，普通变量和指针变量都是地址的助记符，虽然通过 *p 和 a 获取到的数据一样，
但它们的运行过程稍有不同：a 只需要一次运算就能够取得数据，而 *p 要经过两次运算，多了一层“间接”。


//程序被编译和链接后，a、p 被替换成相应的地址。使用 *p 的话，要先通过地址 0XF0A0 取得变量 p 本身的值，
这个值是变量 a 的地址，然后再通过这个值取得变量 a 的数据


也就是说，使用指针是间接获取数据，使用变量名是直接获取数据，前者比后者的代价要高。

可以用指针来改变被指向那个变量的值 如：

#include 
int main(void){
    int a = 1, b = 66, c = 2;//定义普通变量
    int *p = &a;  //定义指针变量并指向a的地址
    *p = b;  //通过指针变量将a的值改变了 （因为在这里，*p指向了a 就等于*p和a身处同一个内存空间了，
                                                                所以对*p修改 就相当于对a修改）
    c = *p;  //把指针p的值的赋值给了C (根据前面说的，相当于将a赋值给了C)
    printf("%d, %d, %d, %d
", a, b, c, *p);//所以他们的值都是同一个了
    return 0;
}
*在不同的场景下有不同的作用：*可以用在指针变量的定义中，
表明这是一个指针变量，以和普通变量区分开；使用指针变量时在前面加*表示获取指针指向的数据，或者说表示的是指针指向的数据本身。

也就是说，定义指针变量时的*和使用指针变量时的*意义完全不同。以下面的语句为例：

int *p = &a;//这里表示指向a的地址
*p = 100;  //这里表示获取指针所指向的数据

其他一些骚操作：

int x, y, *px = &x, *py = &y;
y = *px + 5;  //表示把x的内容加5并赋给y，*px+5相当于(*px)+5
y = ++*px;  //px的内容加上1之后赋给y，++*px相当于++(*px)
y = *px++;  //相当于y=(*px)++
py = px;  //把一个指针的值赋给另一个指针

关于“&”和“*”

“&”和“ * ”都是右结合的。假设有变量 x = 10，则*&x 的含义是，先获取变量 x 的地址，再获取地址中的内容。因为“&”和“ * ”互为逆运算，所以 x = *&x。

假设有一个 int 类型的变量 a， pa 是指向a的指针，那么*&a和&*pa分别是什么意思呢？

*&a可以理解为*(&a)，&a表示取变量 a 的地址（等价于 pa），*(&a)表示取这个地址上的数据（等价 * pa），绕来绕去，又回到了原点，*&a仍然等价于 a。

&*pa可以理解为&(*pa)，*pa表示取得 pa 指向的数据（等价于 a），&(*pa)表示数据的地址（等价于 &a），所以&*pa等价于 pa。

野指针与空指针

空指针是说,这个指针没有指向一块有意义的内存,比如说:char* k; 这里这个k就叫空指针.我们并未让它指向任意点.

又或者char* k = NULL; 这里这个k也叫空指针,因为它指向NULL 也就是0,注意是整数0,不是'�'

一个空指针我们也无法对它进行取内容操作,空指针只有在真正指向了一块有意义的内存后,我们才能对它取内容.也就是说要这样 k = "hello world!"; 这时k就不是空指针了.

对于空指针值，一般的文档中倾向于用 NULL 表示，而没有直接说成 0。但是我们应该清楚：对于指针类型来说，返回 NULL 和 返回 0 是完全等价的，因为 NULL 和 0 都表示 “null pointer”（空指针）。一句话， 空指针是什么，就是一个被赋值为0的指针，在没有被具体初始化之前，其值为0.（百度解释）

如 ：

int *a;//定义一个指针a=NULL;//让这个指针指向空a =0;//这样也是让一个指针指向空的方式

注意：void* 这不叫空指针,这叫无确切类型指针.这个指针指向一块内存,却没有告诉程序该用何种方式来解释这片内存.所以这种类型的指针不能直接进行取内容的操作.必须先转成别的类型的指针才可以把内容解释出来.

还有'�',这也不是空指针所指的内容. '�'是表示一个字符串的结尾而已,并不是NULL的意思

void*因为是表示不知道要指向什么东西的指针，计算时于char相同（但不相通）

野指针不同于空指针，空指针是指一个指针的值为null，而野指针的值并不为null，野指针会指向一段实际的内存，只是它指向哪里我们并不知情，或者是它所指向的内存空间已经被释放，所以在实际使用的过程中，我们并不能通过指针判空去识别一个指针是否为野指针。避免野指针只能靠我们自己养成良好的编程习惯

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）指针变量在定义时如果未初始化，其值是随机的，指针变量的值是别的变量的地址，意味着指针指向了一个地址是不确定的变量，此时去解引用就是去访问了一个不确定的地址，所以结果是不可知的。（百度解释）

下面说说哪些情况下会产生野指针，以及怎样避免。

1、指针变量的值未被初始化： 声明一个指针的时候，没有显示的对其进行初始化，那么该指针所指向的地址空间是乱指一气的。如果指针声明在全局数据区，那么未初始化的指针缺省为空，如果指针声明在栈区，那么该指针会随意指向一个地址空间。所以良好的编程习惯就是在声明指针的时候就对其进行初始化，如果暂时不知道该初始化成什么值，就先把指针置空。

int main(void){
int *a;//野指针


if(a!=NULL){
....
}


/*
int *a; 
a=NULL/0;  正确的引用
*/
}

2、指针所指向的地址空间已经被free或delete：在堆上malloc或者new出来的地址空间，如果已经free或delete，那么此时堆上的内存已经被释放，但是指向该内存的指针如果没有人为的修改过，那么指针还会继续指向这段堆上已经被释放的内存，这时还通过该指针去访问堆上的内存，就会造成不可预知的结果，给程序带来隐患，所以良好的编程习惯是：内存被free或delete后，指向该内存的指针马上置空。

void func()
{
    int *ptr = new int[5];
    delete [ ]ptr;
    // 执行完delete后，ptr野指针


  //还应该这样做：ptr=NULL; 正确


}

3、指针操作超越了作用域，如果在一个程序块中让一个指针指向那个块中的某个变量，但是那个变量只是在块中有效，出了那个程序块，此变量就无效了，此时指向它的指针也就变成了野指针

void func()
{
    int *ptr = nullptr;
    {
        int a = 10;
        ptr = &a;
    } // a的作用域到此结束


    int b = *ptr;    // ptr指向的a，但是a已经被回收，所以ptr变成野指针
  //还应该这样做：ptr=NULL; 正确
}

所以 使用指针时应当注意”规避“：初始化时置 NULL，释放时置 NULL

3、指针的运算

C 指针是一个用数值表示的地址。因此，您可以对指针执行算术运算。可以对指针进行四种算术运算：++、--、+、-。递增递减加减，两个指针相减

#include
int main(void) {
  int a=10; 
  int *pa = &a,*pA=&a;


  double b = 22.2;
  double *pb = &b;


  char c = 'C';
  char *pc = &c;


  //最初的值
  printf("1- %#x %#x %#x 
", &a, &b, &c);//%#x表示 转换成十六进制带格式输出地址,
                                                 //效果为在输出前加0x
  printf("2- %#x %#x %#x 
", pa, pb, pc);


  //指针加法
  pa += 2; pb += 2; pc += 2;
  printf("3- %#x %#x %#x 
", pa, pb, pc);


  //指针减法
  pa -= 2; pb -= 2; pc -= 2;
  printf("4- %#x %#x %#x
", pa, pb, pc);


  //指针的比较
  if (pa == pA) {
    printf("5=%d
", *pA);


  }
  else {
    printf("6=%d
", *pa);
  }


  return 0;


}


//从运算结果可以看出：pa、pb、pc 每次加 1，它们的地址分别增加 4、8、1，正好是 int、double、char 类型的长度；
                            减 2 时，地址分别减少 8、16、2，正好是 int、double、char 类型长度的 2 倍。


/*简单的概括就是：
指针的每一次递增，它其实会指向下一个元素的存储单元。
指针的每一次递减，它都会指向前一个元素的存储单元。
指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度，比如 int 就是 4 个字节。




指针变量除了可以参与加减运算，还可以参与比较运算。当对指针变量进行比较运算时，比较的是指针变量本身的值，也就是数据的地址。
如果地址相等，那么两个指针就指向同一份数据，否则就指向不同的数据。当然还有其他逻辑运算符


上面的代码（第一个例子）在比较 pa 和 pA 的值时，pa 已经指向了 a 的上一份数据，所以它们不相等。而 a 的上一份数据又不知道是什么，
所以会导致 printf() 输出一个没有意义的数，这正好印证了上面的观点，不要对指向普通变量的指针进行加减运算


注意：不能对指针变量进行乘法、除法、取余等其他运算，除了会发生语法错误，也没有实际的含义。

#include//指针的加减法其实上的地址上的移动
int main(void) {
  char a[] = {2,3,4,5,6};
  char *p = &a[0];
  char *p1 = &a[10];


  printf("p1-p=%d
", p1 - p);
  printf("p=%p
", p);
  printf("p1=%p
", p1);


  //这里如果运算为大于零，就是真 输出 0
  //如果运算为小于零，就是假 输出   -1
  int *t = a[0];
  int *k = a[3];
  printf("* %d
", t-k);


  int b[] = { 1,2,3,4,5,6 };
  int *q = &b[0];
  int *q1 = &b[6];
  printf("q1-q=%d
", q1 - q);
  printf("%p
", q1);
  printf("%p
", q);


  return 0;
}

常见的指针运算：

*（++p）: 先移动指针，取下一个单元的值

*（p++）: 先取出当前单元的值，再移动指针

（ * p）++ : 先取出当前单元的值，再使当前单元的值加1 （指针不移动）

++（ * p） : 先使当前单元的值加1，再取出当前单元的值 （指针不移动）

指针的类型转换：

int *p=&i;

void *q=(void * )p;

这并没有改变p所指向的变量的类型，而是让后人用不同的眼光通过p看它所指的变量

意思是：这里的p我不再当你是int了，认为你就是个void类型的

注意 由于优先级的问题 *p++和 * （p++）是等价的

取地址符 &补充：

获得变量的地址，它的操作必须是变量，

int i,printf("%x",&i); 取得i的地址并输出。

int i,printf("%p",&i); 取得i的地址并输出。

地址的大小是否于int相同取决于编译器

注意 使用指针的时候的类型，无论指向什么类型，所有的指针的大小都是一样的，因为都是地址，但是指向不同类型的指针是不能相互赋值的，这是为了避免用错指针。