集合（运算符重载）

时间限制: 1 Sec 内存限制: 128 MB

题目描述

集合是由一个或多个确定的元素所构成的整体。集合的运算有并、交、相对补等。
集合A和集合B的交集：由属于A且属于B的相同元素组成的集合。
集合A和集合B的并集：由所有属于集合A或属于集合B的元素所组成的集合。
集合B关于集合A的相对补集，记做A-B：由属于A而不属于B的元素组成的集合。
假设集合A={10，20，30}，集合B={1，10，50，8}。则A与B的并是{10，20，30,1,50,8}，A与B的交是{10}，B关于A的相对补集是{20,30}。
定义整数集合类CSet，属性包括：集合中的元素个数n，整型指针data存储集合中的元素。
方法有：重载输出，按样例格式输出集合中的元素。
重载+运算符，求集合A和集合B的并集，并返回结果集合。
重载-运算符，求集合B关于集合A的相对补集，并返回结果集合。
重载*运算符，求集合A和集合B的交集，并返回结果集合。
主函数输入集合A、B的数据，计算集合的并、交、相对补。
可根据题目，为CSet类添加需要的成员函数。

输入

测试次数
每组测试数据两行，格式如下：
第一行：集合A的元素个数和元素
第二行：集合B的元素个数和元素

输出

每组测试数据输出如下：
第一行：集合A
第二行：集合B
第三行：A和B的并
第四行：A和B的交
第五行：B关于A的相对补集 与 A关于B的相对补集的并，即(A-B)+(B-A)
每组测试数据间以空行分隔。

样例输入

2
3 10 20 30
4 10 1 2 3
5 100 2 3 4 -10
6 -34 12 2 4 90 100

样例输出

A:10 20 30
B:10 1 2 3
A+B:10 20 30 1 2 3
A*B:10
(A-B)+(B-A):20 30 1 2 3

A:100 2 3 4 -10
B:-34 12 2 4 90 100
A+B:100 2 3 4 -10 -34 12 90
A*B:100 2 4
(A-B)+(B-A):3 -10 -34 12 90

提示

解决方案

这个其实没啥好说的…思路清晰就可以了。并集运算可以先生成一个临时数组，加入集合A的元素，然后再加入集合B中不和已加入元素重复的元素。相对补集可以先生成、添加，然后再删除重复的。
主要问题可能在于有同学试图返回一个指向了即将失效的临时变量的指针。

You are returning a temporary object, but because you return it by value, the copy is created. If you return pointer or reference to temporary object, that would be a mistake.

If you change the return type to const char * and return ss.str().c_str() you would return pointer to some buffer of temporary std::string returned by ss.str() and that would be bad.

C++ returning temporary objects confusion – Stack Overflow

#include <iostream>
#include <vector>
#include <algorithm>

class Set {
public:
    explicit Set(std::vector<int> data) : data(std::move(data)) {}

    Set operator+(const Set &rhs) const {
        std::vector<int> tmp;
        tmp.assign(this->data.begin(), this->data.end());
        for (auto i : rhs.data) {
            if (std::find(tmp.begin(), tmp.end(), i) == tmp.end()) {
                tmp.push_back(i);
            }
        }
        return Set(tmp);
    }

    Set operator-(const Set &rhs) const {
        std::vector<int> tmp;
        tmp.assign(this->data.begin(), this->data.end());
        for (auto i : rhs.data) {
            auto it = std::find(tmp.begin(), tmp.end(), i);
            if (it != tmp.end()) {
                tmp.erase(it);
            }
        }
        return Set(tmp);
    }

    Set operator*(const Set &rhs) const {
        std::vector<int> tmp;
        for (auto i1 : this->data) {
            for (auto i2 : rhs.data) {
                if (i1 == i2) {
                    tmp.push_back(i1);
                }
            }
        }
        return Set(tmp);
    }

    friend std::ostream &operator<<(std::ostream &os, const Set &rhs) {
        std::cout << rhs.data.front();
        for (int i = 1; i < rhs.data.size(); ++i) {
            os << ' ' << rhs.data[i];
        }
        return os;
    }

private:
    std::vector<int> data;
};

int main() {
    int T;
    std::cin >> T;

    while (T--) {
        int sizeA, sizeB;
        std::cin >> sizeA;
        std::vector<int> vectorA(sizeA);
        for (auto &i : vectorA) {
            std::cin >> i;
        }
        std::cin >> sizeB;
        std::vector<int> vectorB(sizeB);
        for (auto &i : vectorB) {
            std::cin >> i;
        }
        Set setA(vectorA), setB(vectorB);
        std::cout << "A:" << setA << std::endl
                  << "B:" << setB << std::endl
                  << "A+B:" << setA + setB << std::endl
                  << "A*B:" << setA * setB << std::endl
                  << "(A-B)+(B-A):" << (setA - setB) + (setB - setA) << std::endl;
        std::cout << std::endl;
    }

    return 0;
}