Please enable JavaScript.

Coggle requires JavaScript to display documents.

(big 3, C++ Class Checklist), DPOSDMAHRS, big 5, uses of the const keyword…

- - - - 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
    - - 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 this 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
  - - - 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
  - - - assignment(makes it a deep copy, not a shallow copy)
- - - - 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
      - 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
    - - 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
- - - - step 1. source code(.java) compiled into object(.class, bytecode)
        step 2. JVM interprets the object(byte)code
      - 2 advantages
        
        programs can run on any cpu as long as JVM is installed
        interpretation in JVM takes less time since it is interpreting low-level(object/byte) code, not high-level like purely interpreted langs(python)
- - - - 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
        
        original
        
        big 5
        
        copy and swap
- - - - new/delete
      - malloc/realloc
- - - - *
      - visiting the block of memory the pointer holds/is pointing to
      - how to avoid a dereferencing operation
        
        ex:
        
        given:LinkedList* list = new LinkedList();
        
        const LinkedList& printAccess = someList; // read only
        LinkedList& justSwitchToRust = someList; //read and write
- - - - public class classname{
        //same class rules as c++ without the
        declarations in .h and implementaitons in .cpp)
        
        rightclick package->new->JUnit test case->TestClassName->uncheck setup->select methods to test
        
        import static org.junit.Assert.;
        import static org.hamcrest.CoreMatchers.;
        import org.hamcrest.core.IsNull;
        import org.hamcrest.core.IsName;
        
        rightclick test ->run as->junit test
      - rightclick package->new->class->classname->generate comments
- - - - 7 benefits of Jar files
        
        SDCPPPP
        
        packaged for sealing
        
        Compressed
        
        Decreased Download Time
        
        leading to
        
        because it is
        
        packaged for extension
        
        allows your software to become extensions of the java platform
        
        portable
        
        Java core api provides handling for jar files
        any platform with java on it can handle jars
        
        packaged for versioning
        
        jars contain version and vendor info
        
        as well as time of creation
        
        Secure
        
        Jar files can be digitally signed by their author
        
        users of the software who recognize the signature can choose to grant it permissions
      - a single archive containing all the class files and auxilary resourcess needed for certain applets/applications
      - is a variety of zip file
        
        zip files
        
        good for 4 things
        
        compression
        
        advantages/disadvantages
        
        reduced file size, decreased download time
        requires extraction, increased time to load the program since it requires a decompressing operation
        
        decompression
        
        archiving
        
        unarchiving
        
        meaning this command will work
        
        unzip -l allInOne.jar
      - Java Archiver/Java archive tool, java archive file
    - - Java virtual machine
      - an instance of this is created when the java launcher tool is ran
- - - - provides wide array of classes for us to use in our code
        
        User interface toolkits to build GUIs
        
        JavaFX
        
        Java 2D
        
        Swing
      - application programming interface