CPP Memory

Question 1

Rule of Three

Answer 1

If a class requires one of the following, it is likely it needs all 3:

• user-defined destructor
• user-defiend copy-constructor
• user-defined copy assignement operator

Question 2

Rule of Five

Answer 2

If a class follows the rules of three, move operations are defined as deleted

• if move semantics are desired for a class, it must have all fve special member functions
• if only move semantics are desired, all five special members must be defined, but defining the copy operations as deleted.

Question 3

Copy Costructor

Answer 3

Simple, copies data, doesn’t steal, doesn’t change the object from which is copying from (that why it is const).

Question 4

Move Costructor

Answer 4

Copysemantics has high costs of overhead, or is not wanted.

Move semantics provides a solution.

Move constructor is invoked: A(A&& other);

• T a(std::move(b));
• T a = std::move(b);
• f(std::move(a)) with void f(T v);
• return a; inside T f();

Move assignement: A& operator=(A&& other)

• similar to constructor, but called when the object has been already constructed.

Question 5

Smart pointers

Answer 5

include <memory></memory>

• unique_ptr
  
  • Essentially RAII semantics for arbitrary pointers
  • assumes unique ownership of another C++ object through a pointer
  • automatic free when out of scope
  • almost a raw pointer -> only difference is it can only be moved, not copied.
  • members:
    
    • get -> returns const raw pointer
    • release -> returns raw pointer and releases ownership
  • Examples:
    
    • std::unique_ptr<int> valuePtr(new int(15));</int>
    • image
• shared_ptr
  
  • expensive, its use should be avoided when possible