STL容器之set

【1】set容器

一个集合（set）是一个容器，它其中所包含的元素的值是唯一的。

【2】set容器方法

（1）set构造函数、插入函数、遍历过程

应用示例代码如下：

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

bool funcComp(int lhs, int rhs)  
{
    return lhs > rhs;
}

struct classcomp
{
    bool operator() (const int& lhs, const int& rhs) const
    {
        return lhs < rhs;
    }
};
// 正向遍历
void print(const set<int> & lessSet)
{
    set<int>::iterator iter = lessSet.begin();
    for (; iter != lessSet.end(); ++iter)
    {
        cout << (*iter) << " ";
    }
    cout << endl;
}
// 反向遍历
void print(const set<int, greater<int>> & greaterSet)
{
    set<int, greater<int>>::reverse_iterator ritor;
    ritor = greaterSet.rbegin();
    while (ritor != greaterSet.rend())
    {
        cout << (*ritor) << " ";
        ++ritor;
    }
    cout << endl;
}

void print(const set<int, bool(*)(int, int)> & funcpSet)
{
    set<int, bool(*)(int, int)>::iterator iter = funcpSet.begin();
    for (; iter != funcpSet.end(); ++iter)
    {
        cout << (*iter) << " ";
    }
    cout << endl;
}

void print(const set<int, classcomp> & classSet)
{
    set<int, classcomp>::iterator iter = classSet.begin();
    for (; iter != classSet.end(); ++iter)
    {
        cout << (*iter) << " ";
    }
    cout << endl;
}

void main ()
{
    // 1.默认构造函数创建一个空的set容器
    set<int> first;
    int n = 1;
    while (n <= 10)
    {
        first.insert(n++);
    }
    cout << "打印first容器的值：" << endl;
    print(first);
  
    // 2.默认是以小于比较器less<int>创建的，再创建一个带大于比较器的set
    set<int, greater<int>> second;
    n = 10;
    while (n <= 20)
    {
        second.insert(n++);
    }
    cout << "打印second容器的值：" << endl;
    print(second);

    // 3.用数组元素值创建一个容器
    int myInts[] = {10, 20, 30, 40, 50};
    set<int> third(myInts, myInts + 5);
    cout << "打印third容器的值：" << endl;
    print(third);

    // 4.调用拷贝构造函数创建一个容器
    set<int> fourth(third);
    cout << "打印fourth容器的值：" << endl;
    print(fourth);

    // 5.由已知对象的区间创建一个容器
    set<int> fifth(first.begin(), first.end());
    cout << "打印fifth容器的值：" << endl;
    print(fifth);

    // 6.以函数指针为比较器
    bool(*func_pt)(int, int) = funcComp;
    set<int, bool(*)(int, int)> sixth(func_pt);
    for (int i = 0; i < 10; ++i)
    {
        sixth.insert(rand() % 100);
    }
    cout << "打印sixth容器的值：" << endl;
    print(sixth);

    // 7.以仿函数为比较器
    set<int, classcomp> seventh;
    for (int i = 0; i < 10; ++i)
    {
        seventh.insert(rand() % 100);
    }
    cout << "打印seventh容器的值：" << endl;
    print(seventh);

    system("pause");
}

// run out:
/*
打印first容器的值：
1 2 3 4 5 6 7 8 9 10
打印second容器的值：
10 11 12 13 14 15 16 17 18 19 20
打印third容器的值：
10 20 30 40 50
打印fourth容器的值：
10 20 30 40 50
打印fifth容器的值：
1 2 3 4 5 6 7 8 9 10
打印sixth容器的值：
78 69 67 64 62 58 41 34 24 0
打印seventh容器的值：
5 27 36 42 45 61 81 91 95
请按任意键继续. . .
*/

（2）插入、大小、判空、最大个数等等

示例代码如下：

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

// 正向遍历
void print(const set<int> & lessSet)
{
    set<int>::iterator iter = lessSet.begin();
    while (iter != lessSet.end())
    {
        cout << (*iter) << " ";
        iter++;
    }
    cout << endl;
}

