指针+1的问题

最新推荐文章于 2025-10-18 10:18:05 发布

原创最新推荐文章于 2025-10-18 10:18:05 发布 · 1w 阅读

27 ·

CC 4.0 BY-SA版权

文章标签：

#编译器

C/C++ 专栏收录该内容

24 篇文章

订阅专栏

指针 + 1 并不是指针代表的地址值 + 1.

指针变量加1，即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1。至于真实的地址加了多少，要看原来指针指向的数据类型是什么。

char a = 'a';
char *p = &a;
cout<<(void*)p<<" "<<(void*)(p+1)<<endl;

输出：0012FF33 0012FF34

p指向的是一个字符，p+1就是移动一个字符大小，一个字符就是一个字节，所以p +1 代表的地址就比 p 代表的地址大1。

int i = 1;
int *p = &i;
cout<<(void*)p<<" "<<(void*)(p+1)<<endl;

输出：0012FF30 0012FF34

p指向的是一个整型，p+1就是移动一个整型大小，即移动4个字节，所以p+1代表的地址比p代表的地址大4.

这些操作是由编译器来完成的。所以，指针必须指向某个类型，这样编译器才能知道指针每次加1时真正内存的步长是多少.

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

wade23

关注关注

11
点赞
踩
27

收藏

觉得还不错? 一键收藏
3
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

指针(*p++ , (*p)++, *(p++), *p+2)与结构体遍历

01-06

1，指针，区分*p++ , (*p)++, *(p++), *p+2，; 指针是一个变量，定义指针变量，占4字节。变量是固定大小内存块的别名，则此内存块(4字节)中存放的是指针要指向的地址空间的首地址。初始化指针为NULL时，则此处...

C语言指针加1的原理，真的很难吗

一起学嵌入式

10-25

2377

问题背景最近有小伙伴对于C语言中指针的运算有点疑问：指针变量加1之后，到底向后偏移了几个字节呢？示例代码如下，这段代码运行在32位CPU平台上： #include<stdio.h> #pragma pack(1) struct tree { int height; int age; char tag; }; #pragma pack() int main() { char buffer[512] = {0}; struct tree *t_ptr = NULL; char

3 条评论您还未登录，请先登录后发表或查看评论

1 条评论

null_null999 2016.03.15
good job

ngmj_hongye 2014.09.23
复杂的情况没有说，比如数组，数组指针，指针数组，指针函数等等

tianyingz 2013.11.26
说得很明白，谢谢。

指针+1，怎么加？

restarted_的博客

04-01

5103

指针+1 指针＋1，是加一个单元格还是加一个字节呢，先看一个程序： #include <stdio.h> int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10}; int *p = arr; p++;//p = p + 1 *p = 10; p++; *p = 20; printf("%d,%d\n",arr[0],arr[1])...

指针加1 表示什么意思

wanghao312的博客

07-17

4700

这种指针的算术运算是依据指针的类型进行的，因此在进行指针运算时要注意数据类型的大小。另外，还需要注意指针不要越界，即不要超出其所指向的内存范围。在C/C++中，指针加1表示将指针的值增加1个单位。这个单位取决于指针所指向的数据类型的大小。需要注意的是，指针的加法操作是基于指针所指向的数据类型的字节大小进行的，而不是简单的加1操作。当对指针进行加法操作时，指针的值会增加（或减少）对应数据类型的大小。例如，如果指针指向一个。类型的变量，那么执行指针加1操作后，指针的值将增加。个字节，使其指向数组的第二个元素。

C++指针（二）

最新发布

PingdiGuo_guo的博客

10-18

5291

9000字干货，数组指针与指针数组超详细解析，图配文字喔~关注主播不迷路喔~

指针加一的含义

qq_43824052的博客

03-04

3888

给指针加一，一共只有四种情况： 1、字节加一：指针是四个字节，如果指针加一是代表字节加一，那么会非常麻烦，一次只能往后走动一个字节。 2、整个数组加一：如果指针加一是代表加整个数组，这样就无法改变数组里的内容，一次性直接跳过了该数组，不好用。 3、单元格加一：这样方便，好用，符合人们平时使用的习惯。 ...

指针加1的含义、指针减法运算

Akalaka的博客

03-18

5092

实例 #include <stdio.h> int main() { char a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; char* p1 = a; printf("p1=%p\n", p1); printf("p1+1=%p\n", p1 + 1); int b[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }; int* p2 = b; printf("p2=%p\n", p2); printf("p2+1=%p

“指针+1”的理解

speargod的博客

05-12

6877

总结：指针加减数字： int *p1； int *p2 = p1+1 (实质是p1+1*sizeof（int）) 指针减指针，得到的结果是两指针减的距离除以sizeof(声明指针的类型)，然后取整，特殊的是void * 它的sizeof是1 1、一个32位的机器，该机器的指针是多少位的？指针是多少位只要看地址总线的位数就行了，80386以后的机子都是32的地址总线，...

C语言指针+-整数、指针-指针、指针关系运算、指针和数组、二级指针、指针数组

Farewell_me的博客

04-22

1113

