Index

Symbols

#define function-like macro #include search path make

#pragma once ``*this`` keyword

A

abstract base class interface abstract data type abstraction, [1], [2], [3] fundamental types accumulate activation record activecode adapter design patterns address adjacency list adjacency matrix adjacent ADT adversary argument aggregate type aggregation UML algorithm algorithm analysis algorithms loops model refactoring, [1] allocate allocator_traits allocator_traits allocate construct deallocate destroy allocators alphabet trie analysis hash table list separate chaining string, [1] vector ancestor Andrei Alexandrescu namespace using anonymous namespace

anti-pattern anti-patterns introductory topics comments antisymmetric API api approximation algorithm argc argv array character sequence containers array index operator overload array-based list array-based queue array-based stack arrays pointers as C function parameters vector ASCII character coding ASCII table assembly code assert assert macro NDEBUG macro assignable association multiplicity UML associative container associative containers hashing concepts map set STL asymptotic algorithm analysis asymptotic analysis at vector functions attribute auto keyword trailing return type average case

B

backing storage backing store bag balanced tree base base case base class base type begin() binary search tree best case best practices introductory topics comments big-O notation, [1] big-Oh notation binary search binary search tree begin() end() iterators operator++() binary search trees binary tree binary trees trees; recursion

binary trie binary_search binning bintree bird inheritance graph bitset std::bitset Bjarne Stroustrup FAQ multiple inheritance block boolean variable bucket bucket hashing bug build steps, [1] graph by reference parameter passing by value parameter passing byte string C string, [1] graph

C

C string byte string, [1] C++ introductory topics c++ compiler C++ evolution graph c_str string functions cache memory cache miss memory call stack, [1] functions graph, [1] capacity vector vector functions cartesian product ceiling ceiling function chain of responsibility design pattern char array graph character array character arrays child cin circular queue clamp clang clang-tidy; clang-format; gcc class, [1] container keyword operator overloads operator[] overload static member functions templates class design UML visualization class diagram graph visibility class hierarchy class invariant class invariants encapsulation class members pointers class vs. struct classes composition constexpr immutable inheritance patterns client closed closed hash system closed hashing collisions closed-form solution cmake make code block Code Blocks compiling code generation code optimization codelens cohesion coliru command line argument parsing parsing command line arguments collision collision resolution collision resolution policy collisions closed hashing hash table open hashing

command line argument command line argument parsing coliru repl.it command line arguments graph command prompt linux, [1] comment comments anti-patterns, introductory topics best practices, introductory topics compact list graph comparable comparator comparison comparison sort compilation vs. linking introductory topics compile compile-time error compile-time evaluation Compile-time polymorphism compile-time polymorphism compiler, [1] file extensions compiler arguments debugging compiling Code Blocks Docker introductory topics Linux MacOS Visual Stidio Xcode compiling locally complete binary tree Composite design pattern composite type composition classes UML compound type concepts templates const guidelines keyword, [1] pointers const class functions const pointers const reference parameter passing const vs define constant running time constant time constexpr classes keyword construct allocator_traits constructor copy constructors, [1] container class container class containers STL string vector copy constructor copy(_if) cost cost model count(_if) cout cppreference.com FAQ CPU current position cyclic buffer

D

data field data item data member data structure data type deallocate allocator_traits debugging, [1] compiler arguments gdb gdb commands infinite loop link errors pointers runtime errors semantic errors syntax errors valgrind decision tree declaration decltype keyword delete memory dependency UML depth depth-first search depth-first search tree deque sequence containers

dequeue derivation derived class descendant deserialization design pattern chain of responsibility strategy design patterns adapter destroy allocator_traits deterministic diamond of death dictionary discriminator disjoint disjoint sets divide and conquer divide-and-conquer recurrences Do I need to know math FAQ Docker compiling doctest catch2 domain double hashing, [1] doubly linked list dynamic array dynamic memory allocation

E

echo, [1] edge element empty string functions encapsulation, [1] class invariants oo concepts end() binary search tree enqueue enum keyword enumerated types enumeration equal equal_range

equivalence class equivalence relation errno macro error masks error-handling errors estimation exception exception handling exceptions I/O streams standard exceptions exchange executable exponential growth rate external fragmentation external sort

