常见C++存储数据类型的用法

于 2024-07-18 00:47:00 发布
阅读量468 收藏 9
点赞数 5
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wangtffn/article/details/140508884
版权

（写给未来遗忘的自己）

1.常见类型：

  • 数组：适用于固定大小的场景，访问速度快，但大小固定。
  • vector：动态数组，大小可以自动调整，适用于需要灵活大小的场景。
  • list：双向链表，适用于需要频繁插入和删除的场景。
  • map：关联容器，存储键值对，适用于需要快速查找的场景。
  • 链表：可以使用指针实现，适用于需要动态数据结构的场景

2.使用方法： 

2.1 数组

数组是一种固定大小的数据结构，适用于已知大小的场景。

  • 一维数组：适用于线性数据结构，大小固定。
  • 二维数组：适用于矩阵数据结构，大小固定。
  • 动态数组：适用于在运行时确定大小的数组，需要手动管理内存。

这些示例展示了如何初始化和使用一维和二维数组

#include <iostream>

int main() {
    // 初始化一维数组
    int arr[5] = {1, 2, 3, 4, 5};

    // 或者可以逐个元素初始化
    int arr2[5];
    arr2[0] = 1;
    arr2[1] = 2;
    arr2[2] = 3;
    arr2[3] = 4;
    arr2[4] = 5;

    // 遍历一维数组
    for (int i = 0; i < 5; i++) {
        std::cout << arr[i] << " ";
    }

    std::cout << std::endl;

// 初始化二维数组
    int arr[3][4] = {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };

    // 或者可以逐个元素初始化
    int arr2[3][4];
    arr2[0][0] = 1; arr2[0][1] = 2; arr2[0][2] = 3; arr2[0][3] = 4;
    arr2[1][0] = 5; arr2[1][1] = 6; arr2[1][2] = 7; arr2[1][3] = 8;
    arr2[2][0] = 9; arr2[2][1] = 10; arr2[2][2] = 11; arr2[2][3] = 12;

    // 遍历二维数组
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << arr[i][j] << " ";
        }
        std::cout << std::endl;
    }


    return 0;
}

 静态分配和动态分配的情况

#include <iostream>

int main() {
    // 动态分配一维数组
    int* arr = new int[5];

    // 初始化数组
    for (int i = 0; i < 5; i++) {
        arr[i] = i + 1;
    }

    // 遍历数组
    for (int i = 0; i < 5; i++) {
        std::cout << arr[i] << " ";
    }

    std::cout << std::endl;

    // 释放动态数组
    delete[] arr;

// 动态分配二维数组
    int rows = 3;
    int cols = 4;
    int** arr = new int*[rows];
    for (int i = 0; i < rows; i++) {
        arr[i] = new int[cols];
    }

    // 初始化数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            arr[i][j] = i * cols + j + 1;
        }
    }

    // 遍历二维数组
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            std::cout << arr[i][j] << " ";
        }
        std::cout << std::endl;
    }

    // 释放动态数组
    for (int i = 0; i < rows; i++) {
        delete[] arr[i];
    }
    delete[] arr;

    return 0;
}

2.2 vector

vector 是动态数组，可以自动调整大小，适用于需要灵活大小的场景。

#include <iostream>
#include <vector>

int main() {
    // 初始化 vector
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 添加元素
    vec.push_back(6);
    // 删除第三个元素（索引为2）
    vec.erase(vec.begin() + 2);
   // 删除索引为1到3（包括索引1，但不包括索引3）的元素
    vec.erase(vec.begin() + 1, vec.begin() + 4);
   // 删除所有偶数元素
    vec.erase(std::remove_if(vec.begin(), vec.end(), [](int num){ return num % 2 == 0; 
    }), vec.end());
   // 清空整个 vector
    vec.clear();

    // 访问和修改元素
    vec[0] = 10;

    // 遍历 vector
    for (int i = 0; i < vec.size(); i++) {
        std::cout << vec[i] << " ";
    }
/***********************************************************************/
 // 初始化 二维vector
 std::vector<std::vector<int>> vec2d = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };

    // 访问和修改元素
    std::cout << "Element at (1, 1): " << vec2d[1][1] << std::endl;
    vec2d[1][1] = 10;
    // 要添加的一行元素
    std::vector<int> newRow = {7, 8, 9};

    // 将 newRow 添加到 vec2d 的末尾
    vec2d.push_back(newRow);

    // 遍历二维 vector
    for (int i = 0; i < vec2d.size(); i++) {
        for (int j = 0; j < vec2d[i].size(); j++) {
            std::cout << vec2d[i][j] << " ";
        }
        std::cout << std::endl;
    }

