c++动态数组new和delete

已于 2024-08-14 21:34:43 修改
阅读量1.3k 收藏 25
点赞数 12
分类专栏： c++ 文章标签： c++ 算法 开发语言
于 2024-08-14 21:24:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42384480/article/details/141200733
版权

文章目录

动态数组的使用大全

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;
}

步骤演示

  1. 创建并初始化原始动态数组

    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}

  2. 创建一个更大的数组

    int* newArr = new int[newSize];

    解释： 创建一个新的动态数组 newArr，其大小为 10，此时 newArr 的内容未初始化，包含垃圾值。

  3. 拷贝旧数组的内容到新数组

    std::memcpy(newArr, arr, size * sizeof(int));

    解释： 使用 std::memcpy 将 arr 中的 5 个整数拷贝到 newArr 的开头。此时 newArr 的前 5 个元素与 arr 相同，其余部分仍然包含垃圾值。newArr 的状态如下：

    newArr = {0, 10, 20, 30, 40, ???, ???, ???, ???, ???}

  4. 初始化新数组的新增部分

    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}

  5. 打印新数组

    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

  6. 释放内存

    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;
}

  1. 创建并初始化动态数组

    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}

  2. 调用 printArray 函数

    printArray(arr, size);

    解释：

    • 函数 printArray 被调用，传递了 arr 和 size 作为参数。
    • 在 printArray 函数中，使用一个 for 循环遍历 arr 的每个元素并打印出来。打印输出如下：
    0 10 20 30 40

  3. 释放动态数组的内存

    delete[] arr;

    解释：

    • delete[] 被用来释放之前分配的动态数组 arr 所占的内存。
    • 可以避免内存泄漏。

总结

  1. 创建并初始化数组:

    • 动态数组 arr 被创建并填充了 {0, 10, 20, 30, 40}。

  2. 打印数组内容:

    • printArray 函数打印了 arr 的内容：0 10 20 30 40。

  3. 释放内存:

    • 释放了 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

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

  1. 输入数组的大小
std::cout << "Enter the number of elements: ";
std::cin >> size;

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

  1. 创建动态数组
int* arr = new int[size];

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

  1. 读取用户输入
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。
  1. 打印用户输入的数组
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，显示了用户输入的所有整数。

  1. 释放内存
delete[] arr;

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

总结

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

  1. 用户输入了数组的大小 4。
  2. 动态分配了一个大小为 4 的整数数组。
  3. 用户依次输入了 4 个整数并存储在数组中。
  4. 打印出用户输入的整数。
  5. 最后释放了动态数组所占的内存。
