Please enable JavaScript.

Coggle requires JavaScript to display documents.

C++ - Coggle Diagram

- - - - use it instead of variable assignment
      - const member must be initialized
      - init order of mem init list is not the thing you want to count on, so don't create var that depends on other vars init
    - - when one constructor calls another constructor
      - init or delegation but not both
        
        what if we need both setup and init? create private setup method
      - use it to avoid duplicating your code
  - - - resources allocated to object is tied to object lifetime, which makes sense
  - - - inline functions are exception from this rule, so simple getters can be defined in class header file
- - - - dont use copy init, better use uniform init
  - - - if you have one constructor then you may need destructor copy constructor copy assignment.
        
        custom destructor, copy assignment/constructor should deals only with ownership
    - - Classes that doesn't deal with ownership shouldn't have custom constructor destructors
- - - - is when we lost dimensions of array for e.g. because of passing it like pointer to function
      - if arr is part of class or struct it does not decay
  - - - Prefer passing strings usingstd::string_view(by value) instead of const std::string&, unless your function calls other functions that require C-style strings or std::string parameters.
  - - - inspectors
        
        just view and not modify data, like searching and counting
      - mutetors
        
        modifies data in containers, like sorting and shuffling
      - facilitators
        
        generates result based on data in containers, like multiplying all elements
- - - - std uint_t for bit manipulation
  - - - keyword constexpr
- - - - braced initialization disallows implicit type conversion that lead to data loss
      - float promotion (float to double)
      - numeric promotion (char to int, short to int)
      - numeric conversion (int to short, char to short, double to int, double to float)
        
        narrowing conversion (from big bits to smaller bits)
        
        BEST PRACTICE: avoid this as much as possible, use static_cast for that matter
      - arithmetic conversion (using operators with different types you can get arithmetic conversion when one type converted to another)
        
        if on priority list, result is converted to type that is higher on this list
        
        if the same types then numeric promotion occurs
    - - type casting
        
        c-style cast
        
        uses other types of casting depending on context. Even uses const cast and reinterpret cast that we should avoid.
        
        thus BEST PRACTICE avoid using c style cast
        
        static cast
        
        the best choice when casting one fundamental type to another
        
        const cast
        
        avoid using
        
        dynamic cast
        
        reinterpret cast
        
        avoid using
  - - - trailing return syntax auto f() -> int
      - auto uses the same rule as template type param, for function declaration
      - can deduce constness and pointiness (because it is part of type), but no ref
      - Will never perform conversions!
      - use cases
        
        auto will never perform conversions, so it can be used to ease the pain of using long and int and uint and etc etc
        
        best default for for loops
        
        better performs because of lack of conversions
  - - - if multiple matches are found then there will be a compile error
- - - - in one file only
      - static keyword
    - - out of one file
      - extern keyword
      - behave different with usual global vars. It means forward declaration with extern int g_var
      - can be accessed by other files via forward declaration
      - should not use in .h files
  - - - C++ 20 function that have to be evaluated during compile time
- - - - stack is last in first out we can push or pop something from stack
      - called function added to stack, after its end it is popped out from stack (it is called unwinding the stack sometimes)
      - items we are pushing or popping from stack are called stack frames
        
        stack frame
        
        contains when pushed in
        
        all function arguments
        
        return address
        
        memory for any local variables
        
        Saved copies of any registers modified by the function that need to be restored when the function returns (?)
        
        when popped off this happens
        
        free the memory
        
        return to where function was called
      - stack pointer is a pointer to the top of the stack
      - Stack overflow
        
        on gcc linux machine stack can be as much as 8MB, but if we used all mem and we are trying to push anyway new data, then it will result in stack overflow. Modern os will likely result throw access violation and program just crushes.
      - Summary
        
        Allocating mem to stack is relatively fast
        
        data stays in stack, until it is popped off the stack
        
        all mem allocated on stack is known at compile time
        
        not a good idea to play around with massive data structures, because of limited nature of stack
  - - - int argc
        
        number of passed arguments, always at least 1 because first is the name of the program
      - char* argv[]
        
        just c style array of string, each string is argument
  - - - method 1: before ellipsis pass count parameters which is the number of ellipsis params
      - method 2: use sentinel value. We can loop through ellipsis "list" until some special value
      - method 3: use decoder string (better see code example)
    - - in c++17 were introduced fold expressions
  - - - already implemented most common actions with lambda like comparison, addition, subtraction and etc etc
    - - give access to variables that normally out of scope of lambda func, it is in this "[ ]" things
      - creates a copy of captured variable with the same name
      - captured vars have the same name, but not the same type with origin
      - captures default to const value
      - mutable keyword allows to change all captured variables
        
        if we change var to new value and then call lambda again, then we will see that var has new value and not old one
        
        we can pass by reference outer variable
        
        the world of pain, because of being object (copy problem) and being mutable lambda. So just don't use mutable lambdas
      - default captures, we don't need to enlist anything with this, compiler automatically enlist everything
      - defining new variables in capture is possible
        
        do this if type is obvious and it is really short
      - dandling capture variables - captured variables have to outlive the lambda otherwise it will lead to Undefined Behavior
      - lambda is just an object, so it can be copied
- - - - deal with it within function
        
        retry
        
        ignore
        
        cancel
      - throw exception
      - halt the program
  - - - Precondition
        
        conditions that have to be true before executing a function
      - invariants
        
        must be true while function in execution
      - postcondition has to be true after execution of function
    - - NDEBUG macro disables assert
    - - abort program, so if you have db connections just dont use it
      - mustn't have side effects, code must run with or without assert in the same way
    - - also static_assert can be placed anywhere in the code
- - - - type
        
        result of expression has type, and so this is type of expression too
        
        type of expression is determent at compile time, but value can be determent either at compile time (constexpr) or runtime (not constexpr)
      - value
        
        this property is what expression resolves to. For e.g. this expression resolves to value, function, or an object of some kind.
    - - expression that resolves to identifiable object or function
      - types of lvalue
        
        modifiable lvalues
        
        not modifiable lvalues
      - lvalue implicitly converted to rvalue when we assign some other lvalue to lvalue
      - lvalues expressions are those that evaluate to variables or other identifiable objects that persist beyond the end of the expression.
      - lvalue references
        
        lvalue reference to const
        
        can be binded to rvalue
        
        temporary object is rvalue that assigned to const lvalue reference, when reference destroyed, temporary object destroyed too.
        
        reference can be returned by function, BUT returned identifiable object has to outlive function return expression, otherwise it will lead to undefined behavior.
    - - exist only within one expression for e.g. literals
      - i.e. it is not lvalue
      - rvalues expressions are those that evaluate to literals or the returned value of functions and operators that are discarded at the end of the expression.
  - - - top level const is const that applied to object like int* const ptr, const int val
      - low level const is const that applied to object that is referenced to or pointed to like const int* ptr, const int& ref
- - - - Define you tools, target, backup plans
        
        Breaking hard problems down to easy ones
- - - - name enum type PascalCase and values with camelCase
      - may have collisions with other values from other enums
      - enum class (scoped enums)
        
        defines their own region, so no collision possible
        
        dont implicitly convert to integers, only static_cast
        
        use enum class and not enum
    - - aggregate data type
        
        data type that can have multiple data members
      - aggregate init and initializer list
      - BEST PRACTICE: init all members in struct to avoid undefined behavior
      - prefer braces init
      - to optimize our structs compiler will add bytes to our struct, this is called padding
      - class template
        
        CTAD class template argument deduction cpp17
        
        deduction guide
        
        tells compiler how to deduce arguments type to template of struct