/***********************************************************************/
std::vector<std::vector<std::vector<int>>> vec3d = {
        {
            {1, 2},
            {3, 4}
        },
        {
            {5, 6},
            {7, 8}
        }
    };

    // 访问和修改元素
    std::cout << "Element at (1, 1, 1): " << vec3d[1][1][1] << std::endl;
    vec3d[1][1][1] = 10;

    // 遍历三维 vector
    for (int i = 0; i < vec3d.size(); i++) {
        for (int j = 0; j < vec3d[i].size(); j++) {
            for (int k = 0; k < vec3d[i][j].size(); k++) {
                std::cout << vec3d[i][j][k] << " ";
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }
    return 0;
}

2.3 list

list 是双向链表，适用于需要频繁插入和删除的场景。

#include <iostream>
#include <list>

int main() {
    // 初始化 list
    std::list<int> lst = {1, 2, 3, 4, 5};

    // 添加元素
    lst.push_back(6);
    lst.push_front(0);

    // 遍历 list
    for (auto it = lst.begin(); it != lst.end(); ++it) {
        std::cout << *it << " ";
    }

    return 0;
}

2.4 map

map 是一种关联容器，存储键值对，按键排序，适用于需要快速查找的场景。map有三种类型。

  • td::map：有序关联容器，根据键进行排序。
  • std::unordered_map：无序关联容器，使用哈希表实现快速查找。
  • std::multimap：允许重复键的有序关联容器，可以存储相同键的多个值。
#include <iostream>
#include <map>

int main() {
    // 初始化 map
    std::map<int, std::string> mp;
    mp[1] = "one";
    mp[2] = "two";
    mp[3] = "three";

    // 访问和修改元素
    mp[1] = "ONE";

    // 遍历 map
    for (const auto& pair : mp) {
        std::cout << pair.first << ": " << pair.second << "\n";
    }
/**************************************************************************************/

std::unordered_map<int, std::string> myMap;

    // 插入元素
    myMap.insert({1, "apple"});
    myMap.insert({2, "banana"});
    myMap.insert({3, "cherry"});

    // 访问元素
    std::cout << "Value for key 2: " << myMap[2] << std::endl;

    // 遍历 unordered_map
    for (const auto& pair : myMap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }
/**************************************************************************************/

std::multimap<int, std::string> myMultimap;

    // 插入元素
    myMultimap.insert({1, "apple"});
    myMultimap.insert({2, "banana"});
    myMultimap.insert({2, "orange"}); // 允许重复键

    // 访问元素
    std::cout << "Values for key 2:" << std::endl;
    auto range = myMultimap.equal_range(2);
    for (auto it = range.first; it != range.second; ++it) {
        std::cout << it->second << std::endl;
    }

    // 遍历 multimap
    for (const auto& pair : myMultimap) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }


    return 0;
}

2.5单向链表

链表是一种动态数据结构，可以使用指针实现，适用于需要动态数据结构的场景。

#include <iostream>

struct Node {
    int data;
    Node* next;
};

int main() {
    // 初始化链表
    Node* head = new Node{1, nullptr};
    head->next = new Node{2, nullptr};
    head->next->next = new Node{3, nullptr};

    // 遍历链表
    Node* current = head;
    while (current != nullptr) {
        std::cout << current->data << " ";
        current = current->next;
    }

    // 释放链表内存
    current = head;
    while (current != nullptr) {
        Node* next = current->next;
        delete current;
        current = next;
    }

    return 0;
}

2.6 双向链表

双向链表比单向链表多了一个指向前一个节点的指针。

#include <iostream>

struct Node {
    int data;
    Node* next;
    Node* prev;
};

