精华内容
下载资源
问答
  • C++标准模板库介绍

    2021-03-31 21:30:37
    第六章 C++标准模板库 前言:在C语言中很多功能需要读者自己实现,而C++语言引入了STL,其封装了很多实用的容器,可以利用它们直接调用本身封装的函数来实现很多功能。 它对程序的简化有非常显著的效果。 精髓:...

    第六章 C++标准模板库

    前言:在C语言中很多功能需要读者自己实现,而C++语言引入了STL,其封装了很多实用的容器,可以利用它们直接调用本身封装的函数来实现很多功能。

    它对程序的简化有非常显著的效果。

    精髓:掌握用法、熟知区别。

    6.1vector常见用法详解

    vector翻译为向量,”变长数组“的叫法更容易理解。使用前添加vector头文件,即#include<vector>。除此之外,还需要添加一句using namespace std;

    6.1.1定义:

    vector<typename> name

    为何用?

    答:普通数组超内存时,使用vector会让问题便捷许多。另外,可以用来以邻接表的方式储存图,对于无法使用邻接矩阵的题目(结点数太多)、又害怕使用指针实现邻接表的读者非常友好。

    有什么注意事项?

    答:如果typename也是一个STL容器,定义的时候要记得在>>符号之间加上空格。

    vector数组定义:1、vector<vector<typename>> name ;2、vector<typename> Arrayname[arraySize]。

    6.1.2访问方式:

    1、下标访问

    2、迭代器访问

    迭代器的定义:vector<typename>::iterator it;它类似一个指针的东西,并且通过*it来访问vector里的元素。迭代器实现了两种自加操作:++it和it++

    vi[i]和*(vi.begin()+i)是等价的,此外vi.end()作为迭代器末尾标志,取尾元素地址的下一个地址。左闭右开思维。

    vector迭代器不支持it<vi.end()写法,迭代时循环条件只能用it!=vi.end()。

    只有在vector和string中,才允许使用vi.begin()+3这种迭代器加整数的写法。

    6.1.3常用函数实例:

    push_back():时间复杂度O(1)

    pop_back():时间复杂度O(1)

    size():返回unsigned long long int类型,不过一般来说用%d输出不会出很大的问题。时间复杂度O(1)

    clear():时间复杂度O(n)。即vi.erase(vi.begin(),vi.end())。

    insert():时间复杂度O(n)

    1. insert(it,x):it为迭代器

    erase():时间复杂度O(n)

    1. erase(it)
    2. erase(start,end):删除区间[start,end)内的所有元素

    6.1.4常见用途

    储存数据

    1. 本身作为数组,在元素个数不确定的场合可以很好节省空间。
    2. 某些场合需要把部分数据输出在同一行,数据中间用空格隔开。由于输出数据的个数是不确定的,可以先用vector记录需要输出的数据,然后一次性输出,以便处理最后一个满足条件的数据后面不输出额外的空格的情况。

    用邻接表存储图

    1. 使用vector实现邻接表可以让一些指针不太熟悉的读者有比较方便的写法。

    6.2set的常见用法详解

    内部自动有序且不含重复元素的容器。有序去重

    6.2.1定义

    set<typename> name;

    6.2.2访问方式

    除开vector和string之外的STL容器都不支持*(it+i)的访问方式。

    6.2.3set常用函数实例

    insert():时间复杂度O(log(n))。并自动递增排序和去重。

    find(value):返回set中对应值为value的迭代器,时间复杂度为O(log(n))。
    erase()

    1. 删除单个元素erase(it),可与find()函数结合使用。其中erase(it)本身O(1),结合find()函数使用,时间复杂度为O(log(n))。
    2. 删除单个元素erase(value),时间复杂度为O(log(n))。
    3. 删除一个区间内的所有元素erase(first,last)

    size():时间复杂度O(1)

    clear():时间复杂度O(N)

    6.2.3set的常见用途

    set主要作用是自动去重并按升序排序,遇到需要去重但不方便直接开数组的情况,可以尝试用set解决。

    set中元素是唯一的,若要处理不唯一的情况,则需要使用multiset

    C++11标准还增加了unordered_set,以散列代替set内部的红黑树(Red Black Tree,一种自平衡二叉查找树)。使其可以用来处理只去重但不排序的需求,速度比set要快得多。

     

     

     

     

     

    展开全文
  • STL提供了一组表示容器,迭代器,函数对象和算法的模板。(1)容器是一个与数组类似的单元,用来存储值,且存储的值的类型相同;(2)迭代器能够用来遍历容器的对象,与能够遍历数组的指针类型;(3)函数对象和算法...

    C++ STL(标准模板库)是一套功能强大的c++模板类提供了通用的模板类和函数,这些模板类和函数可以实现多种流行和常用的算法和数据结构,如向量、链表、队列、栈。包含以下三个组成部分

    组件描述
    容器(Containers)容器是一个与数组类似的单元,用来存储值,且存储的值的类型相同;比如deque、list、vector、map等
    算法(Algorithms)算法作用于容器,它们提供了执行各种操作的方法,包括对容器内容执行初始化、排序、搜索、转换等操作
    迭代器(iterators)迭代用于遍历对象集合的元素,这些集合可能是容器,也可能是容器的子集

    零、 前言

    1. 命名空间

    当工程代码采用不同的程序和程序库时,针对不同的对象使用相同的标识符,就会出现名称冲突的现象,使用namespace就可以解决这个问题。标识符的可见范围namespace和class不同,namespace具有扩展开放性,可以出现在任意源码文件中。

    C++ 标准程序库的所有标识符都被定义于一个名为std的namespace中,有以下三种方法使用:

    1. 直接指定标识符,例如
        std::cout << std::hex << 3.4 << std::endl;
    
    1. 使用using declaration的方法,例如:
        using std::cout;
        using std::endl;
    
    1. 使用using directive,这是最简便的方法,就像被声明为全局标识符一样,但是由于某些重载的规格,这种方法可能导致意外地命名冲突,因此应避免使用第三种,除非程序很小为了方便。
        using namespace std;
        cout << hex << 3.4 << endl;
    

    2. 通用工具

    Pairs(对组)

    class pair,凡需要将两个值视为一个单元的场景(例如必须返回两个值的某函数)就必须用到它,例如容器类别map和multimap,就是使用pairs来管理键值对元素

    std::pair<int, float> p; // 初始化p.first 和 p.second为 0
    std::pair<int, char *> p(42, "hello");
    

    数值极限

    标准库通过template numeric_limits提供极值,定义于,浮点数定义于

    
    #include<iostream>  
    #include<string>  
    #include<limits>   //头文件  
    using namespace std;  
    int main(){  
     cout<<"numeric_limits<unsigned short>::min()= "<<numeric_limits<unsigned short>::min()<<endl; //unsigned short的最小值  
     cout<<"numeric_limits<unsigned short>::max()= "<<numeric_limits<unsigned short>::max()<<endl;  //unsigned short的最大值  
     cout<<"numeric_limits<int>::min()= "<<numeric_limits<int>::min()<<endl; //int的最小值  
     cout<<"numeric_limits<int>::max()= "<<numeric_limits<int>::max()<<endl;  //int的最大值  
     cout<<"numeric_limits<short>::min()= "<<numeric_limits<short>::min()<<endl;  
     cout<<"numeric_limits<short>::max()= "<<numeric_limits<short>::max()<<endl;  
     cout<<"numeric_limits<double>::min()= "<<numeric_limits<double>::min()<<endl;  
     cout<<"numeric_limits<double>::lower()="<<numeric_limits<double>::lower()<<endl;  //double最小值是lower,min只会返回e的负数次方
     cout<<"numeric_limits<double>::max()= "<<numeric_limits<double>::max()<<endl;  
      
     cout<<"numeric_limits<int>::is_signed()= "<<numeric_limits<int>::is_signed<<endl;//是否有正负号  
     cout<<"numeric_limits<string>::is_specialized()= "<<numeric_limits<string>::is_specialized<<endl;//是否定义了数值极限  
     return 0;  
    } 
    

    辅助函数

    定义在内的是哪个辅助函数,max()、min()、swap()。

    namespace std {
        template <class T>
        inline const T& min(const T& a, const T& b) {
            return b < a ? b : a;
        }
        
        template <class T>
        inline const T& max(const T& a, const T& b) {
            return a < b ? b : a;
        }
        
        template <class T>
        inline void swap(T& a, T& b) {
            T temp {a};
            a = b;
            b = temp;
        }
    }
    

    非成员函数的方法

    如果要为每一个容器类型,单独定义一个排序,查找的方法,则工作量会非常巨大,并且很多都是重复性的工作,因此STL定义了非成员函数,来完成通用的容器算法,如sort(),find(),swap().如果该容器类型vector.swap()存在,则代表要比普通的swap()函数效率更高.

    • 1.遍历容器
    for (vector<int>::iterator pr = test.begin(); pr != test.end(); pr++)
    替换为:
    for_each(test.begin(), test.end(), cout);
    
    • 2.排序:
    sort(test.begin(), test.end());
    
    1> 如果要排序的对象是用户自己定义的,则需要重载比较操作符
    struct Review {
        string title;
        int rating;
    }
    bool operator<(const Review &r1, const Review &r2) 
    {
        if (r1.title < r2.title) {
            return true;
        } else if (ri.title == r2.title && r1.rating < r2.rating) {
            return true;
        } else {
            return false;
        }
    }
    然后就可以使用sort函数对自定义对象进行排序了.
    sort(book.begin(), book.end());
    
    2>如果想按照其他排序方式,则可以使用第三个入参
    bool worseTahn(const Review &r1, const Review &r2) 
    {
        if (r1.rating < r2.rating) {
            return true;
        } esle {
            return false;
        }
    }
    
    • 3.capacity和size属性的区别:

    size : 是当前vector容器真实占用的大小,也就是容器拥有多少个元素,对应resize()

    capacity : 是值发生在realloc前能允许的最大元素数,即预分配的内存空间,对应reserve(),对于list, map, set, deque由于内存是散列分布的,因此capacity()对于这些容器是没有意义的.在STL中,拥有capacity属性的只有vector和string.

    #include <iostream>
    #include <vector>
    
    using std::vector;
    int main(void)
    {
        vector<int> v;
        std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
        v.reserve(10);
        std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
        v.resize(10);
        v.push_back(0);
        std::cout<<"v.size() == " << v.size() << " v.capacity() = " << v.capacity() << std::endl;
    
        return 0;
    }
    

    在这里插入图片描述

    对于空的vector,如果直接用[]访问,可能会发生越界报错,建议用at()会首先进行越界检查.

    3. 容器类型

    总体容器可以分为两类:

    1. 序列式容器Sequence containers:表述为可序的群集,每个元素均有固定的位置,取决于插入时机和地点,和元素值无关,如vector, deque, list。
    2. 关联式容器Associative containers:表述为已序群集,元素位置取决于特定的排序准则,如果元素的位置取决于元素值,和插入次序无关,例如:set, multiset, map, multimap。
      在这里插入图片描述
      关联式容器在C++实现中,采用红黑树的方法,因此会自动对元素排序,其优点为当搜索元素时,可以放心的使用二分搜索法等有序要求的算法。

    一、String容器

    当程序需要处理字符串的时候,C语言在string.h和cstring里提供了一系列函数,但是不支持C++的string类。string类也是STL容器中的一种

    1. string类构造函数

    # 1.按照C风格创建字符串
    string one("hello world");
    
    # 2.创建由10个C组成的字符串
    string two(10, 'c');          // "cccccccccc"
    
    # 3.复制构造函数将string对象初始化为对象one
    string three(one);            // "hello world"
    
    # 4.重载[]运算符,可以用下标访问
    three[0] = 'P'                
    
    # 5.重载+=运算符将字符串Oops附件到字符串one后
    one += "Oops!";              
    string four;                  // 默认构造函数创建一个以后可以赋空值
    four = two + three + '!'      // 重载=运算符,可以给对象赋值
    
    # 6.将C风格字符串和整数作为参数,其中整数表示要复制多少个字符串
    char alls[] = "All well that end well"
    string five(alls, 20)
    
    # 7.迭代器模板拷贝,[begin, end)是迭代器,前闭后开
    template<class Iter> string(Iter begin, Iter end);
    string six(alls + 6, alls + 10);
    string six(five + 6, five + 10);    //这种方法不可行,因为five是对象,并不是指针
    
    # 8.将另一个string对象的部分内容拷贝到构造的对象中
    string seven(four, 7, 16);
    

    2. string类输入

    # 1.按照C风格输入字符串
    char info[100];
    cin >> info;                     // 读取一个单词
    cin.getline(info, 100);          // 读取一行,丢弃换行符
    cin.get(info, 100);              // 读取一行,换行符保存在队列中
    
    # 2.对于string对象,有两种方式:使用cin读入字符串时,遇到空白就停止读取。比如程序输入的是
    "     Hello   World"
    那么我们得到的字符串将是"Hello",前面的空白没了,后面的world也读不出来。如果我们想把整个hello world读进来怎么办?那就这样做
    cin >> s1 >> s2;
    hello存在s1里,world存在s2里了。有时我们想把一个句子存下来,又不想像上面那样创建多个string来存储单词,怎么办?那就是用getline来获取一整行内容。
    string str;
    getline(cin, str);              // 会自动调整string的大小,使其刚好存下输入
    cout << str << endl;
    

    3. string类方法

    # 1.重载了比较操作符, '<', '>', '='
    string one("gedit");
    string two("name");
    one > two || one < two || one != two
    
    # 2.判断字符串长度
    one.size() == one.length();     // size和length的函数行为一模一样,size是为了提供stl兼容性而后添加的
    
    # 3.find方法
    one.find('e');                   // 返回字符串中第一次出现e的下标
    one.find("dit");                 // 返回字符串中第一次出现子串的下标
    
    one.rfind('e');                  // 返回字符串中最后一次出现e的下标
    one.find_first_of("eat");        // 返回"eat"中任意一个字符最早出现的索引
    one.find_last_of("eat")          // 返回"eat"中任意一个字符最后出现的索引
    one.find_first_not_of("eat")     // 返回原字符串,在"eat"中第一个没有出现的索引
    
    # 4.内存块大小
    程序将一个字符添加到字符串的末尾时,不能仅仅将已有的字符串加大,相邻的内存可能被占用了,因此可能需要分配一个新的内存块,并将原来的信息拷贝过去。
    实现过程:
    1>初始创建的时候,分配一个比实际字符串大的内存块。
    2>如果超过了内存块的大小,程序将分配一个原来为两倍的新内存空间。
    3>方法capacity()返回当前分配给字符串的内存块大小,reserve()获取内存块的最小长度
    

    二、vector容器

    vector表示了一组可以随机访问的值,可以通过[]运算符来直接访问矢量的第n个元素.

    1. vector分配器

    通常使用来表示使用的类型,同时vector是动态分配的内存

    int n;
    cin >> n;
    vector<int> test(n);
    

    分配器可以在构造函数摸板的时候选择,该参数指定了使用哪个分配器来管理内存

    template<class T, class Allocator = allocator<T> >
    如果省略了Allocator的值,则默认使用new和delete来管理内存.
    

    2. vector方法

    所有的STL容器都提供了一些基础方法,其中包括了size(),swap(),begin(),end()等.

    # 1.迭代器
    vector<double> scores;
    vector<double>::iterator pd;
    pd = score.begin()
    
    for (pd = score.begin(); pd != score.end(); pd++) {     // 这里不能用pd<sorce.end()
        *pd = 12.3;
        cout << pd[i];
    }
    
    # 2.从尾部添加元素,自动负责内存管理
    vector<int> test;
    while (cin >> temp && temp >= 0) {
        test.push_back(temp);
    }
    
    # 3.删除区间的元素,左闭右开
    test.erase(test.begin(), test.begin() + 2);
    
    # 4.在某位置插入元素,或插入一个区间
    test.insert(test.begin(), 1);
    test.insert(test.begin(), new.begin(), new.end())
    
    # 5.插入和弹出从尾部的效率是O(1),其他从任意位置都是O(n)
    弹出的过程不能获得元素,因此需要先获取,再弹出
    test.pop_back()
    test.push_back()
    
    展开全文
  • 目录 数据结构3 C++标准库 1.stack ...C++标准库 ...在很多编程语言中,算法与数据结构的相关类和函数都与...下面对C++标准库的核心,即标准模块(standard template library,STL)做简单介绍。 STL中有很多...

    目录

    数据结构3

    C++标准库

    1.stack

    2.queue

    3.vector

    4.list

    总结


    数据结构3

    C++标准库

            在很多编程语言中,算法与数据结构的相关类和函数都与输入输出,字符串等一同加入了,我们可以直接从库中调用。

            但是在使用之前,我们不但要了解库的特征和复杂度,还要将其有效运用至更高的算法与数据结构之中。

            下面对C++标准库的核心,即标准模块库(standard template library,STL)做简单介绍。

            STL中有很多名为容器的类,用于管理数据集合,我们只需定义对应的容器,然后调用相应的函数或算法即可。

            下面介绍stack,queue,vector,list的使用方法。

    1.stack

            #include<stack>用来将STL中的stack包含到程序中。

            stack<> 用于生成栈,我们需要在<>中指定类型,从而生成该类型数据的栈。例如:stack<int> S; 

    stack中的函数及功能
    函数名功能复杂度
    size()返回栈中元素的个数O(1)
    top()返回栈顶元素O(1)
    pop()取出并删除栈顶元素O(1)
    push()向栈顶添加元素O(1)
    empty()在栈为空时返回trueO(1)

            stack的使用方法:

    #include<stack>
    #include<iostream>
    using namespace std;
    
    int main() {
    
    	stack<int> S;
    
    	S.push(1);
    	S.push(4);
    	S.push(0);
    
    	cout << S.size() << " ";
    
    	cout << S.top() << " ";
    	S.pop();
    
    	cout << S.top() << " ";
    	S.pop();
    
    	cout << S.top() << " ";
    	S.pop();
    
    	S.push(9);
    
    	cout << S.top() <<endl;
    
    	return 0;
    }

    2.queue

            #include<queue>用来将STL中的queuek包含到程序中。

            queue<> 用于生成队列,我们需要在<>中指定类型,从而生成该类型数据的队列。例如:queue<string> Q; 

    queue中的函数及功能
    函数名功能复杂度
    size()返回队列中元素的个数O(1)
    front()

    返回队头的元素

    O(1)
    pop()取出并删除队头元素O(1)
    push()向队列中添加元素O(1)
    empty()队列为空时返回trueO(1)

            queue的使用方法:

    #include<queue>
    #include<iostream>
    using namespace std;
    
    int main() {
    
    	queue<string> Q;
    
    	Q.push("E");
    	Q.push("t");
    	Q.push("e");
    	Q.push("r");
    	Q.push("n");
    	Q.push("a");
    	
    	cout << Q.size() << " ";
    
    	cout << Q.front() << " ";
    	Q.pop();
    
    	cout << Q.front() << " ";
    	Q.pop();
    
    	cout << Q.front() << " ";
    	Q.pop();
    
    	cout << Q.front() << " ";
    	Q.pop();
    
    	cout << Q.front() << " ";
    	Q.pop();
    
    	cout << Q.front() << " ";
    	Q.pop();
    
    	Q.push("Eternal");
    
    	cout << Q.front() <<endl;
    	
    	return 0;
    }

    3.vector

            只能容纳一定数量的元素的数组称为静态数组,而可以在添加元素时增加长度的数组称为动态数组变长数组。可以借助vector来实现动态数组。

            #include<vector>用来将STL中的vector包含到程序中。

            vector<> 用于生成向量,我们需要在<>中指定类型,从而生成该类型数据的向量。例如:vector<double>  V; 

            在访问向量中的元素时,可以与数组一样使用“[]”运算符。

    vector中的函数及功能
    函数名功能复杂度
    size()返回向量中元素的个数O(1)
    push_back(x) 在向量末尾添加元素xO(1)

    pop_back(x)

    删除向量最后一个元素O(1)

    begin()

    返回指向向量开头的迭代器O(1)
    end()返回指向向量末尾(最后一个元素的后一个位置)的迭代器O(1)
    insert(p,x)在向量的位置p处插入元素xO(n)
    erase(p)删除向量中位置p的元素O(n)
    clear()删除向量中的全部元素O(n)

            这里的迭代器可以看作指针。

            要注意,像长度为n的vector的特定位置执行插入或删除操作时,算法复杂度为O(n)。

            vector的使用方法:

    #include<iostream>
    #include<vector>
    using namespace std;
    
    void print(vector<double> V) {
    	for (int i = 0; i < V.size(); i++) {
    		cout << V[i] << " ";
    	}
    	cout << endl;
    }
    int main() {
    
    	vector<double> V;
    
    	V.push_back(0.1);
    	V.push_back(0.2);
    	V.push_back(0.3);
    
    	print(V);
    
    	V[2] = 0.4;
    
    	print(V);
    
    	V.insert(V.begin() + 1, 0.8);
    	print(V);
    
    	V.erase(V.begin() + 1);
    	print(V);
    
    	V.push_back(0.9);
    	print(V);
    
    	return 0;
    
    }

    4.list

            #include<list>用来将STL中的list包含到程序中。

            listr<> 用于生成双向链表,我们需要在<>中指定类型,从而生成该类型数据的双向链表。例如:list<char>  L; 

            list可以像vector一样通过“[]”运算符直接访问特定元素,也可以用迭代器逐个进行访问。

            另外,list还具备一项vector所不具备的特长,那就是元素的插入与删除操作只需O(1),效率高。

    list中的函数及功能
    函数名功能复杂度
    size()返回表中元素的个数O(1)
    begin()返回指向表开头的迭代器O(1)
    end()返回指向表末尾(最后一个元素的后一个位置)的迭代器O(1)
    push_back(x)在表的末尾添加元素xO(1)
    push_front(x)在表的开头添加元素xO(1)
    pop_back()删除位于表末尾的元素O(1)
    pop_front()删除位于表开头的元素O(1)
    insert(p,x)

    在表的位置p插入元素x

    O(1)
    erase(p)删除表中位置p的元素O(1)
    clear()删除表中所有元素O(n)

            list的使用方法:

    #include<iostream>
    #include<list>
    using namespace std;
    
    int main() {
    
    	list<char> L;
    
    	L.push_front('b');
    	L.push_back('c');
    	L.push_front('a');
    
    
    	cout << L.front();
    	cout << L.back();
    
    	L.pop_front();
    	L.push_back('d');
    
    	cout << L.front();
    	cout << L.back() << endl;
    
    	return 0;
    
    }

    总结

            灵活的标准模板库中的这些算法,可以让我们高效的管理数据。

            以上只是一些简单的使用方式,我们要学会将这些知识与实际问题,例题相结合,才能更好的发挥出它们真正的本领。


    读《挑战程序设计竞赛》第六天 (侵删)2021.2.24

    (2021.7.6 第一次修改)

    展开全文
  • C++模板为泛型程序设计奠定了关键的基础 术语:概念 用来界定具备一定功能的数据类型。例如: 将“可以比大小的所有数据类型(有比较运算符)”这一概念记为Comparable 将“具有公有的复制构造函数并可以用...

    10.1 泛型程序设计及STL的结构

    10.1.1 泛型程序设计的基本概念

    • 编写不依赖于具体数据类型的程序
    • 将算法从特定的数据结构中抽象出来,成为通用的
    • C++的模板为泛型程序设计奠定了关键的基础

    术语:概念

    • 用来界定具备一定功能的数据类型。例如:
      • 将“可以比大小的所有数据类型(有比较运算符)”这一概念记为Comparable
      • 将“具有公有的复制构造函数并可以用‘=’赋值的数据类型”这一概念记为Assignable
      • 将“可以比大小、具有公有的复制构造函数并可以用‘=’赋值的所有数据类型”这个概念记作Sortable
    • 对于两个不同的概念A和B,如果概念A所需求的所有功能也是概念B所需求的功能,那么就说概念B是概念A的子概念。例如:
      • Sortable既是Comparable的子概念,也是Assignable的子概念

    术语:模型

    • 模型(model):符合一个概念的数据类型称为该概念的模型,例如:
      • int型是Comparable概念的模型。
      • 静态数组类型不是Assignable概念的模型(无法用“=”给整个静态数组赋值)

    用概念做模板参数名

    • 很多STL的实现代码就是使用概念来命名模板参数的。
    • 为概念赋予一个名称,并使用该名称作为模板参数名。
    • 例如

      • 表示insertionSort这样一个函数模板的原型:

    template <class Sortable>
    void insertionSort(Sortable a[], int n);

    原文链接:侵删

    https://www.cnblogs.com/alec7015/p/12465052.html

    展开全文
  • C++模板为泛型程序设计奠定了关键的基础 术语:概念 用来界定具备一定功能的数据类型。例如: 将“可以比大小的所有数据类型(有比较运算符)”这一概念记为Comparable 将“具有公有的复制构造...
  • C++ STL标准模板库

    2021-05-20 13:58:20
    标准模板库(STL)包含许多用于实现数据类型和算法的模板。STL 中最重要的数据结构是容器和迭代器。容器是一种存储数据并以某种方式组织数据的类。迭代器是一个像指针一样工作的对象,允许访问存储在容器中的项目。...
  • 01、文章目录 ...map以模板(泛型)方式实现,可以存储任意类型的数据,包括使用者自定义的数据类型。Map主要用于资料一对一映射(one-to-one)的情況,map內部的实现自建一颗红黑树,这颗树具有对数据自动排
  • C++常用标准模板库 1.vector(向量,即动态数组) 时间复杂度分析:数组后面插入元素和删除尾部元素O(1),头部或者中间插入删除依旧是O(n) 优点:可以动态的随着元素的增加和减少改变数组的长度,使用起来与普通...
  • C++ 标准模板库

    2021-03-07 10:53:14
    C++ 的面向对象 和 泛型编程思想,目的就是复用性的提升 大多情况下,数据结构和算法都未能有一套标准,导致被迫从事大量重复工作 为了建立数据结构和算法的一套标准,诞生了STL 1、STL 的诞生 面向对象三大特性:...
  • C++ 标准模板库 STL 关联容器

    千次阅读 2021-08-29 17:07:55
    C++ 标准模板库 STL 关联容器 容器 数据结构 时间复杂度 顺序性 重复性 set 红黑树 插入、删除、查找 O(log2n) 有序 不可重复 multiset 红黑树 插入、删除、查找 O(log2n) 有序 可重复 map 红黑树 插入...
  • STL 提供了非常多(大约 100 个)的数据结构算法,它们都被设计成一个个的模板函数,这些算法在 std 命名空间中定义,其中大部分算法都包含在头文件 中,少部分位于头文件 中。 迭代器 如果一个类将 () 运
  • C++标准模板库记录

    2021-05-16 19:25:15
    C++标准模板库记录 1.#include vector的数据安排以及操作方式,与array非常相似,两者的唯一差别在于空间的运用的灵活性… 2.#include 链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是...
  • C++ STL标准模板库简介

    2021-05-03 13:58:38
    文章目录1. 什么是STL?...标准模板库(英文:Standard Template Library,缩写:STL),是一个C++软件库,大量影响了C++标准程序库但并非是其的一部分。其中包含4个组件,分别为算法、容器、函数、
  • C++标准模板库(STL)常用容器及其函数 standard template library 参考网站: cplusplus.com cppreference.com gcc.gnu.org 六大部件: 容器 分配器:allocator 算法 迭代器(泛化的指针) 仿函数 适配器 序列...
  • vector是STL标准模板库中的一个容器,可以容纳不同的数据类型,并且数据可以自动向前增长,因此称之为向量,vector是一个序列式容器,里面的底层实现是一个顺序表结构 vector容器的特性 1.数据自动初始化为0 2.可以动态...
  • c++ 标准模板库 stl 顺序容器容器顺序性重复性支持迭代器vector动态数组无序可重复随机访问迭代器deque双向队列无序可重复随机访问迭代器list双向链表无序可重复双向迭代器动态数组 vector​ vector #include 动态...
  • =,<,,>,>=比较大小,比较规则是先以first的大小作为标准,相等时再去判别second的大小. 应用举例: #include #include #include using namespace std; int main() { map mp; mp.insert(make_pair("heihei",5)); mp....
  • C++ 标准模板库STL

    2021-08-09 15:59:33
    C++ 标准模板库的核心包括以下三个组件: 组件 描述 容器(Containers) 容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器,比如 deque、list、vector、map 等。 算法(Algorithms) ...
  • C++ 标准模板库 STL 顺序容器

    千次阅读 2021-05-11 13:42:58
    C++ 标准模板库 STL 顺序容器 容器 数据结构 顺序性 重复性 支持迭代器 vector 动态数组 无序 可重复 随机访问迭代器 deque 双向队列 无序 可重复 随机访问迭代器 list 双向链表 无序 可重复 双向迭代器...
  • 可执行的操作 vector 容器以类模板 vector( T 表示存储元素的类型)的形式定义在 头文件中,并位于 std 命名空间中。 故我们在使用之前需要引入头文件: #include // 命名空间也可以在使用容器时额外注明 using ...
  • C++ 标准模板库 STL 容器适配器

    千次阅读 2021-08-30 11:16:02
    C++ 标准模板库 STL 容器适配器 容器 数据结构 时间复杂度 顺序性 重复性 stack deque / list 顶部插入、顶部删除 O(1) 无序 可重复 queue deque / list 尾部插入、头部删除 O(1) 无序 可重复 priority_...
  • C++标准模板库应用

    2021-11-27 19:27:42
    一、实验内容 1.撰写自己的算法和函数,结合容器和迭代器解决序列变换(如取反、平方、立方),像素变换...1.1 非模板函数实现 就是使用最普通的方法对元素进行取反、平方和立方操作。 实现代码: void transInvT
  • C++标准模板库 STL

    2021-12-11 22:09:26
    实验目的:掌握map、set、vector、list、deque等容器的使用 实验内容:定义一个容器存储学生的学号、成绩、电话等,对该容器实现增加、查找、删 除、调用等功能。并实现以上容器的增删改(查)操作。...
  • 第六章 C++标准模板库介绍 6.9 algorithm头文件下的常见函数 6.9.6 sort() 头文件:#include <algorithm> 和 using namespace std; 1. 具体使用 sort(首元素地址,尾元素元素地址的下一个地址(首元素地址+数组...
  • C++标准模板库STL

    2021-03-25 08:54:52
    标准模板库 标准模板库(standard template library,简写为STL)是用模板定义的一组类和函数。 STL定义了一组常用的数据结构,如向量,链表,集合,映射等,这些数据结构都被称为容器(container),为什么叫做容器...
  • 1 C++标准模板库STL

    2021-08-14 12:50:47
    文章目录1. STL的定义和基本概念2. 容器概述2.1 顺序容器2.1.1 `vector`2.1.2 `deque`2.1.3 `list`2.2 关联容器2.2.1 `set/multiset`2.2.2 `map/multimap`2.3 容器适配器3....标准模板库(standard template
  • c++标准模板库STL

    2021-03-02 20:21:19
    STL中几乎所有的代码都采用了类模板模板函数实现,这相比于传统有更好的代码重用的机会。 三大组件:容器(container)、算法(algorithm)、迭代器(iterator) 三者关系:算法操作数据,容器存储数据,迭代器是...
  • 标准模板库(Standard Template Library,STL)是惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时所开发出来的。虽说它主要表出现到C++中,但在被引入C++...
  • C++标准模板库介绍1.vector的常见用法详解1.1vector的定义1.2 vector的元素的访问通过下标访问迭代器访问 1.vector的常见用法详解 1.1vector的定义 文件头 //文件头 #include<stdio.h> #include<vector>...
  • C++标准模板库(STL)

    2021-03-13 22:25:26
    分配器 容器(Containers) 迭代器 适配器 算法 仿函数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,042
精华内容 32,816
关键字:

c++标准模板库

c++ 订阅
友情链接: 北京交通.rar