语法基础之STL、位运算与库函数

最新推荐文章于 2023-11-28 10:19:13 发布
最新推荐文章于 2023-11-28 10:19:13 发布
阅读量225 收藏 2
点赞数
分类专栏： 语法基础 文章标签： c++ c语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37448336/article/details/120790456
版权

目录

1、vector

可以自动改变数组长度
vector是变长数组，支持随机访问，不支持在任意位置O(1)插入。为了保证效率，元素的增删一般应该在末尾进行。

   声明
#include <vector> 	头文件
vector<int> a;		相当于一个长度动态变化的int数组
vector<int> b[233];	相当于第一维长233，第二位长度动态变化的
int数组
struct rec{…};
vector<rec> c;		自定义的结构体类型也可以保存在vector中

size/empty
size函数返回vector的实际长度（包含的元素个数），empty函数返回一个bool类型，表明vector是否为空。二者的时间复杂度都是O(1)。
所有的STL容器都支持这两个方法，含义也相同，之后我们就不再重复给出。

clear
clear函数把vector清空。

迭代器
迭代器就像STL容器的“指针”，可以用星号“*”操作符解除引用。
一个保存int的vector的迭代器声明方法为：
vector<int>::iterator it;
vector的迭代器是“随机访问迭代器”，可以把vector的迭代器与一个
整数相加减，其行为和指针的移动类似。可以把vector的两个迭代器
相减，其结果也和指针相减类似，得到两个迭代器对应下标之间的距离。

begin/end
begin函数返回指向vector中第一个元素的迭代器。例如a是一个
非空的vector，则*a.begin()与a[0]的作用相同。
所有的容器都可以视作一个“前闭后开”的结构，end函数返回vector
的尾部，即第n个元素再往后的“边界”。*a.end()与a[n]都是越界访问
，其中n=a.size()。
下面两份代码都遍历了vector<int>a，并输出它的所有元素。
for (int I = 0; I < a.size(); I ++) cout << a[i] << endl;
for (vector<int>::iterator it = a.begin(); it != a.end(); it ++) 
cout << *it << endl;

front/back
front函数返回vector的第一个元素，等价于*a.begin() 和 a[0]。
back函数返回vector的最后一个元素，等价于 a[a.size() – 1]。

push_back() 和 pop_back()
a.push_back(x) 把元素x插入到vector a的尾部。
b.pop_back() 删除vector a的最后一个元素。

#include<iostream>
#include<vector>
using namespace std;

int main()
{
  //声明
   vector<int> a({1,2,3});
   //遍历
   for(int i=0;i<a.size();i++) cout<<a[i]<<" ";
   cout<<endl;
  // for(vector<int>::iterator i=a.begin();i!=a.end();i++)
   for(auto i=a.begin();i!=a.end();i++)
   cout<<*i<<" ";
   cout<<endl;
   for(int x:a) cout<<x<<" ";
   cout<<endl;
   //begin end  front back
   cout<<*a.begin()<<" "<<a.front()<<" "<<a[0]<<endl;
   cout<<a.back()<<" "<<a[a.size()-1]<<endl;
  //push 放  pop出
   a.push_back(4);
   for(int x:a) cout<<x<<" ";
   cout<<endl;
    
   a.pop_back();
   for(int x:a) cout<<x<<" ";
   cout<<endl;
   
   
}

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

2、queue

队列 、优先队列 、栈 没有clear函数。

#include<iostream>
#include<queue>
using namespace std;

int main()
{
    queue<int> q;//队列
    priority_queue<int> a;//大根堆
    priority_queue<int,vector<int>,greater<int>> b;
    //小根堆
    
    struct Rec 
    {
        int a,b;
        //大根堆
        bool operator <(const Rec& t) const
        {
            return a<t.a;
        }
        //小根堆
         bool operator >(const Rec& t) const
        {
            return a>t.a;
        }
    };
    priority_queue<Rec> d;
    priority_queue<Rec,vector<Rec>,greater<Rec>> e;
    d.push({1,2});
    e.push({1,2});
    //q是队列
    q.push(1);//队尾插入
    q.pop();//弹出队头
    q.back();//返回队尾
    q=queue<int>();//初始化或者清空队列
    //大根堆 a
    a.push();//插入
    a.top();//取最大值
    a.pop();//删除顶峰值
}

3、栈

在这里插入图片描述
插入 栈顶 取出。 先进后出。