int main() {
    // 初始化链表
    Node* head = new Node{1, nullptr, nullptr};
    Node* second = new Node{2, nullptr, head};
    head->next = second;
    Node* third = new Node{3, nullptr, second};
    second->next = third;

    // 遍历链表（向前）
    Node* current = head;
    while (current != nullptr) {
        std::cout << current->data << " ";
        current = current->next;
    }

    std::cout << std::endl;

    // 遍历链表（向后）
    current = third;
    while (current != nullptr) {
        std::cout << current->data << " ";
        current = current->prev;
    }

    // 释放链表内存
    current = head;
    while (current != nullptr) {
        Node* next = current->next;
        delete current;
        current = next;
    }

    return 0;
}

2.7 set

set 是一种关联容器，用于存储唯一值，并且会自动对其进行排序。set 提供了三种常见的类型：std::set、std::unordered_set 和 std::multiset，

  • std::set：有序关联容器，存储唯一值，并根据元素的值进行排序。
  • std::unordered_set：无序关联容器，使用哈希表实现存储和查找，插入和查找的平均时间复杂度为 O(1)。
  • std::multiset：允许存储重复值的有序关联容器，会保持所有插入的元素，并根据元素的值进行排序。
#include <iostream>
#include <set>

int main() {
    // 创建一个 std::set
    std::set<int> mySet;

    // 插入元素
    mySet.insert(3);
    mySet.insert(1);
    mySet.insert(5);

    // 遍历 set
    for (const auto& elem : mySet) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 检查元素是否存在
    if (mySet.find(2) != mySet.end()) {
        std::cout << "Element 2 is in the set" << std::endl;
    } else {
        std::cout << "Element 2 is not in the set" << std::endl;
    }
/************************************************************************************/
// 创建一个 std::unordered_set
    std::unordered_set<int> mySet;

    // 插入元素
    mySet.insert(3);
    mySet.insert(1);
    mySet.insert(5);

    // 遍历 unordered_set
    for (const auto& elem : mySet) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 检查元素是否存在
    if (mySet.find(2) != mySet.end()) {
        std::cout << "Element 2 is in the set" << std::endl;
    } else {
        std::cout << "Element 2 is not in the set" << std::endl;
    }

/************************************************************************************/
// 创建一个 std::multiset
    std::multiset<int> myMultiset;

    // 插入元素
    myMultiset.insert(3);
    myMultiset.insert(1);
    myMultiset.insert(5);
    myMultiset.insert(3); // 允许重复值

    // 遍历 multiset
    for (const auto& elem : myMultiset) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 检查元素个数
    std::cout << "Number of occurrences of 3: " << myMultiset.count(3) << std::endl;
    return 0;
}

