Question

此代码用于查找两个排序列表的交集和并集。从具有所有基本功能的列表类继承的排序列表。主要问题是该函数的返回类型是什么。它是指向列表还是列表本身的指针？我将如何显示该“指针”的内容。

template <typename Object>
class sorted_list : public List<Object>{
    friend sorted_list<Object>*& slUnion( const sorted_list<Object>& list1, const sorted_list<Object> & list2){
        auto i=list1.begin();
        auto j=list2.begin();
        sorted_list<Object> un;
        static sorted_list<Object>* newlist=&un;
        while(i!=list1.end() && j!=list2.end()){
            if(*i<*j){
                un.push_back(*i);
                i++;
            }
            else if(*i>*j){
                un.push_back(*j);
                j++;
            }
            else{ //if equal
                un.push_back(*i);
                i++; j++;
            }
        }
        while(i!=list1.end())
            un.push_back(*i++);
        while(j!=list2.end())
            un.push_back(*j++);
        return newlist;
    }
};

程序运行时，main中的“ un”指向NULL。

int main(){
    sorted_list<int> l1;
    int i=1;
    while(i<10){
        l1.push_back(i++);
    }
    sorted_list<int>l2;
    int j=1;
    while(j<10){
        l2.push_back(j);
        j+=2;
    }
    sorted_list<int> *un = slUnion(l1,l2);
}

Answer 1

您通常应按值返回，即sorted_list<Object>。较新版本的cpp向您保证它们实际上不会复制。

您现在正在做的事情是错误的，因为它具有未定义的行为。您正在使用函数堆栈中的un，并返回指向它的指针。到函数返回un的时间已超出范围，并且内存位置已被重用。只需完全删除newlist指针并返回un。

您似乎也对类，方法和函数感到困惑。照原样，您的方法不必在类内部，或者，因为它似乎不使用类状态，所以如果在类内部，则它可以是静态的。似乎也不必成为朋友。如果您想将其编写为成员函数，它将看起来像这样：

sorted_list<Object>& unionWith(const sorted_list<Object>& rhs) {
  // merge this and rhs w deduplication into temp, then swap temp with this
  ...

  return *this;
}

我认为您可能遇到的问题是，您没有将&un分配给newlist，而是用newlist初始化了&un。初始化仅对函数静态变量执行一次，因此方法的未来迭代仅跳过该行，并且指针指向un的原始版本所在的位置。尝试将作业放在另一行。那应该可以解决您眼前的问题，但是使用静态指针的解决方案仍然非常糟糕，因为所有实例都共享该指针。

两个排序列表的交集和并集（返回类型）

1 个答案: