Question

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

感谢编码员。

HEADER文件

                #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

MAIN文件

            #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;
            }

实施文件

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

            IntegerSet::IntegerSet(int size)
            {
                set = new int[size];
                set_size = size;                    
                for (int i = 0; i < size; i++)
                    set[i] = 0;
            }

            IntegerSet::~IntegerSet()
            {
                delete [] set;
            }

            void IntegerSet::insertElement(int k) const
            {
                (*this).set[k] = 1;
            }

            void IntegerSet::printSet(int size) const
            {
                int temp = 0;
                for (int i = 0; i < size; i++)
                {
                    if (set[i] == 1)
                    {
                        std::cout << i << " ";
                        temp++;
                    }
                }
                if (temp == 0)
                    std::cout << "----";
             }


            IntegerSet * IntegerSet::unionOfSets(const IntegerSet & set2) //make this return the union of 2 sets; THIS and the passed ARG reference; return address
            {


                   return this;
            }

Answer 1

随机早晨咆哮

您尝试创建的内容多为std::bitset而非std::set。一组通常是"a collection of well defined distinct objects"（Cantor的定义有点复杂，但我们坚持这一点）。因此，一个集合可能包含几个成对不相关的对象。

现在，在说完之后，请看std::bitset。请注意，其大小由模板参数N确定。 std::bitset::set几乎等同于您的IntegerSet::insertElement，但它会抛出std::out_of_range。我建议您检查索引的有效位置：

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

然而，std::bitset不支持工会，所以是时候解决你的问题。

IntegerSet :: unionofSets

看看那些线。

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

第一行用一个指针初始化obj3，该指针包含一个内部集合大小为11的新创建的IntegerSet的内存。在下一行中，抛出指针。所以你丢掉资源并造成内存泄漏。

如果您要创建一个 new IntegerSet，那么您的解决方案将非常简单：

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;
}

但是你的实现改变了调用它的对象，所以它不是const而是有点不同：

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;
}

这应该足够了。请记住，您不得使用new IntegerSet来创建联合：

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::set<int>是否足够，因为您可以使用<algorithm>中的std::set_union。

修改

提供unionOfSets成员函数，该函数创建第三个IntegerSet，它是两个现有IntegerSet实例的并集（因此，此函数创建的第三个集合包含用于创建它的两个集合中的所有成员 - 因此，如果其中一个或两个执行联合的集合中有一个元素，第三个集合将具有该元素）

在这种情况下，忘记IntegerSet * IntegerSet::unionOfSets(const IntegerSet&)并使用IntegerSet IntegerSet::unionOfSets(const IntegerSet&) const（带有返回对象的第一个变体而不是返回的指针）。

EDIT2

由于您没有遵循三条规则，返回的IntegerSet中的内存将无效。您可能必须实现复制构造函数/赋值运算符才能解决此问题，或者提供具有动态存储持续时间（new）的新对象。为此，您只需稍微调整一下方法：

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;
}

Answer 2

使用标准设施...

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

联盟2套;返回简单对象 - C ++

2 个答案:

随机早晨咆哮

IntegerSet :: unionofSets

修改

EDIT2