【C/C++ 线性表 简介】C/C++中的线性表探索:从标准库到自定义实现

简介: 【C/C++ 线性表 简介】C/C++中的线性表探索:从标准库到自定义实现

1. 线性表简介 (Introduction to Linear Tables)

线性表是数据结构中的基础概念,它是由零个或多个数据元素组成的有限序列。在这个序列中,数据元素之间存在着一种前后关系,这种关系是线性的,即每个数据元素都有一个前驱和一个后继,除了第一个和最后一个元素外。

1.1 定义与特点 (Definition and Characteristics)

线性表的定义很简单,但它的应用非常广泛。从数组到链表,从栈到队列,这些都是线性表的具体实现形式。线性表的主要特点如下:

  • 有限性:线性表中的数据元素数量是有限的。
  • 唯一性:线性表中的每个数据元素都是唯一的,不会有重复。
  • 有序性:线性表中的数据元素按照一定的顺序排列。

正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“数据结构是算法的基础,而线性表是数据结构的基石。”

1.2 线性表的应用场景 (Applications of Linear Tables)

线性表在计算机科学和日常生活中都有广泛的应用。例如,当我们使用文本编辑器编写文档时,文档中的每个字符都可以看作是一个线性表中的元素。再如,当我们在线购物时,购物车中的每个商品都可以看作是一个线性表中的元素。

但是,线性表不仅仅是一个简单的数据结构。它反映了我们人类思维的线性特点,即我们习惯于按照一定的顺序思考问题,从一个点到另一个点,从一个思路到另一个思路。这种线性的思维方式在很多情况下都是非常有效的,但在某些情况下,我们也需要跳出这种线性的框架,进行更为深入和全面的思考。

2. C++标准库中的线性表 (Linear Tables in C++ Standard Library)

在现代编程中,数据结构是任何算法或程序的核心。C++作为一种强大的编程语言,提供了一系列的标准库来帮助开发者更高效地处理数据。在这一章中,我们将深入探讨C++标准库中的线性表,并通过源码分析来理解其背后的设计哲学。

2.1 vector (Dynamic Array)

vector是C++标准库中最常用的线性表之一,它是一个动态数组,可以根据需要自动调整其大小。

特点:

  • 连续的内存存储,保证了高效的随机访问。
  • 动态地调整大小,但可能导致额外的内存分配。

示例:

#include <vector>
std::vector<int> vec = {1, 2, 3, 4, 5};
vec.push_back(6);  // 在尾部添加元素

在GCC的实现中,vector的核心代码位于头文件中,特别是_Vector_base_Vector_impl类中。这些类定义了vector的内部结构和存储机制。

正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“C++的标准库不仅仅是一些工具或一套例程,它是一个语言。”这句话强调了标准库在C++编程中的重要性。

2.2 array (Fixed-size Array)

array是一个固定大小的数组,它的大小在编译时确定,因此不支持动态调整。

特点:

  • 连续的内存存储,保证了高效的随机访问。
  • 大小固定,不支持动态调整。

示例:

#include <array>
std::array<int, 5> arr = {1, 2, 3, 4, 5};

在C++标准库的实现中,array的核心代码位于头文件中。与vector不同,array没有动态内存分配的开销,因此在某些情况下可能更加高效。

2.3 list (Doubly Linked List)

list是一个双向链表,支持在任意位置插入和删除元素。

特点:

  • 非连续的内存存储,随机访问相对较慢。
  • 任意位置的插入和删除操作非常高效。

示例:

#include <list>
std::list<int> lst = {1, 2, 3, 4, 5};
lst.push_front(0);  // 在头部添加元素

在C++标准库的实现中,list的核心代码位于头文件中,特别是_List_node_List_iterator类中。这些类定义了list的内部结构和迭代机制。

2.4 forward_list (Singly Linked List)

forward_list是C++11引入的新数据结构,它是一个单向链表。

