题目

通过使用c++的类 ，重载，vector容器等相关知识来实现集合间的：交 并 补 差 对称差这五种关系
这里不直接set使用有关集合关系的函数

相关数学知识

并集：设A与B是任意两个集合，由至少属于集合A与集合B之一的一切元素构成的集合成为A与B的并集，记作A∪B（或B∪A），读作“A并B”（或“B并A”），即A∪B={x|x∈A,或x∈B}。

交集：对于给定的两个集合A 和 集合B 的交集是指含有所有既属于 A 又属于 B 的元素所构成的集合。由属于A且属于B的相同元素组成的集合，记作A∩B（或B∩A）读作“A交B”（或“B交A”），即A∩B={x|x∈A,且x∈B}。

差集：设A与B是任意两个集合，由属于A但不属于B的一切元数构成的集合称为A与B的差集，记为A\B或A-B，即A\B={x|x∈A且x∉B}。

补集：设S是一个集合，A是S的一个真子集,由S中所有不属于A的元素组成的集合，叫做子集A在S中的补集，于集也称为补集，记作CsA或Ac或A’。即Ac=S\A。

对称差：两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合。设A与B是任意两个集合，集合 A 和 B 的对称差可记为 AΔB，对称差相当于两个相对补集的并集，即AΔB=（A-B）∪（B-A）。也可以表示为两个集合的并集减去它们的交集，即AΔB=（A∪B）-（B∩A）。

功能实现

通过创建两个类，一个学生类，一个学生集合类，分别代表元素和集合，将学生类里面的数据放在一个vector的容器中可以在学生集合类里进行储存及使用。

头文件以及实现

学生类

创建一个学生类

class Student
{
private:
	int m_uiId;
public:
	Student();
	Student(int id);
	Student(const Student& student);
	Student& operator=(const Student& student);
	bool operator==(const Student& student) const;
	bool operator!=(const Student& student) const;
	int GetID() const { return m_uiId; }
};

学生类实现

默认构造：为其赋初值，在使用rand （） 函数在使用时是已经固定的值，所以创建一个随机种子来改变其值，同时用srand（time（NULL））实现随机种子，根据时间变化而产生学号，这个可以避免学号创建出来是一样的情况

Student::Student(){
	srand((unsigned int)time(NULL));
 	m_uiId = rand() % 20 + 1;
}

随机产生学生学号范围在1-20之间

 rand() % 20 + 1;

有参构造
实现参数id保证传入的参数的准确性

Student::Student(int id){
  m_uiId=id;
}

拷贝构造函数
传入进来的是一个对象，通过引用的方式进行传入，并的将传进来的对象的m_uiId赋值给本身的m_uiId进而来实现拷贝效果

Student::Student(const Student & student){
  m_uiId=student.m_uiId;
}

重载赋值运算符
这个重载赋值和拷贝函数很像，在返回值上有区别，要实现一个链式编程的思想，为了将重载赋值运算符可以链式的使用下去，所以我们需要将其返回一个指针的形式

Student &Student::operator=(const Student &student){
   m_uiId=student.m_uiId;
   return *this;
}

重载关系运算符
是一个bool类型的函数，判断是否相等，相等则返回true，否则返回false类型

bool Student::operator==(const Student &student)const{
     if(student.m_uiId==m_uiId) return true;
     return false;
}
bool Student::operator!=(const Student &student)const{
     if(student.m_uiId!=m_uiId) return true;
     return false;
}

学生集合类

接着创建 学生集合类 在学生集合类里面实现相应函数
我们创建一个Student类型的容器去存放数据

在创建学生集合类时使用了vector容器，需要加入头文件#include<vector>

class StudentSet
{
private:
	vector<Student>m_vecData;
public:
	StudentSet();
	StudentSet(const StudentSet&studentset);
	StudentSet& operator=(const StudentSet&studentset);
	bool Insert(const Student student);
	bool Remove(const int id);
	StudentSet Union(const StudentSet&studentset) const;
	StudentSet InterSect(const StudentSet&studentset) const;
	StudentSet Difference(const StudentSet&studentset) const;
	StudentSet Complement() const;
	StudentSet SymDifference(const StudentSet&studentset) const;
	bool IsEmpty() const;
	void Clear();
	void Output() const;
};

