1-STL体系结构基础介绍

最新推荐文章于 2022-08-12 12:43:19 发布
最新推荐文章于 2022-08-12 12:43:19 发布
阅读量250 收藏
点赞数
分类专栏： STL 文章标签： c++ stl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41033011/article/details/108503277
版权

文章目录

一、STL 六大部件（Components）

  • 容器（Containers）
  • 分配器（Allocators）
  • 算法（Algorithms）
  • 迭代器（Iterators）
  • 适配器（Adapters）
  • 仿函数（Functors）

六大部件的关系目前可以初步用下图来表示：
在这里插入图片描述
下面我们用一个程序来使用这六大部件
t
1. 前闭后开区间

  对于迭代器来说，begin() 指向的是容器的第一个元素，end() 指向容器最后一个元素的下一个位置，所以经常使用 end() 来判断是否遍历到了容器结尾。如下图所示：
在这里插入图片描述

Container<T> c;
...
Container<T>::iterator it = c.begin();
for(; it != c.end(); ++it)
	...

2. range-based for statement (since C++11)

【语法】
for(decl : coll)
{
	statement;
}
【举例】
vector<int> vec;
...
for(auto elem : vec)
{
	cout << elem << endl;  // 打印vec中每一个元素
}
for(auto &elem : vec)
{
	elem *= 3;
}

3. auto 关键字(since C++11)

list<string> c;
...
list<string>::iterator it;
it = find(c.begin(), c.end(), target);

【等同于】
list<string> c;
...
auto it = find(c.begin(), c.end(), target);

二、容器之分类

  其实容器主要分为两大类：序列容器和关联容器。但是 C++11 后新增了 Unordered Containers，其实它的本质还是属于关联容器。

1. 序列容器（Sequence Containers）

  所谓序列式容器，其中的元素都可序，但未必有序，C++ 语言本来提供了一种序列式容器 array，STL 另外再提供 vector，list，deque，stack，queue，priority-queue 等等序列式容器。其中 stack 和 queue 由于只是将 deque 改头换面，技术上被归类为一种配接器（Adapter）。

1. Array（数组）（C++11）

  在 C/C++ 里面本来就存在数组，它是语言的一部分。在 C++11 中把数组也变成一个 class。Array在内存中是连续分配的， 当初你定义了多大空间它就有多大空间，它是一个定长数组，当数组中空间不够时，它是没有办法扩充的。
在这里插入图片描述

2. Vector

单向开口的动态数组，在内存中是连续分配的。当 vector 中空间不够时，它会自动扩充（分配器）。
在这里插入图片描述

3. Deque

双向开口的的队列，简称双端队列。deque 是由分段的连续线性空间组合而成
在这里插入图片描述

4. List

双向环状链表，在内存中不一定是连续存储的。
在这里插入图片描述

5. Forward-List（C++11）

单向链表，
在这里插入图片描述

2. 关联容器（Associative Containers）

  标准的 STL 关联式容器分为 set（集合）和 map（映射）两大类，以及这两大类的衍生体 mutiset（多键集合）和 multimap（多键映射表）。这些容器的底层均以 RB-tree（红黑树）完成。RB-tree 也是一个独立容器，但并不开放给外界使用。

此外，SGI STL 还提供了一个不再标准规格之列的关联式容器：hash table（散列表），以及以此 hash table 为底层实现机制而完成的 hash_set（散列集合）、hash_map（散列映射表）、hash_multiset（散列多键集合）和 hash_multimap（散列多键映射表）。

该容器下元素由 key 和 value 组成。key 为关键值，通过 key 可以很快找到 value 的值。所以关联容器很适合做快速的查找。

1. Set/Multiset

set 的 key 就是 value。set 中的元素不允许重复，如果想要重复，使用 multiset。
在这里插入图片描述

2. Map/Multimap

map 由 key 和 value 组成。map 中的元素的键值不允许重复，如果想要重复，使用 multimap。
在这里插入图片描述

3. 不定序容器（Unordered Containers）（C++11）

其实 Unordered Containers 也是一种关联式容器。底层是使用 hashtable 实现。