特点:

  • 非连续的内存存储,随机访问相对较慢。
  • 由于只有单向链接,其内存消耗比双向链表list更少。
  • 任意位置的插入和删除操作非常高效。

示例:

#include <forward_list>
std::forward_list<int> flst = {1, 2, 3, 4, 5};
flst.push_front(0);  // 在头部添加元素

在C++标准库的实现中,forward_list的核心代码位于头文件中。由于其单向性质,forward_list在某些特定场景下,如只需要单向迭代的情况,可能比list更加高效。

2.5 deque (Double-ended Queue)

deque是一个双端队列,支持在头部和尾部进行插入和删除操作。

特点:

  • 非连续的内存存储,但支持高效的随机访问。
  • 头部和尾部的插入和删除操作非常高效。
  • 内部实现为多个固定大小的数组,这些数组的指针存储在一个中心数组中。

示例:

#include <deque>
std::deque<int> dq = {1, 2, 3, 4, 5};
dq.push_front(0);  // 在头部添加元素
dq.push_back(6);   // 在尾部添加元素

在GCC的实现中,deque的核心代码位于头文件中。其内部结构确保了高效的随机访问,同时也支持高效的头部和尾部操作。

2.6 string (Character String)

string是字符的线性表,用于表示文本。

特点:

  • 连续的内存存储,保证了高效的随机访问。
  • 动态地调整大小,但可能导致额外的内存分配。
  • 提供了丰富的文本处理功能。

示例:

#include <string>
std::string str = "Hello, World!";
str += " Welcome to C++!";

在C++标准库的实现中,string的核心代码位于头文件中。它提供了丰富的方法和操作符,使文本处理变得简单而高效。

3. C语言中的线性表实现

在计算机科学中,线性表是最基础的数据结构之一,它为我们提供了一种组织和存储数据的方式。在C语言中,我们可以使用数组和指针来实现各种线性表。本章将详细介绍如何在C语言中实现动态数组和链表。

3.1 动态数组的实现

动态数组是一种可以动态调整大小的数组。与普通数组不同,动态数组可以在运行时增加或减少其大小。

3.1.1 基本原理

动态数组的核心思想是使用指针来访问连续的内存块,并在需要时重新分配内存。当数组的大小达到其当前容量时,我们可以分配一个更大的内存块,将原始数据复制到新的内存块中,然后释放原始内存块。

typedef struct {
    int *data;     // 指向数组的指针
    int size;      // 当前数组的大小
    int capacity;  // 数组的容量
} DynamicArray;

3.1.2 动态数组的操作

  1. 初始化:为动态数组分配初始容量的内存,并设置其大小为0。
  2. 插入:在数组的末尾添加一个新元素。如果数组已满,则将其容量加倍。
  3. 删除:删除数组的最后一个元素。如果数组的大小小于其容量的一半,则减少其容量。
  4. 访问:使用索引访问数组中的元素。

3.1.3 代码示例

#include <stdio.h>
#include <stdlib.h>
// 初始化动态数组
DynamicArray* initDynamicArray(int initialCapacity) {
    DynamicArray *arr = (DynamicArray*)malloc(sizeof(DynamicArray));
    arr->data = (int*)malloc(initialCapacity * sizeof(int));
    arr->size = 0;
    arr->capacity = initialCapacity;
    return arr;
}
// 插入元素
void insert(DynamicArray *arr, int value) {
    if (arr->size == arr->capacity) {
        arr->capacity *= 2;
        arr->data = (int*)realloc(arr->data, arr->capacity * sizeof(int));
    }
    arr->data[arr->size++] = value;
}
// 删除元素
void delete(DynamicArray *arr) {
    if (arr->size > 0) {
        arr->size--;
        if (arr->size < arr->capacity / 2) {
            arr->capacity /= 2;
            arr->data = (int*)realloc(arr->data, arr->capacity * sizeof(int));
        }
    }
}
// 访问元素
int get(DynamicArray *arr, int index) {
    if (index < 0 || index >= arr->size) {
        printf("Index out of bounds\n");
        exit(1);
    }
    return arr->data[index];
}

