C++ 2组的并集；返回简单对象-C++；

实现以下目标的最佳方式是什么？我试图找到两个集合的并集。我正在创建两个对象（一个称为set1，另一个称为set2）。我的目标是创建第三个对象，它是两个对象的并集，而不必使用复制构造函数。必须使用动态内存分配、指针和/或引用。感谢所有能解决这一困境的人，任何指点（并非双关语）都会有所帮助

谢谢编码人员

头文件

                #ifndef INTEGERSET_H_
                #define INTEGERSET_H_

                class IntegerSet
                {
                private:
                    int * set;
                    int set_size;
                public:
                    IntegerSet(int size);    //default constructor
                    ~IntegerSet();           //destructor
                    IntegerSet * unionOfSets(const IntegerSet & set2);      
                    void insertElement(int k) const;
                    void printSet(int size) const;
                };
                #endif

主文件

            #include <iostream>
            #include "integerset.h"

            using std::cout;
            using std::endl;

            int main()
            {
                IntegerSet set1(11);

                //testing below
                set1.insertElement(3);
                set1.insertElement(4);
                set1.insertElement(6);
                set1.insertElement(10);

                set1.printSet(11);
                cout << endl;

                IntegerSet set2(8);
                set2.insertElement(3);
                set2.insertElement(6);
                set2.insertElement(7);

                set2.printSet(11);
                cout << endl;



                IntegerSet * obj3 = new IntegerSet(11);
                obj3 =  set1.unionOfSets(set2);                    
                obj3->printSet(11);

            //  system("pause");
                return 0;
            }