学生集合类实现

学生集合类的三个构造函数和学生类的一样，在学生集合类中，默认构造函数让其清空
注意在重载赋值函数中，要清空函数，否则会保留上一次的数据

StudentSet::StudentSet(){
   m_vecData.clear();
}
StudentSet::StudentSet(const StudentSet &studentset){
   int len=studentset.m_vecData.size();
   for(int i=0;i<len;i++){
    m_vecData.push_back(studentset.m_vecData[i]);
   }
}
StudentSet& StudentSet::operator=(const StudentSet & studentset){
	m_vecData.clear();//清空防止在下一次的使用时仍含有上一次的值
   int len=studentset.m_vecData.size();
   for(int i=0;i<len;i++){
    m_vecData.push_back(studentset.m_vecData[i]);
   }
   return *this;
}

插入和删除函数，是bool类型的函数，需要判断该集合中是否有与我们插入的id重复，如果有，则返回false，没有则返回true,同理删除函数一样
插入和删除都用到了vector容器里面的push_back函数和erase函数

判断是否有重复的思路
所使用的方法：我使用了map容器，通过map容器的两个参数值key和value，是键值对，他们之间有着一一对应的关系，同时在map容器中key 值是没有重复的。将m_vecData[i].GetID()全标记为1，此时m_vecData[i].GetID()就相当于map容器里的key值，标记的1就是相当于value值，这样在通过判断传进来的id的value值是否是1，如果是1，代表有重复的，之没有，没有重复的我们将其插入并返回true。

删除函数：就是在本身的范围内开始遍历，如果有和传入的id相同的，记录一下当前的遍历的位置，使用m_vecData.erase(m_vecData.begin()+i);的方法删除重复的那个

注：m_vecData[i].GetID()==id的要注意私有成员函数只能由该类内部成员函数调用

bool StudentSet::Insert(const Student student){//插入
	int len =m_vecData.size();
	map<int ,int >mp;
	
	for(int i=0;i<len;i++){
		mp[m_vecData[i].GetID()]=1;
	}
	if(!mp[student.GetID()]){
		m_vecData.push_back(student);
     	return true;
	}else {
		return false;
	}
}
bool StudentSet::Remove(const int id){//删除
     int len=m_vecData.size();
     for(int i=0;i<len;i++){
     if(m_vecData[i].GetID()==id){   ///私有成员函数只能被该类内部成员函数调用
         m_vecData.erase(m_vecData.begin()+i);
         return true;
        }
     }
     return false;
}

并 交 差 补 对称差

实现方式和插入函数的逻辑类似都是通过map函数的key值和value值进行判断的

并集：在本身这个集合内进行遍历将其全部插入到我们创建的的新的集合st里面，并且我们将map函数的key值为那个本身的学号，并将其的value值标记为1
int len=m_vecData.size(); for(int i=0;i<len;i++){ st.Insert(m_vecData[i]); mp[m_vecData[i].GetID()]=1; }再在传入进来的集合中进行遍历，如果在这个传入的集合中的id（key值）没有等于1的（value值），就意味着传入集合中的元素和我们本身的元素之间没有重复的，那么我们就将其插入进来 ，这样就可以得到我们这个并集了，

StudentSet StudentSet::Union(const StudentSet&studentset) const{//并集
     StudentSet st;
     map<int,int>mp;
     int len=m_vecData.size();
     for(int i=0;i<len;i++){
        st.Insert(m_vecData[i]);
        mp[m_vecData[i].GetID()]=1;
     }
     len=studentset.m_vecData.size();
     for(int i=0;i<len;i++){
        if(!mp[studentset.m_vecData[i].GetID()]){
            st.Insert(studentset.m_vecData[i]);
        }
     }
     return st;
}

交集： 同样在本身这个集合中进行遍历并将其标记为1，，然后在传入的集合中进行遍历，如果有一样被标记为1的我们就将其插入到我们所新建的那个集合中

StudentSet StudentSet::InterSect(const StudentSet&studentset) const{//交集
     StudentSet st;
     map<int,int>mp;
     for(int i=0;i<m_vecData.size();i++) {
     	mp[m_vecData[i].GetID()]=1;
	 }
     for(int i=0;i<studentset.m_vecData.size();i++){
        if(mp[studentset.m_vecData[i].GetID()]) {
        	st.m_vecData.push_back(studentset.m_vecData[i]);
		}
     }
     return st;
}

差集：在一个集合中把含有另一个集合的元素去除，我们这里是如果没有一样的元素我就插入进来
在传入的集合中进行遍历并将其标记为1，再在本身这个集合中进行遍历，如果这里面没有等于1的我们就将其插入到我们创建的新的集合中来

StudentSet StudentSet::Difference(const StudentSet&studentset) const{//差集
     StudentSet st;
     map<int,int>mp;
     int len=studentset.m_vecData.size();
     for(int i=0;i<len;i++) 
     mp[studentset.m_vecData[i].GetID()]=1;
     len=m_vecData.size();
     for(int i=0;i<len;i++){
        if(!mp[m_vecData[i].GetID()])
		st.m_vecData.push_back(m_vecData[i]);
     }
     return st;
}

补集：在全集是:IDMAX是0-20之间，求补集，我们在本身这个集合中遍历，并将其标记为1，再在全集中遍历，如果有不等于1的我们就将其插入到我们创建的新集合中来

StudentSet StudentSet::Complement() const{//补集
     StudentSet st;
     map<int ,int >mp;
     int len=m_vecData.size();
    for(int i=0;i<len;i++) 
	mp[m_vecData[i].GetID()]=1;
    for(int i=0;i<=IDMAX;i++){
		if(!mp[i]){
			Student a(i);
			st.m_vecData.push_back(a);
    	}
	}
     return st;
}

对称差实际上是两个集合的并集和交集再做一下差集
实现:创建一个新的集合a存放st和传入参数的并集，集合b存放的是st和传入参数的交集，完了再让a和b做差集，这样我们就得到了对称差

StudentSet StudentSet::SymDifference(const StudentSet&studentset) const{//对称差
     StudentSet st;
     int len=m_vecData.size();
     for(int i=0;i<len;i++) st.m_vecData.push_back(m_vecData[i]);
     StudentSet a=st.Union(studentset);
     StudentSet b=st.InterSect(studentset);
     StudentSet res=a.Difference(b);
     return res；
}

判断是否为空，清空函数以及输出函数
是否为空就是看vector.size()==0是否成立

bool StudentSet::IsEmpty() const{
     if(m_vecData.size()==0) return true;
     return false;
}
void StudentSet::Clear(){
     m_vecData.clear();
}
void StudentSet::Output() const{
     int len=m_vecData.size();
     for(int i=0;i<len;i++)
		cout<<m_vecData[i].GetID()<<endl;
}

主函数

int main()
{
	srand((unsigned int)time(NULL));
	StudentSet set1, set2, set3;
	set1.Clear();
	set2.Clear();
	set3.Clear();
	for (unsigned int i = 0; i < 5; i++)
	{
		Student tmpstudent(i);
		set1.Insert(tmpstudent);
	}
	set1.Output(); 
	system("pause");
	Student tmpstudent1(3);
	cout << set1.Insert(tmpstudent1) << endl;
	system("pause");
	Student tmpstudent2(10);
	cout << set1.Insert(tmpstudent2) << endl;
	system("pause");
	for (unsigned int i = 7; i < 12; i++)
	{
		Student tmpstudent(i);
		set2.Insert(tmpstudent);
	}
	set2.Output();
	system("pause");
	set3 = set1.Union(set2);
	set3.Output();
	system("pause");
	set3 = set1.InterSect(set2);
	set3.Output();
	system("pause");
	set3 = set1.Difference(set2);
	set3.Output();
	system("pause");
	set3 = set3.Complement();
	set3.Output();
	system("pause");
	set3 = set1.SymDifference(set2);
	set3.Output();
	system("pause");
	return 0;
}

总结

这个实验中主要使用的就是vector容器 插入、删除、清空、容量等一系列函数，运算符重载，以及map函数间的key值和value值之间的一一对应关系，以及我们对集合之间关系的掌握与理解.

注意注意
map里面有一种插入方法:（这里所有map的插入方式全都是这种）

map<int ,int>mp;
mp[1]=10;//key=1;value=10,

map中输出元素：如果是输出该容器内含有的元素，可以正常输出其value值，但是如果输出其中没有的，不会进行报错，会输出是0

博文首先贴出交集、并集、差集、对称差运算的C++代码以及程序运行结果，然后再进行一个比较完整的构建代码思路解析，整个项目的实现功能如下：

1. 实现代码以及程序运行结果

代码不太理解的，看下面解析。

1.1 头文件定义 UFSets.h

//该文章的原创作者：阿伟加油鸭。首发于CSDN平台，装载请标注博文出处。
//网址：https://blog.csdn.net/qq_45877524/article/details/106972508

/**
选择题目一：
结合离散数学中集合的性质于运算，设计集合类（元素的类型自行定义),并实现集合的基本运算，
包括：
……
**/

#ifndef UFSETS_H_
#define UFSETS_H_
#include<iostream>
#include<vector>
#include<algorithm>
#include<iterator>
#include<ostream>

using namespace std;

/**

UFSets类的设计思路：
用STL的容器vector以及algorithm库的算法来进行设计

**/
class UFSets {
private:
/**
	
用vector的原因：
1.vector自带智能指针，不需要进行特殊的删除，所以可以用默认析构函数
2.vector本身自带了许多检测函数比较方便

**/
	vector<int> data;            
	

public:
	UFSets();                   //构造函数，用来在空集上确定具体的元素
	~UFSets();                  //析构函数，这里用默认构造函数

	bool isEmpty();             //确定是否为空集
	bool isContain(int element) const;             //确定是否包含某一个元素
	bool isEquality( const UFSets& anotherSets);   //判断两个集合是否相等
	bool isSubSets(const UFSets& anotherSets);    //判断是否为子集

	void add(int element);                          //只是单纯的增加一个元素
	void addElement(int element[], int length);      //增加一组元素
	void del(int element);                           //删除一个元素

	UFSets unionSet(const UFSets& anotherSets);          //并集操作
	UFSets intersectSet(const UFSets& anotherSets);      //交集操作
	UFSets differenceSet(const UFSets& anotherSets);      //差集操作
	UFSets symDif(const UFSets& anotherSets);            //全名：Symmetric difference，对称差运算

	int getCount() const;           //返回元素的个数
	void Print() const;             //打印当前的元素  


};

#endif

1.2 抽象基类的实现 UFSets.cpp

//该文章的原创作者：阿伟加油鸭。首发于CSDN平台，装载请标注博文出处。
//网址：https://blog.csdn.net/qq_45877524/article/details/106972508


#include "UFSets.h"

//首先将vector容器设置为空
UFSets::UFSets()
{
	data = { };
}

UFSets::~UFSets()
{
}


bool UFSets::isEmpty()
{
	//bool std::vector<int>::empty() const 如果为空返回true，不为空为false
	if (data.empty() == true)
		return true;
	else
		return false;
}

bool UFSets::isContain(int element) const
{
	//find函数用迭代器找元素，找的到就返回他在vector的位置，找不到就算球
	if (find(data.begin(), data.end(), element) != data.end())
		return true;
	else
		return false;
}


//其实该函数可以用vector自带的重载运算符==，来进行判断，但是打完才想起来算了
bool UFSets::isEquality(const UFSets& anotherSets)
{
	if (data.size() != anotherSets.data.size()) {        //连长度都不相等，肯定不相等
		return false;
	}

	for (int i = 0; i < data.size(); i++) {
		for(int j = 0;j < anotherSets.data.size();j++)   //一个一个元素进行比较
		if (data[i] != anotherSets.data[j])
			return false;
	}

	return true;
}


//algorithm函数库中的includes函数来判断子集
bool UFSets::isSubSets(const UFSets& anotherSets)
{
	return includes(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end());
}

//vector语法
void UFSets::add(int element)
{
	data.push_back(element);              //push_back函数为容器后面添加元素
}

//vector语法
void UFSets::addElement(int element[], int length)
{
	for (int i = 0; i < length; i++)
		add(element[i]);                 //一个一个往里面添加

    sort(data.begin(),data.end());
}


