Index

Symbols

#define function-like macro #include search path make

#pragma once ``*this`` keyword

A

abstract base class abstract base classes interfaces abstract data type abstraction, [1], [2], [3] fundamental types accumulate activation record activecode adapter pattern design patterns address adjacency list adjacency matrix adjacent ADT adversary argument aggregate type aggregation UML algorithm algorithm analysis, [1] average case best case hash tables std::list std::string, [1] std::vector worst case algorithm comparison algorithms, [1] loops model refactoring standard library model allocate allocator_traits allocator_traits allocate construct deallocate destroy allocators alphabet trie analysis separate chaining ancestor

Andrei Alexandrescu namespace using anonymous namespace anti-pattern antisymmetric API api approximation algorithm argc argc and argv command line arguments argv 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, [1] hash tables std::map std::set asymptotic algorithm analysis asymptotic analysis at std::vector attribute auto keyword trailing return type average case algorithm analysis

B

backing storage backing store bag balanced tree base base case, [1] base class base type begin() binary search tree best case algorithm analysis Big-O notation big-O notation big-Oh notation Big-Theta notation binary search binary search tree begin() end() iterators operator++() binary search trees binary tree binary trees recursion binary trie

binary_search binning bintree bitset std::bitset Bjarne Stroustrup FAQ multiple inheritance block boolean variable bubble sort sorting algorithms bucket bucket hashing bug build steps, [1] building software Code::Blocks Linux macOS Visual Studio Xcode by reference parameter passing by value parameter passing byte strings C strings

C

C strings byte strings character arrays, [1] std::string C++ c++ compiler C++ history C++ keywords virtual, [1] C++ standard library containers c_str std::string cache memory cache miss memory call stack, [1] functions, [1] pointers call stack unwinding recursion capacity std::vector vector cartesian product Catch2 ceiling ceiling function chain of responsibility design pattern character arrays C strings, [1] child cin circular buffer queue operations circular queue clamp Clang clang-format clang-tidy class, [1] container keyword operator overloads operator[] overload static member functions templates class design UML class diagram visibility class diagrams class hierarchy inheritance, [1] 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 hash tables closed-form solution CMake code block code generation code optimization Code::Blocks building software codelens cohesion collision collision resolution collision resolution policy collisions closed hashing hash tables open hashing

command line argument command line argument parsing command line arguments argc and argv command prompt GNU/Linux, [1] command-line compilation comment commenting anti-patterns commenting best practices comments comparable comparator comparison comparison costs sorting algorithms comparison sort compilation linking compile compile-time error compile-time evaluation Compile-time polymorphism compile-time polymorphism compiler, [1] file extensions compiler arguments debugging compiling Docker 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 adaptors std::queue std::stack container class containers std::string std::vector contiguous storage std::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 data types 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 dequeue derivation

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

E

echo, [1] edge element empirical analysis empty std::string encapsulation, [1] class invariants object-oriented programming 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 exchange sorting 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 std::string find(_if) find_first_of std::string fixed-length coding floating point representations floor floor function flyweight folding method

for_each 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 pointers pointers to functions function templates function writing guidelines function-like macro #define functions call stack, [1] friend operator overloads passing parameters fundamental type fundamental types abstraction

G

g++ compiler gap sequence Shell sort garbage garbage collection GCC gdb debugging gdb commands debugging general tree generalization UML generate

generic programming Git, [1] git editor vim git setup GitHub GNU/Linux, [1] command prompt, [1] grammar graph greedy algorithm growth rate guidelines const

H

hash function hash functions hash tables hash system hash table hash tables algorithm analysis associative containers closed hashing collisions hash functions open hashing hashing head header file extensions header files header guard, [1] header node

heap, [1] heap property heap sort heap sort heap property sorting algorithms 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] class hierarchy, [1] classes multiple object-oriented programming private UML inheritance diagrams UML initializer_list inner_product inorder traversal insertion sort sorting algorithms instance variable integer overflow

integrated development environment FAQ interface interfaces abstract base classes interfaces and implementation intermediate code intermediate code generation internal fragmentation internal node internal sort interpreter 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

L

lambda trailing return type 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 linking compilation Linus Torvalds Linux