目前，hashTable 大多都采用很多链表组成。HashTable Separate Chaining 数据结构如下图所示：
在这里插入图片描述

1. Unordered Set/Multiset
在这里插入图片描述

2. Unordered Map/Multimap
在这里插入图片描述

三、容器测试

1. 使用容器 array

#include <iostream>
#include <array>
#include <ctime>
#include <cstdlib>
using namespace std;
#define ASIZE 500000
// 随机生成 1-500000 之间的数
long get_a_target_long()
{
    return rand() % 500000 + 1;
}
int compareLongs(const void *p1, const void *p2)
{
    return *(long *)p1 < *(long *)p2;
}

void test_array()
{
    cout << "\ntest array() ..............\n";
    array<long, ASIZE> arr;

    clock_t startTime = clock();
    for(long i = 0; i < ASIZE; i++)
        arr[i] = rand() % 500000 + 1;
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "array.size()：" << arr.size() << endl;
    cout << "array.front()：" << arr.front() << endl;
    cout << "array.back()：" << arr.back() << endl;
    cout << "array.data()：" << arr.data() << endl;

    int target = get_a_target_long();

    startTime = clock();

    // 排序
    // void qsort (void* base, size_t num, size_t size, int (*compar)(const void*,const void*));
    qsort(arr.data(), ASIZE, sizeof(long), compareLongs);

    // 二分查找：使用二分查找之前一定要先排序
    // void* bsearch (const void* key, const void* base, size_t num, size_t size, int (*compar)(const void*,const void*));
    long *pItem = (long *)bsearch(&target, (arr.data()), ASIZE, sizeof(long), compareLongs);
    cout << "qsort() + bsearch(), milli-seconds：" << (clock() - startTime) << endl;
    if(pItem)
        cout << "found：" << *pItem << endl;
    else
        cout << "Not Found！" << endl;

}

int main()
{
    test_array();
    return 0;
}

在这里插入图片描述

2. 使用容器 vector

#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <ctime>
#include <cstdlib>
using namespace std;
// ****************** vector ********************//
string get_a_target_string()
{
    srand(time(nullptr));
    long target = rand() % 50000 + 1;
    char buf[10];
    snprintf(buf, 10, "%d", target);
    return string(buf);
}
int compareString(const void *str1, const void *str2)
{
    return *(string *)str1 < *(string *)str2;
}
void test_vector(long &value)
{
    cout << "\ntest_vector()...................... \n";

    vector<string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str.push_back(string(buf));
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "vector.size()：" << str.size() << endl;
    cout << "vector.front()：" << str.front() << endl;
    cout << "vector.back()：" << str.back() << endl;
    cout << "vector.data()：" << str.data() << endl;
    cout << "vector.capacity()：" << str.capacity() << endl; // 一定比 size 大

    string target = get_a_target_string();

    startTime = clock();

    auto pItem = find(str.begin(), str.end(), target); // find 返回迭代器
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;

    if(pItem != str.end())
        cout << "find：" << *pItem << endl;
    else
        cout << "Not found" << endl;
}
// ****************** vector ********************//
int main()
{
    long target = 1000000;
    test_vector(target);
    return 0;
}

在这里插入图片描述