void main()
{
    set<int> myset;
    set<int>::iterator it;
    pair<set<int>::iterator, bool> ret;
    // 插入数据元素
    for (int i = 1; i <= 5; ++i) 
    {
        myset.insert(i * 10);    // 元素为: 10 20 30 40 50
    }

    ret = myset.insert(20);  // 再插入20，发现已存在，则插入操作失败！
    if (false == ret.second) 
        it = ret.first;  // it迭代器指向了20这个元素

    myset.insert (it, 25);
    myset.insert (it, 24);
    myset.insert (it, 26);

    int myints[] = {5, 10, 15};  // 10已经在容器中
    myset.insert(myints, myints + 3);
    cout << "打印mySet容器的值：" << endl;
    print(myset);

    set<int> firstSet;
    for (int i = 0; i < 10; ++i)
    {
        firstSet.insert(rand() % 100);
    }
    cout << "打印firstSet容器的值：" << endl;
    print(firstSet);

    cout << "empty()：" << firstSet.empty() << endl; 
    cout << "size()：" << firstSet.size() << endl;
    cout << "max_size()：" << firstSet.max_size() << endl;
    
    system("pause");
}

// run out:
/*
打印mySet容器的值：
5 10 15 20 24 25 26 30 40 50
打印firstSet容器的值：
0 24 34 41 58 62 64 67 69 78
empty()：0
size()：10
max_size()：1073741823
请按任意键继续. . .
*/

（3）删除、清空、交换

示例代码如下：

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

// 正向遍历
void print(const set<int> & lessSet)
{
    set<int>::iterator iter = lessSet.begin();
    while (iter != lessSet.end())
    {
        cout << (*iter) << " ";
        iter++;
    }
    cout << endl;
}

void main ()
{
    set<int> mySet;
    set<int>::iterator it;
    for (int i = 1; i < 10; i++) 
        mySet.insert(i * 10);  // 10 20 30 40 50 60 70 80 90
    cout << "打印mySet容器数据：" << endl;
    print(mySet);

    it = mySet.begin();
    ++it;
    // 第一种删除方式
    mySet.erase(it);
    // 第二种删除方式
    mySet.erase(40);
    it = mySet.find(60);
    // 第三种删除方式
    mySet.erase(it, mySet.end());
    cout << "删除后，打印mySet容器数据：" << endl;
    print(mySet);

    set<int> firstSet;
    for (int i = 1; i < 10; ++i)
    {
        firstSet.insert((i + 2) * 10);
    }
    cout << "打印firstSet容器的值：" << endl;
    print(firstSet);
    // 第四种删除
    set<int>::iterator iter = firstSet.begin();
    for (; iter != firstSet.end(); )
    {
        if ((*iter) == 50)
        {
            firstSet.erase(iter++);
        }
        else
        {
            ++iter;
        }
    }
    cout << "删除50后，打印firstSet容器的值：" << endl;
    print(firstSet);

    mySet.clear();  // 清空
    firstSet.swap(mySet); // 交换两个容器
    cout << "交换后，打印mySet容器的值：" << endl;
    print(mySet);
    cout << "交换后，打印firstSet容器的值：" << endl;
    print(firstSet);

    system("pause");
}

//run out:
/*
打印mySet容器数据：
10 20 30 40 50 60 70 80 90
删除后，打印mySet容器数据：
10 30 50
打印firstSet容器的值：
30 40 50 60 70 80 90 100 110
删除50后，打印firstSet容器的值：
30 40 60 70 80 90 100 110
交换后，打印mySet容器的值：
30 40 60 70 80 90 100 110
交换后，打印firstSet容器的值：

请按任意键继续. . .
*/

（4）key_comp函数

函数返回比较函数对象，默认的是升序排列。

示例代码如下：

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

// 正向遍历
void print(const set<int> & lessSet)
{
    set<int>::iterator iter = lessSet.begin();
    while (iter != lessSet.end())
    {
        cout << (*iter++) << " ";
    }
    cout << endl;
}

