C++ 从对象外部操作链表

我想从对象外部操纵一个链表，但它不像我想象的那样工作

情况就是这样： 我有一个对象，它有一个指向第一个条目的基类指针，用来标记链表的开头

class theObject {
public:
    theObject() : mFirstEntry(0), mLastEntry(0) {}
    ~theObject() {}

    template<class T>
    void addEntry(const std::string &blah, const std::string &blub, const T &hui)
    {
        child<T> *newEntry = new child<T>(blah, blub, hui);

        if (mFirstEntry) {
            mLastEntry->setNext(newEntry);
            mLastEntry = newEntry;
        }
        else {
            mFirstEntry = newEntry;
            mLastEntry = newEntry;
        }
    }

    base * getFirstEntry() const
    {
        return mFirstEntry;
    }

    void printEntrys() const
    {
        base *data = mFirstEntry;
        while(data) {
            std::cout << data->getBlah() << data->getBlub() << std::endl;
            data = data->getNext();
        }
    }

private:
    base *mFirstEntry;
    base *mLastEntry;
};

class base {
public:
    base() : mBlah(""), mBlub(""), mNext(0) {}

    base(const std::string &blah, const std::string &blub) : mBlah(blah), mBlub(blub), mNext(0) {}

    virtual ~base()
    {
        if (mNext) {
            delete mNext;
        }
    }

    void setNext(base *next)
    {
        mNext = next;
    }

    base * getNext() const
    {
        return mNext;
    }

    std::string getBlah() const
    {
        return mBlah;
    }

    std::string getBlub() const
    {
        return mBlub;
    }

protected:
    std::string mBlah;
    std::string mBlub;
    base *mNext;
};

链表的每个条目的类型都是child，它是一个模板并继承基类

template<class T>
class child : public base {
public:
    inline child(const std::string &blah, const std::string &blub, const T &hui, base *next = 0) : mHui(hui), base(blah, blub)
    {
        if(next) {
            mNext = next;
        }
    }

    inline child(const child &r)
    {
        *this = r;
    }

    inline const child & operator = (const child &r)
    {
        if (this == &r) return *this;

        mBlah = r.mBlah;
        mBlub = r.mBlub;
        mNext = r.mNext;
        mHui = r.mHui;

        return *this;
    }

    inline const T getData() const
    {
        return mHui;
    }

protected:
    T mHui;
};

现在我用几个条目填充对象

int main(int argc, char* argv[])
{
    theObject data;
    int a(0), b(1), c(2), d(3);
    const std::string blah("blah"), blub("blub");
    data.addEntry(blah, blub, a);
    data.addEntry(blah, blub, b);
    data.addEntry(blah, blub, c);
    data.addEntry(blah, blub, d);

    std::cout << "Original entries" << std::endl;
    data.printEntrys();

然后我想修改链表

    base *stuff = data.getFirstEntry();
    std::cout << "Changed in stuff list" << std::endl;
    while(stuff) {
        stuff = new child<double>("noBlah", "noBlub", 3.14, stuff->getNext());
        std::cout << stuff->getBlah() << stuff->getBlub() << std::endl;
        stuff = stuff->getNext();
    }

并希望操纵原件…但我只操纵了一份副本

    std::cout << "linked list in data object should now be stuff list" << std::endl;
    data.printEntrys();

    return 0;
}

有人知道为什么它不起作用吗？getFirstEntry返回一个指针，因此我认为应该操作它指向的对象

致以最良好的祝愿，

---

Ben

通过base*stuff=data.getFirstEntry；，可以获得指向第一个元素的指针；，然后用stuff=newchildnoblah，noBlub，3.14，stuff->getNext；将其指向一个新对象；。换句话说，您更改的是指针，而不是指向的值

---

我建议你复习一下关于指针的教程。有人曾经推荐过这段视频：

返回指针并更改本地指针，而不更改指针指向的值！ 你应该做：

*stuff = child<double>("noBlah", "noBlub", 3.14, stuff->getNext());

通过这种方式，您将实际更改指针指向的对象

---

LG ntor

好的，多亏了ntor，我才得以独家发行

这是代码示例，代码从一开始就是有效的

template<class T>
child<T> * getnewEntry(const std::string &a, const std::string &b, const T &c, base *next)
{
    child<T> *nc= new child<T>(a, b, c, next);
    return nc;
}

int main(int argc, char* argv[])
{
    theObject data;
    int a(0), b(1), c(2), d(3);
    const std::string blah("blah"), blub("blub");
    data.addEntry(blah, blub, a);
    data.addEntry(blah, blub, b);
    data.addEntry(blah, blub, c);
    data.addEntry(blah, blub, d);

    base *stuff = data.getFirstEntry();
    stuff = getnewEntry("noBlah", "noBlub", 3.14, stuff->getNext());
    data.mFirstEntry->setNext(0);
    delete data.mFirstEntry;
    data.mFirstEntry = stuff;

    while (stuff->getNext()) {
        base *tmpstuff = getnewEntry("noBlah", "noBlub", 3.14, stuff->getNext()->getNext());
        stuff->getNext()->setNext(0);
        delete stuff->getNext();
        stuff->setNext(tmpstuff);
        stuff = tmpstuff;
    }

    data.mLastEntry = stuff;

    return 0;
}

---

这是在链表的某个位置更改对象并更新链表

您可以从这个示例中删除很多代码，并且仍然演示了问题。这可能是真的，但它与我们的代码非常接近。我认为模板子类可能是一个问题。下一次我试着去拿它，哈哈，这个Binky指针的东西很搞笑：D我觉得很奇怪，我对这样的东西发笑。。。我应该暂停一下编码：-/Hm好的，听起来合乎逻辑。但是后来链接被破坏了，下一个条目是一个坏指针为什么？上一个仍然指向同一个地址，指针是由getNext通过接管旧地址来设置的，不是吗？是的，直到它通过返回离开=运算符*这一切都很好，但这是一个坏指针否，看，我不是在做新的child…，而是child。。。。。因此指针的东西甚至都不会被碰。它将使用在child类中声明的操作符=constchild&是的，这也是我正在做的：base*stuff=data.getFirstEntry；whilestuff{*stuff=getnewEntrynoBlah，noBlub，3.14，stuff->getNext；stuff=stuff->getNext；}

    base *stuff = data.getFirstEntry();
    std::cout << "Changed in stuff list" << std::endl;
    while(stuff) {
        stuff = new child<double>("noBlah", "noBlub", 3.14, stuff->getNext());
        std::cout << stuff->getBlah() << stuff->getBlub() << std::endl;
        stuff = stuff->getNext();
    }