C++指针（五）完结篇


#include <iostream>

// 左边修饰
void guo1() {
    int n=20,mu=1000;    
    const int* ptr=&n;
    *ptr=10;//ok?
    ptr=&mu;//ok?
    std::cout << *ptr << std::endl;
}

// 右边修饰
void guo2() {
    int n=20,mu=1000;    
    int const* ptr=&n;
    *ptr=10;//ok?
    ptr=&mu;//ok?
    std::cout << *ptr << std::endl;
}

// 中间修饰
void guo3() {
    int n=20,mu=1000;    
    int const* const ptr=&n;
    *ptr=10;//ok?
    ptr=&mu;//ok?
    std::cout << *ptr << std::endl;
}

// 无修饰
void guo4() {
   int n=20,mu=1000;    
    int* ptr=&n;
    *ptr=10;//ok?
    ptr=&mu;//ok?
    std::cout<<*ptr<<std::endl;
}

int main() {
    int num = 5;
    guo1();    
    guo2();
    guo3();
    guo4();

    return 0;
}

在上述示例中，分别定义了四个函数，用于演示const修饰指针变量的不同情况。调用这些函数并传入一个整数的指针变量。

注：黑色圆圈处表示有语法错误。

总结：const修饰在左边，表示指针所指向的数据是常量，无法通过指针修改其值，但是可以修改指针的值。
const修饰在右边，表示指针本身是常量，无法通过指针修改其指向的地址，但指针指向的值可以通过指针改变。
const修饰在中间，表示指针本身和其所指向的数据都是常量，无法通过指针修改其指向的地址和值。
没有使用const修饰，表示指针和指针所指向的数据都可以修改。

注意，在上述示例中，对于const修饰的指针变量，是无法通过指针修改其指向的数据的，但是可以通过其他方式修改其指向的数据，比如通过其他指针或者直接使用变量名访问。

2.野指针

野指针是指未初始化或者指向已经释放的内存的指针。野指针可能会导致严重的错误，因为我们无法预测野指针指向的内存中存储了什么数据，或者该内存是否还有效。当我们试图访问野指针指向的内存时，可能会导致程序崩溃、数据损坏或其他意想不到的行为。

2.1为何会出现野指针？

野指针的成因可以有多种情况，主要包括以下几种：

2.1.1未初始化指针

当我们声明一个指针变量但没有初始化它时，它将包含一个不确定的值，即垃圾值。这个指针指向的内存地址是未知的，因此成为野指针。

int* ptr; // 未初始化指针，成为野指针

2.1.2 指针越界访问

当我们使用指针访问超出其指向对象边界的内存时，它可能指向其他未知的内存地址，导致成为野指针。

int arr[5];
int* ptr = &arr[0];

// 在指针越界访问后，ptr成为野指针
ptr += 10; // 超出arr数组边界

2.1.3 指针指向已释放的内存

当我们使用delete释放一个指针指向的内存后，如果没有将指针设置为nullptr或者重新指向其他有效的内存地址，它仍然保留之前指向的无效内存地址，成为野指针。

int* ptr = new int;
delete ptr; // 释放指针指向的内存

// 没有将ptr设置为nullptr或重新指向其他内存，ptr成为野指针

2.1.4 函数返回局部变量指针

当一个函数返回一个指向局部变量的指针时，当函数结束时，局部变量会被销毁，指针将指向无效的内存地址，成为野指针。

int* getLocalPointer() {
    int num = 10;
    int* ptr = &num;
    return ptr; // 返回指向局部变量的指针
}

int* ptr = getLocalPointer(); // ptr成为野指针，指向已销毁的内存

2.1.5 引用指针的指针

当我们使用一个指向指针的指针时，如果没有正确地进行地址传递或赋值，指针指向的地址可能是未知的，导致成为野指针。

int num = 10;
int* ptr = &num;
int** refPtr = &ptr; // 指向指针的指针

int* wildPtr = *refPtr; // 未正确传递地址，wildPtr成为野指针

2.2如何避免野指针？

要避免野指针问题，可以采取以下几个方法：