正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“我们不仅仅是编写代码,我们还在与计算机对话,表达我们的思想和创意。”动态数组是这种对话的一个例子,它展示了如何使用C语言的基本工具来实现复杂的数据结构。

3.2 链表的实现

链表是另一种常见的线性数据结构,它由一系列节点组成,每个节点都包含一个数据元素和一个指向下一个节点的指针。

3.2.1 单链表

单链表是最简单的链表形式,每个节点只有一个指向下一个节点的指针。

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

3.2.2 双链表

与单链表不同,双链表的每个节点都有两个指针,一个指向前一个节点,另一个指向下一个节点。

typedef struct DoublyNode {
    int data;
    struct DoublyNode *prev;
    struct DoublyNode *next;
} DoublyNode;

3.2.3 代码示例

// 单链表插入节点
void insertNode(Node **head, int value) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}
// 双链表插入节点
void insertDoublyNode(DoublyNode **head, int value) {
    DoublyNode *newNode = (DoublyNode*)malloc(sizeof(DoublyNode));
    newNode->data = value;
    newNode->next = *head;
    newNode->prev = NULL;
    if (*head != NULL) {
        (*head)->prev = newNode;
    }
    *head = newNode;
}

链表与动态数组在许多方面都有所不同,但它们都是线性数据结构的基础。选择使用哪种结构取决于特定的应用需求和性能考虑。

3.3 循环缓冲区的实现 (Implementing Circular Buffers)

循环缓冲区,也称为环形缓冲区或环形队列,是一种特殊的线性数据结构,用于存储固定数量的元素。当缓冲区满时,下一个插入的元素会覆盖最早插入的元素。这种数据结构在许多实时应用中都很有用,例如音频处理、数据流处理等。

3.3.1 基本原理 (Basic Principle)

循环缓冲区的关键思想是使用一个固定大小的数组和两个指针(通常称为“头”和“尾”)来跟踪数据的开始和结束位置。当头和尾指针相遇时,缓冲区要么是空的,要么是满的,这取决于最后一个操作是插入还是删除。

3.3.2 数据结构 (Data Structure)

typedef struct {
    int *buffer;    // 缓冲区数组
    int capacity;   // 缓冲区容量
    int size;       // 当前存储的元素数量
    int head;       // 头指针
    int tail;       // 尾指针
} CircularBuffer;

3.3.3 代码示例 (Code Example)

// 初始化循环缓冲区
CircularBuffer* initCircularBuffer(int capacity) {
    CircularBuffer *cb = (CircularBuffer*)malloc(sizeof(CircularBuffer));
    cb->buffer = (int*)malloc(capacity * sizeof(int));
    cb->capacity = capacity;
    cb->size = 0;
    cb->head = 0;
    cb->tail = 0;
    return cb;
}
// 插入元素
void insert(CircularBuffer *cb, int value) {
    if (cb->size == cb->capacity) {
        cb->tail = (cb->tail + 1) % cb->capacity;
    }
    cb->buffer[cb->head] = value;
    cb->head = (cb->head + 1) % cb->capacity;
    cb->size++;
}
// 删除元素
int delete(CircularBuffer *cb) {
    if (cb->size == 0) {
        printf("Buffer is empty\n");
        exit(1);
    }
    int value = cb->buffer[cb->tail];
    cb->tail = (cb->tail + 1) % cb->capacity;
    cb->size--;
    return value;
}

循环缓冲区提供了一种高效的方式来处理数据流,特别是在有限的内存空间中。正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“数据结构和算法是计算机科学的核心。”循环缓冲区是这一思想的完美体现,它展示了如何使用简单的数据结构来解决实际问题。

4. 线性表的差异化 (Differences Among Linear Tables)

4.1 性能对比 (Performance Comparison)

线性表是数据结构中最基础的概念,它在C++中有多种实现方式。每种实现方式都有其特定的性能特点,这些性能特点往往是基于其内部结构和设计目标而来的。

为了更直观地展示各种线性表的性能差异,我们可以使用图表来进行对比。但在此之前,我们先简要描述一下各种线性表的性能特点。

  • vector (动态数组 Dynamic Array): vector的随机访问性能非常高效,但在中间插入或删除元素时性能较差,因为需要移动后续的所有元素。正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“vector是为了高效访问而设计的,而不是为了高效插入或删除。”
  • array (固定大小数组 Fixed-size Array): array的随机访问性能与vector相似,但由于其大小是固定的,所以不能进行动态扩容。
  • list (双向链表 Doubly Linked List): list在任意位置插入或删除元素时都非常高效,但随机访问的性能较差,因为需要从头部或尾部遍历到目标位置。
  • forward_list (单向链表 Singly Linked List): forward_list的性能特点与list相似,但由于它是单向的,所以不能进行反向迭代。
  • deque (双端队列 Double-ended Queue): deque在头部和尾部插入或删除元素时都非常高效,而且支持高效的随机访问。

我们的思维方式往往是基于我们的经验和知识。当我们理解了这些数据结构的内部工作原理,我们就可以更好地选择合适的数据结构来满足我们的需求。例如,如果我们知道我们的应用主要是进行随机访问,那么vectorarray可能是更好的选择。但如果我们的应用主要是在中间位置插入或删除元素,那么list可能是更好的选择。

接下来,我们将展示一个表格,从多个角度对这些线性表进行对比。

数据结构 随机访问 中间插入/删除 头部/尾部插入/删除
vector 高效 较慢 较慢
array 高效 不支持 不支持
list 较慢 高效 高效
forward_list 较慢 高效 高效
deque 高效 较慢 高效

在选择线性表时,我们应该根据我们的实际需求来选择最合适的数据结构。每种数据结构都有其优点和缺点,选择正确的数据结构可以大大提高我们的程序的性能。

在C++标准库的源码中,我们可以深入研究这些数据结构的实现。例如,std::vector的实现可以在头文件中找到,其中的push_backemplace_back方法展示了如何动态扩容。

4.2 内存使用 (Memory Usage)

内存使用是评估数据结构效率的另一个重要指标。不同的线性表结构会有不同的内存消耗模式,这些模式往往与其内部结构和设计目标有关。

  • vector (动态数组 Dynamic Array): vector在内存中是连续的,这意味着它的元素是紧密排列的,没有额外的内存开销。但是,为了支持动态扩容,vector通常会预留一些额外的内存空间,这可能导致内存浪费。
  • array (固定大小数组 Fixed-size Array): array的内存使用与vector相似,但由于其大小是固定的,所以没有预留的内存空间。
  • list (双向链表 Doubly Linked List): list的每个元素都有两个额外的指针,分别指向前一个和后一个元素。这意味着list的内存开销比vectorarray要大。
  • forward_list (单向链表 Singly Linked List): 与list相比,forward_list的每个元素只有一个指针,指向下一个元素,因此其内存开销比list小。
  • deque (双端队列 Double-ended Queue): deque的内存结构是一系列的块,每个块包含多个元素。这种设计使得deque在头部和尾部都可以高效地插入和删除元素,但可能导致一些内存浪费。

正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“选择正确的数据结构可以大大提高程序的性能,但也可能增加内存开销。”

下面的表格从内存使用的角度对这些线性表进行对比:

数据结构 内存连续性 额外内存开销 是否有预留空间
vector 连续
array 连续
list 非连续 有 (两个指针)
forward_list 非连续 有 (一个指针)
deque 非连续

在选择线性表时,除了考虑性能外,我们还应该考虑内存使用。有时,为了节省内存,我们可能会选择一个性能稍差但内存使用更少的数据结构。

4.3 设计思想与应用场景 (Design Philosophy & Application Scenarios)