4、 deque

在这里插入图片描述
双端队列deque是一个支持在两端高效插入或删除元素的连续线性存储空间。它就像是vector和queue的结合。与vector相比，deque在头部增删元素仅需要O(1)的时间；与queue相比，deque像数组一样支持随机访问。

[] 随机访问
begin/end，返回deque的头/尾迭代器
front/back 队头/队尾元素
push_back 从队尾入队
push_front 从队头入队
pop_back 从队尾出队
pop_front 从队头出队
clear 清空队列

#include<iostream>
#include<deque>
using namespace std;

int main()
{
    deque<int> a;
    a.begin();
    a.end();
    a.front();
    a.back();
    a.push_back(2);
    a.push_front(1);
    a.pop_back();
    a.pop_front();
    a.clear();
    return 0;
}

5、set

头文件set主要包括set和multiset两个容器，分别是“有序集合”和“有序多重集合”，即前者的元素不能重复，而后者可以包含若干个相等的元素。set和multiset的内部实现是一棵红黑树，它们支持的函数基本相同。

声明
set  <int>  s;
struct rec{…}; set<rec> s;	// 结构体rec中必须定义小于号
multiset<double> s;

size/empty/clear
与vector类似

迭代器
set和multiset的迭代器称为“双向访问迭代器”，不支持“随机访问”，支持
星号(*)解除引用，仅支持”++”和--“两个与算术相关的操作。
设it是一个迭代器，例如set<int>::iterator it;
若把it++，则it会指向“下一个”元素。这里的“下一个”元素是指在元素从小
到大排序的结果中，排在it下一名的元素。同理，若把it--，则it将会指向
排在“上一个”的元素。

begin/end
返回集合的首、尾迭代器，时间复杂度均为O(1)。
s.begin() 是指向集合中最小元素的迭代器。
s.end() 是指向集合中最大元素的下一个位置的迭代器。
换言之，就像vector一样，是一个“前闭后开”的形式。因此--s.end()是指向集合中最大元素的迭代器。

insert
s.insert(x)把一个元素x插入到集合s中，时间复杂度为O(logn)。
在set中，若元素已存在，则不会重复插入该元素，对集合的状态无影响。

find
s.find(x) 在集合s中查找等于x的元素，并返回指向该元素的迭代器。若不存在，则返回s.end()。时间复杂度为O(logn)。

lower_bound/upper_bound
	这两个函数的用法与find类似，但查找的条件略有不同，时间复杂度为 O(logn)。
s.lower_bound(x) 查找大于等于x的元素中最小的一个，并返回指向该元素的迭代器。
s.upper_bound(x) 查找大于x的元素中最小的一个，并返回指向该元素的迭代器。

erase
设it是一个迭代器，s.erase(it) 从s中删除迭代器it指向的元素，时间复杂度为O(logn)
设x是一个元素，s.erase(x) 从s中删除所有等于x的元素，时间复杂度为O(k+logn)，其中k是被删除的元素个数。

count
s.count(x) 返回集合s中等于x的元素个数，时间复杂度为 O(k +logn)，其中k为元素x的个数。


#include<iostream>
#include<set>
using namespace std;

int main()
{
    set<int> a;//元素不能重复
    multiset<int> b;//元素可以重复
    struct Rec
    {
        int x,y;
        bool operator <(const Rec& t) const
        {
            return x<t.x;
        }
    };
    set<Rec> c;
    
    auto it=a.begin();
    it++;
    it--;
    ++it;
    --it;
    a.end();
    a.insert(1);
    int x;
    //判断x在a中是否存在
    if(a.find(x)==a.end()){}
    //二分
    a.lower_bound(x);
    //找到大于等于x的最小的元素的迭代器
    a.upper_bound(x);
    //找到大于x的最小的元素的迭代器
    
    a.erase(it);
    a.count(x);//x的个数  
}

6、map

map容器是一个键值对key-value的映射，其内部实现是一棵以key为关键码
的红黑树。Map的key和value可以是任意类型，其中key必须定义小于号运算
符。

声明
		map<key_type, value_type> name;
		例如：
		map<long, long, bool> vis;
		map<string, int> hash;
		map<pair<int, int>, vector<int>> test;

size/empty/clear/begin/end均与set类似。

Insert/erase
与set类似，但其参数均是pair<key_type, value_type>。

