blocks|key|3306367|text|如果您正在使用boost，那么防止类被复制的最简单方法是从noncopyable派生您的类|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3306368|#include+<boost/noncopyable.hpp>

class+Foo+:+private+boost::noncopyable
{
}|code-block|syntax|javascript|3306369|它使您的意图比手动将复制构造函数和赋值运算符设置为私有更清晰，并且具有相同的结果。|3306370|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_39_0/libs/utility/utility.htm^0|T|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|C|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

If you are using boost, then the easiest way to prevent a class from being copied is by deriving your class from <a href="http://www.boost.org/doc/libs/1_39_0/libs/utility/utility.htm" rel="noreferrer">noncopyable</a>:

<pre><code>#include &lt;boost/noncopyable.hpp&gt;

class Foo : private boost::noncopyable
{
}
</code></pre>

It makes your intention clearer than manually making the copy constructor and assigment operator private, and it has the same result.

blocks|key|3306394|text|是的，将赋值运算符和复制构造函数设置为私有将阻止您使用standart方法创建对象的任何副本(但如果您确实需要对象的副本，则可以实现，例如，Copy()方法，它将执行深度复制)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3306395|看看boost::noncopyable吧。|offset|length|3306396|更新+(re+to+Tal+Pressman)：|style|BOLD|3306397|3306398|+...you应该意识到这些事情，并注意不要意外地复制了不应该复制的对象。|blockquote|3306399|3306400|3306401|好吧，我假设，任何意外的复制都将使用赋值操作符或复制构造函数来执行。因此，将它们设置为私有实际上是有意义的:如果对象复制是代价高昂的操作，那么复制必须是显式的:其他开发人员可以无意中间接调用copy+op，编译器会通知他，这是被禁止的。|3306402|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_39_0/boost/noncopyable.hpp^0|0|2|I|0|0|0|2|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@$D|11|E|12|1|13]]|A|$]]|$1|F|3|G|5|6|7|14|8|@$D|15|E|16|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|18|8|@]|9|@]|A|$]]|$1|N|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1B|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1C|8|@]|9|@]|A|$]]]|S|$T|$5|U|V|W|A|$X|Y]]]]

Yes, making assignment operator and copy constructor private will prevent you from creating any copy of object using standart methods (but if you really need a copy of an object you can implement, for example, Copy() method, which will perform deep copy).

Take a look on <a href="http://www.boost.org/doc/libs/1_39_0/boost/noncopyable.hpp" rel="noreferrer">boost::noncopyable</a>.

Update (re to Tal Pressman):

<blockquote>
 ...you should be aware of these things and watch out that you don't accidentally copy objects you're not supposed to.
</blockquote>

Well, I presume, that any accidental copy will be performed using either assignment operator or copy constructor. So making them private actually makes sense: if object copying is costly operation, then copying must be explicit: other developer can unintentionally indirectly call copy op and compiler will inform him, that this is forbidden.

blocks|key|335497|text|你在正确的轨道上。如果您不想使用boost，您可以执行以下操作:将复制构造函数和复制赋值运算符设置为私有，并且不实现它们。因此，如果你试图复制一个实例，你会得到一个编译器错误。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|335498|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|$]]

You are on the right track. If you do not want to use boost you can do the following: Make copy constructor and copy assignment operator private and do not implement them. Thus you will get a compiler error if you try to copy an instance.

blocks|key|331926|text|从避免错误的角度来看，你的列表看起来很棒，例如，由于隐式复制对象的共享指针而多次删除相同的内存区域。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|331927|我希望这也是相关的；从“意识到(意外)复制可以被防止的方式”这句话中，你可能会认为这意味着“意识到无意的不必要的复制”。这意味着可能会影响性能的情况。在一个非常简单的示例中，您的编码约定可能意味着您应该更喜欢：|331928|std::string+text1(+"some+text"+);|code-block|syntax|javascript|331929|结束：|331930|std::string+text1+=+"some+text";|331931|第二种情况将导致在调用赋值操作符(一种复制形式)以使用“一些文本”填充text1之前，创建一个临时字符串来保存“一些文本”。显然，这是一个微不足道的例子，良好的实践表明，只要有可能，就应该使用构造函数初始化(第一个例子)。|331932|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|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Your list looks great from the point of view of avoiding errors, e.g. deleting the same area of memory more than once due to shared pointers from implicit copying of objects.

I hope this is also relevant; from the statement "be aware of the ways (accidental) copying can be prevented" you might take this to mean 'be aware of unintentional unnecessary copying'. This would mean circumstances which might affect performance. In a very simple example your coding conventions might mean you should prefer:

<pre><code>std::string text1( "some text" );
</code></pre>

over:

<pre><code>std::string text1 = "some text";
</code></pre>

The second case would result in a temporary string being created to hold "some text" before the assignment operator is invoked (a form of copying) to populate text1 with "some text". Obviously this is a trivial example and good practice would dictate that you should use the constructor initialisation (first example) where ever possible.

In our company's coding standard, we have been told to "be aware of the ways (accidental) copying can be prevented".

I am not really sure what this means, but assume that they mean we should stop classes from being copied if this is not required.

What I can think of is as follows:

<ol>
<li>Make the copy constructor of a class private.</li>
<li>Make the assignment operator (operator=) of a class private.</li>
<li>Make the constructor of a class explicit (to stop classes from being created using incorrect variables).</li>
<li>For all classes that carry out memory allocation and where copying is required, make sure that the copy constructor and assignment operator carry out deep copying rather than shallow copying.</li>
</ol>

Am I on the right track? Is there anything I might have missed out?

prevent accidental object copying in C++

编译器

在我们公司的编码标准中，我们被告知“要知道可以防止(意外)复制的方法”。我不太确定这是什么意思，但假设他们的意思是我们应该停止复制类，如果这不是必需的。我所能想到的是：使类的复制构造函数为私有。使类的赋值运算符(operator=)为私有。使类的构造函数显式(若要停止使用不正确的方法创建类，请确保复制构造函数和赋值运算...

问在C++中防止意外复制对象
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中防止意外复制对象EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在C++中防止意外复制对象
EN