void UFSets::del(int element)
{
	if (isContain(element) == false) {
		cout << "没有这个元素删除个蛇皮" << endl;                   //都不在删除个蛇蛇皮
		return ;
	}

	auto location = find(data.begin(), data.end(), element);        //找到特定元素，然后直接删除

	data.erase(location);
}

/**
交、差、并、对称差运算都是用到了algorithm函数库中的函数
这四个函数的语法都是通用的：

以set_union为例：
set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
		inserter(result.data,result.data.begin()));

前面四个参数都是vector的迭代器，最后一个参数是输出，那么这里在输出那里用inserter函数，将输出的
结果直接搞到vector容器中
**/
UFSets UFSets::unionSet(const UFSets& anotherSets)
{
	UFSets result;
	set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
		inserter(result.data,result.data.begin()));
	return result;
}

UFSets UFSets::intersectSet(const UFSets& anotherSets)
{
	UFSets result;
	set_intersection(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
	return result;
}

UFSets UFSets::differenceSet(const UFSets& anotherSets)
{
	UFSets result;
	set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
	return result;
}

UFSets UFSets::symDif(const UFSets& anotherSets)
{
	UFSets result;
	set_symmetric_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
	return result;
}


//元素的个数直接用vector的函数方法
int UFSets::getCount() const
{
	return data.size();
}


//打印元素
void UFSets::Print() const
{
	cout << "当前集合的元素" << endl;
	for (int i = 0; i < data.size(); i++) {
		cout << data[i] << " "<<endl;
	}
	cout << "完成" << endl;
}

1.3 测试函数以及测试用例 main.cpp

#include "UFSets.h"
/**

测试用例：
set1 = {1 3 5 7 9}
set2 = {2 4 6 7 9 10}

set2在删除元素2后的预测结果：
set2 = {4 6 7 9 10}

用set1进行属性测试函数的验证：

预期结果：
是否为空集              不是
是否包含元素1           是      
是否与set2相等          不是
set1是否为set2的子集    不是

用set1和删除元素2以后的set2进行并，交，差，对称差运算的结果预测：
并集          1 3 4 5 6 7 9 10
交集          7 9
差集          1 3 5
对称差运算    1 3 4 5 6 10

**/



int main() {
	int setOne[] = { 1,3,5,7,9 };
	int setTwo[] = { 2,4,6,7,9,10 };

	UFSets set1, set2;
	set1.addElement(setOne, 5);             //增加元素
	set2.addElement(setTwo, 6);             //增加元素

	//打印这两个东西
	set1.Print();
	set2.Print();

	//把2删除试一下
	set2.del(2);
	set2.Print();

	//并，交，差，对称差运算
	cout << "并集" << endl;
	UFSets UnionSet = set1.unionSet(set2);
	UnionSet.Print();

	cout << "交集" << endl;
	UFSets IntersectSet = set1.intersectSet(set2);
	IntersectSet.Print();

	cout << "差集" << endl;
	UFSets DifferenceSet = set1.differenceSet(set2);
	DifferenceSet.Print();

	cout << "对称差运算" << endl;
	UFSets symdif = set1.symDif(set2);
	symdif.Print();

	//返回set1的元素个数
	cout << "接下来都是set1的验证" << endl;
	cout << set1.getCount() << endl;
	cout << "是否为空集" << " "<<set1.isEmpty() << endl;
	cout << "是否包含元素" <<" " <<set1.isContain(1) << endl;
	cout << "是否相等" <<" "<< set1.isEquality(set2) << endl;
	cout << "set1是否为set2的子集" <<" "<< set1.isSubSets(set2) << endl;

	return 0;
}

1.4 代码运行结果

1.5 代码环境

C++11，运行不成功可能是dev版本过老的问题，反正我用dev和visual stduio 2020都是没有问题的。

2 代码构建思路

我的代码构建思路可能不太成熟，望大佬指正。

设计一个类，首先应该考虑的是用什么东西来存储相应的元素，那么对于设计的需求而言，我要做的是元素（单个数据）与元素（单个数据）之间的交互。所以有两个选择，一个是数组，那么另外一个STL容器的vector（vector容器比较常用，相当于数组的2.0版本）

考虑到下面两个原因，我选择vector容器：

1. 在algorithm中本身就有差集、交集、并集和对称差运算的标准函数。它们的用法如下（看不懂的，看下面文章链接，里面有迭代器、vector容器、algorithm的介绍）：
2. vector容器可以进行自我检测，empty之类都有，可以非常方便的运算减少
   当然，在交集、并集、差集、对称差运算这三个学校所谓必须要掌握，实际没个der的程序中，我也会用数组的方法，进行解释。

这是STL的介绍补充以及vector容器的用法：

1. CSDN博主禾夕的《STL vector的内部实现原理及基本用法》
2. CSDN博主boke_fengwei的《c+±–vector的使用》
3. CSDN博主yyce的《面向对象程序设计(C++) 示例程序——集合类》
4. CSDN博主 HUST_Miao的《C++中STL用法超详细总结》

3. 交集、并集、差集、对称差运算

有两种方法进行实现：一种是用到了algorithm函数库里面的函数，一种是直接头铁来弄。

3.1 运用到了algorithm函数库里面的函数

其实我这个程序，已经用到了algorithm函数库里面的函数，下面对着来讲一下：

UFSets UFSets::unionSet(const UFSets& anotherSets)
{
	UFSets result;
	set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
		inserter(result.data,result.data.begin()));
	return result;
}