find
h.find(x) 在变量名为h的map中查找key为x的二元组。

[]操作符
h[key] 返回key映射的value的引用，时间复杂度为O(logn)。	
[]操作符是map最吸引人的地方。我们可以很方便地通过h[key]来得到key对
应的value，还可以对h[key]进行赋值操作，改变key对应的value。


#include<iostream>
#include<map>
#include<vector>
using namespace std;

int main()
{
    //像用数组一样用其它的结构
    map<int,int> a;
    a[1]=2;//插入元素
    map<string,int> b;
    b["xyc"]=2;
    cout<<b["xyc"]<<endl;
    map<string,vector<int>> c;
    c["xyc"]=vector<int>({1,2,3,4});
    cout<<c["xyc"].size()<<endl;
    cout<<c["xyc"][2]<<endl;
    c.insert({"a",{0}});//插入元素（二元组）
    cout<<(c.find("xyc")==c.end())<<endl;
}

7、unordered_set

#include<iostream>
#include<unordered_set>
using namespace std;

int main()
{
   unordered_set<int> a;
   //哈希表实现，不能出现重复元素
   //除了二分之外，与set一样
   unordered_multiset<int> b;
   //可以存放重复的元素
}

8、unordered_map

#include<iostream>
#include<unordered_map>
using namespace std;

int main()
{
    //与map一致，不支持二分，速度快于map
    //在c++11支持
}

8、bitset

#include<iostream>
#include<bitset>
using namespace std;

int main()
{
   //位运算中使用；
   bitset<1000> a,b;//长度是1000位的串
   a[0]=1;
   cout<<a[0]<<endl;
   a.count();//返回1的个数
   
   //位运算
   a&=b;
   a|=b;
   
   //将第3位设置成1
   a.set(3);
   //将第3位设置成0
   a.reset(3);
   return 0;
}

9、 pair

#include<iostream>
using namespace std;

int main()
{
    pair<int ,string> a;
    a={3,"xyc"};
    cout<<a.first<< " "<<a.second<<endl;
    a=make_pair(4,"abc");
    cout<<a.first<< " "<<a.second<<endl;
    //pair可以进行比较  != == > <
    //双关键字比较 先比较第一个关键字，再比较第二个。
}

10、位运算

在这里插入图片描述

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

>>右移 减位数
<<左移 加0

常用操作：
(1) 求x的第k位数字 x >> k & 1

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
(2) lowbit(x) = x & -x，返回x的最后一位1
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

11、reverse

翻转一个vector：
reverse(a.begin(), a.end());
翻转一个数组，元素存放在下标1~n：
reverse(a + 1, a + 1 + n);

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int main()
{
    vector<int> a({1,2,3,4,5});
    reverse(a.begin(),a.end());
    //翻转数组是数组的起始位置+最后一个位置的下一个位置
    int b[]={1,2,3,4,5};
    reverse(b,b+5);
    for(int x:b) cout<<x<<" ";
    cout<<endl;
    
    for(int x:a) cout<<x<<" ";
    cout<<endl;
}

12、unique 去重

前提：保证相同元素挨在一起
返回的是新数组中不同元素最后一个的下一个位置
在这里插入图片描述

返回去重之后的尾迭代器（或指针），仍然为前闭后开，即这个迭代器是去重之后末尾元素的下一个位置。该函数常用于离散化，利用迭代器（或指针）的减法，可计算出去重后的元素个数。

把一个vector去重：
int m = unique(a.begin(), a.end()) – a.begin();
m是不同元素的个数     unique返回的是新数组不同元素中最后一个的下一个位置
把一个数组去重，元素存放在下标1~n：
int m = unique(a + 1, a + 1 + n) – (a + 1);

在这里插入图片描述

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int main()
{
    int a[]={1,1,2,2,3,3,4};
    int m=unique(a,a+7)-a;
    cout<<m<<endl;
    for(int i=0;i<m;i++) cout<<a[i]<<" ";
    cout<<endl;
    
    /*
    vector<int> b({1,1,2,2,3,4,5});
    int w=unique(b.begin(),b.end())-b.begin();
    for(int i=0;i<w;i++)
    {
        cout<<b[i];
    }
    */
    vector<int> b({1,1,2,2,3,4,5});
    b.erase(unique(b.begin(),b.end()),b.end());
    for(auto x:b) cout<<x<<" ";
    cout<<endl;
    return 0;
}