2.2.1初始化指针

在声明指针变量时，立即将其初始化为nullptr或者有效的内存地址，这样可以避免使用未初始化的指针。

int* ptr = nullptr; // 初始化为nullptr
int n=1;
*ptr=&n;

2.2.2 及时释放和重置指针

在使用完成后，及时释放指针所指向的内存，并将指针重置为nullptr，以防止它成为野指针。

int* ptr = new int;
// 使用ptr指向的内存

delete ptr; // 释放内存
ptr = nullptr; // 重置指针为nullptr

2.2.3 避免越界访问

确保指针在访问内存时不会超出其所指向对象的边界，这样可以避免指针成为野指针。

int arr[5];
int* ptr = &arr[0];
// 使用ptr访问arr的合法元素

// 避免越界访问

2.2.4 使用智能指针

使用C++标准库提供的智能指针类，如std::shared_ptr、std::unique_ptr等，来自动管理内存资源。智能指针会负责在不需要时自动释放内存，避免野指针的问题。

std::shared_ptr<int> ptr = std::make_shared<int>(5);
// 使用ptr指向的内存

// 不需要手动释放内存

2.2.5 避免返回指向局部变量的指针

确保在函数返回指向局部变量的指针之前，将其转移到堆上分配的内存或者是静态存储区域中。

int* getDynamicPointer() {
    int* ptr = new int(10);
    return ptr; // 返回指向堆上分配的内存的指针
}

int* ptr = getDynamicPointer(); // 调用后，ptr指向有效的内存

2.2.6 使用合适的作用域和生命周期管理

确保在适当的时候创建和销毁指针，避免指针超出其作用域而导致成为野指针。
void foo() {
    int* ptr = new int;
    // 使用ptr指向的内存

    delete ptr; // 在合适的位置释放内存
}

遵循这些规则和最佳实践可以有效地避免野指针问题，并提高代码的稳定性和可靠性。

3.assert断言

断言是在程序中用于验证预设条件的一种机制。断言通常用于检查程序中的错误、逻辑错误或不可能发生的情况。当断言条件为假时，程序会中止执行，并输出相关的错误信息。

3.2断言实现

在C++中，断言的使用需要包含<assert.h>头文件，并使用assert宏来进行断言。assert宏接受一个表达式作为参数，如果表达式为假（即false），则会触发断言失败。

示例代码如下：

#include <iostream>
#include <cassert>

int main() {
    int x = 10;
    
    assert(x > 0); // 断言条件 x > 0 为真
    
    std::cout << "Program continues..." << std::endl;
    
    return 0;
}

在上述代码中，assert(x > 0) 断言了变量x大于0的条件。如果x小于等于0，程序会中止执行，并输出相关的错误信息。

断言的目的是在开发和测试阶段快速发现和诊断错误，因此在发布版本的代码中通常会禁用断言。可以使用NDEBUG宏定义来在编译时禁用断言。在编译时加上"-DNDEBUG"选项，或者在代码中添加如下代码：

#define NDEBUG

断言的使用可以帮助程序员快速发现和解决错误，但需要注意，过多地使用断言可能会导致代码冗余和性能下降，因此需要在必要的地方使用，并在发布版本中禁用。

4.双指针

双指针是指在算法中使用两个指针来解决问题的一种技巧。这两个指针可以指向同一个数组或链表的不同位置，也可以分别指向两个不同的数组或链表。

4.1双指针的作用

双指针常用于解决数组、链表或字符串相关的问题，如判断回文串、找出两个有序数组的交集、反转链表等。使用双指针技巧可以在O(n)或O(nlogn)的时间复杂度内完成操作，提高了算法的效率。

双指针的作用主要有以下几个方面：

1. 求解数组或链表中的特定问题：双指针可以用来解决一些特定的数组或链表问题，如判断链表是否有环、找到链表的中间节点、找到数组中的两个数等。

