What is The Rule of Three

Question

What does copying an object mean  What are the copy constructor and the copy assignment operator  When do I need to declare them myself  How can I prevent my objects from being copied

User · Answer

The Rule of Three is a rule of thumb for C++, basically saying

If your class needs any of

a copy constructor,

an assignment operator,

or a destructor,

defined explictly, then it is likely to need all three of them.

The reasons for this is that all three of them are usually used to manage a resource, and if your class manages a resource, it usually needs to manage copying as well as freeing.

If there is no good semantic for copying the resource your class manages, then consider to forbid copying by declaring (not defining) the copy constructor and assignment operator as private.

(Note that the forthcoming new version of the C++ standard (which is C++11) adds move semantics to C++, which will likely change the Rule of Three. However, I know too little about this to write a C++11 section about the Rule of Three.)

User · Answer

What does copying an object mean   There are a few ways you can copy objects--let s talk about the 2 kinds you re most likely referring to--deep copy and shallow copy   Since we re in an object-oriented language  or at least are assuming so   let s say you have a piece of memory allocated   Since it s an OO-language  we can easily refer to chunks of memory we allocate because they are usually primitive variables  ints  chars  bytes  or classes we defined that are made of our own types and primitives   So let s say we have a class of Car as follows   class Car   A very simple class just to demonstrate what these definitions mean    It s pseudocode C   Javaish  I assume strings do not need to be allocated    private String sPrintColor  private String sModel  private String sMake   public changePaint String newColor       this sPrintColor   newColor     public Car String model  String make  String color    Constructor      this sPrintColor   color     this sModel   model     this sMake   make     public  Car     Destructor     Because we did not create any custom types  we aren t adding more code    Anytime your object goes out of scope   program collects garbage   etc  this guy gets called   all other related destructors    Since we did not use anything but strings  we have nothing additional to handle    The assumption is being made that the 3 strings will be handled by string s destructor and that it is being called automatically--if this were not the case you would need to do it here     public Car const Car  amp other     Copy Constructor      this sPrintColor   other sPrintColor     this sModel   other sModel     this sMake   other sMake    public Car  amp operator   const Car  amp other     Assignment Operator      if this     amp other             this sPrintColor   other sPrintColor        this sModel   other sModel        this sMake   other sMake          return  this         A deep copy is if we declare an object and then create a completely separate copy of the object   we end up with 2 objects in 2 completely sets of memory   Car car1   new Car  mustang    ford    red    Car car2   car1    Call the copy constructor car2 changePaint  green      car2 is now green but car1 is still red    Now let s do something strange   Let s say car2 is either programmed wrong or purposely meant to share the actual memory that car1 is made of    It s usually a mistake to do this and in classes is usually the blanket it s discussed under    Pretend that anytime you ask about car2  you re really resolving a pointer to car1 s memory space   that s more or less what a shallow copy is     Shallow copy example   Assume we re in C   because it s standard behavior is to shallow copy objects if you do not have a constructor written for an operation    Now let s assume I do not have any code for the assignment or copy operations like I do above   with those now gone  C   will use the default    Car car1   new Car  ford    mustang    red      Car car2   car1    car2 changePaint  green     car1 is also now green   delete car2   I get rid of my car which is also really your car   I told C   to resolve   the address of where car2 exists and delete the memory   which is also  the memory associated with your car     car1 changePaint  red     program will likely crash because this area is  no longer allocated to the program      So regardless of what language you re writing in  be very careful about what you mean when it comes to copying objects because most of the time you want a deep copy   What are the copy constructor and the copy assignment operator  I have already used them above   The copy constructor is called when you type code such as Car car2   car1   Essentially if you declare a variable and assign it in one line  that s when the copy constructor is called   The assignment operator is what happens when you use an equal sign--car2   car1    Notice car2 isn t declared in the same statement   The two chunks of code you write for these operations are likely very similar   In fact the typical design pattern has another function you call to set everything once you re satisfied the initial copy assignment is legitimate--if you look at the longhand code I wrote  the functions are nearly identical   When do I need to declare them myself   If you are not writing code that is to be shared or for production in some manner  you really only need to declare them when you need them   You do need to be aware of what your program language does if you choose to use it  by accident  and didn t make one--i e  you get the compiler default   I rarely use copy constructors for instance  but assignment operator overrides are very common   Did you know you can override what addition  subtraction  etc  mean as well   How can I prevent my objects from being copied  Override all of the ways you re allowed to allocate memory for your object with a private function is a reasonable start   If you really don t want people copying them  you could make it public and alert the programmer by throwing an exception and also not copying the object

User · Answer

Rule of three in C   is a fundamental principle of the design and the development of three requirements that if there is clear definition in one of the following member function  then the programmer should define the other two members functions together  Namely the following three member functions are indispensable  destructor  copy constructor  copy assignment operator   Copy constructor  in C   is a special constructor  It is used to build a new object  which is the new object equivalent to a copy of an existing object   Copy assignment operator is a special assignment operator that is usually used to specify an existing object to others of the same type of object   There are quick examples      default constructor My Class a      copy constructor My Class b a       copy constructor My Class c   a      copy assignment operator b   a

