在 C++ 中初始化集合的不同方法

集合是 C++ 标准模板库 (STL) 中可用的关联容器，用于按特定顺序存储唯一元素，它在内部使用二叉搜索树的工作原理来存储元素。

在 C++中初始化集合的不同方法：

1. 使用默认构造函数进行初始化。
2. 使用初始化列表进行初始化。
3. 使用数组初始化。
4. 使用向量初始化。
5. 使用复制构造函数从另一个集合初始化。
6. 使用范围构造函数从另一个可迭代数据结构初始化。

1. 使用默认构造函数初始化

初始化集合的一种标准方法是使用默认构造函数进行初始化，这将生成一个空集合。可以使用内置集将元素添加到其中。插入（）方法。

句法：

setNew_set;
New_set.insert(element1)

在这里， insert() 方法可以进一步用于将元素插入到集合中。

下面是实现上述方法的 C++ 程序：

C++

// C++ program to implement
// the above approach
#include 
#include 
using namespace std;
 
// Driver code
int main()
{   
    // Initialize set using
    // default constructor
    setNew_set;
   
    // set.insert() method to
    // insert elements to the set
    New_set.insert(5);
    New_set.insert(1);
    New_set.insert(3);
    New_set.insert(2);
    New_set.insert(7);
     
    // Traverse through the set(elements
    // will be returned in ascending order)
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

---

---

输出

1
2
3
5
7

2. 使用初始化列表初始化

另一种初始化方法是将预定义的元素列表 (initializer_list) 作为参数传递给集合的默认构造函数，如下所示：

句法：

setNew_set({element1, element2, element3, element4});

下面是实现上述方法的 C++ 程序：

C++

// C++ program to implement
// the above approach
#include 
#include 
using namespace std;
 
// Driver code
int main()
{  
   // Initialize set passing initializer
   // list as an argument to the
   // default constructor
   setNew_set({4, 3, 9, 2, 0, 6});
    
   // Traverse through the unordered_set
   for(auto x: New_set)
   {
      cout << x << endl;
   }
   return 0;
}

输出

0
2
3
4
6
9

3. 使用数组初始化

可以使用相同数据类型的数组将元素添加到集合中。

句法：

setNew_set(old_arr, old_arr + n); 

这里，old_arr 是将内容复制到 New_set 的整数数组。

下面是实现上述方法的 C++ 程序：

C++

// C++ program to implement
// the above approach
#include 
using namespace std;
 
// Driver code
int main()
{
    // Initialize an array of
    // integers
    int old_arr[] = {4, 3, 6, 1, 8};
    int n = (sizeof(old_arr) /
             sizeof(old_arr[0]));
   
    // Adding these elements stored
    // in the array
    setNew_set(old_arr,
                    old_arr + n);
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

输出

1
3
4
6
8

4. 使用向量初始化

可以使用相同数据类型的向量将元素存储到集合中。

句法：

setNew_set(old_vector.begin(),old_vector.end()); 

这里，old_vector 是整数向量，内容将从该向量复制到 New_set。

下面是实现上述方法的 C++ 程序：

C++

// C++ program to implement
// the above approach
#include 
using namespace std;
 
// Driver code
int main()
{
    // Initialize a vector of integers
    vectorold_arr = {4, 1, 8, 2, 9};
   
    // Adding these elements
    // stored in the vector
    setNew_set(old_arr.begin(),
                    old_arr.end());
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x << endl;
    }
    return 0;
}

输出

Table
Cement
Floor
Grass
Ground

5. 使用复制构造函数从另一个集合初始化

初始化集合的一种方法是使用复制构造函数从另一个集合中一个接一个地复制内容。

句法：

setNew_set(old_set);

这里，old_set 是将内容复制到 New_set 的集合

下面是实现上述方法的 C++ 程序：

C++

// C++ program to implement
// the above approach
#include 
#include 
using namespace std;
 
// Driver code
int main()
{
    // Initialize an unordered_set
    // using default constructor
    setold_set;
   
    // set.insert() method to insert
    // elements to the unordered_set
    old_set.insert(5);
    old_set.insert(3);
    old_set.insert(4);
    old_set.insert(1);
    old_set.insert(2);
   
   
    // Create a new_set where contents
    // of the previous set will be
    // copied using copy constructor   
    setNew_set(old_set);
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x <

输出

1
2
3
4
5

6. 使用范围构造函数从另一个可迭代数据结构初始化

初始化集合的另一种方法是使用范围构造函数将元素从可迭代数据结构复制到新初始化的集合。

句法：

setNew_set(begin(old_set), end(old_set));

这里，old_set 是将内容复制到 New_set 的集合。

下面是实现上述方法的 C++ 程序：

C++

// C++ program to implement
// the above approach
#include 
#include 
using namespace std;
 
// Driver code
int main()
{
    // Initialize a set using
    // default constructor
    setold_set;
   
    // unordered_set.insert() method
    // to insert elements to the
    // unordered_set
    old_set.insert(3);
    old_set.insert(1);
    old_set.insert(4);
    old_set.insert(8);
    old_set.insert(5);
   
   
    // Create a new_set where contents
    // of the previous set will be
    // copied using range constructor   
    setNew_set(begin(old_set),
                    end(old_set));
   
    // Traverse through the unordered_map
    for(auto x: New_set)
    {
       cout << x <

输出

1
3
4
5
8