0

我的部分任务是创建一个类，其中包含两个其他类的两个列表并创建“大 4”（构造函数、复制构造函数、运算符 =、析构函数）

这是我所做的：

using namespace std;

class A{...};
class B{...};

class C{
  list<A> a;
  list<B> b;
  public:
    C();
    ~C();
    C(const C& c);
    void operator=(const C& c);
};

C::C(){
  //How to allocate memory for a and b?
}

C::~C(){
  //How to free the memory?
}

C::C(const C& c){
  a=c.a;
  b=c.b;
}

void operator=(const C& c){
  if(&c==this) return;
  // how do I delete a and b?
  a=c.a;
  b=c.b;
}

您能否清除我不理解的内容（如代码中的注释）。如果我没有正确地做任何事情，也给建议？

4

5 回答 5

2

由于您使用的是值（std::list值），因此无事可做。您的构造函数将自动调用std::list构造函数，从而分配所需的任何资源。你的析构函数会调用std::list析构函数，它会释放它获取的资源。

如果您持有指向列表的指针（ie）或指针列表（） - 或两者都有（ ），您将需要一些额外的工作。std::list<A> *a;std::list<A*> a;'std::list<A*> *a;

于 2012-08-31T14:11:51.793 回答
0

//如何为a和b分配内存？

您不需要自己分配内存。因为你在堆栈上分配你的成员变量。当有人实例化您的课程时，它会自动设置。

//如何释放内存？

您不需要自己释放内存。出于同样的原因。当 scop 结束时，您的堆栈变量将自动释放。

// 如何删除 a 和 b？

为什么需要删除 a 和 b ？您正在将数据从其他对象复制到此对象。

于 2012-08-31T14:14:31.147 回答
0

您的变量正在使用自动存储类，它们不需要显式删除。

你的赋值运算符

void operator=(const& C rhs);

不应该返回无效。// 因为这不是内置类型所做的，并且阻止了赋值链接。

例如

int x, y, z;
x = y = z = 0;

看起来你试图用你的评论来实现移动语义

// how do I delete a and b?

您的分配操作员应该复制状态，或者您应该记录它使用非标准行为。例如移动语义、boost::noncopyable 等等。

于 2012-08-31T14:27:05.047 回答
0

如果您使用 std::list，您的 A 或 B 类应该：1 可以在堆栈上分配，堆 2 不能是单例对象。

于 2012-08-31T15:23:58.900 回答
0

随着移动构造器的出现，它现在是六巨头。在这里学习并了解所有细节，您将获得类样板硕士学位。

#include <list>

class A {};
class B {};

class C{
  std::list<A> a;
  std::list<B> b;
  public:
    typedef std::list<A>::size_type size_type;
    explicit C(size_type sz =0);
    virtual ~C();
    C(const C& c);

    // Specialize external swap. Necessary for assignment operator below,
    // and for ADL (argument-dependant lookup).
    friend void swap(C& first, C& second); 

    // Assignment-operator. Note that the argument "other" is passed by value.
    // This is the copy-and-swap idiom (best practice).
    C& operator=(C other);  // NOTE WELL. Passed by value

    // move-constructor - construct-and-swap idiom (best practice)
    C(C&& other);

};

C::C(size_type sz) : a(sz), b(sz) {}

C::~C(){}

C::C(const C& c) :a(c.a), b(c.b){}

void swap(C& first, C& second) {
        // enable ADL (best practice)
        using std::swap; 
        swap(first.a, second.a);
        swap(first.b, second.b);
}

// Assignment-operator. Note that the argument "other" is passed by value.
// This is the copy-and-swap idiom (best practice).
C& C::operator=(C other) {
    swap(*this, other); // Uses specialized swap above.
    return *this;
} 

// move-constructor - construct-and-swap idiom (best practice)
C::C(C&& other): a(0) , b(0) {
    swap(*this, other);
}
于 2012-08-31T16:56:12.877 回答