Wangtffn
关注
C++数据的存取
Joseph_tony的博客
08-12 1361
常量 常量是指在程序中使用的一些具体的数、字符。在程序运行过程中，其值不能更改。如123、1.23、‘a’、“abc”、True等。 常量的定义 const 类型 常量名 = 常量值 例如：const double PI=3.1415926 变量 计算机中有个存储单元，存储单元中存放了一些数据。这些数据在程序的运行过程中可能变化或被复制，我们趁这个存储单元叫做变量。 也就是说变量代表了一个存储单元，其中的值是可以改变的。依据放入变量中数据可能出现的大小，为了能够规范开辟空间，高级语言把数据进行了分类，称之为
C++数据类型
qq_55185342的博客
10-25 962
c++ 数据类型
C++ 保存数据到excel文件
08-01
纯C++ 代码保存数据到excel文件
【C/C++】数据的存储
m0_74899080的博客
12-12 1735
整型在计算机中的表示形式，signed char和unsigned char表示范围，大小端存储，整型，浮点型在内存中的存储和读取。
C++数据存储和运算符及表达式
m0_74344909的博客
08-13 499
C++数据存储和运算符及表达式
转载C++数据存储
jackchoise030的博客
01-17 341
链接地址：https://www.cnblogs.com/DannyShi/p/4584750.html
C++基本数据类型和表达式ppt课件.ppt
11-13
C++基本数据类型是指在C++语言中可以使用的基本数据类型，包括整型、字符型、实型、结构体、联合体、枚举体、类、数组、指针、空类型等。 1. 整型（Integer Type） 整型是C++语言中最基本的数据类型，用于存储整数...
浅析C++ 数据类型
08-24
C++ 数据类型的应用非常广泛，在实际开发中，正确地选择和使用数据类型是非常重要的。例如，在字符串处理中，使用 wchar_t 可以正确地处理 Unicode 字符，而使用 char 则可能会出现乱码问题。 C++ 数据类型是 C++ ...
Visual C++的介绍和数据类型详细说明-综合文档
05-23
数据类型是编程的基础，C++中的数据类型系统丰富而强大。主要分为基本数据类型、复合数据类型、枚举类型、指针类型和自定义类型（如类）等几大类。 1. 基本数据类型：包括整型（如int）、浮点型（如float和double）...
C++实现数据文件存储与加载
08-25
主要为大家详细介绍了C++实现数据文件存储与加载，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
数据存储
Seincfe
09-27 178
1) 基本内置类型： 数据类型就是对变量的划分 char //字符数据类型 short //短整型 int //整形 long //长整型 long long //更长的整形 float //单精度浮点型 double //双精度浮点型 //C语言没有字符串类型 基本类型的归类 整型 , 浮点型 , 构...
C++学习：数据的存储、作用域、链接
最新发布
m0_49968063的博客
10-18 459
声明的变量，以及函数的参数，是自动存储的。在程序执行对应函数的时候创建这些变量，对应的函数执行完之后，它们使用的内存被释放。也就是所谓的局部变量。2、静态存储在函数定义外的变量、以及使用static关键字定义的变量都是静态存储的，它们在程序的整个运行过程中都是存在的。函数定义外的变量。
【C/C++】数据在内存中的存储（完整篇非常详细）
m0_66977204的博客
06-02 2844
包含数值类型与取值范围的介绍，介绍原码、反码、补码原理，数据在内存中存储的原理，有大端字序存储与小端字序存储等等，内容比较多。
C++中数据的存储方式和作用域
qq_40250056的博客
05-04 1632
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 C++中的数据前言一、C++的数据变量的存储方式类型1.1 自动存储1.2 静态存储变量1.3 动态存储二、数据变量的存储持续性、作用域和链接性2.1 存储的持续性2.2 作用域和链接性2.2.1 自动变量的作用域和链接性2.2.2 静态变量的作用域和链接性2.2.3 静态变量的外部链接性2.2.3.1 单定义规则2.2.4 静态变量的内部链接性2.2.5 静态变量的无链接性三、存储说明符和限定符 前言   本文主要介绍C++中变量的存
C++ 保存数据
热门推荐
一个神奇的博客
03-20 1万+
C++ 保存数据 再用C++编写程序时，你也许会发现，每次的数据都得重新计算，那么可不可以将一些数据保存起来下次在使用呢？接下来我们就将学习C++保存数据的方法。 方法一：freopen 说到保存数据，我们最熟悉的肯定就是freopen了，我们先来看看它的函数原型： FILE *__cdecl freopen( const char * __restrict__ _Filename, const char * __restrict__ _Mode, FILE * __restrict__ _File
C++——存储方式
mankeywang的博客
11-13 4576
文章目录内存模型与命令空间单独编译储存持续性、作用域、连接性作用域和连接自动存储连续性1. 自动变量初始化2. 自动变量和栈3. 寄存器变量静态持续变量5种变量储存方式静态变量的初始化静态持续性、外部链接性静态持续性，内部链接性静态存储持续性，无连接性命名空间 内存模型与命令空间 单独编译 C++也允许鼓励程序员将组件函数放在 ** 独立文件中 ** 。 将 ** 一个程序放在多个文件中 ** ，将引出新的问题：不能简单的以main()之后的虚线为界，将原来的文件分为两个。问题在于 < u >
C++——数据存储
漫长IT路
08-06 3107
静态/动态内存分配 一个程序被加载到内存中，这块内存首先就存在两种属性：静态分配内存和动态分配内存。 静态分配内存：是在程序编译和链接时就确定好的内存。 动态分配内存：是在程序加载、调入、执行的时候分配/回收的内存。 数据存储 Text   也称为代码段(Code)，用来存放程序执行代码，同时也可能会包含一些常量(如一些字符串常量等）。该段内存为静态分配，这部分区域的大小在程序运行前就已经确定，并且内存区域属于只读。这块内存是共享的,当有多个相同进程(Process)存在时，共用同一个text段。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值