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.
• 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
• How to prevent this? Don't allocate on stack. auto bp = make_unique<Manga>(...)

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.