3. 使用容器 list

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>
#include <ctime>
#include <cstdlib>
using namespace std;
// ****************** list ********************//
void test_list(long &value)
{
    cout << "\ntest_list()...................... \n";

    list<string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str.push_back(string(buf));
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "list.size()：" << str.size() << endl;
    cout << "list.max_size()：" << str.max_size() << endl;
    cout << "list.front()：" << str.front() << endl;
    cout << "list.back()：" << str.back() << endl;

    string target = get_a_target_string();

    startTime = clock();

    auto pItem = find(str.begin(), str.end(), target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;

    if(pItem != str.end())
        cout << "find：" << *pItem << endl;
    else
        cout << "Not found" << endl;

    startTime = clock();
    str.sort(); // 调用容器内部的 sort 方法，不是标准库中的 sort。
    cout << "str.sort(), mill-seconds：" << (clock() - startTime) << endl;
}
// ****************** list ********************//
int main()
{
    long target = 1000000;
    test_list(target);
    return 0;
}

在这里插入图片描述

4. 使用容器 forward_list

#include <iostream>
#include <vector>
#include <list>
#include <forward_list>
#include <algorithm>
#include <functional>
#include <ctime>
#include <cstdlib>
using namespace std;
// ****************** forward_list ********************//
void test_forward_list(long &value)
{

    cout << "\ntest_forward_list()...................... \n";

    forward_list<string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str.push_front(string(buf)); // 只有 push_front() 方法，没有 push_back() 方法
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "forward_list.max_size()：" << str.max_size() << endl;
    cout << "forward_list.front()：" << str.front() << endl;
    //cout << "forward_list.back()：" << str.back() << endl;   // 没有此函数
    //cout << "forward_list.size()：" << str.size() << endl; // 没有此函数

    string target = get_a_target_string();

    startTime = clock();

    auto pItem = find(str.begin(), str.end(), target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;

    if(pItem != str.end())
        cout << "find：" << *pItem << endl;
    else
        cout << "Not found" << endl;

    startTime = clock();
    str.sort();
    cout << "str.sort(), mill-seconds：" << (clock() - startTime) << endl;
}
// ****************** forward_list ********************//

int main()
{
    long target = 1000000;
    test_forward_list(target);
    return 0;
}

在这里插入图片描述

注意：只有 list 和 forward_list 才有自带的排序方法。

5. 使用容器 deque

deque 是由分段的连续线性空间组合而成。
在这里插入图片描述

#include <iostream>
#include <vector>
#include <list>
#include <forward_list>
#include <deque>
#include <algorithm>
#include <functional>
#include <ctime>
#include <cstdlib>
using namespace std;
// ****************** deque ********************//
void test_deque(long &value)
{

    cout << "\ntest_forward_list()...................... \n";

    deque<string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str.push_front(string(buf));
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "deque.size()：" << str.size() << endl;
    cout << "deque.front()：" << str.front() << endl;
    cout << "deque.back()：" << str.back() << endl;
    cout << "deque.max_size()：" << str.max_size() << endl;

    string target = get_a_target_string();

    startTime = clock();

    auto pItem = find(str.begin(), str.end(), target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;

    if(pItem != str.end())
        cout << "find：" << *pItem << endl;
    else
        cout << "Not found" << endl;

    startTime = clock();
    sort(str.begin(), str.end());
    cout << "sort(), mill-seconds：" << (clock() - startTime) << endl;
}
// ****************** deque ********************//

int main()
{
    long target = 1000000;
    test_deque(target);
    return 0;
}

在这里插入图片描述

6. 使用容器 multiset

#include <list>
#include <forward_list>
#include <deque>
#include <algorithm>
#include <functional>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
using namespace std;
// ****************** multiset ********************//
void test_multiset(long &value)
{

    cout << "\ntest_multiset()...................... \n";

    multiset<string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str.insert(string(buf));
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "multise.size()：" << str.size() << endl;
    cout << "multise.max_size()：" << str.max_size() << endl;

    string target = get_a_target_string();

    startTime = clock();

    auto pItem = find(str.begin(), str.end(), target); // 采用算法中的 find
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;

    if(pItem != str.end())
        cout << "find：" << *pItem << endl;
    else
        cout << "Not found" << endl;

    startTime = clock();
    auto it = str.find(target);  // 调用容器自身的 find
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;
    if(it != str.end())
        cout << "find：" << *it << endl;
    else
        cout << "Not found" << endl;
}
// ****************** multiset ********************//

int main()
{
    long target = 1000000;
    test_multiset(target);
    return 0;
}

在这里插入图片描述

7. 使用容器 multimap

#include <list>
#include <forward_list>
#include <deque>
#include <algorithm>
#include <functional>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
using namespace std;
// ****************** multimap ********************//
void test_multimap(long &value)
{

    cout << "\ntest_multimap()...................... \n";

    multimap<long, string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            // multimap 不可使用 [] 做 insertion
            str.insert(pair<long, string>(i, buf)); 
            //str.insert({i, buf}); // 第二种插入方式
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "multimap.size()：" << str.size() << endl;
    cout << "multimap.max_size()：" << str.max_size() << endl;

    long target = get_a_target_long();

    startTime = clock();
    auto it = str.find(target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;
    if(it != str.end())
        cout << "find, value：" << it->second << endl;
    else
        cout << "Not found" << endl;
}
// ****************** multimap ********************//

int main()
{
    long target = 1000000;
    test_multimap(target);
    return 0;
}

在这里插入图片描述

8. 使用容器 unordered_multiset

// ****************** unordered_multiset ********************//
void test_unordered_multiset(long &value)
{

    cout << "\ntest_unordered_multiset()...................... \n";

    unordered_multiset<string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str.insert(string(buf)); // 只有 push_front() 方法，没有 push_back() 方法
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "unordered_multiset.size()：" << str.size() << endl;
    cout << "unordered_multiset.max_size()：" << str.max_size() << endl;
    cout << "unordered_multiset.bucket_count()：" << str.bucket_count() << endl; // 篮子的个数
    cout << "unordered_multiset.load_factor()：" << str.load_factor() << endl;
    cout << "unordered_multiset.max_load_factor()：" << str.max_load_factor() << endl;
    cout << "unordered_multiset.max_bucket_count()：" << str.max_bucket_count() << endl;

    string target = get_a_target_string();

    startTime = clock();

    auto pItem = find(str.begin(), str.end(), target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;

    if(pItem != str.end())
        cout << "find：" << *pItem << endl;
    else
        cout << "Not found" << endl;

    startTime = clock();
    auto it = str.find(target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;
    if(it != str.end())
        cout << "find：" << *it << endl;
    else
        cout << "Not found" << endl;
}
// ****************** unordered_multiset ********************//

int main()
{
    long target = 1000000;
    test_unordered_multiset(target);
    return 0;
}

在这里插入图片描述
在这里插入图片描述

9. 使用容器 unordered_multimap

// ****************** unordered_multimap ********************//
void test_unordered_multimap(long &value)
{

    cout << "\ntest_unordered_multimap()...................... \n";

    unordered_multimap<long, string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            //str.insert(pair<long, string>(i, buf)); // 只有 push_front() 方法，没有 push_back() 方法
            str.insert({i, buf});
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "unordered_multimap.size()：" << str.size() << endl;
    cout << "unordered_multimap.max_size()：" << str.max_size() << endl;

    long target = get_a_target_long();

    startTime = clock();
    auto it = str.find(target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;
    if(it != str.end())
        cout << "find, value：" << it->second << endl;
    else
        cout << "Not found" << endl;
}
// ****************** unordered_multimap ********************//


int main()
{
    long target = 1000000;
    test_unordered_multimap(target);
    return 0;
}

10. 使用容器 set

// ****************** multiset ********************//
void test_set(long &value)
{

    cout << "\ntest_set()...................... \n";

    set<string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str.insert(string(buf)); // 只有 push_front() 方法，没有 push_back() 方法
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "set.size()：" << str.size() << endl;
    cout << "set.max_size()：" << str.max_size() << endl;

    string target = get_a_target_string();

    startTime = clock();

    auto pItem = find(str.begin(), str.end(), target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;

    if(pItem != str.end())
        cout << "find：" << *pItem << endl;
    else
        cout << "Not found" << endl;

    startTime = clock();
    auto it = str.find(target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;
    if(it != str.end())
        cout << "find：" << *it << endl;
    else
        cout << "Not found" << endl;
}
// ****************** set ********************//


int main()
{
    long target = 1000000;
    test_set(target);
    return 0;
}

在这里插入图片描述
我们申请了 1000000 个元素，但是 set 实际元素个数为 32768。

11. 使用容器 map

//****************** map ********************//
void test_map(long &value)
{

    cout << "\ntest_map()...................... \n";

    map<long, string> str;
    char buf[10];

    clock_t startTime = clock();
    for(long i = 0; i < value; i++)
    {
        try{ // 当内存不够时，捕获异常
            snprintf(buf, 10, "%d", rand());
            str[i] = string(buf);
        }
        catch(exception &p){
            cout << "i = " << i << " " << p.what() << endl;
            abort();
        }
    }
    cout << "milli-seconds：" << (clock() - startTime) << endl;
    cout << "map.size()：" << str.size() << endl;
    cout << "map.max_size()：" << str.max_size() << endl;

    long target = get_a_target_long();

    startTime = clock();
    auto it = str.find(target);
    cout << "find, milli-seconds：" << (clock() - startTime) << endl;
    if(it != str.end())
        cout << "find, value：" << it->second << endl;
    else
        cout << "Not found" << endl;
}

// ****************** map ********************//

int main()
{
    long target = 1000000;
    test_map(target);
    return 0;
}

在这里插入图片描述

蓝子娃娃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
stl如果开o2_如何自己写一个STL(上)
weixin_39774491的博客
12-22 265
昨天，我的一个小项目 MyTinySTL 发布了 v2.0.0 版本，宣布这个项目告一段落。这个项目从去年暑假开始动工，至今已经过了一年多了，期间完成过多次重构，这一次算是第三次重构，进行了非常多的修改。可以看到，提交数已经超过 1000，当然我没有特地凑这个数字，而是我最后一次 merge 之后，刚好就是一千了！而代码量，现存下来的不是很多，2W 余行，但是期间 debug 过的代码量，远远超过...
嵌入式-linux-c++-arm体系结构教程
最新发布
03-29
压缩包主要包含了以下内容： (1) Unix基础 (2)标准C编程 (3)标准C++编程 (4)数据结构和算法 (5)STL与模板 (6)项目一 ...(12) arm体系结构 (13) linux系统移植 (14) linux驱动开发 配套教学视频的阿里云链接
自己实现STL容器——list
Nire_Yeyu的博客
09-17 1322
通过自己实现STL的list容器，相信大家会对list容器以及相关函数有进一步的了解 #include <iostream> using namespace std; class NotElementException:public exception{ public: NotElementException(const char *info="没有元素"):errinfo(inf...
STL容器——自定义容器
qq_38082979的博客
04-08 362
1.定义MyList类 #pragma once #include <list> template <class T> class MyList:public std::list<T> { public: typename std::list<T>::iterator append(const T& x = T()) { return std::list<T>::insert(this->end(), x); } }; 新
自己动手写STL中的vector
晴天的专栏
11-13 1452
M0313-array_class_template.h#ifndef DYNAMIC_ARRAY_H_ #define DYNAMIC_ARRAY_H_ #include #include struct A { A(int n = 0): i(n) { printf("A(%d)\n", i); } ~A() { printf("~A(%d)\n", i); } i
拓展C++ STL功能，函数适配器，复合函数composite
helloxiyue的博客
10-09 1168
复合函数 数学定义：u=f(x,y)，v=g(u)，则把u=g(f(x,y))，称作g和f的复合函数，记作g。f，在STL中已经有很多的系统函数对象，如果将他们复合，将会实现更强大的功能，可惜STL的函数适配器没有提供这样的功能函数。于是，我仿造bind2nd和binder2nd的实现方法，自己写了composite和compositer的复合函数，实现g(f(x,y)的功能 函数原型
CSCI-463：CSCI 463-计算机体系结构和系统组织
02-09
计算机体系结构和系统组织是计算机科学中的核心课程，它涵盖了硬件和软件之间的接口以及它们如何协同工作以执行计算任务。CSCI-463课程旨在深入理解这些概念，特别是通过使用C++编程语言来实现和分析系统级问题。C++...
01-绪论和线性表1
08-04
学习数据结构与算法，我们还将接触到计算机体系结构的优化，如现代文件系统在磁盘到 SSD 的改进，以及如何在多核、跨 CPU 和集群环境下进行大规模并行计算。了解缓存通信、片内通信、总线通信和网络通信对数据同步的...
C&&C++知识体系结构图
09-09
C和C++的知识体系结构图通常会以图形方式展示这些概念的层次关系和相互联系，帮助学习者理解并构建清晰的知识框架。"c语言知识体系.png"和"c++知识体系 (2).png"可能是这样的可视化表示，它们将有助于你直观地掌握这...
STEP 7 STL指令
06-04
本文将深入解析STL指令的核心功能，通过分析其标题、描述及部分关键内容，为读者呈现一个全面的STL指令体系概览。 #### 一、整型数学运算指令：精确计算的基石 - **加整型常数**：这一指令允许用户在程序中添加...
【试着自己写一个STL 】Knife_STL —— pair.h
Velconia的专栏
01-22 754
#ifndef KNIFE_PAIR_H #define KNIFE_PAIR_H #include "config.h" #include _STL_NAMESPACE_BEGIN template struct pair { typedef A_Type first_type; typedef B_Type second_type; A_Type first; B_Type
【试着自己写一个STL 】Knife_STL —— alloc.h
Velconia的专栏
01-22 935
#ifndef KNIFE_ALLOC_H #define KNIFE_ALLOC_H #include "config.h" #include "knifeio.h" #include #include // 通常写注释会中英混杂，其实我英文也不是很好，主要是懒得切换输入法了，就当练练口语交际 // 这次实现的就是STL的重要部分了：allocator // 仍旧是SGI_STL 203
【试着自己写一个STL 】Knife_STL —— config.h
Velconia的专栏
01-22 721
#ifndef CONFIG_H #define CONFIG_H #define _STL_NAMESPACE_BEGIN namespace knife { #define _STL_NAMESPACE_END } _STL_NAMESPACE_BEGIN // define different size type by basic type #define Byte ch
从零开始写STL—容器—vector
aocan6909的博客
03-12 243
从0开始写STL—容器—vector vector又称为动态数组，那么动态体现在哪里？vector和一般的数组又有什么区别？vector中各个函数的实现原理是怎样的，我们怎样使用会更高效？ 以上内容我们将通过写一个自己的vector来进行学习 typedef 简析 在容器类的最前面我们会看到许多的typedef ，常见的如下: public: type...
自己动手实现简易STL
weixin_44344205的博客
04-15 1953
自己动手实现简易STLSTL六个组件迭代器 & 算法容器，迭代器部分适配器仿函数额外的工作小结 之前学习C++看侯老师的书的时候实现了一下STL的基本组件，包括了6个组件,allocator, iterator, container, trait, functor, algorithm的组件，也是终于搞清楚了6个组件之间的相互关联，但是这么写着(CTRL C + V)有点无聊，于是做了一些数据结构的可视化，当时本来是想加更多的功能来着，比如高亮最近改变或者查找的某个数据。 STL六个组件 比较难理解
C++ STL 扩展
m0_37981386的博客
01-05 302
#include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;vector&gt; #include &lt;map&gt; #include &lt;string&gt; //#include &lt;utility&gt; class Mydata { public: Mydata() { data = 0; }...
C++ STL基本组成（6大组件+13个头文件）
ym18861512953的博客
08-24 277
STL 是由容器、算法、迭代器、函数对象、适配器、内存分配器这 6 部分构成，其中后面 4 部分是为前 2 部分服务的，它们各自的含义如下表所示。 STL的组成 含义 容器 一些封装数据结构的模板类，例如 vector 向量容器、list 列表容器等。 算法 STL 提供了非常多（大约 100 个）的数据结构算法，它们都被设计成一个个的模板函数，这些算法在 std 命名空间中定义，其中大部分算法都包含在头文件 中，少部分位于头文件 中。 迭代器 在 C++ STL 中，对容器中数
C++手动实现STL部分容器和算法
m0_62755690的博客
08-12 555
C++手动实现STL和部分算法
stl手写合集
santongding
08-05 896
水平不够写得和stl差远了。。只能说是基本实现其功能吧。。。现在对c++的了解基本是0，等以后系统学习之后也许会慢慢完善。 vector struct vtr{ int *s,*e; int memsize,cnt; vtr(){ memsize=2; e=s=new int[memsize]; cnt=0; } ...
基础编程与STL的重要性
基础的计算机科学知识，如离散数学、算法与数据结构、计算机体系结构等，对于理解和使用STL至关重要。它们提供了解决问题的基本逻辑框架，使你能更好地理解STL背后的机制，从而编写出更高效、更健壮的代码。没有这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值