Programming foundations cheat sheet (C++)

1. 1Language basicsThe building blocks every program uses: values and types, decisions, loops, functions, strings and missing values. Get these automatic before anything else.9 concepts

   1. 1Variables and typesA variable is a name that refers to a value.
   2. 2Static and dynamic typingStatically typed languages (Java, C++, C#) check types when the code is compiled.
   3. 3ConditionalsCode that runs only when a condition is true, with else if branches checked in order and an optional else for everything left.
   4. 4LoopsA loop repeats a block of code: a for-each loop visits every item in a collection, a counting for loop runs over a range of indexes, and a while loop…
   5. 5FunctionsA named block of code that takes inputs (parameters), does one job and can return a result.
   6. 6ScopeScope is the part of the code where a name is visible.
   7. 7Strings and formattingA string is a sequence of text characters.
   8. 8Null and missing valuesA special value meaning "nothing here": None in Python, null and undefined in JavaScript, null in Java and C#.
   9. 9Reading and validating inputReading text typed by a user or passed to the program, then converting it to the type you need, such as an integer, and rejecting anything that does not fit.

   9 in this chapterOpen this chapter
2. 2Collections, errors and filesThe core collections you use every day, what happens when you share them, and how to handle errors, files and code split across modules.8 concepts

   1. 1Lists and dynamic arraysAn ordered collection that grows as you add items and gives fast access by index: list in Python, arrays in JavaScript, ArrayList in Java, std::vector in…
   2. 2Dictionaries and mapsA collection of key and value pairs where you look a value up by its key, such as a product name to its stock count.
   3. 3SetsAn unordered collection of unique values with fast membership checks.
   4. 4Mutability and copyingA mutable value can change in place; an immutable one cannot.
   5. 5ExceptionsAn exception is an error object thrown when something goes wrong.
   6. 6Reading files and cleaning upFiles, network connections and locks must be closed when you are done, even if an error happens halfway.
   7. 7Modules and importsA module is a file (or group of files) of related code that other files import by name.
   8. 8Reading errors and debuggingA stack trace lists the chain of function calls that led to an error, with file names and line numbers.

   8 in this chapterOpen this chapter
3. 3C++ essentialsModern C++ in practice: how code is built, references and pointers, who owns memory, and the undefined behaviour you must learn to avoid.7 concepts

   1. 1Compiling and linkingThe compiler turns each .cpp file into an object file, and the linker joins object files and libraries into one executable.
   2. 2References and constA reference (T&) is another name for an existing object.
   3. 3PointersA pointer holds the memory address of an object.
   4. 4RAIIRAII ties a resource (memory, file, lock) to an object: the constructor acquires it and the destructor releases it when the object goes out of scope, even if an…
   5. 5Smart pointersstd::unique_ptr is the single owner of a heap object and deletes it automatically.
   6. 6Undefined behaviourCode the C++ standard places no requirements on, such as reading out of bounds, using uninitialised variables, signed integer overflow or using a destroyed…
   7. 7Move semanticsMoving transfers the resources of an object (such as the buffer of a string) to another object instead of copying them.

   7 in this chapterOpen this chapter
4. 4Command line and GitThe terminal and Git commands every team expects from day one: moving around, committing, branching, working with GitHub and recovering from mistakes.11 concepts

   1. 1Shell navigationThe shell is a text interface for running programs and working with files.
   2. 2Repositories and commitsA Git repository stores the full history of a project.
   3. 3Staging areaThe staging area holds the changes that will go into the next commit.
   4. 4.gitignoreA file listing patterns of files and folders Git should not track, such as dependencies, build output, logs and local secrets.
   5. 5BranchesA branch is a movable name that points to a commit.
   6. 6Merging and rebasingMerging joins another branch into yours, adding a merge commit if both changed.
   7. 7Merge conflictsA conflict happens when two branches changed the same lines.
   8. 8Remotes: clone, fetch, pull and pushA remote is a copy of the repository on a server such as GitHub, usually named origin.
   9. 9Pull requestsA pull request asks to merge one branch into another on GitHub.
   10. 10Undoing mistakesrestore discards uncommitted changes to a file, commit --amend fixes the last commit, revert adds a commit that undoes an old one, reset moves your…
   11. 11Commit messagesA short summary line in the imperative mood (about 50 characters), a blank line, then a body that explains why the change was made.

   11 in this chapterOpen this chapter
5. 5How computers run your codeEnough of what happens below your code that memory and number bugs stop surprising you: bits, text, the CPU, memory, compilers and the operating system.9 concepts

   1. 1Bits, bytes and binaryA bit is a 0 or 1.
   2. 2Text encoding and UnicodeUnicode gives every character a number (a code point).
   3. 3How the CPU runs a programThe CPU repeatedly fetches an instruction from memory, decodes it and executes it: simple steps such as add, compare, jump and copy.
   4. 4Compiled and interpreted codeA compiler translates source to machine code before running (C++).
   5. 5Stack and heapThe stack holds each running function's local variables in frames that vanish when it returns.
   6. 6Passing arguments to functionsPython, JavaScript and Java always pass a copy of the value, but for objects that value is a reference, so the function can change the object but not rebind…
   7. 7Floating point numbersFloats store numbers in binary with limited precision, so most decimal fractions such as 0.1 are approximations.
   8. 8Integer overflowFixed-size integers have a maximum.
   9. 9Processes and threadsThe operating system runs each program as a process with its own memory.

   9 in this chapterOpen this chapter
6. 6Data structures and Big-OThe handful of structures most code is built from, and how to reason about the time and memory a solution costs as the input grows.10 concepts

   1. 1Big-O notationBig-O describes how the running time or memory of an algorithm grows as the input size n grows, ignoring constants.
   2. 2Arrays and amortised growthAn array stores items side by side in memory, so reading by index is O(1).
   3. 3Linked listsA chain of nodes where each node holds a value and a pointer to the next (and, in a doubly linked list, the previous) node.
   4. 4StacksA last-in, first-out collection: you push onto the top and pop from the top, both O(1).
   5. 5Queues and dequesA queue is first-in, first-out: add at the back, remove from the front, both O(1).
   6. 6How hash tables workA hash table turns a key into a number with a hash function, uses it to pick a bucket in an array, and stores the entry there.
   7. 7Trees and binary search treesA tree is a hierarchy of nodes with one root, where each node has children and no cycles.
   8. 8GraphsA graph is a set of nodes (vertices) connected by edges, which may have directions or weights.
   9. 9RecursionA function that calls itself on a smaller version of the problem, with a base case that stops the calls.
   10. 10Binary searchSearching a sorted array by checking the middle element and discarding the half that cannot contain the target, until it is found or the range is empty.

   10 in this chapterOpen this chapter
7. 7Object-oriented design and clean codeHow to organise programs so they stay readable as they grow: classes where they help, clear boundaries, good names and the principles reviewers ask about.10 concepts

   1. 1Classes and objectsA class is a blueprint that groups data (fields) with the behaviour that works on it (methods).
   2. 2EncapsulationKeeping an object's data private and exposing only the operations that keep it valid.
   3. 3Inheritance and compositionInheritance builds a class from a parent class and reuses its code ("is a").
   4. 4Interfaces and polymorphismAn interface is a contract listing methods a type must provide.
   5. 5Separation of concernsSplitting a program so each part handles one concern: reading input, business logic, storage and output live in separate functions or modules.
   6. 6DRY, KISS and YAGNIDRY: keep each piece of knowledge in one place.
   7. 7Naming and small functionsNames that say what a value is or what a function does (unpaid_invoices, send_reminder), and functions short enough to do one thing at one level of detail.
   8. 8SOLIDFive design principles: a class has one reason to change; extend behaviour without editing working code; subtypes must work wherever the parent does; keep…
   9. 9Code smells and refactoringA code smell is a sign of a deeper design problem: long functions, duplicated blocks, many parameters, deep nesting.
   10. 10Comments, docstrings and READMEsComments explain why code does something non-obvious.

   10 in this chapterOpen this chapter
8. 8Testing your codeUnit tests on the logic that matters, test-driven development, test doubles and the edge cases that break most beginner programs.5 concepts

   1. 1Unit testsSmall automated tests that call one function or class with known input and assert on the result.
   2. 2Test-driven developmentWriting a failing test first (red), then the least code that makes it pass (green), then cleaning up (refactor), in short cycles.
   3. 3Test doublesStand-ins for real dependencies in tests: a stub returns fixed answers, a fake is a simple working version (an in-memory store), and a mock checks how it was…
   4. 4Edge casesInputs at or beyond the limits of normal use: empty collections, zero, negative numbers, one item, very large values, missing fields and unexpected text.
   5. 5The test pyramidA guideline for balancing test types: many fast unit tests, fewer integration tests that check parts working together, and a few slow end-to-end tests through…

   5 in this chapterOpen this chapter
9. 9Build and ship projectsTurning skills into finished, shareable work: scoping, JSON and APIs, dependencies, configuration, a good README and publishing on GitHub.7 concepts

   1. 1Scoping a small projectCutting an idea down to the smallest version that solves one real problem end to end, then splitting it into a handful of milestones.
   2. 2Reading and writing JSONJSON is a text format for objects, arrays, strings, numbers, booleans and null.
   3. 3Calling a public APISending an HTTP request (usually GET or POST) to a web service and reading its response, typically a status code plus a JSON body.
   4. 4CMakeCMake describes how to build a C++ project in CMakeLists.txt and generates the real build files for your platform.
   5. 5Configuration and secretsSettings that change between machines (API keys, URLs, file paths) are read from environment variables or a local config file instead of being written into the…
   6. 6Writing a READMEThe front page of a repository: what the project does and for whom, a demo, how to install, run and test it, how it works and its known limits.
   7. 7Publishing on GitHubPushing a project to a public GitHub repository with a README, a licence, a .gitignore and a clean history of meaningful commits.

   7 in this chapterOpen this chapter
10. 10Glossary, A to ZEvery concept in the sheet and the smaller terms it uses, in one list.161 terms

First language, Git, CS basics.