C++指针运算与内存地址访问技巧

30次阅读

C++指针运算通过偏移量访问内存，偏移以指针类型大小为单位，如int*加1移动4字节，常用于数组遍历、动态内存和数据结构操作，但需防越界和空指针解引用，结合const可限定指针或指向的值不可变，访问结构体成员用->运算符，推荐使用智能指针管理动态内存以防泄漏。

<p> C++指针运算与内存地址访问技巧 p> <p>C++指针运算，简单说就是通过加减偏移量来访问内存中的数据。它直接操作内存地址，既强大又危险，用得好能提高效率，用不好就可能导致程序崩溃。p> <p>指针运算与内存地址访问技巧p>

如何理解C++指针的加减运算？

<p>C++指针的加减运算，实际上是在指针所指向的内存地址上进行偏移。这个偏移量不是简单的字节数，而是指针类型大小的倍数。比如，

<pre>int* ppre>

，

<pre>p + 1pre>

实际上是将

<pre>ppre>

指向的地址加上

<pre>sizeof(int)pre>

个字节。p> <p>举个例子，假设

<pre>int arr[5] = {1, 2, 3, 4, 5}; int* p = arr;pre>

那么

<pre>p + 2pre>

就指向了

<pre>arr[2]pre>

的地址，也就是数字3的存储位置。这种运算在数组遍历时非常有用。p> <p>pan>立即学习pan>“ps://pan.quark.cn/s/6e7abc4abb9f" style="text-decoration: underline !important; color: blue; font-weight: bolder;" rel="nofollow" target="_blank">C++免费学习笔记（深入）”；p> <p>但是，要注意指针越界问题。如果

<pre>p + 5pre>

，那么指针就指向了数组之外的内存，访问这个地址可能会导致程序崩溃或者产生不可预测的结果。这就是指针运算的风险所在。p>

指针运算在哪些场景下特别有用？

<p>指针运算在处理数组、动态内存分配和数据结构时非常有用。p>

数组遍历： 前面已经提到了，通过指针的加减运算可以快速访问数组中的元素，而无需使用下标。
动态内存分配： 使用
<pre>newpre>
动态分配的内存，通常需要用指针来管理。指针运算可以帮助我们在分配的内存块中定位不同的数据。
数据结构： 比如链表、树等数据结构，它们通常由指针连接各个节点。指针运算可以用来遍历这些结构。

<p>例如，假设我们有一个动态分配的数组：p>