User · Answer

Many of the existing answers already touch the copy constructor  assignment operator and destructor  However  in post C  11  the introduction of move semantic may expand this beyond 3   Recently Michael Claisse gave a talk that touches this topic  http   channel9 msdn com events CPP C-PP-Con-2014 The-Canonical-Class

User · Answer

The law of the big three is as specified above   An easy example  in plain English  of the kind of problem it solves   Non default destructor  You allocated memory in your constructor and so you need to write a destructor to delete it   Otherwise you will cause a memory leak   You might think that this is job done    The problem will be  if a copy is made of your object  then the copy will point to the same memory as the original object   Once  one of these deletes the memory in its destructor  the other will have a pointer to invalid memory  this is called a dangling pointer  when it tries to use it things are going to get hairy   Therefore  you write a copy constructor so that it allocates new objects their own pieces of memory to destroy   Assignment operator and copy constructor  You allocated memory in your constructor to a member pointer of your class   When you copy an object of this class the default assignment operator and copy constructor will copy the value of this member pointer to the new object   This means that the new object and the old object will be pointing at the same piece of memory so when you change it in one object it will be changed for the other objerct too   If one object deletes this memory the other will carry on trying to use it - eek   To resolve this you write your own version of the copy constructor and assignment operator   Your versions allocate separate memory to the new objects and copy across the values that the first pointer is pointing to rather than its address

User · Answer

When do I need to declare them myself    The Rule of Three states that if you declare any of a    copy constructor copy assignment operator destructor   then you should declare all three  It grew out of the observation that the need to take over the meaning of a copy operation almost always stemmed from the class performing some kind of resource management  and that almost always implied that    whatever resource management was being done in one copy operation probably needed to be done in the other copy operation and  the class destructor would also be participating in management of the resource  usually releasing it   The classic resource to be managed was memory  and this is why all Standard Library classes that manage memory  e g   the STL containers that perform dynamic memory management  all declare    the big three     both copy operations and a destructor    A consequence of the Rule of Three is that the presence of a user-declared destructor indicates that simple member wise copy is unlikely to be appropriate for the copying operations in the class  That  in turn  suggests that if a class declares a destructor  the copy operations probably shouldn   t be automatically generated  because they wouldn   t do the right thing  At the time C  98 was adopted  the significance of this line of reasoning was not fully appreciated  so in C  98  the existence of a user declared destructor had no impact on compilers    willingness to generate copy operations  That continues to be the case in C  11  but only because restricting the conditions under which the copy operations are generated would break too much legacy code      How can I prevent my objects from being copied    Declare copy constructor  amp  copy assignment operator as private access specifier   class MemoryBlock   public     code here  private  MemoryBlock const MemoryBlock amp  other       cout lt  lt  copy constructor  lt  lt endl        Copy assignment operator  MemoryBlock amp  operator  const MemoryBlock amp  other     return  this        int main        MemoryBlock a     MemoryBlock b a       In C  11 onwards you can also declare copy constructor  amp  assignment operator deleted  class MemoryBlock   public  MemoryBlock const MemoryBlock amp  other    delete     Copy assignment operator  MemoryBlock amp  operator  const MemoryBlock amp  other   delete      int main        MemoryBlock a     MemoryBlock b a

User · Answer