每种线性表都有其独特的设计思想,这些设计思想往往是基于特定的应用场景。了解这些设计思想和应用场景可以帮助我们更好地选择和使用合适的数据结构。

  • vector (动态数组 Dynamic Array): vector的设计思想是提供一个可以动态扩容的数组。它非常适合需要频繁随机访问元素但不需要频繁在中间插入或删除元素的场景。
  • array (固定大小数组 Fixed-size Array): array的设计思想是提供一个固定大小的数组。它适合已知元素数量并且不需要动态扩容的场景。
  • list (双向链表 Doubly Linked List): list的设计思想是提供一个可以在任意位置高效插入和删除元素的数据结构。它适合需要频繁在中间插入或删除元素的场景。
  • forward_list (单向链表 Singly Linked List): forward_list的设计思想是提供一个更轻量级的链表,它只支持单向迭代。它适合不需要反向迭代的场景。
  • deque (双端队列 Double-ended Queue): deque的设计思想是提供一个可以在头部和尾部都高效插入和删除元素的数据结构。它适合需要在两端都进行操作的场景。

正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“数据结构的选择应该基于其设计思想和应用场景,而不仅仅是基于性能。”

下面的表格从设计思想和应用场景的角度对这些线性表进行对比:

数据结构 设计思想 主要应用场景
vector 动态扩容的数组 需要频繁随机访问的场景
array 固定大小的数组 已知元素数量的场景
list 在任意位置高效插入和删除 需要频繁在中间插入或删除的场景
forward_list 轻量级的单向链表 不需要反向迭代的场景
deque 在两端都高效操作 需要在头部和尾部都进行操作的场景

选择合适的数据结构可以帮助我们更好地满足应用的需求。例如,如果我们正在开发一个需要频繁在头部和尾部插入和删除元素的应用,那么deque可能是一个很好的选择。

5. 如何学习线性表 (How to Learn Linear Tables)

5.1 推荐的学习资源 (Recommended Learning Resources)

学习线性表,尤其是在C++中,需要一个结构化的方法和高质量的资源。以下是一些经过筛选的学习资源,旨在为您提供一个全面而深入的学习体验。

  1. 书籍 (Books)
  • 《C++ Primer》:这本书是C++学习的经典之作,涵盖了C++的基础知识和高级特性。其中,线性表的部分讲解得尤为详细。正如Stanley B. Lippman, Josée Lajoie, and Barbara E. Moo在书中所说:“Understanding the nature and behavior of containers is essential to writing good C++ programs.”
  • 《数据结构与算法分析:C++描述》:这本书由Mark Allen Weiss著,专门针对数据结构和算法在C++中的应用。它为读者提供了深入的洞察,帮助他们理解数据结构背后的原理和实现。
  1. 在线课程 (Online Courses)
  • Coursera的“Data Structures and Algorithm Specialization”:这是一个专门针对数据结构和算法的系列课程,其中包括线性表的详细讲解。通过实际的编程任务和挑战,学生可以深入理解和应用所学知识。
  1. 开源项目和代码库 (Open-source Projects and Codebases)
  • C++ STL源码:为了真正理解C++中的线性表如何工作,最好的方法就是直接查看其源代码。例如,std::vector是在GCC编译器的头文件中实现的。通过深入研究这些代码,您可以获得关于其设计和实现的深入见解。
  1. 论坛和社区 (Forums and Communities)
  • Stack Overflow:这是一个全球范围内的程序员社区,您可以在这里找到关于线性表和C++的许多讨论和问题。与其他开发者互动可以帮助您更好地理解和应用所学知识。

学习线性表并不仅仅是为了掌握一种数据结构。它是一种思维方式,一种看待问题和解决问题的方法。正如古人所说:“学而不思则罔,思而不学则殆。”当我们学习线性表时,我们不仅仅是在学习一种技术,更是在培养一种思维方式和解决问题的能力。

5.2 实践与项目 (Practice and Projects)