2. 滑动窗口问题：滑动窗口是指在一个固定大小的窗口内进行移动的一种技巧。双指针可以用于实现滑动窗口算法，以解决一些字符串或数组中的子串或子数组问题，如找到字符串中的最长无重复字符子串、找到数组中满足某种条件的最短连续子数组等。

3. 排序问题：双指针也可以用于解决排序相关的问题，如快速排序、归并排序等。双指针可以在不同的位置同时移动，以实现快速的交换和比较操作，从而实现排序的目的。

总的来说，双指针是一种灵活且高效的算法技巧，可以用于解决多种不同的问题。具体要根据不同的问题情况来选择使用双指针的方法和策略。

4.2双指针的实现

双指针可以实现以下几种操作：

4.2.1快慢指针

通过定义两个指针，一个移动速度较快，一个移动速度较慢，从而实现对数据结构的遍历或查找。通常情况下，快指针每次移动一定步数，而慢指针每次移动一步。这种方法常用于解决链表中的问题。

ListNode* findMiddle(ListNode* head) {
    ListNode* slow = head; // 慢指针
    ListNode* fast = head; // 快指针
    
    while (fast != nullptr && fast->next != nullptr) {
        slow = slow->next; // 慢指针每次移动一步
        fast = fast->next->next; // 快指针每次移动两步
    }
    
    return slow; // 返回慢指针指向的节点，即链表的中间节点
}

4.2.2左右指针

通过定义两个指针，一个指向数据结构的开头（一般为0），一个指向数据结构的末尾（一般为数组长度-1），从而在有序数组中进行搜索、查找或双向遍历。左指针向右移动，右指针向左移动，根据问题的要求，我们可以根据比较结果决定指针的移动策略。

int twoSum(vector<int>& nums, int target) {
    int left = 0; // 左指针
    int right = nums.size() - 1; // 右指针
    
    while (left < right) {
        int sum = nums[left] + nums[right]; // 当前左右指针指向的元素之和
        
        if (sum == target) {
            return true; // 如果和等于目标值，返回true
        }
        else if (sum < target) {
            left++; // 如果和小于目标值，左指针右移一位
        }
        else {
            right--; // 如果和大于目标值，右指针左移一位
        }
    }
    
    return false; // 如果找不到满足条件的两个元素，返回false
}

4.2.3 对撞指针

对撞指针也是一种常见的在有序数组或字符串中查找特定目标值的方法。通过定义两个指针，一个指向起始位置，一个指向结束位置，然后通过根据问题的要求，不断调整左指针和右指针的移动策略，来找到满足条件的解。

int binarySearch(vector<int>& nums, int target) {
    int left = 0; // 左指针
    int right = nums.size() - 1; // 右指针
    
    while (left <= right) {
        int mid = left + (right - left) / 2; // 中间位置的索引
        
        if (nums[mid] == target) {
            return mid; // 如果中间元素等于目标值，返回索引
        }
        else if (nums[mid] < target) {
            left = mid + 1; // 如果中间元素小于目标值，更新左指针为中间位置的右侧
        }
        else {
            right = mid - 1; // 如果中间元素大于目标值，更新右指针为中间位置的左侧
        }
    }
    
    return -1; // 如果找不到目标值，返回-1
}

4.2.4滑动窗口

这是一种在数组或字符串上定义一个窗口，通过调整窗口的大小和位置，来满足问题的要求。通常需要定义两个指针，一个指向窗口的起始位置，一个指向窗口的结束位置，然后根据条件来滑动窗口，得到问题的解。

int minSubArrayLen(int target, vector<int>& nums) {
    int left = 0; // 窗口左边界
    int sum = 0; // 窗口内元素的和
    int minLength = INT_MAX; // 最小子数组长度
    
    for (int right = 0; right < nums.size(); right++) {
        sum += nums[right]; // 右指针扩大窗口，累加元素
        
        while (sum >= target) { // 当窗口内元素之和大于等于目标值时
            minLength = min(minLength, right - left + 1); // 更新最小长度
            
            sum -= nums[left]; // 缩小窗口，左指针右移，从窗口中移除元素
            left++;
        }
    }
    
    return minLength == INT_MAX ? 0 : minLength; // 如果找不到满足条件的子数组，返回0
}

