Basic C++ Practices

1. The rule of thumb here is Almost Always Auto
   • In most cases, when declaring local variables, it makes sense to use auto
2. Below are some examples:

auto x = y; // inferred as int
auto y = 2.0; // inferred as double
auto z = 2u;  // inferred as unsigned int
auto q = uint16_t{45}; // explicit type

• auto declarations require an initialization
  • In other words, auto x; results in a compilation error
• auto selects the best general-purpose integer type for the machine
• auto does not prevent you from explicitly specifying types

1. A safe, dynamically re-sizable, array
   • Like a python List
2. A most versatile data-structure of first resort

auto v = std::vector<int>{2, 3, 4};
auto x = v.at(2); // 4
v.at(0) = 1; // v == {1, 3, 4}

1. Always use v.at(index) to into the vector
   • Ensures run-time check of the index, will throw an exception if out-of-bounds
2. (Almost) Never use v[index]
   • No run-time check of the bounds
   • Boosts performance, but if your code has bugs can cause major problems
   • Only use if you have determined, through measurements, that you cannot afford the run-time check.
3. Avoid indexing and use a range-based for loop, with Constrained Algorithms or std::algorithms
   • Usually it's a good idea, but when doing mathematical code indexes can be useful.

1. std::vector is a relatively straightforward data-structure with a known performance profile
2. std::vector is usually good enough
3. Modern computers favor linear algorithms with minimal branching, which fits well with std::vector

1. Don't use std::vector<bool> because it does not conform to the proper container interface
2. Use std::vector<uint8_t>, std::deque<bool> or std::bitset.
   • All have various trade-offs, std:"vector<uint8_t> at least behaves like a normal vector
3. See Meyers, Scott Effective STL, Chapter 2, Item 18
4. It's a fine data structure, just named incorrectly

• C++ provides programmers with direct access to the memory where variables and objects are stored
• This provides absolute control over the program, but also creates the chance to introduce bugs

1. The stack is a part of memory where local variables are stored
   • Local variables also include the parameters to the function
2. When a function is called, it's local variables are placed on the stack
3. When a function returns, it's local variables are removed from the stack
4. Thus, the memory used for storing local variables
   • Is automatically allocated upon entering a function
   • Is automatically de-allocated upon leaving a function
5. Local variables do not persist beyond a function call

1. The heap is an area of memory managed by the programmer
2. Objects can be allocated on the heap with the new operator
   • Calling new allocates memory and calls the Object's constructor
3. Objects can be de-allocated from the heap with the delete operator
   • Calling delete calls the object's destructor and de-allocates it's memory
4. new [] and delete [] can allocate and de-allocate arrays of objects
5. If your program forgets to de-allocate memory (e.g., does not call delete) it can leak memory
6. If your program accidentally de-allocates memory twice it can crash and create a security bug

• Every variable has a memory address.
• Pointers store the memory address of a variable
• In Modern C++ pointers should almost never be used.
  • However, a basic understanding of pointers is useful

Consider the following code:

auto var = 20;
//int * pvar = &var;
auto pvar = &var;
//int ** ppvar = &pvar
auto ppvar = &pvar;

Memory might be laid out as below:

• The variable var holds 20.
• The address of var is &var and it is 0x1000 (in reality the address would be 64 bits on an x86_64 machine).
• The pointer pvar == &var.
  • To access var through pvar it can be de-referenced.
  • For example *pvar == 20 and *pvar = 40; var == 40
• Pointers are in-and-of-themselves variables and are stored at memory locations
  • &pvar == = 0x1004 in this case
• nullptr indicates that a pointer is invalid and does not point to anything
  • nullptr pointers should never be dereferenced
• Pointers allow passing the address of data, rather than copying the data itself
  • Only the address needs to be copied, not the whole data structure
• Pointers can be re-assigned to point to new objects

1. References are like pointers that are:
   • Never nullptr
   • Cannot be re-asssigned
   • Are always dereferenced
2. Taking the address of a reference returns the address of the underlying variable
3. References are primarily used for two purposes
   1. Passing objects to functions
   2. Referring to the current element in range-based for loops

4. Here is an example of how they work (illustrative only)

   auto x = 2;
   auto & y = x;
   y = 3;
   // now x == 3
   

1. In general, pointers should be avoided. They can be used in a few situation
   • Interfacing with C code that uses pointers
   • Non-owning use in contexts when references don't make sense.
     • Someone else is responsible for managing memory lifetime
     • The value pointed at may be nullptr
     • The context is not a parameter passing context
2. References should be used only for parameter passing and range-based for loops
   • Don't use references as member variables (they prevent copying your object)
3. In most cases you don't need to allocate your own memory
   1. Containers like std::vector instead
   2. std::shared_ptr<>, created with std::make_shared
   3. std::unique_ptr<>, created with std::make_unique
   4. There is no need to use new or delete in this class
4. If you must allocate memory (e.g., to make your own data structures)
   • Use Objects: Memory is allocated in constructors and deallocated in destructors
   • See: Scott Meyers Effective C++, Chapter 3, Item 13

1. Pass by value is the preferred method for passing small objects to functions
2. Consider void func(MyObject obj)
   • In this example, obj is passed by value
   • This means that the copy constructor of obj is called
     • If obj has no copy constructor, pass by value cannot be used
   • Copying large objects can be time consuming, but is trivial for small objects

1. Pass by reference to const is a method for passing objects without requiring copying
2. Consider void func(const MyClass & obj) and void func(MyClass const & obj)
   • Both examples are exactly the same semantically
   • The first is more common, the second is more consistent with other uses of const
   • No copy is made when passing by reference to const
   • func can cannot modify obj (see for precisely how/why)
   • func borrows obj
     • The usage of obj must end when func returns
     • This means that func should not store a pointer/reference to obj anywhere
       • Some other part of the code owns obj and could destroy obj, which would lead to a dangling reference (very bad)

1. Pass the shared_ptr object by value: void myfunc(shared_ptr<MyClass> obj)
2. Shared ownership means that myfunc can retain a shared_ptr to obj
3. obj is destroyed when there are no more shared_ptr pointing to obj
   • In other words, all the shared owners can use the object
   • When the shared owners are done, the object is destroyed
4. Edge Case: Does not work if their are circular references:
5. Just because you have a shared_ptr to an object, does not mean you should pass by shared_ptr
   • In most cases it is appropriate to de-reference the pointer and pass by const reference
   • Only if the method that is called must retain the object after it is finished do you need to share ownership

1. Pass the unique_ptr by value: void func(unique_ptr<MyClass> obj)
2. The caller must transfer ownership to func using std::move:
3. func now becomes responsible for managing the lifetime of obj

4. Here is an example

   auto obj = std::make_unique<MyClass>(MyClass constructor arguments);
   func(std::move(obj));
   // x cannot be used
   

These notes don't explain these methods, but they are here for completeness

1. Mutable reference: void myfunc(MyClass & out)
   • Like Python pass-by-reference
   • An implementation of "Output Parameters"
   • out can be modified in myfunc and those changes are seen outside the function
   • Not usually needed because in C++ it is okay to Return By Value
2. lvalue reference: void myfunc(MyClass && lvalue)
3. forwarding reference: template<class T> myfunc(T && myval)
4. Pointer: void myfunc(MyClass * p)
   • Useful for interfacing with C
   • The pointer can also be const