Complete C++ Programming Notes — Theory & Practical

A single-page, comprehensive reference that covers history, language fundamentals, advanced features, STL, best practices, common exam questions, and practical labs. Use the built-in examples and download runnable .cpp files or open them in any online C++ compiler.

History & Evolution of C++

• 1950s–1960s: Early mechanical calculators (abacus) to high level languages: Fortran (1957), COBOL (1959).
• 1970s: C language (1972, Dennis Ritchie) — systems programming and portability.
• 1983: C++ is named and released by Bjarne Stroustrup ("C with Classes" evolved into C++). Introduced OOP to systems programming.
• 1989–1998: Early standardization efforts, ISO C++98 standardized core features (templates, exceptions, standard library). Key contributors: Bjarne Stroustrup, Herb Sutter, Scott Meyers, others.
• 2003: C++03 technical corrections.
• 2011: C++11 major update — move semantics, auto, lambda, threading, smart pointers, range-based for.
• 2014: C++14 small improvements.
• 2017: C++17 — structured bindings, filesystem library, optional, variant.
• 2020: C++20 — concepts, ranges, coroutines, modules (work in progress), std::span.
• 2023+: Ongoing improvements (C++23, C++26 planning), community and compiler support evolving.

Why it matters: Understanding history helps explain design choices: performance, low-level memory control, and the balance of generic programming plus abstraction.

Basics: Getting Started

How to compile and run

1. Install a compiler: g++ (MinGW on Windows, GCC on Linux/Mac), or use Visual Studio / MSVC on Windows.
2. Compile: g++ -std=c++17 -O2 -Wall file.cpp -o program
3. Run: ./program (Windows: program.exe)

Program structure

// hello.cpp
#include <iostream>
int main() {
  std::cout << "Hello, C++!\n";
  return 0;
}

Core concepts

• Variables & Types: int, long, float, double, char, bool, void.
• Compound Types: arrays, pointers, references, structs, classes, enums, std::string.
• Control Flow: if/else, switch, loops (for, while, do-while).
• Functions: declarations, definitions, pass-by-value/reference, default args, overloading.

Syntax & Examples (Concise)

Functions & Overloading

int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }

References & Pointers

void inc_by_ref(int &x) { x++; }
void inc_by_ptr(int *x) { (*x)++; }

Classes & Objects

class Point {
public:
  int x, y;
  Point(int x_, int y_) : x(x_), y(y_) {}
  double dist() const { return std::sqrt(x*x + y*y); }
};

Point p(3,4);

Object-Oriented Programming (OOP)

• Encapsulation: class, private/public/protected members.
• Inheritance: single and multiple inheritance (use virtual base classes to avoid diamond problem).
• Polymorphism: virtual functions and RTTI (dynamic_cast, typeid).
• Constructors/Destructors: default, parameterized, copy/move constructors, assignment operators, explicit keyword.

Rule of Five (important)

1. Destructor
2. Copy constructor
3. Copy assignment operator
4. Move constructor
5. Move assignment operator

class Resource {
  int *data;
public:
  Resource() : data(new int[100]) {}
  ~Resource() { delete[] data; }
  Resource(const Resource &other) { /* deep copy */ }
  Resource& operator=(const Resource &other) { /* ... */ return *this; }
  Resource(Resource&& other) noexcept : data(other.data) { other.data = nullptr; }
};

Advanced Topics

Templates

template <typename T>
T add(T a, T b) { return a + b; }

// Class template
template <class T>
class Stack { /* ... */ };

Smart Pointers

#include <memory>
std::unique_ptr<int> up = std::make_unique<int>(42);
std::shared_ptr<int> sp = std::make_shared<int>(7);

Move Semantics & Rvalue References

void f(std::string &&s) { /* s is an rvalue reference */ }
std::string a = "hello";
std::string b = std::move(a); // move contents

Concurrency (threads)

#include <thread>
#include <mutex>

void worker() { /* do work */ }
std::thread t(worker);
t.join();

