只出现一次的数字（异或运算）-CFANZ编程社区

文章目录

动态数组的使用大全

动态数组的使用大全

1. 基本创建和初始化

示例：

#include <iostream>

int main() {
    int size = 5;
    
    // 创建并初始化动态数组
    int* arr = new int[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = i * 10;
    }
    
    // 打印动态数组
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    
    // 释放动态数组的内存
    delete[] arr;
    
    return 0;
}

说明：创建了一个大小为 5 的动态数组，并将其初始化为 0, 10, 20, 30, 40。使用完成后释放内存。

2. 动态调整大小

要动态调整数组大小，通常需要创建一个新的数组，拷贝原来的内容，然后删除旧的数组。

#include <iostream>
#include <cstring> // for std::memcpy

int main() {
    int size = 5;
    int newSize = 10;
    
    // 创建并初始化动态数组
    int* arr = new int[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = i * 10;
    }
    
    // 创建一个更大的数组
    int* newArr = new int[newSize];
    
    // 拷贝旧数组的内容到新数组
    std::memcpy(newArr, arr, size * sizeof(int));
    
    // 初始化新数组的新增部分
    for (int i = size; i < newSize; ++i) {
        newArr[i] = i * 10;
    }
    
    // 打印新数组
    for (int i = 0; i < newSize; ++i) {
        std::cout << newArr[i] << " ";
    }
    std::cout << std::endl;
    
    // 释放内存
    delete[] arr;
    delete[] newArr;
    
    return 0;
}

步骤演示

创建并初始化原始动态数组
```
int* arr = new int[size];
for (int i = 0; i < size; ++i) {
    arr[i] = i * 10;
}
```
解释： 创建一个大小为 5 的动态数组 arr，并用 0, 10, 20, 30, 40 初始化。这个数组的内容如下：
```
arr = {0, 10, 20, 30, 40}
```
创建一个更大的数组
```
int* newArr = new int[newSize];
```
解释： 创建一个新的动态数组 newArr，其大小为 10，此时 newArr 的内容未初始化，包含垃圾值。
拷贝旧数组的内容到新数组
```
std::memcpy(newArr, arr, size * sizeof(int));
```
解释： 使用 std::memcpy 将 arr 中的 5 个整数拷贝到 newArr 的开头。此时 newArr 的前 5 个元素与 arr 相同，其余部分仍然包含垃圾值。newArr 的状态如下：
```
newArr = {0, 10, 20, 30, 40, ???, ???, ???, ???, ???}
```
初始化新数组的新增部分
```
for (int i = size; i < newSize; ++i) {
    newArr[i] = i * 10;
}
```
解释： 为 newArr 的新增部分填充数据。索引 5 到 9 的元素被初始化为 50, 60, 70, 80, 90。newArr 的最终状态如下：
```
newArr = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90}
```

打印新数组

for (int i = 0; i < newSize; ++i) {
    std::cout << newArr[i] << " ";
}
std::cout << std::endl;

输出： 打印 newArr 的所有元素：

0 10 20 30 40 50 60 70 80 90

释放内存
```
delete[] arr;
delete[] newArr;
```
解释： 释放之前分配的动态数组 arr 和 newArr 所占的内存，避免内存泄漏。

总结

创建了一个大小为 5 的动态数组 arr 并初始化。
创建了一个更大的动态数组 newArr，并将 arr 的内容拷贝到 newArr 的前 5 个位置。
初始化了 newArr 的其余部分。
打印了 newArr 的所有元素。
释放了分配的内存。

3. 动态数组的使用与标准库 `std::vector`

std::vector 是 C++ 标准库提供的一个动态数组类，提供了许多方便的功能，例如动态扩展和自动内存管理。以下是一个使用 std::vector 的例子：

示例：

#include <iostream>
#include <vector>

int main() {
    // 创建并初始化 std::vector
    std::vector<int> vec = {0, 10, 20, 30, 40};
    
    // 添加新元素
    vec.push_back(50);
    
    // 打印 std::vector
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    
    // 删除最后一个元素
    vec.pop_back();
    
    // 打印 std::vector
    for (int i = 0; i < vec.size(); ++i) {
        std::cout << vec[i] << " ";
    }
    std::cout << std::endl;
    
    return 0;
}

说明：std::vector 允许动态添加和删除元素，简化了动态数组的使用和管理。这个示例演示了如何使用 std::vector 添加和删除元素。

4. 动态数组作为函数参数

使用指针创建动态数组以及调用动态数组

#include <iostream>

