blocks|key|1097078|text|如果您的类只包含向量/字符串对象作为其数据成员，则不需要实现这些对象。C%2B%2B类(如向量、字符串)有自己的复制函数、重载赋值运算符和析构函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1097079|但是，如果您的类在构造函数中动态分配内存，那么简单的浅拷贝将导致问题。在这种情况下，您必须实现复制ctor、重载赋值运算符和析构函数。|1097080|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

In case your class contains only vector/string objects as its data members, you don't need to implement these. The C++ STL classes (like vector, string) have their own copy ctor, overloaded assignment operator and destructor.

But in case if your class allocates memory dynamically in the constructor then a naive shallow copy will lead to trouble. In that case you'll have to implement copy ctor, overloaded assignment operator and destructor.

blocks|key|1096866|text|通常的经验法则是:如果你需要它们中的一个，那么你需要它们全部。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1096867|然而，并不是所有的类都需要它们。如果您的类没有任何资源(最值得注意的是内存)，那么没有它们也没问题。例如，只有一个string或vector构成的类并不真正需要它们--除非您需要一些特殊的复制行为(默认情况下只复制成员)。|offset|length|style|CODE|1096868|entityMap^0|0|1L|6|1S|6|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]|$D|N|E|O|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|I|$]]

The usual rule of thumb says: if you need one of them, then you need them all.

Not all classes need them, though. If you class holds no resources (memory, most notably), you'll be fine without them. For example, a class with a single <code>string</code> or <code>vector</code> constituent doesn't really need them - unless you need some special copying behavior (the default will just copy over the members).

blocks|key|1096922|text|如果向量是由value声明的，那么默认的复制构造函数将复制它。注意，如果你在向量中存储了指针，在这种情况下，你需要为复制/分配/销毁提供特定的行为，以避免内存泄漏或多次删除。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1096923|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

The default copy constructor will copy the vector if it is declared by value. Beware if you stored pointers in your vector, in such a case, you need to provide specific behaviour for copy/assignement/destruction to avoid memory leaks or multiple delete.

blocks|key|1097194|text|不会，但是有很多原因让你不允许编译器自动生成这些函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1097195|根据我的经验，最好是自己定义它们，并养成在更改类时确保它们得到维护的习惯。首先，您可能希望在调用特定的ctor或dtor时设置断点。同样，不定义它们可能会导致代码膨胀，因为编译器将生成对成员ctor和dtor的内联调用(Scott+Meyer有一节介绍这一点)。|1097196|此外，有时您还希望不允许使用默认的复制函数和分配。例如，我有一个应用程序，它存储和操作非常大的数据块。我们通常有一个等同于包含数百万个3D点的STL向量，如果我们允许这些容器被复制构造，那将是一场灾难。因此，ctor和赋值操作符被声明为私有的，并且没有定义。这样，如果有人写下|1097197|class+myClass+{
++void+doSomething(const+bigDataContainer+data);+//+not+should+be+passed+by+reference
}|code-block|syntax|javascript|1097198|然后他们会得到一个编译器错误。我们的经验是，显式的that+()或clone()方法不容易出错。|1097199|因此，总而言之，有很多理由要避免自动生成的编译器函数。|1097200|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|T|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

No but there are a number of reasons why you shouldn't allow the compiler to auto generate these functions.

In my experience it is always best to define them yourself, and to get into the habit of making sure that they are maintained when you change the class. Firstly you may well want to put a breakpoint on when a particular ctor or dtor is called. Also not defining them can result in code bloat as the compiler will generate inline calls to member ctor and dtor (Scott Meyers has a section on this). 

Also you sometimes want to disallow the default copy ctors and assignments. For example I have an application that stores and manipulates very large blocks of data. We routinely have the equivalent of an STL vector holding millions of 3D points and it would be a disaster if we allowed those containers to be copy constructed. So the ctor and assignment operators are declared private and not defined. That way if anyone writes

<pre><code>class myClass {
 void doSomething(const bigDataContainer data); // not should be passed by reference
}
</code></pre>

then they'll get a compiler error. Our experience is that an explicit become() or clone() method is far less error prone.

So all in all there are many reason to avoid auto generated compiler functions.

blocks|key|1097005|text|这些容器将需要一个“可复制构造的”元素，如果你不提供复制构造函数，它将通过从你的类成员中推断来调用你的类的默认复制构造函数(浅复制)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1097006|关于默认复制构造函数的简单解释在这里：http://www.fredosaurus.com/notes-cpp/oop-condestructors/copyconstructors.html|offset|length|1097007|对于析构函数也是如此，容器需要访问你的析构函数或默认的类析构函数，如果你没有提供一个(即.如果你声明你的析构函数是私有的，它将不起作用)|1097008|entityMap|0|LINK|mutability|MUTABLE|url|http://www.fredosaurus.com/notes-cpp/oop-condestructors/copyconstructors.html^0|0|J|25|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

those container will need a "copy constructible" element, and if you don't supply the copy constructor, it will call default copy constructor of your class by deducing from your class members (shallow copy).

easy explanation about default copy constructor is here : <a href="http://www.fredosaurus.com/notes-cpp/oop-condestructors/copyconstructors.html" rel="nofollow noreferrer">http://www.fredosaurus.com/notes-cpp/oop-condestructors/copyconstructors.html</a> 

it is so with destructor, the container need to have access to your destructor or your default class destructor if you don't provides one (ie. it will not work if you declare your destructor as private )

blocks|key|1097112|text|当你有一个需要深度拷贝的类时，你应该定义它们。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1097113|具体地说，任何包含指针或引用的类都应该包含它们，例如：|1097114|class+foo+{
private:
++++int+a,b;
++++bar+*c;
}|code-block|syntax|javascript|1097115|主观上，我会说总是定义它们，因为编译器生成的版本提供的默认行为可能不是您期望/想要的。|1097116|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|N|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|O|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

When ever you have a class that requires deep copies, you should define them.

Specifically, any class which contains pointers or references should contain them such as:

<pre><code>class foo {
private:
 int a,b;
 bar *c;
}
</code></pre>

Subjectively, I would say always define them, as the default behavior provided by the compiler generated version may not be what you expect / want.

blocks|key|1097152|text|不适用于字符串或向量，因为简单的构造函数/析构函数等就可以了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1097153|如果您的类有指向其他数据的指针并需要深度复制，或者如果您的类持有必须释放或必须以特殊方式复制的资源。|1097154|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Not for strings or vectors, since the trivial constructors / destructors etc, will do fine.

If your class has pointers to other data and need deep copies, or if your class holds a resource that has to be deallocated or has to be copied in a special way.

Say I've got a class where the sole data member is something like <code>std::string</code> or <code>std::vector</code>. Do I need to provide a Copy Constructor, Destructor and Assignment Operator?

Under what circumstances must I provide, assignment operator, copy constructor and destructor for my C++ class?

编译器

容器

假设我有一个类，其中唯一的数据成员类似于std::string或std::vector。是否需要提供复制构造函数、析构函数和赋值运算符？

问在什么情况下，我必须为我的C++类提供赋值运算符、复制构造函数和析构函数？
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在什么情况下，我必须为我的C++类提供赋值运算符、复制构造函数和析构函数？EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在什么情况下，我必须为我的C++类提供赋值运算符、复制构造函数和析构函数？
EN