Question

所以，我正在尝试使用initializer_list初始化LinkedList类。

template<typename T>
SortedList<T>::SortedList(initializer_list<T> e){
    head_= new Node<T>(*e.begin());

    long intcheck = 0;
    T old;

    for (auto x : e){
        if(intcheck > 0){
            Node<T>* curr = new Node<T>(old);
            if(head_ == curr){
                head_->next_ = new Node<T>(x);
            }
            curr->next_ = new Node<T>(x);
        }

        old = x;
        intcheck = 1;
    }


}

我在尝试打印头_-＆gt; next_时遇到了段错误（我的打印功能没有问题）

Answer 1

我假设您确实希望对SortedList进行排序。如果是这样，这将实现这一目标。如果initializer_list为空，它会提前退出，但仍然会使对象处于合理状态。

template<typename T>
SortedList<T>::SortedList(initializer_list<T> e) : head_{nullptr} {
    if (e.size() == 0)
        return;
    auto it = e.begin();
    for (head_ = new Node<T>(*it); it != e.end(); ++it) {
        Node<T> *n = new Node<T>(*it);
        Node<T> *curr;
        for (curr = head_; curr->next_ && curr->next_->data_ < *it; curr = curr->next_) 
            continue;
        if (*it < curr->data_) {
            n->next_ = curr;
            head_ = n;
        } else {
            n->next_ = curr->next_;
            curr->next_ = n;
        }
    }
}

为了完整性，这里是我用来测试的析构函数：

template<typename T>
SortedList<T>::~SortedList() {
    while (head_->next_) {
        Node<T> *t = head_->next_;
        head_->next_ = t->next_;
        delete t;
    }
    delete head_;    
}

Answer 2

你的代码说head _-＆gt; next_将永远是它的默认值（我们看不到Node构造函数所以我不能说那是什么）。

for (auto x : e){
    if(intcheck > 0){
        Node<T>* curr = new Node<T>(old);
        if(head_ == curr){
            head_->next_ = new Node<T>(x);
        }

可以通过这种方式将初始化列表发送到for循环中。如果它是空的，你将立即退出循环。

然而，您的curr指针就在那里分配，而您的head_指针已在上面分配。因此，它们永远不会相等，因为您正在比较在同一函数中分配的两个指针。

LinkedList使用initializer_list

2 个答案: