C++指针（二）

已于 2024-03-03 07:15:03 修改
阅读量1.3k 收藏 61
点赞数 63
分类专栏： C++干货专栏 文章标签： c++ 开发语言
于 2024-02-29 18:32:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pingdiguo_guo/article/details/136304640
版权

个人主页：PingdiGuo_guo

收录专栏：C++干货专栏

文章目录

前言

1.数组指针

1.1数组指针的概念

1.2数组指针的用处

1.3数组指针的操作

1.4二维数组如何访问

1.5数组指针访问流程

1.6数组指针的练习题

2.指针数组

2.1指针数组的概念

2.2指针数组的用处

2.3指针数组的操作

2.4指针二维数组

2.4指针数组的练习题

3.对比

总结

前言

本篇是介绍数组指针与指针数组的概念，用处，操作以及练习的。点赞破五十，更新下一期。

1.数组指针

在C++指针（一）中，我们知道指针是用来存放地址的，普通的指针只是用来存放一个变量的地址的，可想要存储一个数组的地址呢？接下来就要请出我们的新朋友：数组指针。

1.1数组指针的概念

数组指针是指向数组的指针。它指向数组的第一个元素的地址，通过递增指针的值可以访问数组中的其他元素。数组指针可以帮助程序员更灵活地操作数组，尤其是在需要传递数组作为参数或返回数组的函数中。

1.2数组指针的用处

数组指针有很多用途，以下是其中一些常见的用途：

1.遍历数组：通过指针运算，可以使用数组指针遍历整个数组，访问数组中的每个元素。

2.传递数组给函数：可以使用数组指针作为函数参数，将整个数组传递给函数。这样可以避免在函数中复制整个数组，提高程序的效率。

3.动态分配内存：可以使用数组指针来动态分配内存，创建动态数组。通过指针操作可以方便地访问和修改动态数组中的元素。

4.二维数组访问：对于二维数组，可以使用数组指针来访问和操作多维数组中的元素。

5.字符串操作：字符串在C语言中本质上是一个字符数组，可以使用数组指针来操作和处理字符串。

6.数组的排序和搜索：使用数组指针可以方便地对数组进行排序和搜索操作，以实现快速的查找和排序算法。

1.3数组指针的操作

数组指针存储一个数组的地址的步骤如下：

1. 首先，定义一个数组类型的指针变量。

int *ptr

2. 然后，将数组的首地址赋值给指针变量。有两种方法可以实现这一点：

a. 使用数组名来给指针变量赋值，因为数组名本身就是数组的首地址。具体代码如下所示：

int arr[6]={0,1,2,3,4,5};
ptr = arr;

b. 使用取地址运算符&来获取数组的首地址，并将其赋值给指针变量。具体代码如下所示：

int arr[6]={0,1,2,3,4,5};
ptr = &arr[0];

4.现在，指针变量ptr就存储了数组arr的首地址。我们可以通过该指针变量来访问数组中的元素。例如，可以使用*ptr来访问第一个元素，*(ptr + 1)来访问第二个元素，依此类推。当然，我们也可以用ptr[i]的形式来访问数组元素，这里，我们先学习比较常见的*(ptr+i)的方法。具体代码如下所示：

for (int i = 0; i < 6; i++) {
        cout << *(ptr + i) << " "; // 通过指针变量访问数组元素
    }

运行结果：

数组名为地址：

用取地址符：

5.数组数组的累加操作：首先定义一个整型数组arr，然后将数组的首地址赋值给指针ptr。接下来，使用一个循环和一个累加变量sum以及*(ptr + i)来累加数组中的元素。最后，输出结果。下面是一个示例代码：


 

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    int* ptr = arr;  // 将数组的首地址赋值给指针

    int sum = 0;
    for (int i = 0; i < 5; i++) {
        sum += *(ptr + i);  // 使用指针加法操作来访问数组中的元素
    }

    cout << "Sum: " << sum << endl;

    return 0;
}

