精华内容
下载资源
问答
  • set容器

    2021-03-28 23:44:56
    set/multiset容器 基本概念 所有元素在插入时会自动排序(从小到大) 本质 set/multiset属于关联...当set容器中插入相同的数据时,编译器不会报错,但实际上并不会插入重复的数据 set<int>s; s.insert(20); s.in

    set/multiset容器

    基本概念

    所有元素在插入时会自动排序(从小到大)

    本质

    set/multiset属于关联式容器,底层结构是用二叉树实现

    set和multiset的区别

    • set不允许容器中有重复的元素
    • multiset允许有重复元素

    set容器构造函数

    set容器没有push_back的插入元素方式,只能用insert

    set容器依然有拷贝构造

    当set容器中插入相同的数据时,编译器不会报错,但实际上并不会插入重复的数据

    set<int>s;
    s.insert(20);
    s.insert(10);
    s.insert(20);
    

    容器中只有10和一个20.

    set大小和交换

    函数原型:

    • size()		返回元素数目
      
    • empty()		判断容器是否为空
      
    • swap(st)	交换两个容器
      

      注意

      set容器没有重新指定容器大小的操作,因为重新指定大小时,若指定的大小比原有个数大时,会用0填充,填充的部分不一定只有一个,可能有多个,这样就违背了set容器中没有重复数据的原则。

    set插入与删除

    函数原型:

    insert(elem) 插入元素

    clear() 清空容器

    erase(pos) 删除pos迭代器所指的元素,返回下一个元素的地址

    erase(beg,end) 删除区间【beg,end)的所有元素

    erase(elem) 删除容器中值为elem的元素。

    .begin() 返回的是排序后的第一个元素的地址。

    set查找和统计

    对set容器进行查找数据以及统计数据

    函数原型:

    • find(key) 查找key是否存在。存在则返回位置,不存在则返回end
    • count(key) 查找key的元素个数

    set容器中无重复元素,所以count的返回值只能是0或1;但是multiset容器可以有其他值。

    set的 insert插入数据时的返回值

    set容器的insert插入数据时,是有返回值的,返回值的类型是pair型(对组),里面有两个数据,第一个数据为迭代器类型,表示插在哪里,第二个为布尔类型,表示是否插入成功。

    下面展示,如何接收这个返回值

    set<int>s;
    
    pair<set<int>::iterator,bool>ret=s.insert(10);
    
    if(ret.second)
    {
        cout<<"插入成功"<<endl;
    }
    else
    {
        cout<<"插入失败"<<endl;
    }
    

    之所以用 . 的方式点出第二个数据,因为它的底层是一个结构体。

    当set容器重复插入已存在的值时,就会插入失败。

    multiset容器可以插入相同的值。

    pari(对组)创建及使用

    有两种创建方式:

    • pair<type,type>p(value1,value2)
      
    • pair<type,type>p=make_pair(value1,value2);
      

      访问对组中两个值的方式:

      用 .的方式,.first即第一个值,.second第二个值

    示例:

    pair<string,int>p("tom",20);
    
    pair<string,int>p=make_pair("mike",30);
    
    
    cout<<p.first<<p.second<<endl;
    

    set容器的排序(内含仿函数知识点)重难点!

    内置数据类型

    set容器默认的排序规则为从小到大,利用仿函数,可以改变排序规则

    示例:

    这样是默认排序

    set<int>s;
    s.insert(30);
    s.insert(20);
    s.insert(40);
    s.insert(10);
    
    

    想要按从大到小,我们需要先写仿函数,要创建一个类,再在类中写仿函数

    class Mycompare
    {
        public:
        bool operator()(int v1,int v2)const
        {
            return v1>v2;
        }
    };
    

    然后在创建set容器时就要使用到类名

    set<int,Mycompare>s; //注意看这里
    s.insert(30);
    s.insert(20);
    s.insert(40);
    s.insert(10);
    

    当然,在使用其迭代器时,也需要和创建时的格式一致

    for (set<int, Mycompare>::iterator ret = s.begin();ret != s.end();ret++)
    	{
    		cout << *ret << " " << endl;
    	}
    	cout << endl;
    
    自定义数据类型的排序

    首先,我们自定义了一个类

    class person
    {
      public:
        person(const string name,const int age)
        {
            this->m_name=name;
            this->m_age=age;
        }
        string m_name;
        int m_age;
    };
    
    void testo5()
    {
        person p1("孙悟空",119);
        person p2("猪八戒",100);
        person p3("沙悟净",130);
        set<person>s1;
        s1.insert(p1);
        s1.insert(p2);
        s1.insert(p3);
    };
    

    上面的代码运行起来会错误,因为set容器并不知道如何去给这种数据类型排序。这里我们继续用仿函数解决

    我们再建立一个类

    class mycompare2
    {
        public:
        bool operator()(const person&per1,const person&per2)//这里用引用是避免拷贝构造
        {
            return per1.m_age<per2.m_age;
        }
    }
    

    然后,我们创建set容器时,加上这个类名

    void testo5()
    {
        person p1("孙悟空",119);
        person p2("猪八戒",100);
        person p3("沙悟净",130);
        set<int,mycompare2>s1;
        s1.insert(p1);
        s1.insert(p2);
        s1.insert(p3);
    };
    

    当然,在这样创建set容器后,使用它的迭代器时,也应该这样创建。

    set<iperson,mycompare2>::iterator ret=s1.begin();
    

    总结

    1. 利用仿函数可以指定set容器的排序规则
    2. set存放自定义的数据类型时,必须要指定排序规则,否则它不知道怎样排序。
    展开全文
  • C++set容器set容器排序

    2020-09-08 08:54:43
    C++set容器set容器排序 学习目标: set容器默认排序规则为从小到大,掌握如何改变排序规则 主要技术点: 利用仿函数,可以改变排序规则 //#include <iostream> //#include <set> //using namespace ...

    C++set容器set容器排序

    学习目标:

    • set容器默认排序规则为从小到大,掌握如何改变排序规则

    主要技术点:

    • 利用仿函数,可以改变排序规则
    //#include <iostream>
    //#include <set>
    //using namespace std;
    //
    //class MyCompare
    //{
    //public:
    //	bool operator()(int v1, int v2) const
    //	{
    //		return v1 > v2;
    //	}
    //};
    //void test01()
    //{
    //	set<int> s1;
    //	s1.insert(10);
    //	s1.insert(40);
    //	s1.insert(20);
    //	s1.insert(30);
    //	s1.insert(50);
    //
    //	//默认从小到大
    //	for (set<int>::iterator it = s1.begin(); it != s1.end(); ++it)
    //	{
    //		cout << *it << " ";
    //	}
    //	cout << endl;
    //
    //	//指定排序规则
    //	set<int, MyCompare> s2;
    //	s2.insert(10);
    //	s2.insert(40);
    //	s2.insert(20);
    //	s2.insert(30);
    //	s2.insert(50);
    //
    //	for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); ++it)
    //	{
    //		cout << *it << " ";
    //	}
    //	cout << endl;
    //}
    //int main()
    //{
    //	test01();
    //	return 0;
    //}
    
    #include <iostream>
    #include <set>
    #include <string>
    using namespace std;
    class Person
    {
    public:
    	Person(string name, int age)
    	{
    		this->m_Name = name;
    		this->m_Age = age;
    	}
    public:
    	string m_Name;
    	int m_Age;
    };
    class comparePerson
    {
    public:
    	bool operator()(const Person& p1, const Person& p2) const
    	{
    		//按照年龄进行排序
    		return p1.m_Age < p2.m_Age;
    	}
    };
    
    void test()
    {
    	set<Person, comparePerson> s;
    	Person p1("刘备", 23);
    	Person p2("关羽", 27);
    	Person p3("张飞", 25);
    	Person p4("赵云", 21);
    
    	s.insert(p1);
    	s.insert(p2);
    	s.insert(p3);
    	s.insert(p4);
    
    	for (set<Person, comparePerson>::iterator it = s.begin(); it != s.end(); ++it)
    	{
    		cout << "姓名: " << it->m_Name << " 年龄: " << it->m_Age << endl;
    	}
    }
    int main()
    {
    	test();
    	return 0;
    }
    //总结: 对于自定义数据类型, set必须要指定排序规则才可以插入数据
    
    展开全文
  • set容器和multiset容器

    2020-11-05 21:10:12
    set容器基本概念: 简历: 所有元素都会在插入是自动被排序 本质: set容器和multiset容器属于关联式容器,底层结构是用的二叉数实现。 set容器和multiset容器区别: set容器不允许容器中有重复的元素 multiset容器...

    set容器基本概念:

    简历:
    所有元素都会在插入是自动被排序

    本质:
    set容器和multiset容器属于关联式容器,底层结构是用的二叉数实现。

    set容器和multiset容器区别:
    set容器不允许容器中有重复的元素
    multiset容器中允许有重复的元素

    set容器构造和赋值

    set容器特点:所有元素插入时候自动被排序
    set容器不允许插入重复值

    #include<iostream>
    using namespace std;
    #include<set>
    
    void PrintSet(const set<int>& s)
    {
    	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    
    
    void test01()
    {
    	set<int>s1;
    	//插入数据只有insert方式
    	s1.insert(10);
    	s1.insert(70);
    	s1.insert(30);
    	s1.insert(20);
    
    	//set容器特点:所有元素插入时候自动被排序
    	//set容器不允许插入重复值
    	PrintSet(s1);
    
    	//拷贝构造
    	set<int>s2(s1);
    	PrintSet(s2);
    
    	//赋值
    	set<int>s3;
    	s3 = s1;
    	PrintSet(s3);
    
    }
    
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }
    

    set容器大小和交换:

    #include<iostream>
    using namespace std;
    #include<set>
    
    
    void printSet(const set<int>&s)
    {
    	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    
    void test01()
    {
    	set<int>s;
    	for (int i = 10; i > 0; i--)
    	{
    		s.insert(i);
    	}
    
    	printSet(s);
    	if (s.empty())
    	{
    		cout << "s容器为空" << endl;
    	}
    	else
    	{
    		cout << "s容器不为空" << endl;
    		cout << "s的长度为:" << s.size() << endl;
    	}
    
    
    	//交换
    	set<int>s1;
    	for (int i = 20; i > 10; i--)
    	{
    		s1.insert(i);
    	}
    	cout << "交换前:" << endl;
    	printSet(s);
    	printSet(s1);
    
    	cout << "交换后:" << endl;
    	s.swap(s1);
    	printSet(s);
    	printSet(s1);
    
    }
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }
    

    set容器插入和删除:

    #include<iostream>
    using namespace std;
    #include<set>
    
    void printSet(const set<int>& s)
    {
    	for (set<int>::const_iterator it = s.begin(); it != s.end(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    }
    
    void test01()
    {
    	set<int>s;
    	//插入
    	for (int i = 0; i < 10; i++)
    	{
    		s.insert(i);
    	}
    
    	//遍历
    	printSet(s);
    
    	//删除
    	s.erase(s.begin());
    	printSet(s);
    
    	//删除重载版本
    	s.erase(9);
    	printSet(s);
    
    	//清空
    	//s.erase(s.begin(), s.end());
    	s.clear();
    	printSet(s);
    }
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }
    

    set容器查找和统计:

    查找————find(返回的是迭代器)
    统计————count(对于set,结果为0或者1)

    #include<iostream>
    using namespace std;
    #include<set>
    
    
    void test01()
    {
    	set<int>s;
    	for (int i = 10; i > 0; i--)
    	{
    		s.insert(i);
    	}
    	set<int>::iterator por = s.find(8);
    	if (por != s.end())
    	{
    		cout << "找到元素:" << *por << endl;
    	}
    	else
    	{
    		cout << "找不到元素:" << endl;
    	}
    
    	//对于set而言  统计结果 要么是0  要么是1
    	cout << "个数为:" << s.count(4) << endl;
    }
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }
    

    set和multiset区别:

    set不可以插入重复数据,而multiset可以
    set插入数据的同时会返回插入结果,表示插入是否成功
    multiset不会检测数据,因此可以插入重复数据

    #include<iostream>
    using namespace std;
    #include<set>
    
    void test01()
    {
    	set<int>s;
    	
    	pair<set<int>::iterator, bool> ret = s.insert(20);
    	if (ret.second)
    	{
    		cout << "第一次插入成功" << endl;
    	}
    	else
    	{
    		cout << "第一次插入失败" << endl;
    	}
    
    	ret = s.insert(20);
    	if (ret.second)
    	{
    		cout << "第二次插入成功" << endl;
    	}
    	else
    	{
    		cout << "第二次插入失败" << endl;
    	}
    
    
    	multiset<int>ms;
    	//允许插入重复的值
    	ms.insert(10);
    	ms.insert(10);
    
    	for (multiset<int>::iterator it = ms.begin(); it != ms.end(); it++)
    	{
    		cout << *it << " ";
    	}
    	cout << endl;
    
    }
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }
    

    pair队组创建:

    #include<iostream>
    using namespace std;
    
    
    void test01()
    {
    	//第一种方式
    	pair<string, int>p("Tom", 19);
    	cout << "姓名:" << p.first << " 年龄:" << p.second << endl;
    
    	//第二种方式
    	pair<string, int>p2 = make_pair("Jom", 17);
    	cout << "姓名:" << p2.first << " 年龄:" << p2.second << endl;
    }
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }
    
    展开全文
  • set容器及multiset容器

    2020-01-30 15:25:18
    1.set容器及multiset容器基础知识 2.set交换与大小 3.set容器插入与删除 4.set容器查找与统计 5.set与multiset容器的区别 6.pair对组的创建方式 7.set容器排序(改变排序规则)

    导航

    1.set容器及multiset容器基础知识
    2.set交换与大小
    3.set容器插入与删除
    4.set容器查找与统计
    5.set与multiset容器的区别
    6.pair对组的创建方式
    7.set容器排序(改变排序规则)
    ———————————————————————————————————
    1.set容器及multiset容器基础知识
    set与multiset都是关联式容器,所有被插入时都会自动排序

    set与multiset容器区别

    1.set不能再容器中有重复的数
    2.multiset允许容器中有重复的元素

    构造函数:

    set< T > st
    set(const set& st)

    赋值:

    operator= //赋值

    set例子:

    #include <iostream>
    using namespace std;
    #include <set>
    
    void PrintSet(const set<int>&st)
    {
    	for(set<int>::const_iterator it = st.begin();it!=st.end();it++)
    	{
    		cout<<(*it)<<" ";
    	}
    	cout<<endl;
    }
    
    void test()
    {
    	set<int> st;   
    	st.insert(20); //插入数据用insert
    	st.insert(10);
    	st.insert(30);
    	st.insert(40);
    	st.insert(30);
    	PrintSet(st);
    
    	set<int> st1(st); //拷贝构造
    	PrintSet(st1);
    
    	set<int> st2;
    	st2 = st1;
    	PrintSet(st2);
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述
    ———————————————————————————————————
    2.set交换与大小

    size() //容量
    empty(); //若是容器空为1,不空为0
    swap() //交换容器

    ———————————————————————————————————
    3.set容器插入与删除

    insert() //插入
    clear() //清除
    erase(pos) //清除pos迭代器所指元素,返回下一个元素
    erase(beg,end) //迭代器指向的区间
    erase(elem) //删除容器中为elem的元素

    例子:

    #include <iostream>
    using namespace std;
    #include <set>
    
    void PrintSet(const set<int>&st)
    {
    	for(set<int>::const_iterator it = st.begin();it!=st.end();it++)
    	{
    		cout<<(*it)<<" ";
    	}
    	cout<<endl;
    }
    
    void test()
    {
    	set<int> st;   
    	st.insert(20); //插入数据
    	st.insert(10);
    	st.insert(30);
    	st.insert(40);
    	st.insert(30);
    	PrintSet(st); //遍历
    
    	//删除第一个数据
    	st.erase(st.begin());
    	PrintSet(st);   
    
    	//删除重载  直接放入值
    	st.erase(30);
    
    	//清空
    	//st.erase(st.begin(),st.end());
    	st.clear();
    	PrintSet(st);
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述
    ———————————————————————————————————
    4.set容器查找与统计

    find(key) //找到返回对应元素的迭代器,没有找到返回.end()
    cout(key) //set容器中没有重复的数,所以返回0或1

    例子:

    #include <iostream>
    using namespace std;
    #include <set>
    
    void test()
    {
    	set<int> st;   
    	st.insert(20); //插入数据
    	st.insert(10);
    	st.insert(30);
    	st.insert(30);
    	
    	set<int>::iterator it = st.find(30); //find返回该位置的迭代器,没找到返回st.end()
    	if(it != st.end())     //判断是否相同
    	{
    		cout<<"找到对应的"<<(*it)<<endl;
    	}
    	else
    	{
    		cout<<"没找到"<<endl;
    	}
    
    	cout<<"30的数量为:"<<st.count(30)<<endl; //因为set中没有重复数,返回只有1或着0
    
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行程序:
    在这里插入图片描述
    ———————————————————————————————————
    5.set与multiset容器的区别

    set插入数据时会返回插入的结果,结果表示插入是否成功
    multiset不会检测数据,因此可以插入重复的数据

    检验:

    #include <iostream>
    using namespace std;
    #include <set>
    
    void test()
    {
    	set<int> st;   
    	pair<set<int>::iterator,bool> ret = st.insert(20); //插入数据
    	if(ret.second)
    	{
    		cout<<"第一次插入成功"<<endl;
    	}
    	else
    	{
    		cout<<"插入失败"<<endl;
    	}
    
    	ret = st.insert(20);
    	if(ret.second) 
    	{
    		cout<<"第二次插入成功"<<endl;
    	}
    	else
    	{
    		cout<<"插入失败"<<endl;
    	}
    
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述
    ———————————————————————————————————
    6.pair对组的创建方式
    说明:成对成线的数据,利用对组可以返回两个数据

    两种创建方式:

    pair< type,type>p(value,value)
    pair< type,typoe> p = make_pair(value,value)

    例子:

    #include <iostream>
    using namespace std;
    #include <string>
    #include <set>
    
    //pair对组的创建
    void test()
    {
    	//第一种方式
    	pair<string,int> p("Tom",20);
    	cout<<"姓名:"<<p.first<<" 年龄:"<<p.second<<endl;
    
    	//第二种
    	pair<string,int>p1 = make_pair("小王",15);
    	cout<<"姓名:"<<p1.first<<" 年龄:"<<p1.second<<endl;
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述
    ———————————————————————————————————
    7.set容器排序(改变排序规则)
    set容器默认插入时从小到大排序,如何改变排序规则?

    利用仿函数,可以改变排序规则,必须在插入数之前确定排序方式

    例子:

    #include <iostream>
    using namespace std;
    #include <string>
    #include <set>
    
    class Mycompare
    {
    public:
    	bool operator()(int v1,int v2)  //创建一个带有bool类型的仿函数
    	{
    		return v1>v2;
    	}
    };
    
    //pair对组的创建
    void test()
    {
    	set<int,Mycompare> p;  //加入自己创建的类
    	p.insert(10);
    	p.insert(30);
    	p.insert(20);
    	p.insert(15);
    
    	//遍历
    	for(set<int,Mycompare>::iterator it = p.begin();it!=p.end();it++)
    	{
    		cout<<(*it)<<" ";
    	}
    	cout<<endl;
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述

    若插入自定义数据,如何指定排序规则
    例子:

    #include <iostream>
    using namespace std;
    #include <string>
    #include <set>
    
    //自定义类
    class Person
    {
    public:
    	Person(string name,int age) //构造函数
    	{
    		this->m_name = name;
    		this->m_age = age;
    	}
    	string m_name;
    	int m_age;
    };
    
    class Mycompare
    {
    public:
    	bool operator()(const Person& p,const Person& p1)  //创建一个带有bool类型的仿函数
    	{
    		return p.m_age>p1.m_age;
    	}
    };
    
    //pair对组的创建
    void test()
    {
    	set<Person,Mycompare> st;  //创建容器
    	Person p("小明",15);    //自定义数据
    	Person p1("小红",14);
    	Person p2("小王",16);
    	Person p3("小李",20);
    	st.insert(p);
    	st.insert(p1);
    	st.insert(p2);
    	st.insert(p3);
    	//遍历
    	for(set<Person,Mycompare>::iterator it = st.begin();it!=st.end();it++)
    	{
    		cout<<"姓名:"<<it->m_name<<" 年龄:"<<it->m_age<<endl;
    	}
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述

    展开全文
  • set容器 关于set,必须说明的是set关联式容器。 set作为一个容器也是用来存储同一数据类型的数据类型,并且能从一个数据集合中取出数据,在set中每个元素的值都唯一,而且系统能根据元素的值自动进行排序。应该...
  • set容器用法

    2019-09-15 19:21:18
    begin() ,返回set容器的第一个元素 end() ,返回set容器的最后一个元素 clear() ,删除set容器中的所有的元素 empty() ,判断set容器是否为空 max_size() ,返回set容器可能包含的元素最大个数 size() ,返回当前set...
  • C++set容器set大小和交换 功能描述: 统计set容器大小以及交换set容器 #include <iostream> #include <set> using namespace std; void printSet(set<int>& s) { for (set<int>::...
  • C++之set容器

    2020-05-15 15:46:01
    1.sett.begin() 返回set容器的第一个元素 2.sett.end() 返回set容器的最后一个元素 3.sett.clear()删除set容器的所有元素 4.sett.insert(x)插入一个元素 5.sett.erase()删除一个元素 6.sett.size()返回当前set容器的...
  • set容器,map容器,对组

    2020-06-02 16:22:01
    一.set容器和multiset容器: 1.所有容器在插入的时候都会被自动排序 2.multiset容器中允许有重复元素,但是set容器不允许有重复元素 3.set在插入数据的时候会返回值确定是否插入成功,multiset就不会 1.set容器的...
  • C++set容器set查找和统计 功能描述: 对set容器进行查找数据以及统计数据 #include <set> #include <iostream> using namespace std; void test() { set<int> s1; //插入 s1.insert(10); s1...
  • C++ set容器笔记

    2019-11-12 21:26:35
    set容器 :所有元素都会在插入时自动被排序 本质:set/multiset属于关联式容器,底层结构是用二叉树实现 set和multiset区别: 1.set不允许容器中有重复的元素 2.multiset允许容器中有重复的元素 set容器内置类型指定...
  • C++set容器set插入和删除 功能描述: set容器进行插入数据和删除数据 #include <iostream> #include <set> using namespace std; void printSet(set<int>& s) { for (set<int>::...
  • set容器 set作为一个容器也是用来存储同一数据类型的数据类型,并且能从一个数据集合中取出数据,在set中每个元素的值都唯一,而且系统能根据元素的值自动排序。 构造set集合的主要目的是为了快速检索,使用set前,...
  • set 特点: 快速查找,不允许重复值。 按一定顺序排列,集合中的每...begin() 返回set容器的第一个元素 end() 返回set容器的最后一个元素 clear() 删除set容器中的所有的元素 erase() 删除集合中的元素 empty() 判断s
  • set容器的用法

    2019-05-28 22:17:13
    set容器的用法1.set容器的理解2.实现过程举例 1.set容器的理解 所有元素都会根据元素的键值自动排序,set元素的键值就是实值,实值就是键值。set不允许两个元素有相同的键值。(set的元素不像map那样可以同时拥有实...
  • Set容器的使用

    2017-09-11 14:23:51
    set容器只是单纯键的集合,如果想知道一个值是否存在时,使用set容器比较合适。set容器中的键也是唯一的,不能修改,且set容器不能使用下标操作。 以下使用程序说明set容器的使用:定义、插入、获取 等 #include ...
  • STL之set容器

    2020-08-20 21:46:46
    记录Set的常用操作 #include <... //定义一个set容器,默认从小到大 s.insert(1);//插入一个数 s.insert(5); s.insert(3); s.insert(6);//此时set容器的顺序为1 3 5 6 s.erase(3);//删除元素3,此时s

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,603
精华内容 8,641
关键字:

set容器