Please enable JavaScript.

Coggle requires JavaScript to display documents.

Effective C++ (Object Creation,Destruction,Copying :star: (Virtual…

- - - - Return shared_pointer
      - Easy to use, hard to misuse
      - Custom deleter for shared_pointer
    - - treat as a Type Design
  - - - Easy to copy and swap
      - Specialize template functions
      - Public swap (efficient than the default one)
        
        Non-member swap in same namespace
        calling public swap
        
        Specialize std::swap for your class
- - - - Total template
        specialization
      - Need this-> before
        base class functions
      - Employ using declaration
        to bring to scope
      - Specify Explicitly
  - - - Replace template params
        with function parameters
- - - - Special copying behavior (old set to NULL)
    - - Shared Pointer shared_ptr
        Normal copying behavior
  - - - a class A has a base class which
        is a template specialization
        for the class A itself
      - Implement Singletons
- - - - Everything in base class should be
        applicable to derived class
      - "is-a"" Relationship model
    - - Scope of derived classes is nested in scope of base class
      - using base class members and functions
        to bring them back to scope
    - - inherited from base class become private
      - "is-implemented-in-terms-of" relationship
      - Alternative to Composition + Public Inheritance
      - For Empty Base Optimization EBO
    - - Ambiguity of fields with same name
      - Deadly Diamond
        
        Fixed using virtual inheritance
        But less efficient in space and time
      - Public Inheritance from Interface
        class +Private Inheritance
        from Implementation Class
  - - - must be re-declared by derived classes
      - No definition in abstract classes
      - Inherit function Interface only
    - - Inherit Interface
      - Inherit default implementation
        which could be overridden
    - - Inherit Interface
      - Inherit mandatory implementation
      - Specialization invariant
  - - - Non-virtual Interface Idiom
      - Call private virtual functions
        indirectly through public non-virtual functions
    - - Function Pointers
      - Function Object tr1::function
      - tr1::bind
      - Virtual functions in another hierarchy
  - - - Virtual functions are dynamically bound
      - They are statically bound
    - - Default parameters of even virtual functions
        are statically bound
      - For runtime efficiency
- - - - ENUM HACK
      - constant pointers - const twice
  - - - const_iterator points to something that can't be modified
      - iterator is like T* const - the thing it points to can be modified
    - - const member functions on const objects
      - pass objects by reference-to-const
      - c++ returns objects by value
      - BITWISE vs LOGICAL
        constness
        
        mutable attributes changed by const member functions
        
        Implement non-const functions using const functions by casting
  - - - Reliable initialization of non-local static objects can be problematic