UFSets UFSets::intersectSet(const UFSets& anotherSets)
{
	UFSets result;
	set_intersection(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
	return result;
}

UFSets UFSets::differenceSet(const UFSets& anotherSets)
{
	UFSets result;
	set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
	return result;
}

UFSets UFSets::symDif(const UFSets& anotherSets)
{
	UFSets result;
	set_symmetric_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
	return result;
}

那么好，对其中起主要作用的四个函数进行分析

//并集
set_union(data.begin(),data.end(),anotherSets.data.begin(),anotherSets.data.end(),
		inserter(result.data,result.data.begin()));
		
//交集
set_intersection(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
//差集
set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));

//对称差运算
set_symmetric_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));

这四个函数的注意事项以及调用方式都是一样，那么以std::set_difference为例，先说函数的调用方式，再说注意事项。

调用方式：
template<class InputIterator1,class InputIterator2,class OutputIterator>
OutputIterator set_difference(InputIterator1 first1,InputIterator1 last1,InputIterator2 first2,InputIterator2 last2,OutputIterator result)

InputIterator = 输入数组的迭代器        OutputIterator = 输出迭代器

示例：
UFSets UFSets::differenceSet(const UFSets& anotherSets)
{
	UFSets result;
	set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(), 
		inserter(result.data, result.data.begin()));
	return result;
}

InputIterator输入数组迭代器，直接像我这样用，这个比较明白

在调用方式这里，OutputIterator可能有点蒙，我这里推荐用inserter：

inserter(container,pos)：返回通用插入型迭代器，内部会调用容器container的insert(pos)方法将数据插入到pos位置。

用法通俗一点：

inserter(你现在用的函数，你要插入的位置)

你可以用ostream但是比较复杂一点，按着例子来吧：

set_difference(data.begin(), data.end(), anotherSets.data.begin(), anotherSets.data.end(),ostream_iterator<int>(cout," "));

set_differene虽然头上带着一个set，而是一个通用函数，STL容器（除了个别容器）有手就行，但是有个条件，传递的容器必须是排序的。因此，我在addElement函数那里加了一个sort把他搞有序了：

//vector语法
void UFSets::addElement(int element[], int length)
{
	for (int i = 0; i < length; i++)
		add(element[i]);                 //一个一个往里面添加

    sort(data.begin(),data.end());
}

四个函数非常具体的分析包括底层实现看这里：

1. CSDN博主Sim0Hayha的《【C++】关于 std::set_intersection( ) 函数用法》
2. CSDN博主清远qingyuan的《C++集合操作之集合差集：std::set_difference》
3. CSDN博主清远qingyuan的《C++集合操作之集合并集：std::set_union》
4. CSDN博主星辰浩宇的《关于C++中使用set_union、set_intersection、set_difference，set_symmetric_difference、merge的总结》

3.2 直接用数组

篇幅有限，看这里：CSDN博主tx何家科03的《输入两个集合求出它们的交集，并集，相对差与相对补集并判断他们是否相等》

