c语言9 - 指针基本概念

指针： 地址，内存单元的编号。

内存单元： 计算机中内存最小的存储单位，大小为一个字节，每个内存单元都有唯一的一个编号，称这个内存单元的编号为：“地址”。

指针变量存指针地址的变量

内存单元与地址关系

如下代码可打印出变量的地址：

#include

int main(void){
 int a = 10;
 printf("%p\n", &a);
 return 0;
}

即如下图；地址00062FE1C若存储变量a的值，a=10，则该地址的二进制符号为00001010，其余三个地址的符号为00000000，即剩下三个地址均为a变量使用，且留空。

指针

*p 指针变量

*p的意思就是，将p变量的内容取出，当成地址看待，找到该地址对应的内存空间。若作为左值，则存数据到空间中，若作为右值，则取出空间的内容。

数据在内存中的地址也称为[指针]，如果一个变量存储了一份数据的指针，我们就称它为指针变量。

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

定义指针变量

定义指针变量与定义普通变量非常类似，不过要在变量名前面加星号*，格式为：

datatype *name;

或者

datatype *name = value;

*表示这是一个指针变量，datatype表示该指针变量所指向的数据的类型 。例如：

int *p1;

p1 是一个指向 int 类型数据的指针变量，至于 p1 究竟指向哪一份数据，应该由赋予它的值决定。再如：

int a = 100;
int *p_a = &a;

在定义指针变量 p_a 的同时对它进行初始化，并将变量 a 的地址赋予它，此时 p_a 就指向了 a。值得注意的是，p_a 需要的一个地址，a 前面必须要加取地址符&，否则是不对的。和普通变量一样，指针变量也可以被多次写入。

获取指针数据

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

*pointer;

这里的*称为指针运算符，用来取得某个地址上的数据

#include 
int main(){
    int a = 10;
    int *p = &a;
    printf("%d, %d\n", a, *p);
 printf("&a = %u, &*p = %u, &p = %u\n",&a, &*p, &p);
    return 0;
}

打印结果显示，当*p获取到数据时，能够获取到其指定变量地址的数据，而同时加上&时获取地址。而变量p和a的地址绝对不同，只有*p和a的地址相同，如下图所示

程序被编译和链接后，a、p 被替换成相应的地址。使用 *p 的话，要先通过地址 6487568 取得变量 p 本身的值，这个值是变量 a 的地址，然后再通过这个值取得变量 a 的数据，前后共有两次运算；而使用 a 的话，可以通过地址 6487580 直接取得它的数据，只需要一步运算。

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

指针类型大小

如下代码可查看：

#include

int main(void){
 int a = 10;
//    定义一个指针
 int *p = &a;
//    打印指针
 printf("打印指针*p = %d\n打印类型的指针大小\n", *p);

    printf("sizeof(int *) = %u\n", sizeof(int *));
    printf("sizeof(short *) = %u\n", sizeof(short *));
    printf("sizeof(char *) = %u\n", sizeof(char *));
    printf("sizeof(long *) = %u\n", sizeof(long *));
    printf("sizeof(double *) = %u\n", sizeof(double *));
// 泛型，也称为万能指针
 printf("sizeof(void *) = %u\n", sizeof(void *));
 return 0;
}

我们发现指针的大小和当前PC机的大小有关，32位为4字节，64位为8位。

野指针(杜绝使用)

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

#include

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

会发现该值出现异常，程序会自动去寻找这段地址，但是若寻找不到则会报错。

同时当变量p拥有一个值，但是该值为不可访问的内存区域：

#include

int main(void){
// int *p;
 int *p = 10;
 *p = 6487580;
 
 printf("*p = %d\n", *p);
 return 0;
}

*p中0-255是确认给操作系统使用的，需要高级权限。

空指针

int *p = NULL;

当*p 被间接引用，*p所对应的存储空间一定是一个无效的访问空间。

泛型指针

void *p;

可以先不定义指针的类型，接收任意一种变量的地址，但是使用的时候需要进行类型具体化，使用强行转换。

#include

int main(void){
    int a = 300;
 void *p; //泛型指针，也称万能指针
 p = &a;
//    int *进行转换
 printf("*p = %d\n", *(int *)p);
 return 0;
}

指针与数组

数组的数组名是地址常量，代表了数组无法被修改，或者赋值。如下操作：

#include
int main (void){
 int a[] = {1, 2, 3};
 int b[3];
 b = a;
 return 0;
}

