C++ 指针的算术运算：从基础到实战应用
在 C++ 中，指针是核心特性之一，它赋予程序员对内存的直接操作能力。而指针的算术运算，正是让指针真正“活起来”的关键。很多初学者在学习指针时，往往只停留在“指针指向变量”这个层面，却忽略了它强大的移动能力。今天，我们就来深入聊聊 C++ 指针的算术运算，带你从理解原理到写出高效、安全的代码。
你可能会问：指针还能“加减”？没错，就像我们可以在地图上沿着街道移动一样，指针也可以在内存中“行走”。这种“行走”不是随机的，而是遵循着数据类型的步长规则。掌握这一点，你就能真正驾驭 C++ 的底层能力。
指针算术的基本原理
在 C++ 中，指针变量存储的是内存地址。当你对指针进行加减运算时，不是简单地加减数值，而是根据指针所指向的数据类型，按“步长”移动。
举个例子，假设有一个 int 类型的变量，它在内存中占 4 个字节。如果指针 p 指向这个变量，那么执行 p + 1，实际上会让指针移动 4 个字节，指向下一个 int 类型的内存位置。这个“步长”由数据类型决定，是 C++ 指针算术的核心机制。
这就像你在一栋楼里走楼梯：每层楼高 3 米，你从第 1 层走到第 2 层，实际移动了 3 米。指针的“走”也是这样，不是“走 1 步”，而是“走一个类型大小的步”。
#include <iostream>
using namespace std;
int main() {
int value = 100;
int* ptr = &value; // ptr 指向 value 的内存地址
cout << "原始地址: " << ptr << endl; // 输出当前地址
cout << "ptr + 1 后的地址: " << ptr + 1 << endl; // 移动到下一个 int 位置
// 注意：这里 ptr + 1 并没有改变原值，只是计算新地址
return 0;
}
这段代码中，ptr + 1 的结果是将指针移动了 sizeof(int) 字节（通常是 4 字节），而不是简单地加 1。这个行为由编译器自动处理，是 C++ 语言设计的精妙之处。
常见的指针算术操作
指针支持加法、减法、自增、自减等常见算术操作。这些操作在数组遍历、字符串处理等场景中极为常见。
加法操作（+ 和 +=）
#include <iostream>
using namespace std;
int main() {
int arr[5] = {10, 20, 30, 40, 50};
int* ptr = arr; // 指向数组首元素
// 使用指针遍历数组
for (int i = 0; i < 5; i++) {
cout << "第 " << i + 1 << " 个元素: " << *(ptr + i) << endl;
// ptr + i：从首地址开始，移动 i 个 int 大小的距离
}
return 0;
}
这里 ptr + i 每次都计算出第 i 个元素的地址，然后通过解引用 * 取值。这种写法比用下标访问 arr[i] 更底层，也更灵活。
减法操作（- 和 -=）
减法常用于逆向遍历或计算两个指针之间的距离。
#include <iostream>
using namespace std;
int main() {
int arr[] = {5, 10, 15, 20, 25};
int* start = arr; // 首地址
int* end = arr + 5; // 尾后地址（注意：不是最后一个元素）
// 从后往前遍历
for (int* p = end - 1; p >= start; p--) {
cout << *p << " ";
}
cout << endl;
// 计算数组长度（指针差值）
int length = end - start;
cout << "数组长度: " << length << endl;
return 0;
}
这里 end - start 返回的是两个指针之间的元素个数，而不是字节差。这是 C++ 指针算术的另一个强大之处：它能自动“感知”数据类型。
自增与自减
自增 ++ 和自减 -- 操作符在指针中同样有效，且行为与加减一致。
#include <iostream>
using namespace std;
int main() {
int values[] = {100, 200, 300, 400};
int* p = values;
// 前置自增：先移动，再使用
cout << "前置自增: " << *(++p) << endl; // 输出 200
// 后置自增：先使用，再移动
cout << "后置自增: " << *(p++) << endl; // 输出 200，然后 p 指向 300
// 也可以用于循环
p = values;
while (p < values + 4) {
cout << *p << " ";
p++;
}
cout << endl;
return 0;
}
指针算术的边界与安全问题
虽然指针算术功能强大，但使用不当极易引发内存访问错误。这是初学者最容易踩坑的地方。
越界访问的风险
#include <iostream>
using namespace std;
int main() {
int arr[3] = {1, 2, 3};
int* p = arr;
// ❌ 危险操作：越界访问
cout << *(p + 5) << endl; // 可能读取非法内存，导致崩溃或未定义行为
return 0;
}
这个例子中，p + 5 已经远远超出了数组的范围。C++ 不会自动检查边界，所以这种错误不会在编译时报错，但在运行时可能崩溃。
安全的使用建议
- 始终确保指针在有效范围内移动。
- 使用数组长度或尾后指针作为边界。
- 在循环中使用
p < end而非p <= end - 1。
// ✅ 安全写法
int* start = arr;
int* end = arr + 3; // 数组长度为 3
for (int* p = start; p < end; p++) {
cout << *p << " ";
}
指针算术在数组和字符串中的应用
指针算术是操作数组和字符串的核心手段，尤其在性能要求高的场景中。
数组遍历的两种方式对比
#include <iostream>
using namespace std;
int main() {
int arr[] = {10, 20, 30, 40, 50};
int size = 5;
// 方式一：下标访问（直观）
cout << "下标方式: ";
for (int i = 0; i < size; i++) {
cout << arr[i] << " ";
}
cout << endl;
// 方式二：指针算术（高效）
cout << "指针方式: ";
int* p = arr;
for (int i = 0; i < size; i++) {
cout << *(p + i) << " ";
}
cout << endl;
// 更简洁的写法
cout << "简洁指针: ";
for (int* p = arr; p < arr + size; p++) {
cout << *p << " ";
}
cout << endl;
return 0;
}
两种方式等价，但指针方式在某些编译器优化下可能更快，因为避免了下标计算。
字符串处理示例
字符串在 C++ 中本质是字符数组，指针算术在字符串处理中极为常用。
#include <iostream>
#include <cstring>
using namespace std;
// 计算字符串长度（模拟 strlen）
int my_strlen(const char* str) {
int count = 0;
while (*str != '\0') {
str++; // 指针向前移动
count++;
}
return count;
}
int main() {
char text[] = "Hello, C++";
int len = my_strlen(text);
cout << "字符串: " << text << endl;
cout << "长度: " << len << endl;
// 使用指针遍历字符串
const char* p = text;
while (*p) {
cout << *p << " ";
p++;
}
cout << endl;
return 0;
}
这里 str++ 使得指针逐个移动到下一个字符，直到遇到字符串结束符 '\0'。这种写法是 C 风格字符串处理的经典模式。
实战：实现一个简单的数组拷贝函数
我们来用指针算术实现一个 copy_array 函数，它将源数组内容复制到目标数组。
#include <iostream>
using namespace std;
// 使用指针算术实现数组拷贝
void copy_array(int* dest, const int* src, int size) {
// 使用指针遍历源数组
for (int i = 0; i < size; i++) {
*(dest + i) = *(src + i); // 指针算术访问元素
}
}
int main() {
int source[] = {1, 2, 3, 4, 5};
int dest[5];
cout << "源数组: ";
for (int i = 0; i < 5; i++) {
cout << source[i] << " ";
}
cout << endl;
copy_array(dest, source, 5);
cout << "目标数组: ";
for (int i = 0; i < 5; i++) {
cout << dest[i] << " ";
}
cout << endl;
return 0;
}
这个例子展示了指针算术在实际函数中的价值：它使代码更底层、更高效，尤其适合处理大规模数据。
总结
C++ 指针的算术运算，不是简单的“加减”，而是一种基于数据类型大小的智能移动机制。它让指针成为高效操作内存的强大工具。通过本篇内容，你已经掌握了：
- 指针算术的基本原理与步长机制
- 加减、自增自减等常见操作
- 安全使用指针的边界检查方法
- 在数组和字符串中的实际应用
- 如何编写高效、安全的指针操作函数
记住：指针算术是一把双刃剑。用得好，能写出高性能代码；用得不好，就会引发程序崩溃。因此，务必在理解底层机制的基础上，养成良好的编码习惯。
真正掌握 C++ 指针的算术运算，意味着你已经迈入了 C++ 深层编程的大门。继续深入，你会发现，内存管理、动态分配、算法优化等高级主题，都与指针算术息息相关。