Introduction C   treats variables of user-defined types with value semantics  This means that objects are implicitly copied in various contexts  and we should understand what  quot copying an object quot  actually means  Let us consider a simple example  class person       std  string name      int age   public       person const std  string amp  name  int age    name name   age age                  int main         person a  quot Bjarne Stroustrup quot   60       person b a        What happens here      b   a             And here      If you are puzzled by the name name   age age  part  this is called a member initializer list   Special member functions What does it mean to copy a person object  The main function shows two distinct copying scenarios  The initialization person b a   is performed by the copy constructor  Its job is to construct a fresh object based on the state of an existing object  The assignment b   a is performed by the copy assignment operator  Its job is generally a little more complicated  because the target object is already in some valid state that needs to be dealt with  Since we declared neither the copy constructor nor the assignment operator  nor the destructor  ourselves  these are implicitly defined for us  Quote from the standard   The       copy constructor and copy assignment operator        and destructor are special member functions    Note  The implementation will implicitly declare these member functions for some class types when the program does not explicitly declare them  The implementation will implicitly define them if they are used        end note    n3126 pdf section 12   1   By default  copying an object means copying its members   The implicitly-defined copy constructor for a non-union class X performs a memberwise copy of its subobjects   n3126 pdf section 12 8   16    The implicitly-defined copy assignment operator for a non-union class X performs memberwise copy assignment of its subobjects   n3126 pdf section 12 8   30   Implicit definitions The implicitly-defined special member functions for person look like this     1  copy constructor person const person amp  that    name that name   age that age          2  copy assignment operator person amp  operator  const person amp  that        name   that name      age   that age      return  this        3  destructor  person        Memberwise copying is exactly what we want in this case  name and age are copied  so we get a self-contained  independent person object  The implicitly-defined destructor is always empty  This is also fine in this case since we did not acquire any resources in the constructor  The members  destructors are implicitly called after the person destructor is finished   After executing the body of the destructor and destroying any automatic objects allocated within the body  a destructor for class X calls the destructors for X s direct       members  n3126 pdf 12 4   6   Managing resources So when should we declare those special member functions explicitly  When our class manages a resource  that is  when an object of the class is responsible for that resource  That usually means the resource is acquired in the constructor  or passed into the constructor  and released in the destructor  Let us go back in time to pre-standard C    There was no such thing as std  string  and programmers were in love with pointers  The person class might have looked like this  class person       char  name      int age   public          the constructor acquires a resource         in this case  dynamic memory obtained via new       person const char  the name  int the age                name   new char strlen the name    1           strcpy name  the name           age   the age                the destructor must release this resource via delete        person                 delete   name            Even today  people still write classes in this style and get into trouble   quot I pushed a person into a vector and now I get crazy memory errors  quot  Remember that by default  copying an object means copying its members  but copying the name member merely copies a pointer  not the character array it points to  This has several unpleasant effects   Changes via a can be observed via b  Once b is destroyed  a name is a dangling pointer  If a is destroyed  deleting the dangling pointer yields undefined behavior  Since the assignment does not take into account what name pointed to before the assignment  sooner or later you will get memory leaks all over the place   Explicit definitions Since memberwise copying does not have the desired effect  we must define the copy constructor and the copy assignment operator explicitly to make deep copies of the character array     1  copy constructor person const person amp  that        name   new char strlen that name    1       strcpy name  that name       age   that age        2  copy assignment operator person amp  operator  const person amp  that        if  this     amp that                delete   name             This is a dangerous point in the flow of execution             We have temporarily invalidated the class invariants             and the next statement might throw an exception             leaving the object in an invalid state            name   new char strlen that name    1           strcpy name  that name           age   that age            return  this     Note the difference between initialization and assignment  we must tear down the old state before assigning to name to prevent memory leaks  Also  we have to protect against self-assignment of the form x   x  Without that check  delete   name would delete the array containing the source string  because when you write x   x  both this- gt name and that name contain the same pointer  Exception safety Unfortunately  this solution will fail if new char      throws an exception due to memory exhaustion  One possible solution is to introduce a local variable and reorder the statements     2  copy assignment operator person amp  operator  const person amp  that        char  local name   new char strlen that name    1          If the above statement throws         the object is still in the same state as before         None of the following statements will throw an exception        strcpy local name  that name       delete   name      name   local name      age   that age      return  this     This also takes care of self-assignment without an explicit check  An even more robust solution to this problem is the copy-and-swap idiom  but I will not go into the details of exception safety here  I only mentioned exceptions to make the following point  Writing classes that manage resources is hard  Noncopyable resources Some resources cannot or should not be copied  such as file handles or mutexes  In that case  simply declare the copy constructor and copy assignment operator as private without giving a definition  private       person const person amp  that       person amp  operator  const person amp  that    Alternatively  you can inherit from boost  noncopyable or declare them as deleted  in C  11 and above   person const person amp  that    delete  person amp  operator  const person amp  that    delete   The rule of three Sometimes you need to implement a class that manages a resource   Never manage multiple resources in a single class  this will only lead to pain   In that case  remember the rule of three   If you need to explicitly declare either the destructor  copy constructor or copy assignment operator yourself  you probably need to explicitly declare all three of them    Unfortunately  this  quot rule quot  is not enforced by the C   standard or any compiler I am aware of   The rule of five From C  11 on  an object has 2 extra special member functions  the move constructor and move assignment  The rule of five states to implement these functions as well  An example with the signatures  class person       std  string name      int age   public      person const std  string amp  name  int age             Ctor     person const person  amp     default                    1 5  Copy Ctor     person person  amp  amp   noexcept   default                4 5  Move Ctor     person amp  operator  const person  amp     default         2 5  Copy Assignment     person amp  operator  person  amp  amp   noexcept   default     5 5  Move Assignment      person   noexcept   default                        3 5  Dtor     The rule of zero The rule of 3 5 is also referred to as the rule of 0 3 5  The zero part of the rule states that you are allowed to not write any of the special member functions when creating your class  Advice Most of the time  you do not need to manage a resource yourself  because an existing class such as std  string already does it for you  Just compare the simple code using a std  string member to the convoluted and error-prone alternative using a char  and you should be convinced  As long as you stay away from raw pointer members  the rule of three is unlikely to concern your own code

User · Answer

Basically if you have a destructor  not the default destructor  it means that the class that you defined has some memory allocation  Suppose that the class is used outside by some client code or by you       MyClass x a  b       MyClass y c  d       x   y     This is a shallow copy if assignment operator is not provided   If MyClass has only some primitive typed members a default assignment operator would work but if it has some pointer members and objects that do not have assignment operators the result would be unpredictable  Therefore we can say that if there is something to delete in destructor of a class  we might need a deep copy operator which means we should provide a copy constructor and assignment operator

[c++] What is The Rule of Three?

Examples related to c++

Examples related to copy-constructor

Examples related to assignment-operator

Examples related to c++-faq

Examples related to rule-of-three