#包括
#包括“integerset.h”
使用std：：cout；
使用std：：endl；
int main（）
{
整数集set1（11）；
//测试如下
set1.插入元件（3）；
set1.插入元件（4）；
set1.插入元件（6）；
set1.插入元件（10）；
set1.打印集（11）；
不能在早晨胡言乱语
您尝试创建的是
std:：bitset
而不是
std:：set
。一个集合通常是（Cantor的定义稍微复杂一点，但让我们坚持这一点）。因此，一个集合可以包含多个成对的不相关对象

现在，在讲完这一点之后，看一看。注意，它的大小是由模板参数固定的
N
std:：bitset:：set
几乎等同于您的
IntegerSet:：insertElement
，只是它抛出
std:：out\u of_range
。我建议您检查索引的有效位置：

void IntegerSet::insertElement(int k) const
{
    if( k < 0 || k >= set_size)
        throw std::out_of_range; 
    else
        this->set[k] = 1;
}

第一行使用一个指针初始化
obj3
，该指针包含一个新创建的内部集大小为11的整数集的内存。在下一行中，您将丢弃该指针。因此，您正在丢弃资源并创建内存泄漏

如果要创建一个新的整数集，您的解决方案将非常简单：

IntegerSet IntegerSet::unionOfSets(const IntegerSet & set2) const
{
    IntegerSet tmp (std::max(set2.set_size, this->set_size));

    for(int i = 0; i < set_size; ++i)
        tmp.set[i] = this->set[i];

    for(int i = 0; i < set2.set_size; ++i)
        tmp.set[i] |= set2.set[i];

    return tmp;
}

这就足够了。请记住，不能使用
新整数集
来创建并集：

IntegerSet * obj3 = new IntegerSet(11); // new memory, lets say obj3 = 0x500a
obj3 = set1.unionOfSets(set2); // new memory gone forever

if(obj3 == &set1)
    std::cout << "obj3 is a pointer to set1, changes to obj3 will affect set1" << std::endl;

使用标准设备


std:：vector
比手动滚动的数组更好
std:：sort
和
std:：unique
是好的

因此：

std::vector<int> set1;
set1.push_back(1); // ... and others

std::sort(set1.begin(), set1.end());   // sorts
std::unique(set1.begin(), set1.end()); // removes duplicates


// same with set2


std::vector<int> set3(set1);
set3.insert(set3.end(), set2.begin(), set2.end());

std::sort(set1.begin(), set1.end());   // sorts
std::unique(set1.begin(), set1.end()); // removes duplicates

std:：vector set1；
设置1.向后推（1）；/…和其他
std:：sort（set1.begin（），set1.end（））；//排序
std:：unique（set1.begin（），set1.end（））；//删除重复项
//与set2相同
std：：矢量set3（set1）；
set3.insert（set3.end（），set2.begin（），set2.end（））；
std:：sort（set1.begin（），set1.end（））；//排序
std:：unique（set1.begin（），set1.end（））；//删除重复项
为什么我们必须使用动态内存？还要尝试将代码精简到与您的问题相关的程度。同样，使用
（*此）
也没有必要，我将其精简了一点；我保留了所有重要的代码，以便只需复制/粘贴即可运行。基本上，main是分别填充两个对象，对象是动态的（强迫我不要复制构造函数）这种用法是一种实践。@Duknov007实现一个复制构造函数并按值返回。解决这个问题的任何其他方法都会变得非常混乱。这个方法确实很麻烦。我是否遗漏了一些东西，但这是通过在两个对象内循环来比较这两个对象的最佳和/或唯一方法？你不使用标准库的原因是什么？有一个我正在阅读和剖析这篇文章中的集合操作的数量；看起来很流畅而且考虑周全。我会更新。仍在尝试找出您的编辑。我更喜欢返回指针，但让我看看这里。@Duknov007：老实说，默认的复制/移动构造函数
IntegerSet:：IntegerSet（const&IntegerSet）
或
IntegerSet:：IntegerSet（IntegerSet&
将在我的示例中使用。它由编译器定义，并且只复制值。但是，您的指令声明如下：“创建第三个
IntegerSet
”。这表示不应修改原始的
IntegerSet
。这意味着您必须创建一个新对象。您可以为此使用动态分配（
new
），但这不是必需的。只需返回一个新的
IntegerSet
。此行出现编译错误：IntegerSet tmp（std:：max（set2.size，This->size））；IntegerSet只能接受一个参数，它是int。是否包含
？否则只需使用
set2.size>this->size？set2.size:this->size
+1作为标准功能；为了便于学习，尽管我必须找到其他方法。IntegerSet*tmp=new IntegerSet（set2.set\u size>this->set\u size？set2.set\u size:this->set\u size）；你明白那一段吗？我问了上面的作者。
IntegerSet * IntegerSet::unionOfSets(const IntegerSet & set2) // not const!
{
    if(set2.set_size > set_size){
        // the resulting set is bigger, we need new memory
        int * newset = new int[set2.set_size];

        // copy old values
        for(int i = 0; i < this->set_size; ++i)
            newset[i] = this->set[i];

        // replace old size
        this->set_size = set2.set_size;
        delete[] this->set; // remove old data
        this->set = newset; // replace pointer
    }

    for(int i = 0; i < set2.set_size; ++i)
        this->set[i] |= set2.set[i];

    return this;
}

IntegerSet * obj3 = new IntegerSet(11); // new memory, lets say obj3 = 0x500a
obj3 = set1.unionOfSets(set2); // new memory gone forever

if(obj3 == &set1)
    std::cout << "obj3 is a pointer to set1, changes to obj3 will affect set1" << std::endl;

IntegerSet * IntegerSet::unionOfSets(const IntegerSet & set2) const
{
    IntegerSet * tmp  = new IntegerSet( set2.set_size > this->set_size ? set2.set_size : this->set_size);

    for(int i = 0; i < set_size; ++i)
        tmp->set[i] = this->set[i];

    for(int i = 0; i < set2.set_size; ++i)
        tmp->set[i] |= set2.set[i];

    return tmp;
}

std::vector<int> set1;
set1.push_back(1); // ... and others

std::sort(set1.begin(), set1.end());   // sorts
std::unique(set1.begin(), set1.end()); // removes duplicates


// same with set2


std::vector<int> set3(set1);
set3.insert(set3.end(), set2.begin(), set2.end());

std::sort(set1.begin(), set1.end());   // sorts
std::unique(set1.begin(), set1.end()); // removes duplicates