这种直接赋值无法被允许。而指针是变量，可以使用数组名给指针赋值。

#include
int main (void){
 int a[] = {1, 2, 3};
 int b[3];
// b = a;
 int *p = a;
 printf("%d",*p);
 return 0;
}

取数组元素

若有一个数组a如下，其起始地址为000000，则：

int a[] = {1, 2, 3, 4};

即a【i】 = *(a+i)

如下有四种取数组的方式：

#include
int main(void){
 int a[] = {1, 2, 3, 4};
 int n = sizeof(a)/sizeof(a[0]);
 
 int *p = a;
 for (size_t i = 0; i   printf("%d ", a[i]);
  printf("%d ", *(a+i));
  printf("%d ", p[i]);
  printf("%d ", *(p+i));
 }
 return 0;
}

指针与数组的区别

• 指针是变量，而数组名为常量
• sizeof(指针) ====》 仅4/8，即头一个地址的大小
• sizeof(数组) ====> 实际的数组字节数的

const关键字修饰指针

共四种形式：

• const int *p;
• int const *p;
• int * const p;
• const int *const p;

const int *p 与 int const *p

#include

int main(void){
    int a = 10;
    int b = 30;
    const int *p = &a;
    *p = 500;
    p = &b;
    return 0;
}

这个形式下，可以修改p，但是无法修改*p

int main(void){
    int a = 10;
    int b = 30;
    int const *p = &a;
    *p = 500;
    p = &b;
    return 0;
}

这个格式与上述一致，无法修改*p

int * const p

int main(void){
    int a = 10;
    int b = 30;
    int * const p = &a;
    *p = 500;
    printf("%d \n", *p);
//    p = &b;
    return 0;
}

而这个格式下无法修改p，但是能够修改*p

const int *const p

int main(void){
    int a = 10;
    int b = 30;
    const int * const p = &a;
    *p = 500;
    //    p = &b;
    printf("%d \n", *p);
    return 0;
}

这个格式下p和*p均不可被修改

总结

const向右修饰，被修饰到的部分均不可被修改。

常用于函数形参内用于限制指针对应的内存空间为只读。

指针运算

指针能够进行的四种运算分别是：++,--,-,+

若使用++则取其对应的变量类型，如int类型，则往前递增四个字节，若如p指向100，则p++后指向104

指针递增

#include 
const int MAX = 3;
int main (){
   int  var[] = {1, 2, 3};
   int  i, *ptr;
   /* 指针中的数组地址 */
   ptr = var;
   for ( i = 0; i    {
      printf("存储地址：var[%d] = %x\n", i, ptr );
      printf("存储值：var[%d] = %d\n", i, *ptr );
      /* 指向下一个位置 */
      ptr++;
   }
   return 0;
}

指针递减

#include 
const int MAX = 3;
int main (){
   int  var[] = {10, 20, 30};
   int  i, *ptr;
   /* 指针中最后一个元素的地址 */
   ptr = &var[MAX-1];
   for ( i = MAX; i > 0; i--)
   {
      printf("存储地址：var[%d] = %x\n", i-1, ptr );
      printf("存储值：var[%d] = %d\n", i-1, *ptr );
      /* 指向下一个位置 */
      ptr--;
   }
   return 0;
}

指针比较

指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。

#include 
const int MAX = 3;
int main (){
   int  var[] = {10, 100, 200};
   int  i, *ptr;
   /* 指针中第一个元素的地址 */
   ptr = var;
   i = 0;
   while ( ptr <= &var[MAX - 1] )
   {
      printf("Address of var[%d] = %p\n", i, ptr );
      printf("Value of var[%d] = %d\n", i, *ptr );
      /* 指向上一个位置 */
      ptr++;
      i++;
   }
   return 0;
}

往期文章

2020-10-5

• C++语法1、类与对象

• c++语法2、c执行-命名空间-输入输出

• c++ 3、语法 数据类型

• c++ 4、语法 数组

• c++  c语言- 概述

• c++  c语言 - 控件及概述补充

• c++  c语言 - 数据类型

• c++  c语言 - 进制、原反补码、输入输出函数

• c++  c语言 - 运算符和类型转换

• c++  c语言 - 控制语句

• c++  c语言 - 数组与字符串

图 | 郭嘉

文 | 郭嘉

扫码关注桔梗与少年

微信号 : if-u-remembers

新浪微博：桔梗与少年