深入理解c指针（二）

做完作业了

已于 2024-03-08 10:44:59 修改

阅读量1k

点赞数 29

分类专栏： c语言文章标签： c语言数据结构开发语言

于 2024-02-25 10:04:49 首次发布

本文链接：https://blog.csdn.net/2301_81723939/article/details/136275076

版权

c语言专栏收录该内容

17 篇文章 3 订阅

订阅专栏

二、指针变量类型的意义

1、指针的解引用

以下面两段代码为例，调试我们可以看到，代码1会将n的4个字节全部改为0，但是代码2只是将 n 的第⼀个字节改为0。结论：指针的类型决定了对指针引用时有多大的权限（一次能操作几个字节）。

char 类型的指针 (char*)：一次操作1个字节（8 比特位）的内存。
int 类型的指针 (int*)：通常一次操作一个整数的内存大小，通常是 4 个字节。
float类型的指针(float*):一次操作一个浮点数的内存大小，通常是4个字节。
double 类型的指针 (double*)：一次操作一个浮点数的内存大小，通常是 8 个字节。
short*：一次操作通常是2个字节。
long*：一次操作通常是4个字节。
long long*：一次操作通常是8个字节。
void*：一般情况下，void* 指针不指向具体的数据类型，因此不能直接进行解引用操作。但一次操作的字节数取决于所指向的具体数据类型。

//代码一

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

//代码二

#include <stdio.h>
int main()
{
int n = 0x11223344;
char *pc = &n;
*pc = 0;
return 0;
}

2、指针±整数

通过下面代码查看地址变化，（%p 用来打印地址），（在16进制中A-10，B-11，C-12，D-13，E-14，F-15）。

可以看出 char* 类型指针变量+1跳过一个字节，int* 类型指针变量+1跳过了四个字节。这就是指针变量的类型差异带来的变化。

#include <stdio.h>
int main()
{
  int n = 10;
  char *pc = (char*)&n;
  int *pi = &n;
  printf("%p\n", &n);
  printf("%p\n", pc);
  printf("%p\n", pc+1);
  printf("%p\n", pi);
  printf("%p\n", pi+1);
  return 0;
}

例：由于 char 类型占据一个字节，char 类型的指针在移动时通常是按字节递增的。因此，char 类型的指针每次操作一个字节的内存。在这个例子中，char* 指针 ptr 指向一个包含字符 'A', 'B', 'C', 'D' 的数组，通过循环逐个打印字符，每次 ptr++ 移动一个字节。

#include <stdio.h>

int main() {
    char arr[] = {'A', 'B', 'C', 'D'};
    char *ptr = arr;   //arr等价于&arr[0]

    // 操作每个字节
    for (int i = 0; i < 4; i++) {
        printf("%c\n", *ptr);
        ptr++;
    }

    return 0;
}

3、void* 指针

以下面代码为例，将⼀个int类型的变量的地址赋值给⼀个char*类型的指针变量。编译器给出了一个警告（如下图），是因为类型不兼容。而使用void*类型就不会有这样的问题。

#include <stdio.h>
int main()
{
int a = 10;
int* pa = &a;
char* pc = &a;
return 0;
}

使用void*类型的指针接收地址就不会出现次类型警告，但是进行解引用时会出现如下警告：

#include <stdio.h>
int main()
{
  int a = 10;
  void* pa = &a;
  void* pc = &a;
  *pa = 10;
  *pc = 0;
  return 0;
}

三、const修饰指针

1、const修饰变量

变量是可以修改的，如果把变量的地址交给⼀个指针变量，通过指针变量的也可以修改这个变量。但是如果我们希望⼀个变量加上⼀些限制，不能被修改，这就是const的作用。例如：

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

上述代码中n是不能被修改的，其实n本质是变量，只不过被const修饰后，在语法上加了限制，只要我们在代码中对n进行修改，就不符合语法规则，就报错，致使没法直接修改n。

但是如果我们绕过n，使用n的地址，去修改n就能做到了，虽然这样做是在打破语法规则。

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

如果p拿到n的地址就能修改n，这样就打破了const的限制，这是不合理的，所以应该让p拿到n的地址也不能修改n，那接下来怎么做？

2、const修饰指针变量

注：const 放在 * 左或右含义不同，但是 const 放在 int 左或右没有区别。

例1：不用const，则按代码顺序依次执行，首先指针变量p存储了n的地址，通过*p改变了该地址中的内容，最后指针变量p指向m的地址。

#include <stdio.h>
//代码1
void test1()
{
	int n = 10;
	int m = 20;
	int* p = &n;
	*p = 20;
	 p = &m; 
	 printf("%d %p %d %d", *p, p,n,m);
}
int main()
{
	//测试⽆const修饰的情况
	test1();
	return 0;
}

例2：当const放在 * 左边。

#include <stdio.h>

void test2()
{
	//代码2
	int n = 10;
	int m = 20;
	const int* p = &n;
	*p = 20;
	p = &m; 
	printf("%d %p %d %d", *p, p, n, m);
}
int main()
{
	//测试const放在*的左边情况
	test2();
	return 0;
}

执行到 *p = 20 该行代码时出现如下报错。但是如果注释掉该行代码，则程序正常运行，且指针变量p由指向 n 的地址改变指向了m的地址。

例3：当const放在 * 右边。

void test3()
{
	//代码3
	int n = 10;
	int m = 20;
	int* const p = &n;
	*p = 20; 
    p = &m; 
	printf("%d %p %d %d", *p, p, n, m);
}

int main()
{
	//测试const放在*的右边情况
	test3();
	return 0;
}

执行到 p = &m 该行代码时出现如下报错。如果注释掉该行代码，程序正常运行，且地址n处的内容已经被修改为20。

例4：当 * 左右两边都有const时同理，则 p 与 *p都被限制，无法解引用去修改。

#include <stdio.h>

void test4()
{
	//代码4
	int n = 10;
	int m = 20;
	int const* const p = &n;
	*p = 20; 
	p = &m; 
	printf("%d %p %d %d", *p, p, n, m);
}
int main()
{
	//测试*的左右两边都有const
	test4();
	return 0;
}