酸奶奶昔
关注
专栏目录
C++中关于[]静态数组和new分配的动态数组的区别分析
09-04
而动态数组是在堆上分配的，分配和释放需要通过`new`和`delete`操作符手动完成，虽然这提供了更大的灵活性，但效率相对较低，且可能导致内存泄漏如果忘记`delete`。 关于通过函数返回数组的问题，由于静态数组在...
C++数组之动态数组
weixin_61627067的博客
03-15 1万+
c++ 数组
c++ 动态数组
m0_62870588的博客
03-31 2万+
动态数组 ；使用malloc()和free()动态分配 ；使用new 和delete 两个操作符 ；new/delete 与malloc()/free()的区别。
c++动态数组
热门推荐
manchengpiaoxue的博客
10-18 9万+
注意：静态数组是在堆栈上（不需要自行释放空间）创建，动态数组是在堆上创建（需要自行释放空间） 涉及内容： 堆（heap）-自由存储区（free store） C语言：malloc和free c++语言：new和delete 1.动态数组定义（见后面） 2.初始化动态数组分配 string *p_string = new string[10]; //默认的构造函数初始化 Dog *p...
C/C++数据结构之动态数组篇
qq_63883017的博客
11-05 9211
手把手带你从初识动态数组到手写简单版本的c++vector容器
C++ 动态数组
恋恋风辰的技术博客
01-21 1万+
C++语言和标准库提供了两种一次分配一个对象数组的方法。C++语言定义了另一种new表达式语法，可以分配并初始化一个对象数组。标准库中包含一个名为allocator的类，允许我们将分配和初始化分离。使用allocator通常会提供更好的性能和更灵活的内存管理能力。 new和数组 为了让new分配一个对象数组，我们要在类型名之后跟一对方括号，在其中指明要分配的对象的数目。在下例中，new分配要求数量的对象并（假定分配成功后）返回指向第一个对象的指针： int get_size_new() { ret
C++动态数组类的封装实例
09-04
在C++编程中，动态数组是一种非常重要的数据结构，它允许程序员在运行时根据需要动态地改变数组的大小。为了更好地管理和使用动态数组，我们可以对其进行封装，将其抽象成一个类。下面将详细介绍C++动态数组类封装...
C++实现动态数组功能
08-26
C++实现动态数组功能 本文主要介绍了C++实现动态数组功能的知识点，包括数组的基本概念、动态数组的实现、数组操作方法等。下面是详细的知识点： 一、数组的基本概念 数组是一种线性表数据结构，使用连续的内存...
C++中new和delete的介绍
08-26
C++中的new和delete是两个非常重要的操作符，它们分别用于动态申请和释放内存。今天我们将深入探讨C++中new和delete的介绍，了解它们的区别、使用方法和注意事项。 一、new和delete的概念 new和delete是C++中两个...
C++二维动态数组的创建与删除
08-03
本文将详细讲解如何在C++中创建和删除二维动态数组，以及这两种不同的实现方式。 首先，我们来看第一种创建二维动态数组的方法，这种方式要求列数必须在创建时指定。假设我们要创建一个`TYPE`类型的`M`行`N`列的二...
C++ || 动态数组
weixin_63378697的博客
04-14 1255
静态数组的长度是编程时程序员预先定义好的，在整个程序运行中，数组大小无法改变。对于动态数组类所申请的内存，在使用完必须由程序员自己释放，否则严重会引起内存泄露。所以内存的申请一定要有借有还，才能再借不难，也要注意，不能多还。并完成私有成员的初始化。//友元输出函数，输出 "("<<p.x<<","<<p.y<<")";动态数组的内存空间是从堆（heap）上分配（即动态分配）的。功能：在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值。结果值：成功：T类型的指针，指向新分配的内存；
C++学习之动态数组
最新发布
qq_46454669的博客
09-03 2951
则*pw = 1000，若加入一行代码pw = pw + 1，则*pw = 2000，同理，*ps = 3，若加入一行代码ps = ps + 1，*ps = 2。C++新增了模板类array，与数组一样，array对象的数组长度是固定的，也使用栈（静态内存分配），而不是自由存储区，因此效率与数组相同，但更方便更安全。会编译出一个可执行的1.exe文件，执行./1.exe，最终会运行程序，输出为。另一种访问结构成员的方法是，如果ps是指向结构的指针，则*ps就是被指向的结构本身，由于*ps是一个结构，因此。
C++ 动态数组（new）
baidu_41388533的博客
06-05 5万+
原文链接：动态数组（new） 一、动态数组的定义 数组的维度可以为常量、也可以为一个函数的返回值 int size() { return 3; } const int length = 3; int *p1 = new int[size()]{1,2,3}; int *p2 = new int[length]; int *p3 = new int[3]; 使用typedef为数组类型取别名 typedef int arrT[42]; int *p=new arrT; //分配一个大小
C++ STL之 vector（动态数组）详解
zdlzf的博客
06-16 5629
vector为可变长数组（动态数组），定义的vector数组可以随时添加数值和删除元素。在局部函数中开vector数组，是在堆空间里面开的，与开全局变量比较类似，所以经常见到在局部函数中开大容量数组。1.头文件2.初始化一维初始化//定义了一个名为num的存int数据的一维数组//定义了一个名为num的存double数据的一维数组//node是结构体类型1.指定长度和初始值的初始化//定义一个长度为n的数组，动态定义，不指定初值默认初值为0//所有的元素均为0。
【C++】动态数组
发现问题，并解决问题，批判性思维
01-20 2497
一、动态数组 回顾计算机内存中按照用途被划分的5个区域： //存储在栈 int x=0; int *p=NULL; //存储在堆区，注意这里的数组名为p，而不是int(关键字int) int *p=new int[20]; //全局区 存储全局变量和静态变量 //常量区 string str="hello"; //代码区 存储逻辑代码的二进制 那啥时候我们需要定义动态数组呢？ 【答】很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出 但是问题是，c++要求定义数
7.1 C/C++ 实现动态数组
CSDN
08-15 5185
动态数组相比于静态数组具有更大的灵活性，因为其大小可以在运行时根据程序的需要动态地进行分配和调整，而不需要在编译时就确定数组的大小。这使得动态数组非常适合于需要动态添加或删除元素的情况，因为它们可以在不浪费空间的情况下根据需要动态增加或减少存储空间。 动态数组的内存空间是从堆(heap)上分配的，动态数组需要程序员手动管理内存，因为它们的内存空间是在程序运行时动态分配的。程序员需要在使用完动态数组后手动释放其内存空间，否则可能会导致内存泄漏的问题，进而导致程序崩溃或者运行缓慢。因此，在使用动态数组时，程序
c++ 之动态数组简单介绍
digitalkee的博客
06-05 3852
#include <iostream> #include <memory> using namespace std; int main() { typedef int ptr[109]; int *p = new ptr; for(int i = 0; i!= 109; ++i) p[i] = i; for(int i = 0; i!= 109;++i) cout << p[i] << endl; int n; cin >&gt.
【C++】动态数组(vector)的使用
AAADiao的博客
05-19 7270
在 C++ 中，`std::vector` 是标准库提供的一个容器类，用于存储动态大小的元素序列（即"动态数组"）。它提供了一系列成员函数和操作符，使得元素的访问、插入、删除等操作变得方便和高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值