1802 Set Operations (eden)

You need finish function.

Require knowledge:

1. Know set operations：include

   • intersection(交集）

   • union（并集）

   • the complement of B with respect to A（B对A的补）

   • symmetric difference（对称差）

2. copy constructor

3. overload

Require task:

1. Define a copy constructor

2. Overload four operators

Hint

SourceAuthor： 李天培

Provided Codes

main.cpp

//
//  main.cpp
//  C++
//
//  Created by 李天培 on 16/2/25.
//  Copyright © 2016年 lee. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include "Set.hpp"

void display(int* members, int size) {
    std::sort(members, members + size);
    std::cout << "{";
    for (int i = 0; i < size; i++) {
        if (i < size - 1) std::cout << members[i] << ", ";
        else std::cout << members[i];
    }
    std::cout << "}" << std::endl;
}

int main(int argc, const char * argv[]) {
    int test[6];
    std::cin >> test[0]
    >> test[1]
    >> test[2]
    >> test[3]
    >> test[4]
    >> test[5];
    // Constructor 1
    Set s1 = Set();
    display(s1.getMembers(), s1.getSize());
    std::cout << "is empty set: " << s1.isEmptySet() << std::endl;
    // append func
    std::cout << "append: " << s1.append(test[0]) << std::endl;
    std::cout << "append: " << s1.append(test[4]) << std::endl;
    display(s1.getMembers(), s1.getSize());
    // repeat append
    std::cout << "append: " << s1.append(test[0]) << std::endl;
    display(s1.getMembers(), s1.getSize());

    std::cout << "is empty set: " << s1.isEmptySet() << std::endl;

    // Constructor 2
    Set s2 = Set(test, 5);
    // remove func
    std::cout << "remove: " << s2.remove(test[0]) << std::endl;
    display(s2.getMembers(), s2.getSize());
    // repeat append
    std::cout << "remove: " << s2.remove(test[0]) << std::endl;
    display(s2.getMembers(), s2.getSize());

    std::cout << test[5] << " is in set: " << s2.isInSet(test[5]) << std::endl;
    std::cout << test[2] << " is in set: " << s2.isInSet(test[2]) << std::endl;

    display(s1.getMembers(), s1.getSize());
    display(s2.getMembers(), s2.getSize());

    Set s3;
    s3 = s1 & s2;
    display(s3.getMembers(), s3.getSize());

    s3 = s1 | s2;
    display(s3.getMembers(), s3.getSize());

    s3 = s1 - s2;
    display(s3.getMembers(), s3.getSize());

    s3 = s2 - s1;
    display(s3.getMembers(), s3.getSize());

    s3 = s1 + s2;
    display(s3.getMembers(), s3.getSize());

    return 0;
}

Set.hpp

//
//  Set.hpp
//  C++
//
//  Created by 李天培 on 16/2/25.
//  Copyright © 2016年 lee. All rights reserved.
//

#ifndef Set_hpp
#define Set_hpp

#include <stdio.h>

#define MAX_MEMBERS 100

class Set {
private:
    int members[MAX_MEMBERS];
    int size;
public:
    // Create an empty set.
    Set();
    // Create an set with some element.
    Set(int* m, int s);
    // Copy Constructor
    Set(Set const &s);

    // append a element to set.
    // If element in the set, return false.
    // Or insert in set and return true.
    bool append(int e);

    // remove a element by its value from set.
    // If element in the set, then remove it and return true.
    // Or return false.
    bool remove(int e);

    // return true if the set is empty, or return false.
    bool isEmptySet();

    // return true if the element e is in the set, or return false.
    bool isInSet(int e);

    // & is intersection of two set
    Set operator&(const Set &s);
    // | is union of two set
    Set operator|(const Set &s);
    // A - B is the complement of B with respect to A
    Set operator-(const Set &s);
    // A + B is their symmetric difference. A + B = (A - B) | (B - A)
    Set operator+(const Set &s);

    // return set.
    int* getMembers();

    // return size of set.
    int getSize();

};

#endif /* Set_hpp */

Submission

Set.cpp

 #include "Set.hpp"

// Create an empty set.
Set::Set(){
    size=0;
}
// Create an set with some element.
Set::Set(int* m, int s){
    size=0;
    for(int i=0;i<s;i++)
        append(m[i]);
}
// Copy Constructor
Set::Set(Set const &s){
    size=s.size;
    for(int i=0;i<size;i++)
        members[i]=s.members[i];
}

// append a element to set.
// If element in the set, return false.
// Or insert in set and return true.
bool Set::append(int e){
    if(isInSet(e))
        return false;
    members[size++]=e;
    return true;
}

// remove a element by its value from set.
// If element in the set, then remove it and return true.
// Or return false.
bool Set::remove(int e){
    int i,flag=0;
    for(i=0;i<size;i++)
        if(members[i]==e){
            flag=1;
            break;
        }
    for(int j=i;j<size-1;j++)
        members[j]=members[j+1];
    if(flag){
        size--;
        return true;
    }
    return false;
}

// return true if the set is empty, or return false.
bool Set::isEmptySet(){
    if(size)
        return false;
    return true;
}

// return true if the element e is in the set, or return false.
bool Set::isInSet(int e){
    for(int i=0;i<size;i++)
        if(e==members[i])
            return true;
    return false;
}

// & is intersection of two set
Set Set::operator&(const Set &s){
    Set temp;
    for(int i=0;i<s.size;i++)
        if(isInSet(s.members[i]))
            temp.append(s.members[i]);

    return temp;
}
// | is union of two set
Set Set::operator|(const Set &s){
    Set temp(s);
    for(int i=0;i<size;i++)
        if(!temp.isInSet(members[i]))
            temp.append(members[i]);
    return temp;
}
// A - B is the complement of B with respect to A
Set Set::operator-(const Set &s){
    Set temp(*this);
    for(int i=0;i<s.size;i++)
        if(temp.isInSet(s.members[i]))
            temp.remove(s.members[i]);
    return temp;
}
// A + B is their symmetric difference. A + B = (A - B) | (B - A)
Set Set::operator+(const Set &s){
    Set temp(*this);
    for(int i=0;i<s.size;i++){
        if(temp.isInSet(s.members[i]))
            temp.remove(s.members[i]);
        else
            temp.append(s.members[i]);
    }   
    return temp;
}

// return set.
int* Set::getMembers(){
    return members;
}

// return size of set.
int Set::getSize(){
    return size;
}

Standard Answer

Set.cpp

//
//  Set.cpp
//  C++
//
//  Created by 李天培 on 16/2/25.
//  Copyright © 2016年 lee. All rights reserved.
//

#include "Set.hpp"

Set::Set() {
    size = 0;
}

Set::Set(int* m, int s) {
    size = 0;
    for (int i = 0; i < s ; i++) {
        if (!isInSet(m[i])) {
            members[size++] = m[i];
        }
        if (size == MAX_MEMBERS) break;
    }
}

Set::Set(Set const &s) {
    size = s.size;
    for (int i = 0; i < size; i++) {
        members[i] = s.members[i];
    }
}

bool Set::append(int element) {
    if (size < MAX_MEMBERS && !isInSet(element)) {
        members[size] = element;
        size++;
        return true;
    } else {
        return false;
    }
}

bool Set::remove(int element) {
    for (int i = 0; i < size; i++) {
        if (members[i] == element) {
            members[i] = members[--size];
            return true;
        }
    }
    return false;
}

bool Set::isEmptySet() {
    return (size == 0) ? true : false;
}

int* Set::getMembers() {
    return members;
}

int Set::getSize() {
    return size;
}

bool Set::isInSet(int element) {
    for (int i = 0; i < size; i++) {
        if (members[i] == element) {
            return true;
        }
    }
    return false;
}

Set Set::operator&(const Set &s) {
    Set temp;
    for (int i = 0; i < s.size; i++) {
        if (isInSet(s.members[i])) {
            temp.members[temp.size++] = s.members[i];
        }
    }
    return temp;
}

Set Set::operator|(const Set &s) {
    Set temp(*this);
    for (int i = 0; i < s.size; i++) {
        temp.append(s.members[i]);
    }
    return temp;
}

Set Set::operator-(const Set &s) {
    Set temp(s);
    Set temp2(*this);
    for (int i = 0; i < temp2.size; i++) {
        if (temp.isInSet(temp2.members[i])) {
            temp2.remove(temp2.members[i]);
        }
    }
    return temp2;
}

Set Set::operator+(const Set &s) {
    Set temp(s);
    return (*this - temp) | (temp - *this);
}