请注意，使用指针加法操作访问数组元素时，需要确保指针的有效性和数组的边界。不要越界访问数组元素，否则会导致未定义的行为。

6.数组指针插入操作：

1. 创建一个新的数组，长度比原数组大1；
2. 将要插入位置之前的元素复制到新数组中；
3. 插入新元素到指定位置；
4. 将原数组指定位置之后的元素复制到新数组中；
5. 释放原数组的内存；
6. 将新数组的地址赋值给原数组指针。

代码示例：
 



#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    int size = 5;
    int r = 2, p = 10;

    // 创建新的数组，长度比原数组大1
    int *newArr = new int[size + 1];

    // 将要插入位置之前的元素复制到新数组中
    for (int i = 0; i < r; i++) {
        newArr[i] = arr[i];
    }

    // 插入新元素到指定位置
    newArr[r] = p;

    // 将原数组指定位置之后的元素复制到新数组中
    for (int i = r; i < size; i++) {
        newArr[i + 1] = arr[i];
    }

    // 输出新数组
    std::cout << "新数组：";
    for (int i = 0; i < size + 1; i++) {
        std::cout << newArr[i] << " ";
    }
    std::cout << std::endl;

    // 释放原数组的内存
    delete[] arr;

    // 将新数组的地址赋值给原数组指针
     newArr = arr;

    std::cout<<"地址："<<newArr<<std::endl;
    return 0;
}

在上述代码中，我们通过动态内存分配创建了一个新的数组，然后将原数组的元素复制到新数组中，并在指定位置插入新的元素。最后释放原数组的内存，将新数组的地址赋值给原数组指针。这样就实现了数组中元素的插入操作。

1.4二维数组如何访问

以下是使用数组指针访问二维数组的步骤和示例代码：

步骤：

1. 声明一个二维数组，并初始化。
2. 声明一个指向二维数组的指针变量。
3. 将指针变量指向二维数组的首地址。
4. 使用指针变量访问二维数组的元素。

示例代码：

 

#include <iostream>

int main() {
    // 声明并初始化二维数组
    int matrix[3][3] = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 声明指向二维数组的指针变量，并将其指向二维数组的首地址
    int (*ptr)[3] = matrix;

    // 使用指针变量访问二维数组的元素
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << ptr[i][j] << " ";
        }
        std::cout << std::endl;
    }

    return 0;
}

运行结果：

1.5数组指针访问流程

数组指针访问的流程就是先指向指针头部，再遍历访问数组元素。如下：

其中，下标也可替换为数组元素。

1.6数组指针的练习题

题目：

给定一个整型数组arr和数组的长度size，编写一个函数将数组中的元素按照升序排列。

步骤：
1. 创建一个函数，命名为sortArray。函数参数包括一个整型数组指针arr和一个整型变量size。
2. 使用冒泡排序算法对数组进行排序。冒泡排序的原理是通过比较相邻的元素并交换位置来进行排序。
3. 在排序过程中，需要两层循环。外层循环控制排序的轮数，内层循环用来比较和交换元素。
4. 内层循环的条件是从0到size-1进行遍历，每次比较arr[j]和arr[j+1]的大小，如果arr[j]大于arr[j+1]，则交换两个元素的位置。
5. 在外层循环结束后，数组的元素将按照升序排列。
6. 在main函数中创建一个整型数组并初始化，调用sortArray函数进行排序，然后输出排序后的数组。

知识点：
1. 数组指针
2. 冒泡排序算法
3. 循环控制结构

流程图式：

代码示例：
 

#include <iostream>

void sortArray(int* arr, int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {5, 3, 8, 2, 1};
    int size = sizeof(arr) / sizeof(arr[0]);

    std::cout << "排序前的数组：";
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    sortArray(arr, size);

    std::cout << "排序后的数组：";
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}

运行结果：

题目：
请编写一个程序，实现以下功能：

1. 创建一个包含10个整数的数组，并将其初始化为{1, 3, 5, 7, 9, 2, 4, 6, 8, 10}；
2. 使用指针操作数组元素，找到数组中最大的元素，并输出其值和索引。