以上是一些常用的双指针的实现，它们常用于解决一些特定问题。

4.3双指针的练习

题目：给定一个整数数组和数组的大小n，要求将数组翻转。

步骤：
1. 定义两个指针：left指向数组的第一个元素，right指向数组的最后一个元素。
2. 进入循环，当left小于right时执行以下步骤：
- 交换left和right指向的元素。
- left向右移动一位。
- right向左移动一位。
3. 循环结束后，数组将按照相反的顺序排列。

知识点：
- 双指针：双指针技巧可以在数组中快速交换元素的位置。
- 数组操作：访问数组元素、数组下标、交换数组元素等基本操作。

流程图：

   +---------------------------------------+
   | 初始化左指针和右指针                    |
   +-----+-------------------------------+------+
         |                               |
         v                               v
   +-----|-------------------------------|-----+
   | 交换左指针和右指针指向的元素              |
   +-----+-----------------------+-------+------+
         |                       |       
         v                       v
   +-----|-----------------------|-----+
   | 左指针右移               右指针左移  |
   +-------------------------------+------+

代码：

#include <iostream>
#include <vector>
using namespace std;

void reverseArray(int nums[], int n) {
    int left = 0;
    int right = n - 1;
    
    while (left < right) {//双指针法
        swap(nums[left], nums[right]);
        left++;
        right--;
    }
}

int main() {
    int n;
    
    cin >> n;

    int nums[n];

    for (int i = 0; i < n; i++) {
        cin >> nums[i];
    }

    reverseArray(nums, n);

    for (int i = 0; i < n; i++) {
        cout << nums[i] << " ";
    }
    cout << endl;

    return 0;
}

这段代码演示了如何使用双指针技巧将给定的数组进行翻转，在这里，我们使用了左右指针来解决这道题目。

运行结果：

左右指针执行图表：

5.NULL指针

NULL指针是一个特殊的指针常量，表示指针不指向任何有效的内存位置。它的作用在于表示一个无效的指针，可用于初始化指针变量，将其置为空值。

在C++中，NULL指针通常被定义为值为0的常量或者使用宏定义NULL。随着C++11标准的引入，还可以使用nullptr关键字表示空指针。

5.1NULL指针的操作

NULL指针在C++中可以进行如下操作：

5.1.1 初始化指针变量

可以将指针变量初始化为NULL，表示它不指向任何有效的内存位置。示例代码如下：

int* ptr = NULL;

5.1.2判断指针是否为空

可以使用if语句或条件表达式判断指针是否为空。示例代码如下：

if (ptr == NULL) {
    // 指针为空的处理逻辑
}

// 或者使用条件表达式
bool isEmpty = (ptr == NULL);

5.1.3 赋值为NULL

可以将一个已经声明的指针变量赋值为NULL，表示将其指向空地址。示例代码如下：

int* ptr = new int; // 假设分配了一块动态内存
ptr = NULL; // 将指针赋值为空

5.1.4 检测NULL指针异常

在访问指针指向的内存之前，应该先判断指针是否为空，以避免空指针异常。示例代码如下：

if (ptr != NULL) {
    // 访问ptr指向的内存
} else {
    // 指针为空的处理逻辑
}

总之，NULL指针用于表示指针不指向任何有效的内存位置，可以进行初始化、判断、赋值等操作，以便于安全地处理指针相关的逻辑。

对了，这里大家需要注意一点，把指针赋值为NULL并不是没有给指针初始化，而是赋值为空，所以大家不必担心出现野指针。

总结

本篇博客到这里就结束了，感谢大家的支持与观看，如果有好的建议欢迎留言，制作不易，如果这篇文章对您有帮助，那请给PingdiGuo_guo一个免费的赞，谢谢大家啦！

标签：完结篇,指向,int,C++,内存,NULL,ptr,指针
From： https://blog.csdn.net/PingdiGuo_guo/article/details/136581951

前言

1.const与指针

1.1修饰变量

1.2修饰指针变量