{"title":"C++ vs C","description":null,"content":"C++ didn't appear out of nowhere. It grew directly out of C in the early 1980s, when Bjarne Stroustrup added classes to C and called the result \"C with Classes\". For most of the 80s, the two languages were nearly identical at the syntax level. They've drifted apart since, but the shared DNA is still everywhere: pointers, headers, the preprocessor, even `printf` if you want it. This chapter walks through what C++ added, what it kept, and where the two languages quietly disagree.\n\n---\n\n# Shared Heritage\n\nC++ started as a strict extension of C. The earliest goal was practical: let C programmers write object-oriented code without throwing away anything they already knew. That goal still shapes the language today. You can take a C function, drop it into a `.cpp` file, and most of the time it will compile and run identically.\n\nThe shared surface is large:\n\n- Same fundamental types: `int`, `char`, `float`, `double`, `long`, etc.\n- Same control flow: `if`, `for`, `while`, `switch`, `goto`.\n- Same operators: arithmetic, bitwise, comparison, assignment.\n- Same preprocessor: `#include`, `#define`, `#ifdef`.\n- Same pointer semantics: addresses, dereferencing, pointer arithmetic.\n- Same compilation model: source files compile to object files, linker stitches them together.\n- Same calling convention for plain functions, which is why C++ can call C libraries directly.\n\nA useful mental model is \"C++ = C + a much bigger toolbox\". The C parts are still there. They just aren't the part you reach for first anymore.\n\n\n```mermaid\nflowchart LR\n C[C Language
Core syntax, pointers,
preprocessor, types]:::primary --> CPP[C++ Language]:::secondary\n\n OOP[Classes & Objects]:::orange --> CPP\n TPL[Templates & Generics]:::green --> CPP\n STL[STL Containers
& Algorithms]:::teal\n REF[References]:::orange --> CPP\n EX[Exceptions]:::red --> CPP\n NS[Namespaces]:::green --> CPP\n OL[Function & Operator
Overloading]:::teal --> CPP\n STL --> CPP\n\n classDef primary fill:#00ceff,stroke:#000,color:#000\n classDef secondary fill:#ffa94d,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef red fill:#ff8787,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram is intentionally rough. Each of those additions is a deep topic in its own right, and they all combine in non-trivial ways. The point is that none of them replaced C. They were layered on top.\n\nThe cleanest place to see the family resemblance is \"hello, world\":\n\n\n```shell\n#include \n\nint main(void) {\n printf(\"Welcome to our store!\\n\");\n return 0;\n}\n```\n\n\n\n```cpp\n#include \n\nint main() {\n std::cout << \"Welcome to our store!\" << std::endl;\n return 0;\n}\n```\n\n\nBoth compile, both run, both print the same string. The C version uses `printf` and a format string. The C++ version uses a stream object and the overloaded `<<` operator. The C++ approach is type-safe (the compiler picks the right overload for the type you're printing), while `printf`'s format specifiers are checked only loosely at runtime. That single example already shows two big C++ additions: overloading and the standard library wrapping I/O in objects.\n\n---\n\n# What C++ Adds\n\nThe features below are the ones that make C++ feel like a different language even though the syntax is similar. Each gets its own dedicated section later in the course, so we'll stay high-level here.\n\n### Classes and Objects\n\nC has `struct`, but a struct is just a bundle of fields. Behavior lives in free functions that you pass the struct to. C++ promotes structs into full classes, with methods, constructors, destructors, access control (`public`, `private`, `protected`), inheritance, and polymorphism. That single change rewires how you organize code.\n\nHere's a \"product\" in both styles:\n\n\n```shell\n#include \n#include \n\nstruct Product {\n char name[64];\n double price;\n int stock;\n};\n\nvoid product_print(const struct Product* p) {\n printf(\"%s: $%.2f (stock: %d)\\n\", p->name, p->price, p->stock);\n}\n\nint main(void) {\n struct Product laptop;\n strcpy(laptop.name, \"Laptop\");\n laptop.price = 999.99;\n laptop.stock = 5;\n product_print(&laptop);\n return 0;\n}\n```\n\n\n\n```cpp\n#include \n#include \n\nclass Product {\npublic:\n Product(std::string n, double p, int s)\n : name(std::move(n)), price(p), stock(s) {}\n\n void print() const {\n std::cout << name << \": $\" << price\n << \" (stock: \" << stock << \")\\n\";\n }\n\nprivate:\n std::string name;\n double price;\n int stock;\n};\n\nint main() {\n Product laptop(\"Laptop\", 999.99, 5);\n laptop.print();\n return 0;\n}\n```\n\n\n**Output (both):**\n\n\n```shell\nLaptop: $999.99 (stock: 5)\n```\n\n\nThe C version separates data (the struct) from behavior (free functions that take a pointer to the struct). The C++ version bundles them together and uses a constructor to enforce that no `Product` can exist in a half-initialized state. The C++ version also hides the internal fields behind `private`, so callers can only interact with the object through its methods. Encapsulation isn't possible in plain C.\n\n### References\n\nC passes everything by value, including pointers. If you want a function to modify its argument, you pass a pointer and dereference it inside the function. C++ adds references, which are essentially \"pointers that you can't be `null` and don't need to dereference\".\n\n\n```cpp\n#include \n\nvoid applyDiscount(double& price, double percent) {\n price -= price * (percent / 100.0);\n}\n\nint main() {\n double cartTotal = 200.0;\n applyDiscount(cartTotal, 15.0);\n std::cout << \"After discount: $\" << cartTotal << std::endl;\n return 0;\n}\n```\n\n\nThe `&` in `double& price` makes `price` an alias for the caller's variable. No `*` to write, no risk of a null pointer, no chance of forgetting to dereference. References aren't a replacement for pointers, but they're the everyday tool for \"I want to read or modify the caller's object\".\n\n### Namespaces\n\nC has exactly one global namespace. If two libraries both define a function called `parse`, you have a name collision and your program won't link. C++ adds namespaces so libraries can scope their names.\n\n\n```cpp\nnamespace checkout {\n double computeTotal(double subtotal) { return subtotal * 1.08; }\n}\n\nnamespace shipping {\n double computeTotal(double weight) { return weight * 5.0; }\n}\n```\n\n\nBoth functions can coexist. You call them as `checkout::computeTotal(...)` or `shipping::computeTotal(...)`. The standard library lives in the `std` namespace, which is why you see `std::cout` and `std::string` everywhere.\n\n### Templates and Generic Programming\n\nC has no way to write a function that works for multiple types other than copy-pasting it for each type or doing unsafe tricks with `void*`. C++ adds templates, which let the compiler generate a separate version of the code for each type you use it with.\n\n\n```cpp\n#include \n\ntemplate \nT maxOf(T a, T b) {\n return (a > b) ? a : b;\n}\n\nint main() {\n std::cout << maxOf(10, 20) << \"\\n\"; // ints\n std::cout << maxOf(3.5, 2.1) << \"\\n\"; // doubles\n std::cout << maxOf(\"Mug\", \"Pen\") << \"\\n\";\n return 0;\n}\n```\n\n\nOne source function, three concrete implementations the compiler builds for you. Templates power the entire Standard Template Library, which we'll get to in a moment.\n\n### Function and Operator Overloading\n\nIn C, every function needs a unique name. `print_int`, `print_double`, `print_string`. In C++, you can give them all the same name and let the compiler pick the right one based on the argument types:\n\n\n```cpp\nvoid print(int x) { std::cout << \"int: \" << x << \"\\n\"; }\nvoid print(double x) { std::cout << \"double: \" << x << \"\\n\"; }\nvoid print(const std::string& x) { std::cout << \"string: \" << x << \"\\n\"; }\n```\n\n\nOperator overloading takes the same idea further: you can teach your own classes to work with `+`, `==`, `<<`, `[]`, and so on.\n\n### `new` / `delete` vs `malloc` / `free`\n\nC allocates raw memory with `malloc` and releases it with `free`. The bytes you get back are uninitialized; you have to set them up by hand. C++ adds the `new` and `delete` operators, which allocate memory AND run a constructor (or destructor) on it.\n\n\n```shell\n#include \n\nint* makeCart(int size) {\n int* cart = (int*)malloc(size * sizeof(int));\n // memory is uninitialized; must set each slot manually\n return cart;\n}\n// caller must remember: free(cart);\n```\n\n\n\n```cpp\n#include \n\nstd::string* makeCustomer() {\n return new std::string(\"Anita\"); // allocates AND constructs\n}\n// caller must remember: delete customer;\n```\n\n\nThe C version returns raw bytes. The C++ version gives you a fully-constructed `std::string`, complete with its internal buffer set up. We still call `delete` to release it, but in modern C++ you almost never use raw `new`/`delete` anyway. Smart pointers take over.\n\n### RAII: Destructors Run Automatically\n\nThis is arguably the biggest leap from C, and it doesn't have a flashy keyword. RAII stands for Resource Acquisition Is Initialization. The idea: when an object's constructor runs, it grabs whatever resources it needs (memory, a file handle, a lock). When the object goes out of scope, its destructor runs automatically and releases them.\n\n\n```cpp\n#include \n#include \n\nvoid writeOrder() {\n std::ofstream orderFile(\"order.txt\"); // file opened\n orderFile << \"Order #123\\n\";\n // file closed automatically when orderFile goes out of scope\n}\n```\n\n\nIn C you'd have to remember to call `fclose`. In C++, the destructor does it for you, even if an exception is thrown midway through. This single pattern eliminates entire categories of bugs (leaked memory, unclosed files, forgotten locks). The Memory Management section is essentially \"how to apply RAII to everything\".\n\n### Stronger Type System\n\nC is famously permissive about types. It happily lets you assign an `int` to a `char` and back, treats `0` as a stand-in for false, and lets many pointer types convert implicitly. C++ tightens several of these:\n\n- `bool` is a real type. C added `_Bool` later, but C++ has had `bool` from the start.\n- `enum class` (since C++11) is type-safe and scoped. Plain C enums leak their values into the surrounding scope and convert to `int` silently.\n- Implicit conversions between pointer types are stricter. Casting `void*` to `int*` requires an explicit cast in C++; C allows it silently.\n- Function signatures are part of the function's identity, thanks to overloading. C's name mangling rules are different and looser.\n\nThe practical effect is that more bugs get caught at compile time.\n\n### Standard Template Library (STL)\n\nC's standard library is small and low-level: I/O, strings (as `char` arrays), math, memory. C++'s standard library is much larger and centers on the STL: a set of container types, iterators, and algorithms built on templates.\n\n\n```cpp\n#include \n#include \n#include \n\nint main() {\n std::vector prices = {29.99, 14.99, 9.99, 49.99};\n\n std::sort(prices.begin(), prices.end());\n\n for (double p : prices) {\n std::cout << \"$\" << p << \" \";\n }\n std::cout << std::endl;\n return 0;\n}\n```\n\n\nIn C you'd write the array, write your own sort (or call `qsort` with a comparator function pointer), and manage memory yourself if the array needed to grow. The STL gives you `vector`, `map`, `unordered_map`, `set`, `string`, `sort`, `find`, and dozens of other tools out of the box. We'll spend a full section (Section 16) on it.\n\n### Exception Handling\n\nC reports errors by return codes, errno, or out-parameters. The caller is expected to check after every call. In practice, many callers don't. C++ adds exceptions: a function that hits a problem can `throw`, and the call stack unwinds until something `catch`es it.\n\n\n```cpp\n#include \n#include \n\ndouble applyDiscount(double price, double percent) {\n if (percent < 0 || percent > 100) {\n throw std::invalid_argument(\"discount must be 0-100\");\n }\n return price - price * percent / 100.0;\n}\n\nint main() {\n try {\n std::cout << applyDiscount(50.0, 150.0) << std::endl;\n } catch (const std::exception& e) {\n std::cout << \"Error: \" << e.what() << std::endl;\n }\n return 0;\n}\n```\n\n\nExceptions are controversial. Some C++ codebases ban them entirely (Google's style guide historically did).\n\n### `nullptr` Instead of `NULL`\n\nIn C, `NULL` is typically a macro defined as `((void*)0)` or just `0`. That causes subtle problems when overload resolution gets involved (does `0` match the `int` overload or the `int*` overload?). C++11 added `nullptr`, a real keyword with its own type, `std::nullptr_t`.\n\n\n```cpp\nint* ptr = nullptr; // unambiguous\nif (ptr == nullptr) { ... } // means exactly what it says\n```\n\n\nYou'll still see `NULL` in older code. New code should always use `nullptr`.\n\n### `std::string` vs C-Style char Arrays\n\nA C string is a `char` array terminated by a null byte. You manage its length, allocation, and resizing by hand using `strlen`, `strcpy`, `strcat`, `malloc`. It's error-prone in famous ways: buffer overflows, off-by-one bugs, forgetting the null terminator.\n\n\n```shell\n#include \n\nchar customerName[64];\nstrcpy(customerName, \"Anita\");\nstrcat(customerName, \" Sharma\");\n```\n\n\n\n```cpp\n#include \n\nstd::string customerName = \"Anita\";\ncustomerName += \" Sharma\";\n```\n\n\n`std::string` handles allocation, growth, and bounds for you. It works with all the STL containers and algorithms. There are still cases where C-strings matter (interop with C libraries, embedded systems with tight memory), but for application code, `std::string` is what you reach for.\n\n---\n\n# What C++ Keeps\n\nC++ didn't throw anything out for the sake of purity. Almost every C feature still works, even when there's a cleaner C++ alternative:\n\n- **Pointers.** Raw pointers and pointer arithmetic still exist. You'll use them when interfacing with C libraries, doing low-level work, or when references aren't enough.\n- **Manual memory management.** `malloc` and `free` are still callable from C++ if you include ``. You just shouldn't, in new code.\n- **C-style arrays.** `int prices[5]` still works exactly as it did in C, including the way arrays decay to pointers when passed to functions.\n- **The C standard library.** Almost the entire C standard library is available in C++ under headers like ``, ``, ``. `printf`, `scanf`, `memcpy`, `strlen`, they all still work.\n- **Direct interop with C.** You can declare a function `extern \"C\"` and link to a library written in C with no wrapper layer. This is why C++ is everywhere in systems programming: every operating system's API is fundamentally a C API.\n\nThe cost of this compatibility is that C++ is a big language with multiple ways to do the same thing. Modern C++ guidelines (the C++ Core Guidelines, in particular) help you pick one.\n\n---\n\n# What Changed Between Them\n\nFor about a decade, C++ was a strict superset of C. That isn't quite true anymore. The two languages have evolved separately since C99, and some valid C programs no longer compile as C++. The differences are mostly small but worth knowing:\n\n\n| Area | C | C++ |\n|---|---|---|\n| Implicit `void*` cast | Allowed (`int* p = malloc(...)`) | Requires explicit cast |\n| `bool` | `_Bool` (C99+) or `int` | Built-in `bool` type |\n| Function `f()` | Means \"unknown number of args\" | Means \"no args\" (same as `f(void)`) |\n| `char` literal | Has type `int` | Has type `char` |\n| Designated initializers | Standard since C99 | Standard since C++20 |\n| Variable-length arrays | Standard since C99 | Not supported (use `std::vector`) |\n| Linkage of `const` globals | External by default | Internal by default |\n\n\nIn practice, around 99% of valid C code compiles as C++ if you add the `void*` casts. But \"C with a C++ compiler\" isn't quite the same language as \"C with a C compiler\". When you're working on mixed projects, this matters.\n\n---\n\n# Feature-by-Feature Summary\n\n\n| Feature | C | C++ |\n|---|---|---|\n| OOP (classes, inheritance, polymorphism) | No | Yes |\n| Templates and generic programming | No | Yes |\n| References | No | Yes |\n| Namespaces | No | Yes |\n| Function overloading | No | Yes |\n| Operator overloading | No | Yes |\n| Exception handling | No | Yes |\n| RAII / automatic destructors | No | Yes |\n| Memory allocation | `malloc` / `free` | `new` / `delete` plus smart pointers |\n| Default string type | `char[]` + `` | `std::string` |\n| Standard containers | None (write your own) | STL: `vector`, `map`, `set`, etc. |\n| Null pointer | `NULL` (a macro) | `nullptr` (a keyword, since C++11) |\n| Type safety | Loose | Stricter, especially for enums and casts |\n| Pointers | Yes | Yes (still supported) |\n| Preprocessor | Yes | Yes (still supported, but discouraged for constants) |\n| Compile speed | Fast | Slower (templates and headers cost time) |\n| Runtime speed | Excellent | Excellent (same baseline) |\n\n\nThe bottom line is that C and C++ start from the same performance floor. C++ adds abstractions that mostly cost nothing at runtime (templates compile down to specialized code; references are pointers under the hood; RAII is just deterministic function calls). What you pay for is compile time and language complexity.\n\n---\n\n# When to Choose C vs C++\n\nIf both are options, C++ is usually the better default. You get everything C has, plus a much larger standard library and modern features. But there are real reasons to stick with C:\n\n- **Tiny embedded systems.** A C++ compiler exists for almost every platform, but C++ binaries can be larger and require runtime support (for exceptions, RTTI, the STL). On microcontrollers with 32 KB of flash, C is often the right call.\n- **Operating system kernels.** Linux, FreeBSD, and most OS kernels are written in C. The reason is partly historical and partly that C's runtime model is minimal, which makes it easier to reason about in kernel context.\n- **ABI stability.** C has a stable, well-defined Application Binary Interface. C++ doesn't, in practice. If you're building a library meant to be called from any language, you expose a C API on the outside even if the implementation is C++.\n- **Simpler toolchain.** A C codebase compiles faster and has fewer language features to learn. Some teams choose C specifically to keep the surface area small.\n\nThe flip side: choose C++ when you want the OOP toolkit, the STL, generic programming, exceptions, or just better type safety. Most application code, game engines, browsers, financial systems, and high-performance servers are C++ for exactly these reasons.\n\n---\n\n# Allocating an Array, Side by Side\n\nOne more concrete comparison, since dynamic arrays are where C and C++ feel most different in everyday code.\n\n\n```shell\n#include \n#include \n\nint main(void) {\n int n = 4;\n int* quantities = (int*)malloc(n * sizeof(int));\n if (!quantities) return 1;\n\n for (int i = 0; i < n; i++) {\n quantities[i] = (i + 1) * 10;\n }\n for (int i = 0; i < n; i++) {\n printf(\"%d \", quantities[i]);\n }\n printf(\"\\n\");\n\n free(quantities);\n return 0;\n}\n```\n\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::vector quantities = {10, 20, 30, 40};\n for (int q : quantities) {\n std::cout << q << \" \";\n }\n std::cout << std::endl;\n return 0;\n}\n```\n\n\n**Output (both):**\n\n\n```shell\n10 20 30 40\n```\n\n\nThe C version manages the allocation by hand, checks for failure, fills the array in a loop, and frees the buffer at the end. The C++ version uses `std::vector`, which sizes itself, grows on demand, and releases its memory automatically when it goes out of scope. Both produce the same output. The C++ version is harder to leak from and easier to extend (you can `push_back` more items at any time).\n\n---\n\n# Summary\n\n- C++ began as \"C with Classes\" and kept the C foundation: pointers, headers, the preprocessor, manual memory, and the C standard library are all still available.\n- The big additions are OOP (classes, inheritance, polymorphism), references, namespaces, templates, function/operator overloading, exceptions, RAII, the STL, and a stronger type system.\n- `new`/`delete` replace `malloc`/`free` for object allocation because they run constructors and destructors. Modern C++ goes further with smart pointers.\n- `std::string` and `std::vector` replace C-style char arrays and raw arrays for everyday use. They handle allocation and bounds for you.\n- `nullptr` (C++11) replaced `NULL` and `0` as the canonical null pointer value.\n- C++ is no longer a strict superset of C, but around 99% of C code compiles as C++ with minor changes (mostly explicit casts from `void*`).\n- Choose C for tiny embedded targets, OS kernels, ABI-stable libraries, or simpler tooling. Choose C++ for most other systems work where you want abstractions without paying runtime cost.\n\nIn the next lesson, we'll compare C++ to other modern languages like Java, Python, Rust, and Go.","pageType":"cpp"}

C++ vs C

Get Premium