步骤：

1.创建一个包含10个整数的数组，并将其初始化为{1, 3, 5, 7, 9, 2, 4, 6, 8, 10}。

2.声明一个指针变量ptr，并将其指向数组的首地址，即第一个元素。

3.声明一个变量max，并将其初始化为数组的第一个元素。

4.声明一个变量index，并将其初始化为0。

5.使用for循环从数组的第二个元素开始遍历数组。

6.在循环中，使用指针算术运算访问数组元素，并将其与max进行比较。

7.如果当前元素大于max，则将max更新为当前元素，并将index更新为当前元素的索引。

8.循环结束后，max将存储数组中最大的元素，index将存储最大元素的索引。

9.输出max和index的值。

10.程序结束。

知识点：

数组指针，指针算术运算。

流程图式：
 

代码示例：

 

#include <iostream>

int main() {
    int arr[10] = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
    int *ptr = arr; // 数组指针指向数组的第一个元素

    int max = *ptr; // 假设第一个元素为最大值
    int index = 0; // 最大值的索引

    // 使用指针遍历数组，找到最大值及其索引
    for (int i = 1; i < 10; i++) {
        if (*(ptr + i) > max) {
            max = *(ptr + i);
            index = i;
        }
    }

    // 输出最大值及其索引
    std::cout << "数组中最大的元素为：" << max << std::endl;
    std::cout << "其索引为：" << index << std::endl;

    return 0;
}

运行结果图：

2.指针数组

那有没有每一个元素都是指针的数组呢？当然也有啦，接下来要讲的指针数组就是。

2.1指针数组的概念

指针数组是指一个数组中的每个元素都是指针的数组。每个元素都指向不同的内存地址，可以在内存中找到实际的数据。

2.2指针数组的用处

指针数组有很多使用场景，以下是一些常见的用途：

1. 字符串数组：指针数组可以用来存储多个字符串，每个字符串都是一个指针，指向不同的字符串常量或字符数组。

2. 存储多个对象的引用：指针数组可以用来存储多个对象的指针，通过遍历指针数组可以操作这些对象，比如进行排序、搜索等操作。

3. 多级指针：指针数组还可以用来存储多个指针的指针，即多级指针。多级指针可以用于动态存储和访问多维数组、链表等数据结构。

4. 动态内存分配：指针数组可以用于动态分配内存，比如创建一个动态大小的数组。通过使用指针数组，可以根据需要动态调整数组的大小。

5. 函数参数传递：指针数组可以作为函数参数，传递给函数需要操作数组的指针。通过指针数组，可以在函数内部对数组进行修改，从而达到改变数组的目的。

总的来说，指针数组提供了一种便捷的方式来管理和操作多个相关的数据或对象，具有灵活性、高效性和方便性。

2.3指针数组的操作


1. 声明一个指针数组，代码如下：

// 创建指针数组并确定大小
    const int SIZE = 5;
    int* arr[SIZE];

SIZE是一个常量，用于记录指针数组arr的大小。


2. 初始化指针数组的元素：可以使用已存在的变量或者动态分配内存来创建新的变量。代码如下：

 // 初始化指针数组的元素
    int num1 = 10;
    int num2 = 20;
    int num3 = 30;
    int* ptr1 = new int(40); // 使用动态内存分配创建新变量
    int* ptr2 = new int(50);

    arr[0] = &num1;
    arr[1] = &num2;
    arr[2] = &num3;
    arr[3] = ptr1;
    arr[4] = ptr2;

看到了么，指针数组是可以记录很多相同类型的变量的，也可以记录一个指针。


3. 访问指针数组的元素：即通过指针+循环的形式访问对应的变量或数据，这里就不需要向数组指针那样啦，直接用*arr[i]的形式即可。代码如下：

 // 访问并输出指针数组的元素
    for (int i = 0; i < SIZE; i++) {
        std::cout << *arr[i] << " ";
    }
    std::cout << std::endl;