Linux building software Linus Torvalds list literal load factor local variable local variables locale logarithms logic notation logical form loops algorithms low-level language lower bound lower bounds lower bounds proof lower_bound lvalue lvalue reference lvalues

M

Mac OS macOS building software make, [1] #include search path make_heap makefiles mandatory interfaces map 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 merge sort divide and conquer sorting algorithms

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 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 node storage std::list non-strict partial order non-terminal non-virtual functions nondeterministic null-terminated strings nullptr

O

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

operator++() binary search tree operator+= std::string operator= std::vector operator== std::string std::vector operator[] std::string std::vector operator[] overload class optimization problem overflow 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 partial order partially ordered set partition partition_copy partitioning quick sort pass by reference, [1] pass by value, [1] passing parameters functions path patterns classes permutation permutations physical form picking the right language FAQ picking the right major FAQ Pigeonhole Principle pipe operators pivot quick sort POD pointer stack pointer pointer operations pointer-based implementation for binary tree nodes pointers arrays call stack class members const debugging free store references using

pointers to pointers Polymorphism polymorphism, [1] object-oriented programming, [1] pop portability poset position postorder traversal powerset PR quadtree predicate predicate function preorder traversal primary clustering primitive element primitive type priority priority queue private inheritance probe function probe sequence problem problem instance problem solving problems 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 queue operations circular buffer

quick sort partitioning pivot sorting algorithms

R

radix radix sort digit sorting sorting algorithms RAII rand random random shuffle random uniform_int_distribution random_device range realization UML record recurrence relation recursion, [1] binary trees call stack unwinding recursive call recursive case recursive data structure recursive function redirection operators reduce refactoring algorithms

reference reference count algorithm references pointers reflexive regular type relation requires reserve vector rfind std::string 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 selection sort sorting algorithms semantic error semantic errors debugging semantics separate chaining analysis sequence sequence container sequence containers std::array std::deque std::forward_list std::list std::queue std::stack vector sequential tree representation serialization set set former set notation set product set relations set_difference set_union shadowing shallow copy Shell sort gap sequence sorting algorithms should I learn C first FAQ shuffle sibling signature simple type simulating recursion singly linked list size std::string vector slot software engineering software reuse SOLID object-oriented programming sort sort_heap sorting algorithms bubble sort comparison costs heap sort insertion sort merge sort quick sort radix sort selection sort Shell sort swap costs sorting lower bound sorting problem source code spatial spatial application spatial attribute spatial data spatial data structure SSH ssh secure shell stable_partition, [1] stack stack pointer pointer standard exceptions exceptions standard input standard library model algorithms start symbol

static functions static member functions class static scoping std::array sequence containers std::bitset std::chrono std::deque sequence containers std::equal std::exchange std::find std::forward_list sequence containers std::function std::list algorithm analysis doubly linked list node storage sequence containers std::map associative containers std::move std::multiset std::pair std::priority_queue std::queue container adaptors sequence containers std::set associative containers std::shared_ptr std::stack container adaptors sequence containers std::stod std::stoi std::strcmp std::strcpy std::string algorithm analysis, [1] C strings c_str containers empty find find_first_of operator+= operator== operator[] rfind size std::string::npos std::strncmp std::strncpy std::swap std::toupper std::unique_ptr std::unordered_multiset std::unordered_set std::vector algorithm analysis at capacity containers contiguous storage operator= operator== operator[] storage storage std::vector strategy design pattern strcmp stream strict partial order strong induction struct vs. class subclass subset subtree summation, [1] superset swap costs sorting algorithms symbol table symmetric symmetric matrix syntax syntax analysis syntax error syntax errors debugging

T

tail template template method design patterns templates class concepts function terminal test-driven development text editors this pointer to_string token total order trailing return type auto lambda

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

U

UML aggregation association class design composition dependency generalization inheritance inheritance diagrams Martin Fowler realization unary function Unified Modeling Language (UML)

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

V

valgrind debugging variable-length coding vector as C function parameters capacity reserve sequence containers size version control vertex Vim hello world modes motions

vim git editor virtual C++ keywords, [1] visibility class diagram visit visitor Visual Studio building software volatile

W

widening conversion Windows System for Linux

worst case algorithm analysis WSL

X

Xcode building software