Please enable JavaScript.

Coggle requires JavaScript to display documents.

330/361 - iterators, adts, templates, big 3/big 5 - Coggle Diagram

- - - - using iterator
        using const_iterator
      - begin and end functions
        for both iterators
      - documentation stating what
        is being iterated over
      - Type aliases are preferred over typedefs
  - - - for(auto it: container)
- - - - pass-by-copy/value for objects of that class
        
        5 situations where the copy constructor is used
        
        declare a new object as a copy of an old one
        
        ex
        
        Book book2 (book1);
        or
        Book book2 = book1;
        
        function call passes a parameter by copy/value
        
        ex
        
        void foo(Book b)
        
        When a function returns an object
        
        ex
        
        Book foo(int k){
        Book b;
        ...
        return b;
        }
        
        When data members are initialized in a constructor’s initialization list
        
        ex
        
        Foo::Foo(): dataMemb1(defaultValue)...{}
        
        When an object is a data member of another class for which the compiler has generated its own copy constructor
  - - - 5
        
        move constructor
      - 4
        
        move assignment
      - when to use big 5(move) vs big 3(copy)
        
        move copies the data then deletes the old data
        a new object will have the copied value and the old object will have default values like 0 or nullptr
        
        sometimes when a value is copied it is deleted immediately afterwards, making it a temporary value(rvalue).
        
        rvalue vs lvalue
        
        rvalue is tempoRaRy, only exists within the expression that uses it.
        
        lvalue persists beyond the expression
      - optional
  - - - assignment(makes it a deep copy, not a shallow copy)
  - - - rule of big 3
        
        if you write your own version of any one of the big 3, you must provide your own version of the remaining 2 or 4
      - in the case where pointers are used, and you dont want data to be shared
        
        ex:
        
        obj1 = obj2, where
        their class has a pointer
        data member, this would lead to
        the address the pointer is pointing to
        being copied instead the data located there
        under normal circumstances
    - - use the compiler generated versions
        
        self assignment
        
        can sometimes cause errors if the assignment operator deletes the existing objects to be copied before copying it
        
        can happen in disguised forms,
        like bids[i]=bids[j]
        
        how would we prevent the following code from deleting the bids when doing bids = bids?
        
        BidCollection& BidCollection::operator= (const
        BidCollection& bc) {
        MaxSize = bc.MaxSize;
        size = bc.size;
        delete [] elements;
        elements = new Bid[MaxSize];
        for (int i = 0; i < size; ++i)
        elements[i] = bc.elements[i];
        return *this; }
        
        1 more item...
    - - dont allow copying of this ADT's objects
    - - provide private copy constructors and assignment operators, making it so that the compiler wont provide its own but no one can use them either
  - - - copy-and-swap idiom
        
        3 steps
        
        pass an object of the class youre working on by copy/value(instead of by reference like normal) to the assignment operator forcing it to call the copy constructor
        
        create a friend function named swap
        
        call the swap function within the assignment operator, forcing it to call the destructor implicity instead of having to use delete explicitly within the assignment operator
        
        big 5 with copy and swap idiom