4.插入：声明一个新的指针来存储要插入的元素的地址。将要插入的元素赋值给新的指针。将所有后续元素往后移动一个位置，为要插入的元素腾出空间。在要插入的位置上将新的指针赋值给指针数组。

下面是一个示例代码，演示了如何在指针数组中插入元素：


 

#include <iostream>
using namespace std;

int main() {
    int* arr[5] = { nullptr, nullptr, nullptr, nullptr, nullptr }; // 声明一个指针数组

    int value = 10; // 要插入的元素
    int* newValue = new int(value); // 在堆上分配内存空间，并将元素的地址赋值给新的指针

    int insertIndex = 2; // 要插入的位置

    // 将后续元素往后移动一个位置
    for (int i = 4; i > insertIndex; i--) {
        arr[i] = arr[i - 1];
    }

    // 将新的指针赋值给指针数组的插入位置
    arr[insertIndex] = newValue;

    // 输出指针数组的内容
    for (int i = 0; i < 5; i++) {
        if (arr[i] != nullptr) {
            cout << *arr[i] << " ";
        }
        else {
            cout << "null ";
        }
    }

    delete newValue; // 释放堆上分配的内存

    return 0;
}

注意，在使用完指针数组中的指针后，需要手动释放通过 `new` 运算符分配的内存空间，以避免内存泄漏。


5. 查找：查找指针数组中的特定元素，通过比较指针或变量的值来确定是否存在，我们可以用循环一个一个的查找。代码如下：

 // 查找指针数组中的特定元素
    int* searchNum = &num2;
    bool found = false;
    for (int i = 0; i < SIZE; i++) {
        if (arr[i] == searchNum) {
            found = true;
            break;
        }
    }
    if (found) {
        std::cout << "Element found in the pointer array." << std::endl;
    } else {
        std::cout << "Element not found in the pointer array." << std::endl;
    }

注：这里可以把SIZE改为变量。

对了，最后不要忘记释放内存，代码如下：    

// 释放动态内存
    delete ptr1;
    delete ptr2;

2.4指针二维数组

指针二维数组是一个具有指针类型元素的二维数组。可以使用指针二维数组来表示和操作多维的数据结构，如矩阵、图像等。下面是一个使用指针二维数组来表示矩阵，并进行一些操作的示例代码：


 

#include <iostream>
using namespace std;

int main() {
    int rows = 3;
    int cols = 3;

    // 声明一个指针二维数组
    int** matrix = new int*[rows];
    for (int i = 0; i < rows; i++) {
        matrix[i] = new int[cols];
    }

    // 初始化矩阵
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            matrix[i][j] = i * cols + j + 1;
        }
    }

    // 输出矩阵
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }

    // 释放内存
    for (int i = 0; i < rows; i++) {
        delete[] matrix[i];
    }
    delete[] matrix;

    return 0;
}

在这个示例中，我们首先声明了一个指针二维数组 matrix，它有3行3列。然后，使用 new 运算符为每一行分配内存空间。接下来，我们通过双重循环初始化矩阵的元素值。最后，通过双重循环输出矩阵的元素值。

在使用完指针二维数组后，记得释放为每一行分配的内存空间，并释放指针二维数组本身的内存空间，以避免内存泄漏。

运行结果：

2.4指针数组的练习题

题目：

假设有一个字符串数组，其中存储了一些人的姓名，请编写一个程序，将这些人的姓名按照字典序排序，并输出排序后的结果。

步骤：
1. 声明一个指针数组，用来存储人名的指针。
2. 声明一个整型变量 `n`，表示人名的数量，并根据实际情况进行赋值。
3. 使用动态内存分配为指针数组分配内存空间，使每个指针指向一个字符串。
4. 使用循环输入各个人名，并将每个人名的指针存储到指针数组中。
5. 使用冒泡排序对指针数组中的指针进行排序。
6. 使用循环输出排序后的人名。
7. 释放指针数组的内存空间。

知识点：
- 指针数组的声明和初始化
- 冒泡排序算法
- 动态内存分配和释放