// 打印动态数组的函数
void printArray(int* arr, int size) {
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    int size = 5;
    
    // 创建并初始化动态数组
    int* arr = new int[size];
    for (int i = 0; i < size; ++i) {
        arr[i] = i * 10;
    }
    
    // 使用函数打印数组
    printArray(arr, size);
    
    // 释放动态数组的内存
    delete[] arr;
    
    return 0;
}

创建并初始化动态数组
```
int size = 5;
int* arr = new int[size];
for (int i = 0; i < size; ++i) {
    arr[i] = i * 10;
}
```
解释：
- size 被设置为 5，因此 arr 的大小为 5。
- arr 被分配并初始化为一个包含 5 个元素的动态数组。
- for 循环遍历数组的每个位置，并将其值设置为 i * 10。
- 最终，arr 的内容如下：
```
arr = {0, 10, 20, 30, 40}
```
调用 printArray 函数
```
printArray(arr, size);
```
解释：
- 函数 printArray 被调用，传递了 arr 和 size 作为参数。
- 在 printArray 函数中，使用一个 for 循环遍历 arr 的每个元素并打印出来。打印输出如下：
```
0 10 20 30 40
```
释放动态数组的内存
```
delete[] arr;
```
解释：
- delete[] 被用来释放之前分配的动态数组 arr 所占的内存。
- 可以避免内存泄漏。

总结

创建并初始化数组:
- 动态数组 arr 被创建并填充了 {0, 10, 20, 30, 40}。
打印数组内容:
- printArray 函数打印了 arr 的内容：0 10 20 30 40。
释放内存:
- 释放了 arr 占用的内存。

输出

程序的输出结果是：

0 10 20 30 40

5. 使用动态数组存储用户输入

#include <iostream>

int main() {
    int size;
    
    std::cout << "Enter the number of elements: ";
    std::cin >> size;
    
    // 创建动态数组
    int* arr = new int[size];
    
    // 读取用户输入
    std::cout << "Enter " << size << " integers: ";
    for (int i = 0; i < size; ++i) {
        std::cin >> arr[i];
    }
    
    // 打印用户输入的数组
    std::cout << "You entered: ";
    for (int i = 0; i < size; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
    
    // 释放内存
    delete[] arr;
    
    return 0;
}

说明：这个示例演示了如何创建一个动态数组以存储用户输入，并在程序结束时释放内存。

这些示例涵盖了动态数组的基本操作、调整大小、与标准库的集成以及作为函数参数的用法。std::vector 通常是更推荐的选择，因为它封装了动态数组的管理细节。

步骤演示

假设你在执行这个程序时输入如下数据：

size 输入值为 4
用户输入的整数是 1, 2, 3, 4

我们将逐步调试这个程序，查看每一步的输出结果：

输入数组的大小

std::cout << "Enter the number of elements: ";
std::cin >> size;

输入： 4
输出： Enter the number of elements:
用户输入 4 被赋值给 size 变量。

创建动态数组

int* arr = new int[size];

操作：
创建一个 int 类型的动态数组 arr，其大小为 4。此时，数组的内容未初始化，包含垃圾值（随机数据）。

读取用户输入

std::cout << "Enter " << size << " integers: ";
for (int i = 0; i < size; ++i) {
    std::cin >> arr[i];
}

输出： Enter 4 integers:
用户输入的整数依次存储到数组 arr 中。假设输入的整数是 1, 2, 3, 4。这段代码的循环过程如下：

第一次循环（i=0）： std::cin >> arr[0]，用户输入 1，arr[0] 被设置为 1。
第二次循环（i=1）： std::cin >> arr[1]，用户输入 2，arr[1] 被设置为 2。
第三次循环（i=2）： std::cin >> arr[2]，用户输入 3，arr[2] 被设置为 3。
第四次循环（i=3）： std::cin >> arr[3]，用户输入 4，arr[3] 被设置为 4。

打印用户输入的数组

std::cout << "You entered: ";
for (int i = 0; i < size; ++i) {
    std::cout << arr[i] << " ";
}
std::cout << std::endl;

输出： You entered: 1 2 3 4
这段代码的循环过程如下：

第一次循环（i=0）： 输出 arr[0]，即 1。
第二次循环（i=1）： 输出 arr[1]，即 2。
第三次循环（i=2）： 输出 arr[2]，即 3。
第四次循环（i=3）： 输出 arr[3]，即 4。

最终输出为 You entered: 1 2 3 4，显示了用户输入的所有整数。

释放内存

delete[] arr;

操作：
释放之前分配的动态数组内存。这样可以避免内存泄漏。

总结

这段代码的执行过程如下：

用户输入了数组的大小 4。
动态分配了一个大小为 4 的整数数组。
用户依次输入了 4 个整数并存储在数组中。
打印出用户输入的整数。
最后释放了动态数组所占的内存。