13、random_shuffle 随机 打乱

用法与reverse相同

#include<iostream>
#include<algorithm>
#include<vector>
#include<ctime>
using namespace std;

int main()
{
    
   vector<int> a({1,2,3,4,5});
   srand(time(0));//到当前的时间
   random_shuffle(a.begin(),a.end());
   for(int x:a) cout<<x<<" ";
   cout<<endl;
}

14、sort

对两个迭代器（或指针）指定的部分进行快速排序。可以在第三个参数传入定义大小比较的函数，或者重载“小于号”运算符。

把一个int数组（元素存放在下标1~n）从大到小排序，传入比较函数：

int a[MAX_SIZE];
bool cmp(int a, int b) {return a > b; }
sort(a + 1, a + 1 + n, cmp);

把自定义的结构体vector排序，重载“小于号”运算符：

struct rec{ int id, x, y; }
vector<rec> a;
bool operator <(const rec &a, const rec &b) {
		return a.x < b.x || a.x == b.x && a.y < b.y;
}
sort(a.begin(), a.end());


#include<iostream>
#include<algorithm>
#include<vector>
#include<ctime>
using namespace std;
struct Rec
  {
      int x,y;
      bool operator <(const Rec& t)const
      {
          return x<t.x;
      }
  }w[5];
bool cmp(int a,int b)//a是否排在b的前面
{

    return a>b;
}
bool cmpR(Rec a,Rec b)
{
    return a.x<b.x;
}
int main()
{
    
   vector<int> a({1,2,3,4,5});
   srand(time(0));//1970到当前的时间
   random_shuffle(a.begin(),a.end());
   for(int x:a) cout<<x<<" ";
   cout<<endl;
   
   //从小到大排序
   sort(a.begin(),a.end());
   for(int x:a) cout<<x<<" ";
   cout<<endl;
   
    //从大到小排序
   sort(a.begin(),a.end(),greater<int>());
   for(int x:a) cout<<x<<" ";
   cout<<endl;
   
   //自定义排序
    sort(a.begin(),a.end(),cmp);
   for(int x:a) cout<<x<<" ";
   cout<<endl;
   
   //结构体排序  定义函数
  
   for(int i=0;i<5;i++)
   {
       w[i].x=-i;
       w[i].y=i;
   }
   for(int i=0;i<5;i++)cout<<w[i].x<<w[i].y;
   cout<<endl;
   sort(w,w+5,cmpR);
   for(int i=0;i<5;i++)cout<<w[i].x<<w[i].y;
   cout<<endl;
   //重载小于号 按从小到大的顺序排列
   sort(w,w+5);
   for(int i=0;i<5;i++)cout<<w[i].x<<w[i].y;
   cout<<endl;
   return 0;
}

15、lower_bound/upper_bound 二分

前提：保证传入的数组有序（从小到大）

lower_bound 的第三个参数传入一个元素x，在两个迭代器（指针）指定的部分上执行二分查找，返回指向第一个大于等于x的元素的位置的迭代器（指针）。
upper_bound 的用法和lower_bound大致相同，唯一的区别是查找第一个大于x的元素。当然，两个迭代器（指针）指定的部分应该是提前排好序的。

在有序int数组（元素存放在下标1~n）中查找大于等于x的最小整数的下标：
int I = lower_bound(a + 1, a + 1 + n,. x) – a;

在有序vector 中查找小于等于x的最大整数（假设一定存在）：
int y = *upper_bound(a.begin(), a.end(), x);

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;

int main()
{
   int a[]={1,2,4,5,6};
   //返回大于等于4的第一个元素
   //返回值是一个迭代器
   int *p=lower_bound(a,a+5,4);
   cout<<*p<<endl;
   //返回大于3的第一个元素*t指针
   //t的位置，与a的差就是相差元素
   int t=upper_bound(a,a+5,3)-a;
   cout<<t<<endl;
   
   
   vector<int> w{1,2,4,5,6};
   int z=lower_bound(w.begin(),w.end(),2)-w.begin();
   cout<<w[z]<<endl;
}

16、0到n-1中缺失的数字

在这里插入图片描述

class Solution {
public:
    int getMissingNumber(vector<int>& nums) {
       unordered_set<int> s;
       for(int i=0;i<=nums.size();i++) s.insert(i);
       for(auto x:nums) s.erase(x);
       return *s.begin();
    }
};