流程图：


代码：

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

void bubbleSort(string* arr, int n) {
    for (int i = 0; i < n - 1; i++) {
        for (int j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr[j], arr[j + 1]);
            }
        }
    }
}

int main() {
    int n;
    cout << "Enter the number of names: ";
    cin >> n;

    string* names = new string[n];

    for (int i = 0; i < n; i++) {
        cout << "Enter name " << i + 1 << ": ";
        cin >> names[i];
    }

    bubbleSort(names, n);

    cout << "Sorted names are: ";
    for (int i = 0; i < n; i++) {
        cout << names[i] << " ";
    }
    cout << endl;

    delete[] names;

    return 0;
}


 

在代码中，首先声明了指针数组 `names` 和整型变量 `n`，然后使用动态内存分配为指针数组分配内存空间。接下来，通过循环输入人名，并将每个人名的指针存储到指针数组中。然后，使用冒泡排序算法对指针数组进行排序。最后，通过循环输出排序后的人名，并释放指针数组的内存空间。

题目：

设计一个程序，要求从键盘输入10个学生的成绩，并使用指针数组对成绩进行排序并输出排序后的结果。

步骤：
1. 声明一个指针数组，用于存储学生成绩。
2. 通过循环，从键盘输入10个学生的成绩，将成绩存储到指针数组中。
3. 使用冒泡排序算法对指针数组中的成绩进行排序。
4. 输出排序后的学生成绩。

知识点：指针数组、冒泡排序算法、指针的比较和交换。

流程图：

代码：


 

#include <iostream>
using namespace std;

void bubbleSort(int* arr[], int size) {
    for (int i = 0; i < size - 1; i++) {
        for (int j = 0; j < size - i - 1; j++) {
            if (*arr[j] > *arr[j + 1]) {
                int* temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    const int size = 10;
    int* scores[size];

    // 输入学生成绩
    for (int i = 0; i < size; i++) {
        int score;
        cout << "请输入第" << i + 1 << "个学生的成绩：";
        cin >> score;

        scores[i] = new int(score);
    }

    // 对成绩进行排序
    bubbleSort(scores, size);

    // 输出排序后的成绩
    cout << "排序后的成绩为：" << endl;
    for (int i = 0; i < size; i++) {
        cout << *scores[i] << " ";
    }
    cout << endl;

    // 释放内存
    for (int i = 0; i < size; i++) {
        delete scores[i];
    }

    return 0;
}

以上代码中，我们首先声明了一个指针数组 scores，用于存储学生成绩。然后通过循环，从键盘输入10个学生的成绩，并将成绩存储到指针数组中。接下来，使用冒泡排序算法对指针数组中的成绩进行排序。最后，输出排序后的学生成绩。在程序结束前，记得释放为每个学生成绩分配的内存空间，以避免内存泄漏。

3.对比

指针数组和数组指针是两个不同的概念，有以下区别：

1. 定义方式不同：
   - 指针数组：指针数组是指一个数组，其中的每个元素都是一个指针。定义时需要指定数组的大小，例如 `int* arr[size]`，表示一个大小为 `size` 的指针数组。
   - 数组指针：数组指针是指一个指针，它指向一个数组。定义时需要指定指针所指向数组的类型，例如 `int (*ptr)[size]`，表示一个指向大小为 `size` 的整型数组的指针。

2. 访问方式不同：
   - 指针数组：可以通过索引来访问指针数组中的元素，例如 `arr[i]`。
   - 数组指针：可以通过解引用指针来访问数组中的元素，例如 `(*ptr)[i]`。

3. 内存分配不同：
   - 指针数组：指针数组中的每个元素都可以单独分配内存，可以具有不同的大小和类型。
   - 数组指针：数组指针指向的数组是连续存储的，内存是一次性分配的。

4. 数组维度不同：
   - 指针数组：指针数组的每个元素都可以指向不同大小的数组，维度可以是不同的。
   - 数组指针：数组指针指向的数组有固定的大小和维度，指针只能指向该大小和维度的数组。

需要注意的是，指针数组和数组指针可以结合使用，例如可以定义一个数组指针，使其指向一个指针数组。这样既可以通过指针来访问数组的元素，也可以通过数组的索引来访问指针数组的元素。

总结

本篇博客到这里就结束了，感谢大家的支持与观看，如果有好的建议欢迎留言，谢谢大家啦！

PingdiGuo_guo
关注
  • 63
    点赞
  • 踩
  • 61
    收藏
    觉得还不错? 一键收藏
  • 59
    评论
专栏目录
C++指针存储结构
02-27
—概述—线性排序—二进制存放—数据类型和编码—变量和指针—引用—数组—动态存储分配—函数参数传递在内存中的表示概述c++的学习中，对指针的理解和把握相当重要，可能很多同学对此感到困惑。我个人感觉指针的...
C++指针使用方法
01-19
在下列函数声明中，为什么要同时使用...为了理解指针的这种做法，我们先复习一下C/C++编程中无所不在的指针概念。我们都知道MYCLASS*的意思：指向某个对象的指针，此对象的类型为MYCLASS。 void func1(MYCLASS *pMyClas
C++二级指针
m0_65635427的博客
10-31 2994
C++二级指针以及指针数组、数组指针
c++ 指针详解
m0_62870588的博客
03-29 4万+
使用指针遍历数组 ；指针的概念与理解； 指针的含义；指针的创建与初始化 ；指针的基本操作；指针的解引用和取地址；指针的算数操作 ；指针相减 ；const指针；指向const的指针；指针的数组和数组的指针；数组的指针地址；指针的指针；const_cast ;reinterpret_cast;
C++ - 指针总结
了解➔熟悉➔掌握➔精通
02-26 5万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 指针是什么？ 指针是一变量或函数的内存地址，是一个无符号整数，它是以系统寻址范围为取值范围，32位，4字节。 指针变量： 存放地址的变量。在C++中，指针变量只有有了明确的指向才有意义。 指针类型 int* ptr; // ...
C++ STL 四种智能指针
Dablelv 的博客专栏。
08-07 7万+
auto_ptrunique_ptrshared_ptrweak_ptrauto_ptr 是 C++98 提出的，C++11 已将其摒弃，并提出了 unique_ptr 替代 auto_ptr。虽然 auto_ptr 已被摒弃，但在实际项目中仍可使用，但建议使用更加安全的 unique_ptr，后文会详细叙述。shared_ptr 和 weak_ptr 则是 C+11 从准标准库 Boost 中引入的两种智能指针。
C/C++二维数组指针（指向二维数组的指针）详解
coder_Alger 的博客
03-26 3万+
在概念上是二维的，有行和列，但在内存中所有的数组元素都是连续排列的，它们之间没有 “缝隙”。以下面的二维数组 a 为例： int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} }; 从概念上理解，a 的分布像一个矩阵： 0 1 2 3 4 5 6 7 8 9 10 11 但在内存中，a 的分布是一维线性的，整个数组占用一块连续的内存： C 语言中的二维数组是按行排列的，也就是先存放 a .
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 5万+
血的教训？不学智能指针，本人丢了一份工作。
c++函数指针
weixin_50866517的博客
01-27 1万+
函数指针函数指针基础知识深入探讨函数指针使用typedef进行简化 函数指针基础知识 1.完成函数指针需要的工作： 获取函数的地址 声明一个函数指针 使用函数指针来调用函数 1.获取函数地址:只要使用函数名即可。也就是说，如果think()是一个函数，则think()就是该函数的地址。要将函数作为参数进行传递，必须传递函数名。一定要区分传递的是函数的地址还是函数的返回值： process(think); thought(think()); process（）调用使得process()函数能够在其内部调
C++指针详解
热门推荐
weixin_39640298的博客
12-08 9万+
概述 C/C++语言之所以强大，以及其自由性，很大部分体现在其灵活的指针运用上。因此，说指针是C/C++语言的灵魂一点都不为过。 有好的一面，必然会有坏的一面，指针的灵活导致了它的难以控制，所以C/C++程序员的很多bug是基于指针问题上的。今天就对指针进行详细的整理。 1、指针是什么？ 指针是“指向（point to）”另外一种类型的复合类型。复合类型是指基于其它类型定义的类型。 理解指针，先从...
C++指针的作用
u013365312的专栏
09-08 4324
1.指针允许你以更简洁的方式引用大的数据结构 程序的数据结构从原子级别的数据结构：整型、浮点型、字符型、枚举型，到分子级别的数组、结构体（又称为“记录”），再到数据结构中的队列、栈、链表、树等，无论如何复杂，数据结构总是位于计算机的内存中，因此必有地址。利用指针就可以使用地址作为一个完整值的速记符号，因为一个内存地址在内部表示为一个整数。当数据结构本身很大时，这种策略能节约大量内存空间 2.指针使程序的不同部分能够共享数据 类似于共享内存，如果将某一个数据值的地址从一个函数传递到另外一个函数，这两个函数就能
C++函数指针用法
qq_48201696的博客
01-06 7309
C++函数指针详细理解 函数指针初识 函数指针是指向函数的指针,并不等于函数，它能够执行函数的操作，可以跟指针变量一起来理解，其基本声明格式为: type (*ptrname)(形参列表); 例子，声明一个比较两个字符串大小的函数指针 bool (*cp)(const string s1, const string s2); 需要注意的是，**不要去掉括号！！！**如果去掉括号，含义就变成了返回一个bool指针的函数的声明！ 函数指针指向函数类型 再使用函数指针时，函数指针可以发挥与函数相同的功效，即
C++指针精髓
01-21
要了解指针,多多少少会出现一些比较复杂的类型,其实要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,其原则: 从变量名处起,根据运算符优先级结合...
C++指针介绍.ppt
07-27
C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针介绍.ppt C++指针...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 618
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
pyqt5 子线程如何操作主线程GUI
qq_64919823的博客
05-17 971
在使用pyqt5编写gui时遇到两个问题，会导致界面崩溃，今天就围绕这两个问题来简单说明和改进。1.在主线程中使用while无限循环会导致界面崩溃2.在子线程中操作主线程gui会导致界面崩溃。
C++构造函数和析构函数
最新发布
qq_45361567的博客
05-21 404
默认情况下，c++编译器至少给一个类添加3个函数1.默认构造函数（无参，函数体为空）2.默认析构函数（无参，函数体为空）3.默认拷贝构造函数，对属性进行值拷贝构造函数调用规则如下：如果用户定义有参构造函数 c++不在提供默认无参构造 但是会提供默认拷贝构造如果用户定义拷贝构造函数 c++不会再提供其他构造函数。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 407
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 656
对于类类型，如果定义了接受。
c++ 二级指针 参数
11-20
c二级指针是指一个指针变量指向另一个指针变量，也可以说是指向指针的指针。在C语言中，我们可以在函数中使用二级指针参数来实现对指针的间接修改。当我们想要修改函数外部指针变量的值时，可以传递指针变量的地址，也就是二级指针作为函数参数，这样在函数内部就可以通过间接引用来修改指针变量指向的地址。 当我们需要在函数中动态分配内存空间或者修改指针变量的值时，可以使用二级指针参数。通过二级指针参数，我们可以修改指针变量指向的地址，实现对指针变量的间接修改。 在函数中使用二级指针参数时，需要特别注意对指针变量的合法性进行判断，因为指针可能为空或者指向未分配的内存区域，这可能会导致程序崩溃或者出现未定义的行为。因此，在使用二级指针参数时，需要谨慎处理指针变量的取值和赋值操作。 总之，二级指针参数在C语言中是非常有用的工具，可以通过间接引用来修改指针变量的值，实现对内存空间的动态分配和释放，但同时也需要小心处理指针的合法性和操作，以避免出现潜在的错误和问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 59
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值