{"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` when needed. This chapter walks through what C++ added, what it kept, and where the two languages 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 discarding anything they already knew. That goal still shapes the language today. A C function dropped into a `.cpp` file will, most of the time, 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\nOne way to think of the relationship: \"C++ = C + a much bigger toolbox\". The C parts are still there. They just aren't the part most code uses 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. 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 being printed), while `printf`'s format specifiers are checked only loosely at runtime. That single example 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 this overview stays high-level.\n\n### Classes and Objects\n\nC has `struct`, but a struct is just a bundle of fields. Behavior lives in free functions that take the struct as an argument. C++ promotes structs into full classes, with methods, constructors, destructors, access control (`public`, `private`, `protected`), inheritance, and polymorphism. That single change rewires how code is organized.\n\nThe same \"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. To modify an argument from inside a function, the caller passes a pointer and the function dereferences it. C++ adds references, which act as \"pointers that can't be null and don't need to be dereferenced\".\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 reading or modifying the caller's object.\n\n### Namespaces\n\nC has exactly one global namespace. If two libraries both define a function called `parse`, the program hits a name collision and 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. They're called as `checkout::computeTotal(...)` or `shipping::computeTotal(...)`. The standard library lives in the `std` namespace, which is why `std::cout` and `std::string` appear 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 that uses it.\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. Templates power the entire Standard Template Library, covered below.\n\n### Function and Operator Overloading\n\nIn C, every function needs a unique name. `print_int`, `print_double`, `print_string`. In C++, they can all share a name, and the compiler picks 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: a class can define `+`, `==`, `<<`, `[]`, and so on.\n\n### `new` / `delete` vs `malloc` / `free`\n\nC allocates raw memory with `malloc` and releases it with `free`. The returned bytes are uninitialized; the caller has 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 returns a fully-constructed `std::string`, complete with its internal buffer set up. The code still calls `delete` to release it, but in modern C++ raw `new`/`delete` is rare. 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 acquires 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 the programmer has to remember to call `fclose`. In C++, the destructor does it, 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 accepts assigning an `int` to a `char` and back, treats `0` as a stand-in for false, and allows many pointer types to 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` without diagnosis.\n- Implicit conversions between pointer types are stricter. Casting `void*` to `int*` requires an explicit cast in C++; C accepts it without one.\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 the programmer writes the array, writes a sort (or calls `qsort` with a comparator function pointer), and manages memory by hand if the array needs to grow. The STL provides `vector`, `map`, `unordered_map`, `set`, `string`, `sort`, `find`, and dozens of other tools out of the box. Section 16 covers it in full.\n\n### Exception Handling\n\nC reports errors by return codes, errno, or out-parameters. The caller is expected to check after every call. 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 `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\nOlder code still uses `NULL`. 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. Length, allocation, and resizing are managed by hand with `strlen`, `strcpy`, `strcat`, `malloc`. The pitfalls are famous: 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 automatically. 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 the default choice.\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. They appear 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++ via ``. New code should avoid them.\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` all still work.\n- **Direct interop with C.** A function declared `extern \"C\"` can 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 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++ once the `void*` casts are added. But \"C with a C++ compiler\" isn't quite the same language as \"C with a C compiler\". 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 compile to pointers; RAII is deterministic function calls). The cost 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. It includes everything C has, plus a much larger standard library and modern features. There are still 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. A library meant to be called from any language exposes a C API on the outside, even when 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++ for the OOP toolkit, the STL, generic programming, exceptions, or better type safety. Most application code, game engines, browsers, financial systems, and high-performance servers are C++ for those 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 (`push_back` can add more items at any time).","pageType":"cpp"}

C++ vs C

Get Premium