# Programming in C++

- header files in C++
	- the whole class has to be in the header file (including implementation of the member functions, even private members)
- it is not a good idea to try to modify the value of a function parameter
- when using `const` and pointers together, it might get complicated
	- the behavior will differ based on the `const` keyword position
- function declaration vs. definition
	- declaration – in the header (hpp) file
		- does not have to contain names of the parameters
		- can contain default values of the parameters
	- definition – in the source (cpp) file
- `inline` keyword
- if you insert something in a container, it is copied
- `const` keyword
- `auto&&` → compiler will determine the best way to access the item (might even use const)
- `std::string`
	- mutable
	- assignment copies the characters
	- small strings may be located inside the std::string object (in some implementations)
	- larger strings are stored in a dynamically allocated block owned by the std::string object
		- if the appended characters can fit inside the block, they are just appended
		- otherwise, a larger block is allocated and all the characters are copied there
- how (not) to share links
	- value … `T`
		- default value defined by default constructor
		- we can use `x.member`
	- raw (C) pointers … `T *`
		- undefined by default (if not global)
			- it is good practice to set them as null pointer
		- the instance needs to be deleted (exactly once)
		- star needs to be repeated when creating multiple pointer variables
		- we can use `(*x).member` or `x->member`
	- smart pointers … `std::shared_ptr<T>`
		- initialized as null pointer
		- we can use `x->member`
	- references … `T &`
		- must be initialized
		- cannot be redirected
		- we can use `x.member`
		- reference does not own the object, it has to be owned by someone else
		- assignment replaces the value of the referenced object
- references
	- `T &` used as an output parameter
	- `const T &` used as an input parameter
	- `T &&` used to steal from them
		- two types of r-values
			- prvalue (pure r-value)
			- xvalue (result of std::move or other function/cast returning T&&)
- resolution of the overloaded function depends on the number and types of the arguments
	- or, for member functions, it depends on the type of the object (whether it's modifiable or not)
- rule of five
- virtual destructor for abstract classes
- conventions for the use of references and pointers
- invalidations in containers
	- modification action in sequential container invalidates…
		- pointers
		- references
		- iterators
	- associative containers
		- unordered
			- pointers – not invalidated
			- references – not invalidated
			- iterators – invalidated
		- ordered
			- nothing is invalidated
- for_each makes a copy of the functor using its copy constructor
- when calling a function, the compiler may infer its namespace from the arguments
- using virtual functions
	- we need to have pointers/references to the objects to be able to call their functions virtually
	- otherwise, the call is always non-virtual
	- what happens if we do this? `Derived d; Base b = d;`
		- a copy constructor of the base class is invoked
		- there exists a conversion from the derived class to the base
		- as a result, `b` would be an instance of the Base class, it would contain only a subset of the data members of `d`
		- this is called “slicing”
- casts
- virtual inheritance

---

- forwarding (universal) references
	- compiler selects variable/parameter type according to the actual argument
	- `auto&&` variable type
	- as templated function argument `T&&`
	- perfect forwarding
		- if we want to forward the variable to another function while keeping its original properties (l/r-value and constness), we should use `std::forward<T>(x)`
			- it's a cast to `T&&`
- variadic templates
	- example: `template<typename... TList> void f(TList&&... plist) { g(std::forward<TList>(plist)...); }`
	- fold expression
- traits, policies, functors, tags
	- traits … used to determine properties of a type used in a template
		- example: we want to find the numeric limits of the type T in the current specialization
		- we may use methods like `std::numeric_limits<T>::lowest();` for that – if there exists such specialization for the type
	- policies … classes used as type parameters in templates to influence the internal behavior of the template
		- example: allocation policy of a container
		- we want to pass a set of functions (and types…) that the container should use
		- usually, the functions would be static
		- but it is also possible to pass an instantiated policy as a parameter of the constructor (it would be still used as a type parameter of the template)
		- alternative: to use OOP and require that the allocators implement some interface (stated using an abstract allocator) – this would be slower that the templated version