1. The object’s destructor, if any, is called.
2. The memory used by the object is deallocated.

S& S::operator=( S const &that ) {
  if ( &that != this ) {                      // 2
    delete p;                                 // 3
    p = that.p ? new T{ *that.p } : nullptr;  // 4
  }
  return *this;                               // 6
}

Line 2 guards against self-assignment, that is:

x = x;      // silly, but it still has to be correct

Line 3 deletes the existing T, if any.

It is never necessary to check a pointer for null before deleting it. C++ guarantees that deleting a null pointer does nothing.

Line 4 checks that that.p is non-null (as given, p may be null) and dynamically allocates a copy of *that.p if not; otherwise, just sets p to null.

Line 6 returns *this as all assignment operators do.

To be exception-safe, a function must behave as if nothing happened if an exception is thrown. In this case, the assignment operator must not delete the T to which p points.

To make it exception-safe, introduce a temporary variable:

S& S::operator=( S const &that ) {
  if ( &that != this ) {
    T *t = that.p ? new T{ *that.p } : nullptr;
    delete p;                                 // 4
    p = t;
  }
  return *this;
}

Now instead of deleting p first, call T(T const&) first. If it throws an exception, line 4 will never be reached. If the code reaches line 4, it means that it did not throw an exception so now it’s safe to delete p.

1. The left-hand-side’s T will be memory-leaked immediately.
2. The left-hand- and right-hand-side’s p will point at the same T. When the first S gets destroyed, it will delete T. When the second S gets destroyed, it will try to delete the T that has already been deleted. This will most likely result in a core dump.

• std::map is typically implemented using a balanced binary tree, e.g., a red-black tree, for which both the average and worst-case insertion, look-up, and deletion times are all O(lg n).

• std::unordered_map is implemented using a hash-table for which the average insertion, look-up, and deletion times are all O(1), but whose worst-case times are all O(n).
  

• std::map elements must be less-than comparable.
• std::unordered_map elements must be both equality comparable and hashable.

Each slot contains a pointer-to-function of that class’s implementation of the function. (If a particular class doesn’t override a virtual function of its base class, then its slot contains a pointer to the base’s function.)

For example, given two classes B and D, the compiler generates the vtbls:

struct B {                   void const *const B_vtbl[] = {
  virtual ~B();                (void*)&B_dtor,
  virtual void f(int);         (void*)&B_f,
  void g();                    (void*)&B_h
  virtual void h();          };
};

struct D : B {               void const *const D_vtbl[] = {
  ~D();                        (void*)&D_dtor,
  void h() override;           (void*)&B_f,
};                             (void*)&D_h
                             };

For B_vtbl, a pointer to B_dtor (the implementation of ~B()) is put into slot 0; B_f is put into slot 1, and B_h is put into slot 2. (g() doesn’t get a slot since it’s not virtual.)

For D_vtbl, it’s similar except that slot 1 points to B_f (since D didn’t override B::f()) and slot 2 points to D_h (since it did override B::h()).

Every object of such a class contains a vptr (“vee pointer”) that points to the vtbl for its class. The value of this pointer determines the type of the object at run-time.

For example, the compiler inserts a _vptr member into the base class and initializes it like:

struct B {
  void *const *_vptr;

  B( /*...*/ ) { _vptr = B_vtbl; }
};

struct D : B {
  D( /*...*/ ) { _vptr = D_vtbl; }
};

That is, in every constructor, it inserts code to initialize _vptr with the right vtbl for the class.

Then to call a virtual function, say h(), the compiler looks up h’s slot (here, 2) from its internal mapping, then generates code that:

1. Indexes the vtbl pointed to by the object’s _vptr with the slot to get h’s address; then:
2. Casts the address to the correct pointer-to-function type; then:
3. Calls the function passing the address of the object as the first parameter to become its this pointer.

That is:

void call_h( B *b ) {
  b->h();  // reinterpret_cast<void(*)()>( b->_vptr[2] )( b );
}

Notice that if b actually points to a D, it will call D::h() since _vptr points to D_vtbl.

struct S {
  S() : p1{ new T }, p2{ new T } {
  }

  std::unique_ptr<T> p1, p2;
};

Even though the destructor isn’t called on objects whose constructor (or constructor of a data member) throws, destructors are called for fully constructed data members.

In this case, p1’s destructor will be called (thus freeing p1) if p2’s constructor throws.