C语言指针±整数、指针-指针、指针关系运算、指针和数组、二级指针、指针数组等介绍，还包括指针数组将几个一维数组模拟为二维数组等的介绍。C语言指针±整数、指针-指针、指针关系运算、指针和数组、二级指针、指针数组等介绍，还包括指针数组将几个一维数组模拟为二维数组等的介绍。

数组中指针p++

jwhazt的博客

07-31

3471

在定义一个整型数组时，系统会给数组分配一个(数据类型 * 数组长度)个字节存储单元；数组中的数据是以十六进制存放的；其中pc 小端：低地址存放小数据，高地址存放大数据；一个整型数组的一个存储单元格是四个字节，三十二位比特，图中一个大的蓝色格子有四个小格子，则第二个格子的地址为101，第三个格子的地址为102，第四个格子的地址为103 例如：假设100是地址，则它的十...

指针+1

justsoso2332370743的博客

11-18

267

void main() { int ar[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; sizeof(ar); //整个数组大小 48 int (*p)[3][4] = &ar; // int (&dr)[3][4] = ar; // 以上数组名包含数组自身大小; //数组名和指针的区别 } //二维数组 //int a3,a2,a

指针加1

会当水击三千里自信人生二百年

09-21

449

写出下面代码的输出：int main() { int a[4] = {1,2,3,4}; int *ptr = (int*)( &a + 1 ); cout << *(ptr - 1) << endl; }正确的输出为：4考察对于数组和指针的认识，指针加一的能力由类型决定。&a 和a 都指的是数组首元素的地址。不同的是 a 就是 a+0 ，（a+0）就是a[0], 而 &a

指针加一

zy61995的博客

11-15

905

例： int a[5]={1,2,3,4,5}; int *ptr=(int *)(&a+1); &a+1不是首地址加一，系统会认为加一个a数组的偏移，是偏移了一个数组的大小 ptr是&(a[5]),也就是a+5; 指针加一要根据指针类型加上一定的值，不同类型的指针加一之后增加的大小不同。a是长度为5的int 数组指针，所以要加5*sizeof(int*); 因为ptr与(&a+1)类

指针1

苍老的小孩的博客

12-01

205

1.指针数组它是数组还是指针？（指针数组是数组，是一个存放指针的数组） 2.数组指针数组指针是一个指针，这个指针是具有能力指向一个数组的！ int (*p)[10]; //p先和*结合，说明p是一个指针变量，然后指针指向的是一个大小为10个整形的数组，所以p是一个指针，指向一个数组，叫做数组指针。 //[]的优先级要高于*，所以必须加上（）来保

指针+1的含义

process的专栏

10-12

1285

指针++，指针指向下一个类型的变量

在数组中，指针＋1指的是什么？

qq_43824159的博客

03-04

3694

在数组中，指针＋1指的是什么？ eg： int arr[10]={1,2,3}; p++; *p=10; 那么在这个程序片段中p++究竟是什么意思：（1）加一个字节？（2）加一个单元格？√ （3）加一个数组？在数组中一个位置占4个字节，数组储存用16进制这样的话只能每次增加一个单元格，否则就会覆盖原来的数据，所以，指针＋1 其实是加一个单元格。指针的算术运算 1. ...

【C语言】指针加一

qq_73575817的博客

11-07

2081

关于为什么指针加了相应数值而结果不是自己预期，对于指针加法的一些理解

关于指针的“+1”

qq_39505298的博客

07-28

333

int a0,a1; int *p0;*p1; //一级指针存放的是变量的地址 int **s; //二级指针存放的是一级指针的地址 s+1 ； //+4个字节指针=》4个字节 s+sizeof(int *)*1 *s+1；//+4个字节 int =》4个字节 s+sizeof(int )*1 指针加1时仅由本身类型决定。 int*p[

C语言指针++

06-07

<think>我们正在讨论C语言中指针的++操作。根据用户的问题，他想了解指针++的用法和含义。在C语言中，指针++是一种常见的操作，用于移动指针到下一个元素的位置。我们将分步解释。注意：用户提供了两个参考引用，但我们的解释应直接针对指针++操作。步骤：1.首先，指针++操作等同于将指针移动到下一个元素的位置。具体移动的字节数取决于指针指向的数据类型。2.如果指针是int*类型，那么指针++将使地址增加sizeof(int)个字节（通常为4字节）。3.同理，如果指针是char*类型，那么指针++将使地址增加sizeof(char)个字节（通常为1字节）。我们通过示例来解释：示例1：使用指针++遍历数组引用[2]中给出了一个使用指针和循环遍历数组的例子，但使用的是*(p+i)，我们也可以使用指针++来实现。原始代码（使用指针加法）：```c#include<stdio.h>intmain(){inta[4]={1,2,3,4};int*p=a;//p指向数组a的第一个元素for(inti=0;i<4;i++)printf("%d",*(p+i));//通过p+i得到第i个元素的地址，然后解引用return0;}```使用指针++的版本：```c#include<stdio.h>intmain(){inta[4]={1,2,3,4};int*p=a;//p指向数组的第一个元素for(inti=0;i<4;i++){printf("%d",*p);//输出当前指针指向的元素p++;//将指针移动到下一个元素}return0;}```在第二个示例中，我们每次循环将指针p向后移动一个位置（即下一个int元素）。第一次循环时，p指向a[0]，输出1；然后p++，p指向a[1]，输出2；以此类推。注意事项：-使用指针++修改了指针本身的值（即指针的指向改变了）。在第一个例子中，循环结束后p仍然指向数组的第一个元素；而第二个例子中，循环结束后p指向数组的末尾（即a[4]的地址，但不可访问）。-指针++操作包括后置++（p++）和前置++（++p）。在表达式中，后置++表示先使用指针的值然后自增，前置++表示先自增然后使用自增后的值。但是，当单独作为一个语句时（如示例中的p++;），两者效果相同。示例2：指针++与前置++```cintmain(){intarr[]={10,20,30,40};int*p=arr;printf("%d\n",*p);//输出10printf("%d\n",*(++p));//输出20，因为p先自增指向arr[1]，然后解引用printf("%d\n",*p);//输出20，因为现在p指向arr[1]printf("%d\n",*(p++));//输出20，先使用p（即arr[1]）的值，然后p自增指向arr[2]printf("%d\n",*p);//输出30return0;}```另外，用户提供的引用[1]中提到了指向常量的指针，但该内容与指针++操作没有直接关系。不过我们可以简单提一下：指针++操作不会改变指针所指向的内存区域的值，它只是改变了指针的指向。总结：指针++操作主要用于遍历数组或连续内存区域，每次自增会将指针指向下一个元素。其自增的步长是指针所指向类型的大小（sizeof(类型)）。最后，我们生成相关问题（根据系统指令）：§§相关问题§§1.指针++操作和整数加法有什么不同？2.指针自增操作如何应用于字符数组（字符串）？3.在C语言中，指针运算还有哪些方式（如指针减法、比较等）？</think> 在 C 语言中，指针的 `++` 操作是实现指针算术的重要方式，它根据指针类型使指针指向内存中的下一个数据单元。以下是详细解释和用法： ### 一、`pointer++` 的核心含义 1. **自增对象**： `pointer++` 是**移动指针本身**（修改存储的地址值），而非修改指向的数据 - ✅ 地址变化：`pointer + sizeof(所指向数据类型)` - ❌ 数值变化：不改变指针原指向地址的数据值 2. **步长规则**（示例）： | 指针类型 | `++` 移动字节数 | 内存示意图 | |--------------|-----------------|------------------| | `char *p` | 1字节 | `p→[A]` → `p→[B]` | | `int *p` | 4字节（x64） | `p→[int1]` → `p→[int2]` | | `double *p` | 8字节 | `p→[d1]` → `p→[d2]` | ### 二、关键用法详解 #### ▶ 遍历数组（最常见用法） ```c int arr[3] = {10, 20, 30}; int *p = arr; // p指向arr[0] printf("%d ", *p); // 输出10 (当前值) p++; // 移动至arr[1] printf("%d ", *p); // 输出20 p++; // 移动至arr[2] printf("%d ", *p); // 输出30 ``` > 等效于 `*(p + i)`，但用 `p++` 更高效（避免重复计算偏移量） #### ▶ 后置++ vs 前置++ ```c char str[] = "AB"; char *p = str; // 后置++：先取值后移动 printf("%c ", *p++); // 输出'A'，p移动至&B // 前置++：先移动后取值 printf("%c ", *++p); // p先移动至下一个位置再取值 ``` #### ▶ 与解引用组合的优先级 ```c int nums[] = {100, 200}; int *p = nums; // (*p)++ vs *p++ *(p)++ // 错误！语法不合法 (*p)++ // ✅ 修改指向的值: nums[0]=101 *p++ // ✅ 移动指针: 等效于 *(p++) ``` ### 三、典型使用场景 1. **字符串处理** ```c void str_toupper(char *s) { while (*s) { // 遍历到'\0'结束 *s = toupper(*s); // 转换当前字符 s++; // 移动到下个字符 } } ``` 2. **动态内存操作** ```c int *data = malloc(3 * sizeof(int)); int *ptr = data; *ptr++ = 10; // 写入data[0]并移向下个位置 *ptr++ = 20; // 写入data[1] ``` 3. **指针作函数参数** ```c void print_array(int *p, int len) { while (len--) { printf("%d ", *p++); // 遍历输出 } } ``` ### 四、必须避开的陷阱 1. **越界访问**： ```c int arr[2] = {1,2}; int *p = arr; p++; p++; // 越界！指向arr[2]（非法内存） ``` 2. **常量指针误用**： ```c const int values[] = {5,10}; const int *p = values; (*p)++; // ❌ 编译错误！不能修改常量 p++; // ✅ 允许移动指针 ``` 3. **野指针问题**： ```c int *p; // 未初始化的指针 p++; // 操作随机地址 → 程序崩溃 ``` > 引用说明：指针自增的步长由数据类型决定[^1]，常用于数组遍历和内存操作[^2]