1

首先，让我感谢您在过去几个小时内收到的所有帮助。我一直在努力解决这个问题，如何将原始指针转换为唯一指针并让自己陷入很多错误。然而，在这个社区的帮助下，我很庆幸我的程序最终编译时完全没有错误。但我想我还没到那里。我觉得我离终点线只有一分钟的路程，所以我不会放弃，直到我能解决它。我的程序一运行就崩溃，它说堆栈溢出并抛出异常。我想这一定是我在构造函数中声明和初始化唯一指针作为类成员的方式根本不正确，因此它从调用构造函数的那一刻起就崩溃了。有人能告诉我我应该怎么做才能解决这个错误吗？谢谢。

这是我的主要 cpp 文件：

#include"ContactList.h"
#include<memory>

using namespace std;

int main()
{
    //ContactList* cl1 = new ContactList();

    unique_ptr<ContactList> cl1(new ContactList());
    string name;

    while(true)
    {
        cout << "Enter a name or q to quit: " << endl;
        cin >> name;
        if(name == "q")
            break;
        cl1->addToHead(name);
    }

    cl1->PrintList();
    return 0;
}

联系人列表.h 

#pragma once
#include"Contact.h"
#include<memory>

using namespace std;

class ContactList
{
public:
    ContactList();
    void addToHead(const std::string&);
    void PrintList();

private:
    //Contact* head;
    unique_ptr<Contact> head;
    int size;
};

联系人列表.cpp

#include"ContactList.h"
#include<memory>

using namespace std;

ContactList::ContactList(): head(new Contact()), size(0)
{
}

void ContactList::addToHead(const string& name)
{
    //Contact* newOne = new Contact(name);
    unique_ptr<Contact> newOne(new Contact(name));

    if(head == 0)
    {
        head.swap(newOne);
        //head = move(newOne);
    }
    else
    {
        newOne->next.swap(head);
        head.swap(newOne);
        //newOne->next = move(head);
        //head = move(newOne);
    }
    size++;
}

void ContactList::PrintList()
{
    //Contact* tp = head;
    unique_ptr<Contact> tp(new Contact());
    tp.swap(head);
    //tp = move(head);

    while(tp != 0)
    {
        cout << *tp << endl;
        tp.swap(tp->next);
        //tp = move(tp->next);
    }
}

联系人.h

#pragma once
#include<iostream>
#include<string>
#include<memory>

class Contact
{
    friend std::ostream& operator<<(std::ostream& os, const Contact& c);
    friend class ContactList;

public:
    Contact(std::string name = "none");

private:
    std::string name;
    //Contact* next;    
    std::unique_ptr<Contact> next;
};

Contact.cpp
#include"Contact.h"

using namespace std;

Contact::Contact(string n):name(n), next(new Contact())
{
}

ostream& operator<<(ostream& os, const Contact& c)
{
    return os << "Name: " << c.name;
}

这是我得到的错误：

Unhandled exception at 0x77E3DEFE (ntdll.dll) in Practice.exe: 0xC00000FD: Stack overflow (parameters: 0x00000001, 0x002B2F58).
4

2 回答 2

3

您没有发布 的​​代码Contact，但我认为它与您之前的一个问题相同：

Contact::Contact(string n):name(n), next(new Contact())
{
}

如您所见，构造 aContact需要将其next成员设置为 new Contact。
为了构造它 Contact，您Contact将为它的 next成员创建一个新的。
依此类推，以此类推，直至无限及更远。

这是堆栈溢出的原因 -Contact构造永远不会结束。

您可能不想next成为特别为新构造的任何东西Contact，所以请尝试

Contact::Contact(string n):name(n), next(0)
{
}
于 2013-10-07T10:06:54.187 回答
1

你的方法有一个问题：当你迭代一些项目时，你ContactList::PrintList()不需要只是观察它们。 在观察项目时，原始指针就可以了。unique_ptr

一般来说，拥有 原始指针并不好（某些特殊情况除外），但观察 原始指针就可以了。

此外，还要注意，在ContactList默认构造函数中，您不需要分配一个空Contact的 withnew并将其分配给head unique_ptr数据成员：unique_ptr默认构造函数将自动初始化head为 a nullptr。

另请注意，这些ContactList::PrintList()方法应标记const为正确的const-correctness，因为通常打印某些集合的内容不应更改集合中的项目。

最后，ContactList您的函数中的分配main()可以简单地在堆栈上完成：

ContactList cl;

在这种情况下不需要使用unique_ptr（请使用 C++ 编程，而不是 Java 或 C# 样式）。

而且，样式说明：我不喜欢某些方法以大写字母（例如PrintList()）开头，而另一些方法以小写字母开头（例如addToHead()）：选择一种样式，并与之保持一致（在源文件的列表中级别，如果不是在整个项目级别）。

下面有一个单独的源文件测试代码，基于您的代码并应用了一些修复。

我对其进行了编译并使用 VC10 (Visual Studio 2010 SP1) 进行了一些测试；它似乎工作：

C:\Temp>test.exe
Enter a name or q to quit:
Bob
Enter a name or q to quit:
Jane
Enter a name or q to quit:
John
Enter a name or q to quit:
Mary
Enter a name or q to quit:
q
[Contact name: Mary]
[Contact name: John]
[Contact name: Jane]
[Contact name: Bob]

可编译源代码如下：

#include <iostream>
#include <memory>
#include <ostream>
#include <string>
using namespace std;

// "Imaginary" Contact implementation (you didn't provide it)
struct Contact {
    Contact() {}
    explicit Contact(const string& n) : name(n) {}

    string name;    
    unique_ptr<Contact> next;
};

ostream& operator<<(ostream& os, const Contact& c) {
    os << "[Contact name: " << c.name << "]";
    return os;
}

class ContactList {
public:
    ContactList();
    void AddToHead(const string&);
    void PrintList() const;

private:
    unique_ptr<Contact> head;
    int size;
};

ContactList::ContactList()
  : size(0) {
  // No need to initialize head pointer.
  // It will be automatically initialized to nullptr.
}

void ContactList::AddToHead(const string& name) {
    unique_ptr<Contact> newOne(new Contact(name));
    if(head == 0) {
        head.swap(newOne);
    } else {
        newOne->next.swap(head);
        head.swap(newOne);
    }
    size++;
}

void ContactList::PrintList() const {
    const Contact * pContact = head.get();   
    while (pContact != nullptr) {
        cout << *pContact << endl;
        pContact = pContact->next.get();
    }
}

int main() {
    // No need to allocate ContactList using unique_ptr.
    // Stack scoped-based allocation is just fine.
    ContactList cl;    

    while (true) {
        cout << "Enter a name or q to quit: " << endl;
        string name;
        cin >> name;
        if (name == "q")
            break;
        cl.AddToHead(name);
    }

    cl.PrintList();
}
于 2013-10-07T10:25:27.473 回答