<pre>int* arr = new int[10]; for (int i = 0; i < 10; ++i) { *(arr + i) = i * 2; // 使用指针运算赋值 }pre>

<p>这段代码使用指针运算

<pre>arr + ipre>

来访问数组中的每个元素，并赋值。虽然也可以使用

<pre>arr[i]pre>

，但理解指针运算对于理解C++的底层机制至关重要。p>

如何避免指针运算中的常见错误？

<p>指针运算最常见的错误就是越界访问和空指针解引用。p>

越界访问： 确保指针始终指向有效的内存区域。在进行指针运算时，要仔细检查偏移量是否超出了数组或内存块的范围。
空指针解引用： 在使用指针之前，一定要检查指针是否为空。如果指针为空，解引用会导致程序崩溃。可以使用
<pre>if (p != nullptr)pre>
来判断指针是否为空。

<p>另外，要注意指针的类型。不同类型的指针，加减运算的偏移量是不同的。如果类型不匹配，可能会导致访问错误的内存地址。p> <p>一个建议是，尽量使用迭代器和智能指针来代替原始指针。迭代器可以提供更安全的数组访问方式，而智能指针可以自动管理内存，避免内存泄漏和悬挂指针。p>

指针与`const`关键字结合使用有哪些技巧？

<p>

<pre>constpre>

关键字在C++中可以用来修饰指针，从而限制指针的行为。理解

<pre>constpre>

指针的用法对于编写安全可靠的代码非常重要。p>

*指向常量的指针（`const int p`）：** 这种指针指向的是一个常量，不能通过该指针修改所指向的值。但是，指针本身的值可以改变，可以指向其他的内存地址。
*常量指针（`int const p`）：** 这种指针是一个常量，它的值不能改变，也就是不能指向其他的内存地址。但是，可以通过该指针修改所指向的值。
*指向常量的常量指针（`const int const p`）：** 这种指针既不能修改指向的值，也不能指向其他的内存地址。

<p>例如：p>

ps://phps.yycxw.com/ai/tavus"> C++指针运算与内存地址访问技巧

ai_manual/001/431/639/68b6cfa7b10b4202.png" alt="C++指针运算与内存地址访问技巧">

ps://phps.yycxw.com/ai/tavus">Tavus <p>Tavus是一个AI视频生成平台，可以自动将你的视频个性化给每个观众。p>

pan>84pan>

ps://phps.yycxw.com/ai/tavus"> pan>查看详情pan> C++指针运算与内存地址访问技巧

<pre>int a = 10; const int* p1 = &amp;a; // 指向常量的指针 // *p1 = 20; // 错误，不能通过p1修改a的值 p1 = &amp;a; // 正确，p1可以指向其他的内存地址 int* const p2 = &amp;a; // 常量指针 *p2 = 20; // 正确，可以通过p2修改a的值 // p2 = &amp;a; // 错误，p2不能指向其他的内存地址pre>

<p>使用

<pre>constpre>

指针可以提高代码的安全性，防止意外修改数据。在函数参数中使用

<pre>constpre>

指针，可以告诉函数调用者，该函数不会修改指针所指向的值。p>

如何使用指针访问结构体和类成员？

<p>使用指针访问结构体和类成员，需要用到箭头运算符

<pre>->pre>

。p> <p>假设我们有一个结构体：p>

<pre>struct Person { std::string name; int age; };pre>

<p>我们可以创建一个指向

<pre>Personpre>

结构体的指针，并使用

<pre>->pre>

运算符访问其成员：p>

<pre>Person person; person.name = "Alice"; person.age = 30; Person* p = &amp;person; std::cout << p->name << std::endl; // 输出 "Alice" std::cout << p->age << std::endl; // 输出 30pre>

<p>

<pre>p->namepre>

相当于

<pre>(*p).namepre>

，但是前者更简洁易懂。p> <p>在类中，使用指针访问成员也是类似的。需要注意的是，如果类成员是私有的，那么只能在类的内部通过指针访问。p>

如何使用指针进行动态内存管理，避免内存泄漏？

<p>动态内存管理是C++中一个重要的概念。使用

<pre>newpre>

运算符可以动态分配内存，使用

<pre>deletepre>

运算符可以释放内存。但是，如果忘记释放内存，就会导致内存泄漏。p> <p>为了避免内存泄漏，可以使用智能指针。智能指针是一种特殊的指针，它可以自动管理所指向的内存，当智能指针超出作用域时，会自动释放所管理的内存。p> <p>C++提供了几种智能指针：p>

<pre>std::unique_ptrpre>
：独占式智能指针，一个
<pre>unique_ptrpre>
只能指向一个对象，不能被复制或共享。当
<pre>unique_ptrpre>
销毁时，会自动释放所管理的内存。
<pre>std::shared_ptrpre>
：共享式智能指针，多个
<pre>shared_ptrpre>
可以指向同一个对象。当最后一个
<pre>shared_ptrpre>
销毁时，会自动释放所管理的内存。
<pre>std::weak_ptrpre>
：弱引用智能指针，可以指向
<pre>shared_ptrpre>
所管理的对象，但是不会增加对象的引用计数。
<pre>weak_ptrpre>
可以用来解决
<pre>shared_ptrpre>
循环引用的问题。

<p>使用智能指针可以大大简化动态内存管理，避免内存泄漏。例如：p>

<pre>std::unique_ptr<int> p(new int(10)); // 使用 unique_ptr 管理动态分配的 int std::cout << *p << std::endl; // 输出 10 // p 超出作用域时，会自动释放所管理的内存pre>

<p>总而言之，C++ 指针运算是一把双刃剑，需要小心使用。理解指针的本质，掌握指针运算的技巧，才能写出高效、安全的C++代码。p><p>p>

pan>相关标签：pan>