实践是巩固学习成果的最佳方式。通过实际的项目和挑战,您不仅可以应用所学的知识,还可以在真实的环境中测试和完善您的技能。

  1. 基础实践 (Basic Practice)
  • 线性表操作:创建一个简单的应用程序,允许用户选择不同的线性表结构(如vectorlist等),并执行基本操作(如插入、删除、查找等)。这将帮助您熟悉不同线性表的API和性能特点。
  1. 中级项目 (Intermediate Projects)
  • 联系人管理系统:使用线性表创建一个简单的联系人管理系统,允许用户添加、删除、查找和修改联系人信息。这个项目可以帮助您理解如何在实际应用中使用线性表。
  • 音乐播放器:设计一个简单的音乐播放器,其中播放列表可以使用线性表来实现。用户可以添加、删除、查找和播放歌曲。
  1. 高级挑战 (Advanced Challenges)
  • 路径查找算法:使用线性表实现一个简单的路径查找算法,例如Dijkstra算法或A*算法。这将帮助您理解线性表在算法中的应用。
  • 内存管理模拟:模拟操作系统的内存管理,使用线性表来表示内存块。设计算法来分配和释放内存,并处理内存碎片问题。
  1. 开源贡献 (Open Source Contribution)
  • 考虑为开源项目做出贡献,特别是那些与数据结构和算法相关的项目。这不仅可以帮助您实践所学,还可以与社区的其他成员互动和学习。

正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“Programming is understanding.” 编程不仅仅是写代码,更重要的是理解问题和找到解决方案。通过实践和项目,您可以更深入地理解线性表和其在实际应用中的价值。

5.3 常见的面试问题 (Common Interview Questions)

面试是每个程序员职业生涯中不可避免的一部分。对于线性表这一基础知识点,面试官通常会从多个角度进行提问,以测试应聘者的理解和应用能力。以下是一些常见的线性表相关的面试问题,以及如何准备和回答它们。

1. 描述vectorlist的主要差异,并解释在何种情境下应选择哪种数据结构。

答:vector是基于数组的动态数据结构,支持随机访问,但在中间插入和删除元素时可能需要移动大量元素。而list是基于双向链表的数据结构,不支持高效的随机访问,但可以在任何位置快速插入和删除元素。如果需要频繁的随机访问,vector是更好的选择;如果需要频繁在中间插入和删除元素,list更为合适。

2. 如何实现一个固定大小的循环队列?

答:固定大小的循环队列可以使用数组实现。我们需要两个指针,一个指向队列的头部,另一个指向尾部。当添加或删除元素时,这两个指针会移动。当指针到达数组的末尾时,它会回到数组的开始位置,形成一个循环。

class CircularQueue {
private:
    int *data;
    int head, tail, size, capacity;
public:
    CircularQueue(int k) {
        data = new int[k];
        head = -1;
        tail = -1;
        capacity = k;
        size = 0;
    }
    // ... 其他方法
};

3. 为什么forward_list不支持反向迭代?

答:forward_list是基于单向链表实现的,每个节点只有一个指向下一个节点的指针,没有指向前一个节点的指针。因此,从一个给定的节点开始,我们只能向前移动,不能向后移动,这就是为什么forward_list不支持反向迭代的原因。

正如Bjarne Stroustrup在《The C++ Programming Language》中所说:“选择正确的数据结构和算法可以使问题从不可解变为可解。”

为了更深入地理解线性表,我们可以从人类思维的角度来看。我们的思维方式往往是线性的,从一个点到另一个点,这与线性表的结构非常相似。当我们处理问题时,我们通常会按照一定的顺序或步骤来进行,这也反映了线性表的特性。

在学习线性表时,建议读者深入研究每种数据结构的内部实现,这不仅可以加深对其工作原理的理解,还可以提高编程和问题解决的能力。例如,当学习std::vector时,可以查看其在GCC或Clang编译器中的实现,深入了解其如何动态调整大小,如何处理内存分配等。

