Please enable JavaScript.

Coggle requires JavaScript to display documents.

330 - Review - operator overloading, constructors and the rule of the…

- - - - meaning it contains all the functions to perform the tasks at hand and future tasks that it could reasonably be expected to do based on the requirements of the application
    - - lambda expressions
        
        expression used to define an anonymous function
        
        function w/ no name
        
        3 criteria for use
        
        used to create functions that are passed as arguments to other functions
        Used when you only plan on using a function once
        Used with functions from <Algorithm> like copy and transform
    - - precondition
        
        must always be documented
        
        something that the person calling a function must assume to be true if the function is to work correctly
      - c++ documentation type
        
        doxygen
      - java documentation type
        
        javadoc
    - - two styles for providing access to attributes
        
        getters and setters
        
        reference functions
        
        less flexible and rarely used due to having access AND assign capacities
        
        reference variables
        
        const LinkedList& printAccess = someList; // read only
        LinkedList& justSwitchToRust = someList; //read and write
        
        given:LinkedList* list = new LinkedList();
        
        ex:
        
        1 more item...
        
        ex:
        
        1 more item...
      - encapsulation
        
        putting all of the data(variables) inside a single class/struct and limiting access through member functions
    - - assert
        
        takes a single argument (boolean) that should be true unless a programming mistake was made, and aborts if the bool is false
    - - what should they be initialized to?
        
        it depends on the nature of the problem, 0 or null/nullptr are usual go-to's, must make sense depending on the situation
      - 2 methods for initializing every data member
        
        field-by-field
        
        declaring each data member of each object individually
        
        problems
        
        could forget to initialize a field, could accidentally add code between the initializations causing confusion, it takes a long time, and could lead to using an object without initializing every field, such as const data types
    - - default constructor
        
        constructor that can be called with no arguments
        
        four options for default constructor implementation
        
        write your own
        
        member initialization list
        
        initializes values listed before the constructor is executed
        
        should always be used in lieu/in addition of assignment in the constructor body for initializing at least 2 kinds of data members
        
        the data type has its own default constructor, like strings(std::string)
        
        the data type is an object(className::member)/is from a user-defined data type
        
        declare a constructor as private to prevent other code from creating objects for that class
        
        dont use one at all
        
        use the compiler generated version
    - - based on what makes an object of that class lesser or greater or equal
    - - if a function is not intended to modify the object it is being called on/applied to, declare it as const
        if a formal parameter is not meant to be modifed, either pass it by value or by const reference
        
        3 ways to pass an argument to a function
        
        pass by copy/value
        
        The parameter-passing mechanism by which a copy of the value of the actual parameter is passed to the called procedure. If the called procedure modifies the formal parameter, the corresponding actual parameter is not affected.
        
        used when
        
        value when making a copy is cheap(int,double,float)
        
        pass by reference
        
        When a parameter is passed by reference, the memory location originally referred to by the actual parameter is passed to the formal parameter, such that any changes made to the object by the formal parameter also affect the original actual parameter.
        
        used when
        
        you want the parameter value to be changed
        
        pass by constant reference
        
        takes the value of the parameter without allowing the parameter to be altered and without making a copy
        
        used when
        
        making a copy is expensive and you dont want the parameter value to be changed
      - indicating what formal parameters a function will view without changing(pass by const reference)
        
        uses of the const keyword
        
        declare constants
      - indicating which member functions will not be able to alter the object they are being used on
        
        2 most important uses
    - - variable names should make sense to anyone
        with knowledge of the application domain(what the application is designed to work for)
        
        ex
        
        a book organization application should make sense to a librarian)
- - - - default
        
        aka
        
        package private
- - - - since c++ uses preprocessor statements(#include) to determine program structure, and java uses directory structure to determine program structure
        a file cannot be located in two directories at once
- - - - system.out.format(" Item %2d %: %d \n", 1, inputInt);
        
        2 spaces for an integer
      - system.out.format(" Item %2d %: %4.2f \n", 2, inputDouble);
        
        2 spaces, 4 positions, for 2 decimal places, for a floating point
- - - - changing what is being loaded
- - - - 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
    - - 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
  - - - 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; }
        
        use assert to guard the inputs, or an if, ex:
        if(this != &bc) at the beginning of the block
- - - - 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
- - - - move constructor
    - - move assignment
    - - 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
- - - - 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
- - - - collections.set
        
        generators
        
        tuples
- - - - std::unordered_set
- - - - java.util.hashset
- - - - set
- - - - 2 copy constructor
        
        3 destructor
        
        4 assignment operator =
        
        5 accessors (getters)
        
        6mutators (setters)
        
        7 swap
        
        1 more item...
- - - - 2 clone and/or copy constructor
        
        3 accessors (getters)
        
        4 mutators (setters)
        
        5 equals
        
        6 hashcode
        
        7 toString
        
        1 more item...
- - - - 2 _deepcopy_
        
        3 _del_
        
        4 property
        
        5 attribute.setter
        
        6 _eq_
        
        7 _hash_
        
        1 more item...