题目
通过使用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
6067
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