4. 参考资料

1. CSDN博主Sim0Hayha的《【C++】关于 std::set_intersection( ) 函数用法》
2. CSDN博主禾夕的《STL vector的内部实现原理及基本用法》
3. CSDN博主boke_fengwei的《c+±–vector的使用》
4. CSDN博主yyce的《面向对象程序设计(C++) 示例程序——集合类》
5. CSDN博主 HUST_Miao的《C++中STL用法超详细总结》
6. CSDN博主清远qingyuan的《C++集合操作之集合差集：std::set_difference》

交集

// set_intersection example
#include <iostream>     // cout
#include <algorithm>    // set_intersection, sort
#include <vector>       // vector
using namespace std;
int main () {
    int first[] = {5,10,15,20,25};
    int second[] = {50,40,30,20,10};
    vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    vector<int>::iterator it;

    sort (first,first+5);     //  5 10 15 20 25
    sort (second,second+5);   // 10 20 30 40 50

    it=set_intersection (first, first+5, second, second+5, v.begin());
                                               // 10 20 0  0  0  0  0  0  0  0
    v.resize(it-v.begin());                      // 10 20

    cout << "The intersection has " << (v.size()) << " elements:\n";
    for (it=v.begin(); it!=v.end(); ++it)
        cout << ' ' << *it;
        cout << '\n';

  return 0;
}/*The intersection has 2 elements:
 10 20
*/

并集

// set_union example
#include <iostream>     // cout
#include <algorithm>    // set_union, sort
#include <vector>       // vector
using namespace std;
int main () {
    int first[] = {5,10,15,20,25};
    int second[] = {50,40,30,20,10};
    vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    vector<int>::iterator it;

    //要用交集函数必须先排序
    sort (first,first+5);     //  5 10 15 20 25
    sort (second,second+5);   // 10 20 30 40 50

    it=set_union (first, first+5, second, second+5, v.begin());
                                               // 5 10 15 20 25 30 40 50  0  0
    v.resize(it-v.begin());                      // 5 10 15 20 25 30 40 50

    cout << "The union has " << (v.size()) << " elements:\n";
    for (it=v.begin(); it!=v.end(); ++it)
        cout << ' ' << *it;
        cout << '\n';

  return 0;
}
/*The union has 8 elements:
 5 10 15 20 25 30 40 50
*/

差集

// set_difference example
#include <iostream>     // cout
#include <algorithm>    // set_difference, sort
#include <vector>       // vector
using namespace std;
int main () {
    int first[] = {5,10,15,20,25};
    int second[] = {50,40,30,20,10};
    vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    vector<int>::iterator it;

    sort (first,first+5);     //  5 10 15 20 25
    sort (second,second+5);   // 10 20 30 40 50

    it=set_difference (first, first+5, second, second+5, v.begin());
                                               //  5 15 25  0  0  0  0  0  0  0
    v.resize(it-v.begin());                      //  5 15 25

    cout << "The difference has " << (v.size()) << " elements:\n";
    for (it=v.begin(); it!=v.end(); ++it)
        cout << ' ' << *it;
        cout << '\n';

    return 0;
}
/*The difference has 3 elements:
 5 15 25
*/

对称差

// set_symmetric_difference example
#include <iostream>     // cout
#include <algorithm>    // set_symmetric_difference, std::sort
#include <vector>       // vector
using namespace std;
int main () {
    int first[] = {5,10,15,20,25};
    int second[] = {50,40,30,20,10};
    vector<int> v(10);                      // 0  0  0  0  0  0  0  0  0  0
    vector<int>::iterator it;

    sort (first,first+5);     //  5 10 15 20 25
    sort (second,second+5);   // 10 20 30 40 50

    it=set_symmetric_difference (first, first+5, second, second+5, v.begin());
                                               //  5 15 25 30 40 50  0  0  0  0
    v.resize(it-v.begin());                      //  5 15 25 30 40 50

    cout << "The symmetric difference has " << (v.size()) << " elements:\n";
    for (it=v.begin(); it!=v.end(); ++it)
        cout << ' ' << *it;
        cout << '\n';

  return 0;
 
}
/*The symmetric difference has 6 elements:
 5 15 25 30 40 50*/