C++ as superset of C — key additions — Coding notes

WHY does C++ exist at all?

WHY add to C? C is brilliant for talking to hardware but offers almost no help with organising large programs. As codebases grew, programmers kept re-inventing the same patterns by hand:

grouping data and the functions that act on it → led to classes
generic containers that work for any type → led to templates
safer error signalling than return-code checking → led to exceptions
catching bugs at compile time instead of runtime → led to stronger type checking

So C++ is C + abstractions that let humans manage complexity, paying (ideally) zero runtime cost for features you don't use — the famous "you don't pay for what you don't use" principle.

WHAT got added — the big buckets

Figure — C++ as superset of C — key additions

1. Classes & Object-Oriented Programming (OOP)

WHAT: class/struct bundle data + member functions, with public/private access control, constructors, destructors, inheritance, and virtual polymorphism. WHY: In C you pass a struct Account* to free functions like deposit(acc, x). Nothing stops anyone from corrupting acc->balance directly. A class makes balance private, so the only legal path is through methods → invariants stay protected.

2. Templates (generic programming)

WHAT: template<typename T> lets one definition serve every type. WHY: In C, a "max" must be a macro (#define MAX(a,b)..., unsafe) or rewritten per type. Templates give type-safe, zero-overhead genericity, resolved at compile time.

3. References, `new`/`delete`, `bool`, default args, overloading

References (int& r = x;): an alias — like a pointer that's always valid and auto-dereferenced. WHY: cleaner pass-by-reference than int*.
new/delete: type-aware allocation that calls constructors/destructors (unlike malloc/free).
Function overloading: same name, different parameter lists. WHY: print(int) and print(double) instead of print_int, print_double.
Default arguments, bool as a real type, inline functions.

4. Namespaces

WHAT: namespace net { ... } groups names to avoid clashes. WHY: C has one global namespace, so two libraries both defining init() collide. C++ gives net::init() vs gfx::init().

5. STL + Exceptions + stronger typing

STL: ready-made vector, map, string, sort, iterators.
Exceptions: throw/try/catch separate the error path from the happy path.
Stronger type rules: e.g. C++ forbids implicit void*→T* conversion that C allows.

HOW each addition derives from a C pain-point

Worked example From C struct → C++ class (Why each step?)

C version:

struct Account { int balance; };
void deposit(struct Account* a, int x) { a->balance += x; }

Why this step? Data and behaviour are separate; balance is exposed.

C++ version:

class Account {
    int balance = 0;           // private by default in a class
public:
    void deposit(int x) { balance += x; }   // method bundled with data
    int get() const { return balance; }     // const = promises not to modify
};

Why private? So no outside code can set balance to a garbage value — the invariant "balance changes only via deposit/withdraw" is now enforced by the compiler.

Worked example Macro

MAX → template (Why each step?) C (fragile): #define MAX(a,b) ((a)>(b)?(a):(b)) Why fragile? MAX(i++, j) evaluates i++ twice — a classic bug; no type checking.

C++:

template<typename T>
T maxv(T a, T b) { return a > b ? a : b; }

Why better? It's a real function: arguments evaluated once, type-checked, works for int, double, string — the compiler stamps out one version per type used.

Worked example Reference vs pointer (Why each step?)

void inc(int& r) { r++; }      // r is an alias for the caller's variable
int x = 5; inc(x);             // x becomes 6, no &, no *

Why this matters? Compare C's void inc(int* p){ (*p)++; } inc(&x);. The reference removes the noisy */& and cannot be null/reseated, so a whole class of pointer bugs disappears.

Common mistakes (Steel-manned)

Active recall

Recall Cover the answers — can you reproduce them?

Name the five "buckets" C++ adds to C. → OOP/classes, templates, references+new/delete+overloading, namespaces, STL+exceptions+stronger typing.
Why is C++ a near-superset, not a true superset? → C++ is stricter (no implicit void* cast, reserved keywords, etc.).
One concrete reason new ≠ malloc? → new runs constructors/destructors.
What problem do namespaces solve? → name collisions across libraries.

Recall Feynman: explain to a 12-year-old

Imagine C is a basic LEGO set: you can build anything, but every brick is plain and you must keep track of all of them yourself. C++ is the same box of LEGO plus a few magic helpers: a labelled box that keeps related bricks together and won't let you break them (classes), a photocopier that makes the same shape in any colour you want (templates), and name tags so two kids' pieces don't get mixed up (namespaces). You can still use the plain bricks exactly like before — the helpers are extra, not replacements.

Connections

Classes and Objects in C++
Templates and Generic Programming
Pointers vs References
new and delete vs malloc and free
Namespaces and the std namespace
The STL — vector, map, string
Exception Handling try-catch-throw
Compilation Model — C vs C++

C++ originally went by what name, reflecting its first major addition?

"C with Classes"

Define a near-superset and say why C++ is only a near-superset of C.

Most valid programs of A also compile in B; C++ is stricter (e.g. no implicit void*→T* conversion, more reserved keywords) so a few C programs fail to compile.

List the five buckets of C++ additions over C.

Classes/OOP, Templates, References+new/delete+overloading, Namespaces, STL+exceptions+stronger typing.

What is the key behavioural difference between new/delete and malloc/free?

new/delete call constructors/destructors; malloc/free do not.

Why are templates safer than C macros for generic code like MAX?

Templates are real functions: arguments evaluated once and type-checked; macros can double-evaluate and have no type safety.

What problem do namespaces solve that C cannot?

Name collisions — C has a single global namespace, so two libraries defining init() clash; namespaces give net::init() vs gfx::init().

State the C++ design principle about feature cost.

"You don't pay for what you don't use" — zero overhead for features not used.

What does a reference give you over a raw pointer?

An always-valid, auto-dereferenced alias that cannot be null or reseated, removing a class of pointer bugs.

Give one C snippet that compiles in C but errors in C++.

int* p = malloc(4); — C++ requires an explicit cast from void*.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, C++ ko samajhne ka sabse simple tarika ye hai: C++ = C + extra powers. C ek bahut fast aur low-level language hai — pointers, structs, direct memory access sab kuch deta hai, par bade programs organise karne mein help nahi karta. Isliye Bjarne Stroustrup ne "C with Classes" banaya, jo aage chalke C++ ban gaya. Matlab jo bhi C mein aata hai, woh almost sab C++ mein bhi chalta hai — par C++ thoda strict hai (isliye "near-superset" bolte hain, perfect superset nahi).

Paanch main additions yaad rakho (mnemonic CRiSP-N): Classes/OOP (data aur functions ko ek box mein band karke private se protect karna), References + new/delete + overloading (pointers se cleaner, aur new constructor bhi call karta hai jo malloc nahi karta), STL + Exceptions (ready-made vector, map, aur error handling try-catch se), Parametric templates (ek hi maxv function jo har type ke liye kaam kare, macro ke bina), aur Namespaces (do libraries ka same naam init() clash na ho).

Important baat — ye sab features muft mein speed nahi kha jaate. C++ ka golden rule hai: "you don't pay for what you don't use." Agar tum virtual use nahi karte, to OOP ka koi extra runtime cost nahi. Templates compile-time pe resolve ho jaate hain, isliye macro jaisa danger bhi nahi aur speed bhi full.

Exam aur interview ke liye 80/20 point: yaad rakho ki C++ C ko replace nahi karta, usko extend karta hai. Common galti — "new bilkul malloc jaisa hai" — galat; new/delete constructor/destructor chalate hain, malloc/free nahi. Aur "C ka har code C++ mein chalta hai" — bhi galat, kyunki C++ stricter type rules rakhta hai.

C++ as superset of C — key additions

WHY does C++ exist at all?

WHAT got added — the big buckets

1. Classes & Object-Oriented Programming (OOP)

2. Templates (generic programming)

3. References, `new`/`delete`, `bool`, default args, overloading

4. Namespaces

5. STL + Exceptions + stronger typing

HOW each addition derives from a C pain-point

Common mistakes (Steel-manned)

Active recall

Connections

Concept Map

Hinglish (regional understanding)

Go deeper — visual, from zero

Test yourself — C++ Programming