总之,线性表是计算机科学中的基础知识点,深入学习和理解它对于每个程序员都是非常有益的。

结语

在我们的编程学习之旅中,理解是我们迈向更高层次的重要一步。然而,掌握新技能、新理念,始终需要时间和坚持。从心理学的角度看,学习往往伴随着不断的试错和调整,这就像是我们的大脑在逐渐优化其解决问题的“算法”。

这就是为什么当我们遇到错误,我们应该将其视为学习和进步的机会,而不仅仅是困扰。通过理解和解决这些问题,我们不仅可以修复当前的代码,更可以提升我们的编程能力,防止在未来的项目中犯相同的错误。

我鼓励大家积极参与进来,不断提升自己的编程技术。无论你是初学者还是有经验的开发者,我希望我的博客能对你的学习之路有所帮助。如果你觉得这篇文章有用,不妨点击收藏,或者留下你的评论分享你的见解和经验,也欢迎你对我博客的内容提出建议和问题。每一次的点赞、评论、分享和关注都是对我的最大支持,也是对我持续分享和创作的动力。

目录
相关文章
|
22小时前
|
JSON Linux C语言
全网最权威唯一值得推荐的《C/C++框架和库》
关于C++框架、库和资源的一些汇总列表,内容包括:标准库、Web应用框架、人工智能、数据库、图片处理、机器学习、日志、代码分析等。
12 1
|
1天前
|
算法 安全 Linux
【C++】STL简介(了解)
【C++】STL简介(了解)
|
2天前
|
算法 编译器 C语言
从C语言到C++⑩(第四章_模板初阶+STL简介)如何学习STL(下)
从C语言到C++⑩(第四章_模板初阶+STL简介)如何学习STL
7 0
|
2天前
|
编译器 C语言 C++
从C语言到C++⑩(第四章_模板初阶+STL简介)如何学习STL(上)
从C语言到C++⑩(第四章_模板初阶+STL简介)如何学习STL
6 0
|
6天前
|
存储 算法 搜索推荐
C++|STL简介-string-vector基础运用
C++|STL简介-string-vector基础运用
|
8天前
|
Linux Shell 开发工具
C++ 的 ini 配置文件读写/注释库 inicpp 用法 [ header-file-only ]
这是一个C++库,名为inicpp,用于读写带有注释的INI配置文件,仅包含一个hpp头文件,无需编译,支持C++11及以上版本。该库提供简单的接口,使得操作INI文件变得容易。用户可通过`git clone`从GitHub或Gitee获取库,并通过包含`inicpp.hpp`来使用`inicpp::iniReader`类。示例代码展示了读取、写入配置项以及添加注释的功能,还提供了转换为字符串、双精度和整型的函数。项目遵循MIT许可证,示例代码可在Linux环境下编译运行。
40 0
|
8天前
|
机器学习/深度学习 JSON 编译器
C++ 资源大全:标准库、Web框架、人工智能等 | 最全整理
C++ 资源列表,内容包括: 标准库、Web应用框架、人工智能、数据库、图片处理、机器学习、日志、代码分析等
55 1
|
8天前
|
JSON Java Linux
【探索Linux】P.30(序列化和反序列化 | JSON序列化库 [ C++ ] )
【探索Linux】P.30(序列化和反序列化 | JSON序列化库 [ C++ ] )
24 2
|
8天前
|
算法 C++
【C++入门到精通】智能指针 shared_ptr循环引用 | weak_ptr 简介及C++模拟实现 [ C++入门 ]
【C++入门到精通】智能指针 shared_ptr循环引用 | weak_ptr 简介及C++模拟实现 [ C++入门 ]
17 0
|
8天前
|
安全 算法 数据安全/隐私保护
【C++入门到精通】智能指针 shared_ptr 简介及C++模拟实现 [ C++入门 ]
【C++入门到精通】智能指针 shared_ptr 简介及C++模拟实现 [ C++入门 ]
14 0