F

factorial FAQ Bjarne Stroustrup cppreference.com Do I need to know math frequently asked questions integrated development environment Marshall Cline Microsoft more C++ resources, [1] picking the right language picking the right major should I learn C first FIFO file extensions compiler header find string functions find(_if) find_first_of string functions fixed-length coding floating point representations floor floor function flyweight folding method for_each forward_list sequence containers free block

free block list free store, [1] pointers frequently asked questions FAQ friend functions friend functions friend specifier full tree function overloads templates function overloads video function pointers pointers to functions video function returns video function templates function writing guidelines function-like macro #define functions call stack friend operator overloads passing parameters fundamental type fundamental types abstraction

G

g++ compiler garbage garbage collection gdb debugging gdb commands debugging general tree generalization UML generate generic programming git introductory topics version control ssh git editor vim git setup GitHub GNU/Linux grammar graph bird inheritance build steps byte string C++ evolution call stack, [1] char array class diagram command line arguments compact list person inheritance queue operations shape class hierarchy shape inheritance std::forward_list std::list, [1] std::queue std::stack std::vector STL model template design pattern vector

greedy algorithm growth rate guidelines const

H

hash function hash functions hashing concepts hash system hash table analysis collisions hashing hashing concepts associative containers hash functions head header file extensions header files introductory topics

header guard, [1] header node heap, [1] height height balanced hello world vim Herb Sutter namespace using heuristic heuristic algorithm high-level language home position home slot Huffman codes Huffman coding tree Huffman tree

I

I/O streams exceptions IDE, [1] identifier image-space decomposition immutability immutable classes includes indexing induction step infinite loop debugging inherit inheritance, [1] classes multiple oo concepts private UML initializer_list inner_product inorder traversal instance variable int data type video integer overflow integrated development environment FAQ interface abstract base class interfaces and implementation intermediate code intermediate code generation

internal fragmentation internal node internal sort interpreter introductory topics C++ comments anti-patterns comments best practices compilation vs. linking compiling header files linux make types version control git vim text editors invariants inversion iota irreflexive is_heap is_partitioned is_permutation is_sorted ISO C++ standard iterable iterable types iterator operations using iterator categories iterator operations iterator pattern iterators binary search tree

K

kd tree key key sort key space key-space decomposition key-value pair, [1] keyword ``*this`` auto class const, [1] constexpr decltype enum virtual, [1]

L

lambda trailing return type lambda - function pointer conversion video lambda expressions lambda functions language leaf node level lexical analysis lexical scoping lexicographical_compare lifetime LIFO linear growth rate linear order linear probing, [1] linear probing by steps link error link errors debugging linked list Linus Torvalds Linux Linux compiling Linus Torvalds

linux command prompt, [1] introductory topics list analysis sequence containers literal load factor local variable local variables locale logarithms logic notation logical form loops algorithms low-level language lower bound lower bounds proof lower_bound lvalue lvalue reference lvalues

M

Mac OS MacOS compiling make #include search path introductory topics make_heap map associative containers mapping Marshall Cline FAQ Martin Fowler UML max max heap max_element member member function memory cache miss delete new memory leak memory management merge method Microsoft FAQ

min min heap mod model algorithms modes vim modulus, [1] more C++ resources FAQ, [1] motions vim move move assignment move constructor move semantics moving memory multi-dimensional search key multi-dimensional search structure multilist multiple inheritance multiple inheritance Bjarne Stroustrup multiplicity association multiset mutable iterator

N

name namespace anonymous using directive namespace using Andrei Alexandrescu Herb Sutter narrowing conversion natural language natural order NDEBUG macro assert macro

neighbor new memory next_permutation node non-strict partial order non-terminal non-virtual functions manatory interfaces; nondeterministic nullptr number guessing repl.it

O

object, [1] object code object oriented concepts SOLID object pointers object-oriented programming oo concepts object-oriented programming paradigm object-space decomposition octree Omega notation oo concepts encapsulation inheritance polymorphism, [1] open addressing open hash system open hashing collisions operating system operations iterator operator overload array index operator overloads class functions

operator++() binary search tree operator+= string functions vector functions operator= vector functions operator== string functions vector functions operator[] string functions vector functions operator[] overload class optimization problem overflow video overflow bucket overloading functions overloading guidelines overloads function

