Buffering

Printing is expensive from a physics perspective

• Travel time from processor to screen
• Must be done for each character

Solution (note: similar to N+1 problem)

• Accumulate list of things to print, and send all at once (flushing)
• Only have to pay for one instance of travel time
• Cons: Takes time (usually negligible) for everything to show up
• std::endl flushes buffer

stdout is buffered by default, stderr is unbuffered

Makefile

CXX = g++
CXXFLAGS = -std=c++14 -Wall -g -MMD
EXEC = my_program
OBJECTS = main.o dependency.o
DEPENDS = ${OBJECTS:.o=.d}

${EXEC}: ${OBJECTS}
	${CXX} -o ${OBJECTS} ${EXEC}

-include: ${DEPENDS}

.PHONY: not_a_filename

not_a_filename:
	some_command

-MMD flag to generate dependencies

Preprocessor

Transforms code before it reaches the compiler

#include "lib" inserts the contents of the file lib

#define VAR VALUE defines a symbol

• Replaces all instances of VAR with VALUE
• Define from CLI: g++ -DVAR=VALUE program.cc

Include Guard: Solve the double include problem

#ifndef FILE_H
#define FILE_H
... header file contents
#endif

Constructors

Method called when object is first initialized

• The following happens when an object is constructed:
  1. Space is allocated
  2. Superclass is constructed
  3. Default ctors of object fields called in declaration order
  4. Constructor is called
• Just always add the explicit keyword in front of a ctor

Destructors

Method called when object is destroyed

struct Node {
	int data;
	Node *next;
	~Node () { delete next; }
}

The following happens when an object is destructed:

1. Destructor is called
2. Dtors of object fields called in reverse declaration order
3. Superclass is destructed
4. Space deallocated

Unified Assignment Operator

Node &operator= (Node other) {
	std::swap(this->data, other.data);
	std::swap(this->next, other.next);
	return *this;
}

• Pass-by-value calls other == lvalue ? copy ctor : move ctor
• Replaces copy + move assignment

Tampering

Accessing internal data in an ADT without using public interface - invalidates invariants

• Invariants: Statements that ADTs rely on to be true in order to operator
• Fix by using private and public access modifiers
• Difference between struct and class: struct default access is public, class is private

Friend

Gives something access to my information - one-way. Useful for iterators in an ADT

• friend class X, friend X::foo(int)
• Limit use; weakens encapsulation

Exceptions

Indicates something in program fucked up

• If throwing in ctor: delete all objects
• If throwing in dtor: program will abort automatically
  • Use noexcept (false) in function signature to prevent this

Initializer List

Allows for array-style initialization vector<int> v { 1, 2, 3 };

#include <initializer_list>
vector (std::initializer_list<T> init) :
	n { init.size() }, cap { init.size() }, contents { new T[cap] } {
	size_t i = 0;
	for (auto &t: init) contents[i++] = t;
}

• init is stored in contiguous memory; init.begin() returns a pointer
• Using one array (init) to build another (contents); 2 copies in memory

Operator and Placement New

Difference between new and malloc: malloc returns NULL, new throws.

Regular new = operator new + placement new

Allocation: operator new(size_t n) (strong guarantee)

• Functionally same as malloc; allocates n bytes of uninitialized memory
• Delete with operator delete(thing)

Initialization (Placement New): new (address) type

• Constructs a type object at address addr
• Does not allocate memory - assumes memory is already allocated at addr

Variadic Arguments and Perfect Forwarding

Same syntax and functionality as spread

template <typename T> class Vector {
	template <typename ...Args> 
	void emplace_back (Args&& ...args, T&& example) {
		new (contents + n) T(args...);
		n++;
	}
}

• Args&& is a universal/forwarding reference (can point to either an rvalue or lvalue)
  • How to differentiate from rvalue? && indicates a universal ref iff the type is ambiguous.
  • Here, when calling emplace_back, Args is of an unknown type so Args&& is a universal reference. We already know T, so T&& is an rvalue.
  • Must be in the form of Type&&, cannot be const Type&& or something
• std::forward<Args>(args)... preserves the rvalue/lvalue-ness of each argument
  • Calls std::move if argument is an rvalue, else does nothing

Exception Safety

A function f can offer 3 different levels of safety once an exception has been handled:

• Basic Guarantee: Program is in valid state; no leaked memory/corrupted data
• Strong Guarantee: Program is in exact same state as it was prior to calling the function (as if it wasn't called at all). f either succeeds completely, or not at all.
• No-Throw Guarantee: Will never emit an exception. Always finishes its task.
  • Mark every function that you are sure will not throw with noexcept
• std::move_if_noexcept: std::move(x) if move ctor is noexcept, else x

Slicing

Inheritance allows you to do something like Book b = Manga { ... }.

• Since every manga is a book
• However, when allocating on the stack like this, only enough memory for a Book object is allocated
  • So the extra fields on Manga - in this case bool hasAnime - are "sliced"
  • Also prevents overridden methods from being called; e.g. b.isCool would call Book::isCool rather than Manga::isCool
• How to prevent this? Don't allocate on stack. auto bp = make_unique<Manga>(...)
  • Pointers are always 8 bytes, so no slicing needs to be done.

Virtual Methods and Override

// assume same definitions as above
class Book {
	...
	public:
		virtual bool isCool () const { return true; }
}

class Manga : public Book {
	...
	public:
		bool isCool () const override { return hasAnime; }
}

Every class has a "virtual table", or vtable, which contains all of its virtual methods

• e.g. The vtables for Book/Manga would contain only their versions of isCool
• vtables and lookups do have a time/space cost (derefs + vptr), but it is negligible

Every object (instance) has a vptr, a pointer to that table

• So when book.isCool or manga.isCool are called, it performs the lookup using the vptr and runs the corresponding function
• How lookups work: https://stackoverflow.com/a/8005823/5181021

Casting

For "transforming" types. dynamic_cast<T>(val) is the only one with a runtime effect; all others are compile time casts with O(0) runtime.

(T) val: C-style casting. Combination of the three below. Only use for numbers.

static_cast: Compile time type assurance. You know the type beforehand.

reinterpret_cast: God knows what this does. Don't use it. Intentional UB.

const_cast: Adds or removes const qualifier. Just make your program const-correct and you won't have to use this.

dynamic_cast: See below. Too many details.

Dynamic Casting

Returns val with type T, allowing you to use T's methods, or nullptr if the cast is invalid. For if you don't know the exact type at runtime.

• Useful for downcasting (convert superclass to subclass)
• If T is a reference, throws bad_cast if cast fails

How do dynamic casts work?

• Run-Time Type Information (RTTI) is stored in the vtable of a class
• Thus, dynamic_cast will not work on classes without virtual methods (i.e. non-polymorphic) and will throw instead