17、调整数组顺序使奇数位于偶数前面

在这里插入图片描述

class Solution {
public:
    void reOrderArray(vector<int> &array) {
         int i=0;
         int j=array.size()-1;
         while(i<j)
         {
             while(i<j&&array[i]%2)i++;
             while(i<j&&array[j]%2==0) j--;
             if(i<j) swap(array[i],array[j]);
         }
    }
};

18、从尾到头打印链表

在这里插入图片描述

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    vector<int> printListReversingly(ListNode* head) {
        vector<int> x;
        for(auto a=head;a;a=a->next)
            x.push_back(a->val);
        reverse(x.begin(),x.end());
        return x;
    }
};

19、用两个栈实现队列

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

class MyQueue {
public:
    stack<int> s1,s2;
    /** Initialize your data structure here. */
    MyQueue() {
        
    }
    
    /** Push element x to the back of queue. */
    void push(int x) {
        s1.push(x);
    }
    
    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        while(s1.size()>1) s2.push(s1.top()),s1.pop();
        int t=s1.top();
        s1.pop();
        while(s2.size()) s1.push(s2.top()),s2.pop();
        return t;
    }
    
    /** Get the front element. */
    int peek() {
        while(s1.size()>1) s2.push(s1.top()),s1.pop();
        int t=s1.top();
        while(s2.size()) s1.push(s2.top()),s2.pop();
        return t;
    }
    
    /** Returns whether the queue is empty. */
    bool empty() {
        return s1.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * bool param_4 = obj.empty();
 */

20、最小的k个数

在这里插入图片描述

class Solution {
public:
    vector<int> getLeastNumbers_Solution(vector<int> input, int k) {
       sort(input.begin(),input.end());
       vector<int> a;
       for(int i=0;i<k;i++) a.push_back(input[i]); 
       return a;
    }
};

21、和为S的两个数字（语法基础课）

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

22、数字排列

在这里插入图片描述

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

23、二进制中1的个数

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
lowbit(x) = x & -x，返回x的最后一位1

24、三元组排序

在这里插入图片描述

#include<iostream>
#include<algorithm>
using namespace std;

const int N=10010;
struct Rec
{
  int a;
  double b;
  string c;
}r[N];
bool cmpR(Rec a,Rec b)
{
    return a.a<b.a;
}
int main()
{
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
        cin>>r[i].a>>r[i].b>>r[i].c;
    sort(r,r+n,cmpR);
    for(int i=0;i<n;i++)
        printf("%d %.2f %s\n",r[i].a,r[i].b,r[i].c.c_str());
}
素位明哲
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++STL库常用库函数总结
07-08
C++STL库常用库函数总结 C++STL库常用库函数总结 C++STL库常用库函数总结 C++STL库常用库函数总结 C++STL库常用库函数总结 C++STL库常用库函数总结 C++STL库常用库函数总结 C++STL库常用库函数总结 C++STL库常用...
STL容器从入门到精通的底层详解
m0_66117547的博客
04-04 711
初始化vector #include<bits/stdc++.h> using namespace std; int n; int main(){ cin>>n; vector<int>vec(n+1); for(int i=1;i<=n;i++) cout<<vec[i]<<' '; return 0; } #include<bits/stdc++.h> using namespace std; in
C++基础课：STL、位运算、常用库函数
Learnxiaoli的博客
02-04 232
C++基础课：STL、位运算、常用库函数
STL 用法总结
try_again_later的博客
09-09 516
STL的一个重要特点是数据结构和算法的分离。 STL另一个重要特性是它不是面向对象的。为了具有足够通用性，STL主要依赖于模板而不是封装，继承和虚函数（多态性）——OOP的三个要素。 STL中三大组件： 1）容器（Container），是一种数据结构，如list，vector，和deques ，以模板类的方法提供。为了访问容器中的数据，可以使用由容器类输出的迭代器； 2）迭代器（Iterato...
STL 基本概念与基本语法初尝试
weixin_41874599的博客
06-07 219
容器 序列式容器 容器的元素的位置是由进入容器时间和地点决定 关联式容器 进入容器的的元素的位置不是进入容器的时间和地点决定 算法 通过有限的步骤，解决问题 STL提供了大约100个实现算法的模板函数 迭代器 用来遍历容器中元素的指针，可以理解为指针，对指针的操作基本都可以对迭代器操作 实际上，迭代器是一个类，这个类封装了一个指针 迭代器作为...
C++ STL使用
u012477435的博客
09-23 1829
文章目录C++ STL使用一、什么是STL二、STL内容介绍2.1 STL中六大组件2.2 容器2.3 迭代器2.4 算法2.4.1 算法分类2.5 仿函数2.5.1 仿函数(functor)在编程语言中的应用2.5.2 仿函数在STL中的定义2.6 容器适配器2.6.1 stack2.6.2 queue & priority_queue三、常用容器用法介绍3.1 vector3.1.1 基本函数实现3.1.2 基本用法3.1.3 实例3.2 deque3.2.1 声明deque容器3.2.2 de
STL库函数的一些整理
03-31
stl库函数的一些整理
C++STL库函数
03-30
C++STL库的所有库函数，每个里面都有很详细的中文注释，适合想深入理解STL库函数的人下载学习。
c++基础STL入门ppt课件.ppt
11-13
C++基础STL入门ppt课件 这份PPT课件主要讲解C++基础知识，特别是STL（Standard Template Library）的概念和组成。下面是从这份课件中提炼出的重要知识点： 1. 抽象的重要性：抽象是计算机科学的重要进步，许多都是...
STL标准库函数（形式及用法）
08-02
STL中的库函数，以及形式和用法。STL中的库函数，以及形式和用法。
深入解析C++ STL中的常用容器
09-05
里我们不涉及容器的基本操作之类，只是要讨论一下各个容器其各自的特点。STL中的常用容器包括：顺序性容器（vector、deque、list）、关联容器（map、set）、容器适配器（queue、stac）
stl参考手册（完整版）
11-17
非常适用，尤其适合初学者，当初我就是依靠此书逐渐精通STL的。
stl编程语言入门
11-22
"什么是STL？"，假如你对STL还知之甚少，那么我想，你一定很想知道这个问题的答案，坦率地讲，要指望用短短数言将这个问题阐述清楚，也决非易事。
STL基础知识（个人复习）
最新发布
m0_53098280的博客
11-28 1097
此时我们用一个map来保存，学号作为key，姓名作为value，一个学生的这两个信息作为map的一个元素pair（pair用法总结），这4个元素是按学号(key)升序存放的，我们可以通过学号来得到对应的姓名。简单的理解容器，它就是一些模板类的集合，但和普通模板类不同的是，容器中封装的是组织数据的方法（也就是数据结构）。此外，两个正向迭代器可以互相赋值。vector 的底层为顺序表（数组），list 的底层为双向链表，deque 的底层为循环队列，set 的底层为红黑树，hash_set 的底层为哈希表。
三人表决器逻辑表达式与非_STEP7编程语言学习之STL语言的学习——一．位逻辑指令的学习...
weixin_39759600的博客
11-16 1460
一．位逻辑指令的学习说明位逻辑指令使用两个数字：“1”和“0”。这两个数字构成二进制数字系统的基础。“1”和“0”称为二进制数字或二进制位。对触点与线圈而言，“1”表示动作或通电，“0”表示未动作或未通电。位逻辑指令解释信号状态 1 和 0，并根据布尔逻辑对它们进行组合。这些组合产生结果 1 或 0，称为“逻辑运算结果(RLO)”。布尔位逻辑使用下列基本指令：• A “与”• AN “与非”• O...
STL容器语法
m0_73935863的博客
12-18 379
STL容器语法
STL基础语法总结
wei2060i
09-07 671
STL
STL用法总结
C/C++Linux、音视频、DPDK
03-22 482
推荐视频： STL高级用法 vector stack queue deque set map Vector 1.初始化 数组初始化 int a[5] = {1,2,3,4,5} vector初始化 vector A[10] = {1,2,3,4,5} vector A(10, 1); 2.二维数组初始化赋值 vector<vector> f1(n, vector(m,0)); 3.常用函数 排序：sort(nums.begin(), nums.end()); 插入：nums.inser
从零开始学C++之STL容器、位运算与常用库函数
程天爽的博客
01-24 1125
STL容器和algorithm库中的常用函数
stl容器、位运算与常用库函数
10-25
常见的位运算符有按位与（&）、按位或（|）、按位异或（^）等。位运算在计算机中常用于图像处理、编码解码和算法实现等领域，可以高效地操作二进制数据。 常用库函数是指语言标准库中提供的一些常用函数，可以简化...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值