void main ()
{
  set<int> mySet;
  int highest;
  set<int>::key_compare myComp = mySet.key_comp();
  for (int i = 0; i <= 5; ++i) 
  {
      mySet.insert((i + 1) * 10);
  }

  cout << "打印mySet容器中的数据元素：" << endl;
  print(mySet);

  cout << "利用比较函数打印容器中小于最大值的元素：" << endl;
  highest = *mySet.rbegin();
  set<int>::iterator it = mySet.begin();
  do 
  {
      cout << " " << *it;
  } while (myComp(*(++it), highest));
  cout << endl;

  system("pause");
}

// run out:
/*
打印mySet容器中的数据元素：
10 20 30 40 50 60
利用比较函数打印容器中小于最大值的元素：
 10 20 30 40 50
请按任意键继续. . .
*/

（5）count函数。函数返回值为val的元素的个数，当然在set容器中其要么为0，要么为1。

示例代码如下：

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

void main ()
{
    set<int> mySet;
    // set some initial values:
    for (int i = 1; i < 5; ++i) 
        mySet.insert(i * 3);    // set: 3 6 9 12

    if (mySet.count(9) == 1)
        cout << " 9 is an element of myset.\n";
    else
        cout << " 9 is not an element of myset.\n";
    
    system("pause");
}
// run out:
/*
 9 is an element of myset.
请按任意键继续. . .
*/

（6）lower_bound 和 upper_bound函数

lower_bound 函数返回set中第一个小于或者等于val的元素的iterator。

upper_bound 函数返回set中第一个大于或者等于val的元素的iterator。

示例代码如下：

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

void main ()
{
    set<int> mySet;
    set<int>::iterator itlow, itup;
    for (int i = 1; i < 10; i++) 
        mySet.insert(i * 10); // 10 20 30 40 50 60 70 80 90

    itlow = mySet.lower_bound (30);
    itup = mySet.upper_bound (60); 
    mySet.erase(itlow, itup);  // 10 20 70 80 90

    cout << "mySet contains:";
    for (set<int>::iterator it = mySet.begin(); it != mySet.end(); ++it)
    {
        cout << " " << *it;
    }
    
    cout << endl;
    
    system("pause");
}
// run out:
/*
mySet contains: 10 20 70 80 90
请按任意键继续. . .
*/

（7）equal_range 函数返回等于set中val的上下界的iterator。

示例代码如下：

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

void main ()
{
    set<int> mySet;
    for (int i = 1; i <= 5; ++i) 
        mySet.insert(i * 10);   // mySet: 10 20 30 40 50
  
    pair<set<int>::const_iterator, set<int>::const_iterator> ret;
    ret = mySet.equal_range(30);

    cout << "the lower bound points to: " << (*ret).first << endl;
    cout << "the upper bound points to: " << (*ret).second << endl;

    system("pause");
}

// run out:
/*
the lower bound points to: 30
the upper bound points to: 40
请按任意键继续. . .
*/

（8）get_allocator 函数返回set的分配器对象。

示例代码如下：

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

void main ()
{
    set<int> myset;
    int* p = NULL;
    unsigned int i;

    // allocate an array of 5 elements using myset's allocator:
    p = myset.get_allocator().allocate(5);

    // assign some values to array
    for (i = 0; i < 5; ++i) 
        p[i] = (i + 1) * 10;

    cout << "The allocated array contains:";
    for (i = 0; i < 5; ++i) 
        cout << ' ' << p[i];

    cout << endl;

    myset.get_allocator().deallocate(p, 5);

    system("pause");
}

// run out:
/*
The allocated array contains: 10 20 30 40 50
请按任意键继续. . .
*/

（9）待续......

【3】set容器总结

 一个集合（set）是一个容器，它其中所包含的元素的值是唯一的。

 

Good Good  Study,  Day  Day  Up.

顺序   选择   循环   总结