RAII (Resource Acquisition Is Initialization)

Manage resources (files, locks) via constructors/destructors to ensure deterministic cleanup.

STL: Containers, Iterators, Algorithms

Common Containers

• std::vector — dynamic array
• std::list — doubly-linked list
• std::deque
• std::map / std::unordered_map
• std::set / std::unordered_set
• std::string

Algorithms

#include <algorithm>
#include <vector>

std::vector<int> v = {3,1,4};
std::sort(v.begin(), v.end());
int x = std::binary_search(v.begin(), v.end(), 3);

Iterators & Ranges

Use range-based for loops: for (auto &x : container). C++20 ranges add expressive composition.

Memory Management & Undefined Behavior

• Avoid dangling pointers (returning pointer to local variable).
• Prefer smart pointers (unique_ptr, shared_ptr) over raw new/delete.
• Watch buffer overflows, out-of-bounds access.
• Be mindful of object lifetimes and ownership.

File I/O & Streams

#include <fstream>
std::ofstream ofs("data.txt");
ifs << "...";

Exceptions & Error Handling

try {
  // code that may throw
} catch (const std::exception &e) {
  std::cerr << e.what();
}

Use exceptions for exceptional conditions; avoid using them for control flow in performance-critical code.

Practical Labs & Examples (runnable)

Below are several ready-to-download example programs. Click "Download" to get the .cpp file, then compile locally or paste into an online compiler like Compiler Explorer or cpp.sh.

// hello_input.cpp
#include <iostream>
#include <string>
int main(){
  std::string name;
  std::cout << "Enter your name: ";
  std::getline(std::cin, name);
  std::cout << "Hello, " << name << "!\n";
  return 0;
}

// sort_example.cpp
#include <iostream>
#include <vector>
#include <algorithm>
int main(){
  std::vector<int> v = {5,3,8,1};
  std::sort(v.begin(), v.end());
  for(auto x : v) std::cout << x << ' ';
  std::cout << '\n';
}

// student_save.cpp
#include <iostream>
#include <fstream>
#include <string>
using namespace std;
struct Student{ string name; int id; };
int main(){
  Student s{"Alice", 123};
  ofstream ofs("student.txt");
  ofs << s.name << '\n' << s.id << '\n';
  ofs.close();
}

How to run these examples online:

1. Open Compiler Explorer (Godbolt) and paste the code, select a compiler (e.g., g++ 12.2), and run (Godbolt shows assembly/output depending on setup).
2. Or open cpp.sh, paste code, and run (provides console I/O environment).
3. Or download the file and compile locally: g++ -std=c++17 file.cpp -o file then ./file.

Common Theory Questions (with short model answers)

1. Q: Explain the difference between stack and heap memory.
   A: Stack memory stores function local variables and is automatically managed (LIFO). Heap is for dynamic allocations (new/malloc) and must be freed (delete/free). Stack allocations are faster but limited in size; heap is larger but requires manual management or smart pointers.
2. Q: What is RAII?
   A: Resource Acquisition Is Initialization — resource setup is tied to object lifetime. Destructor frees resource. Ensures exception-safe cleanup.
3. Q: Explain move semantics.
   A: Move semantics allows transferring resources from temporaries (rvalues) using move constructors/assignment, avoiding expensive copies. Implemented using rvalue references (T&&) and std::move.

Cheat Sheet: Common Syntax & Commands

• Compile: g++ -std=c++17 -O2 -Wall file.cpp -o program
• Common includes: <iostream> <vector> <string> <algorithm> <memory> <thread>
• Smart pointers: unique_ptr (exclusive), shared_ptr (shared ownership)

Further Reading & Tools

• Books: "The C++ Programming Language" (Bjarne Stroustrup), "Effective Modern C++" (Scott Meyers), "C++ Primer" (Lippman, Lajoie, Moo).
• Tools: Compiler Explorer (godbolt.org), cppreference.com (language reference), valgrind (memory debugging), sanitizers: -fsanitize=address,undefined.