P

parameter parameter passing by reference by value const reference parameters parent parent pointer representation parity parity bit parse parse tree parser parsing command line arguments coliru repl.it partial order partially ordered set partition partition_copy pass by reference, [1] pass by value, [1] passing parameters functions path patterns classes permutation permutations person inheritance graph physical form picking the right language FAQ picking the right major FAQ Pigeonhole Principle pipe operators POD pointer stack pointer pointer operations pointer to reference video pointer-based implementation for binary tree nodes pointers arrays class members const debugging free store references using

pointers to pointers Polymorphism polymorphism, [1] oo concepts, [1] pop portability poset position postorder traversal powerset PR quadtree predicate predicate function preorder traversal primary clustering primitive element primitive type priority priority queue, [1] private inheritance probe function probe sequence problem problem instance problem solving procedural procedural programming paradigm production production rule program programming language proof proof by contradiction proof by induction pseudo-random probing pseudocode push push_back

Q

quadratic growth rate quadratic probing, [1] quadtree

queue sequence containers queue operations graph

R

radix RAII rand random random shuffle random uniform_int_distribution random_device range realization UML record recurrence relation recursion, [1] recursive call recursive data structure recursive function redirection operators reduce refactoring algorithms, [1] reference reference count algorithm references pointers reflexive

regular type relation repl.it command line argument parsing number guessing parsing command line arguments requires reserve vector rfind string functions ring buffer root runtime environment runtime error runtime errors debugging Runtime polymorphism runtime polymorphism compile-time polymorphism runtime stack rvalue rvalue reference rvalue references rvalues

S

scanner scope, [1] search search key search lower bound search problem search tree search trie searching secondary clustering secure shell ssh semantic error semantic errors debugging semantics separate chaining analysis sequence sequence container sequence containers array deque forward_list list queue stack vector sequential tree representation serialization set associative containers set former set notation set product set relations set_difference set_union shadowing shallow copy shape class hierarchy graph shape inheritance graph should I learn C first FAQ shuffle sibling signature simple type simulating recursion singly linked list size string functions vector slot smart pointer auto_ptr; unique_ptr; shared_ptr software engineering software reuse SOLID object oriented concepts sort sort_heap sorting lower bound sorting problem source code spatial spatial application spatial attribute spatial data spatial data structure ssh secure shell stable_partition, [1]

stack sequence containers stack pointer pointer standard exceptions exceptions standard input start symbol static functions static member functions class static scoping std::bitset std::chrono std::equal std::find std::forward_list graph std::function std::list graph, [1] std::move std::pair std::queue graph std::stack graph std::string vs byte strings std::string::npos std::swap std::vector graph STL associative containers containers STL model graph stod stoi strategy design pattern strcmp, [1] strcpy stream strict partial order string analysis, [1] containers string abstractions string functions c_str empty find find_first_of operator+= operator== operator[] rfind size strncmp strncpy strong induction struct vs. class subclass subset subtree summation, [1] superset symbol table symmetric symmetric matrix syntax syntax analysis syntax error syntax errors debugging

T

tail template template design pattern graph templates class concepts function terminal test-driven development text editors introductory topics vim this pointer to_string token total order toupper trailing return type auto lambda

transform transitive transpose traversal traverse traverval tree tree traversal trees trie truth table tuple, [1] two's complement type type conversion type invariant types introductory topics

U

UML aggregation association class design composition dependency generalization inheritance Martin Fowler realization unary function unified modeling langauage UML uniform_int_distribution

uninitialized_copy uninitialized_fill unit test Unix unordered_multiset unordered_set unsorted list unvisited upper bound upper bounds using iterator pointers using directive namespace

V

valgrind debugging variable-length coding vector, [1] analysis as C function parameters capacity containers graph reserve sequence containers size vector functions at capacity operator+= operator= operator== operator[] version control git, introductory topics vertex video function overloads function pointers function returns int data type lambda - function pointer conversion overflow pointer to reference

vim git editor hello world modes motions text editors, introductory topics virtual keyword, [1] visibility class diagram visit visitor Visual Stidio compiling visualization class design volatile

W

widening conversion Windows System for Linux

worst case WSL

X

Xcode compiling