The C++ ABI, Name Mangling & Linking

#include <iostream>
using namespace std;

// === The C++ build pipeline (three stages) ===
// 1) PREPROCESSOR  expands #include / #define  -> one big "translation unit"
// 2) COMPILER      turns each .cpp into an object file (.o / .obj)
// 3) LINKER        stitches the .o files (+ libraries) into the executable
//
// Key idea: each .cpp is compiled ALONE. The compiler only needs a
// DECLARATION (a promise) to accept a call. The LINKER later finds the
// real DEFINITION (the body). Two different
...

#include <iostream>
using namespace std;

// C allows ONE function per name. C++ allows OVERLOADING — same name,
// different parameters. The linker only sees flat symbol names, so the
// compiler MANGLES each name to bake the parameter types in.

void process(int x)    { cout << "int: "    << x << endl; }
void process(double x) { cout << "double: " << x << endl; }

// GCC/Clang mangle the two functions to DIFFERENT symbols:
//   process(int)    -> _Z7processi   (i = one int)
//   process(double
...

#include <iostream>
using namespace std;

// extern "C" turns OFF mangling, so the symbol is the plain name "c_add".
// That is how C code (and dlopen, and most OS APIs) can find the function:
// C has no mangling, so the names must match exactly.

extern "C" int c_add(int a, int b) {   // symbol is literally "c_add"
    return a + b;
}

// The classic dual-language header guard looks like this:
//   #ifdef __cplusplus
//   extern "C" {
//   #endif
//       int my_init(void);     // declarations
...

#include <iostream>
using namespace std;

int main() {
    // 🎯 YOUR TURN — fix the "undefined reference" by adding a DEFINITION.
    // The forward DECLARATION below promises greet() exists, and main()
    // calls it — but the body is missing, so the LINKER fails.

    // 1) A declaration already promises greet exists:
    //    (this line is correct, leave it)
    //    -> see the line just below main's closing brace

    cout << "Message: ";
    cout << ___ << endl;   // 👉 call greet()  (r
...

#include <iostream>
using namespace std;

// === LINKAGE: who can see a name across files ===
//
// INTERNAL linkage = private to THIS file. Two files can each have their
// own "secret" with the same name and never collide.
namespace {                 // anonymous namespace -> internal linkage (modern)
    int secret = 7;
    void bump() { secret++; }
}
static int fileCounter = 0; // file-scope 'static' -> also internal linkage

// EXTERNAL linkage = visible to OTHER files. There must be exactl
...

#include <iostream>
using namespace std;

// Imagine TWO .cpp files both define a helper called "log". With external
// linkage that is a "multiple definition" link error. Give YOUR copy
// INTERNAL linkage so it can never clash with the other file's "log".

// 🎯 YOUR TURN — wrap the helper so it is private to this file.

___ {                       // 👉 start an anonymous namespace:  namespace {
    void logMsg(const string& m) {
        cout << "[log] " << m << endl;
    }
}                 
...

#include <iostream>
using namespace std;

// === Worked example: the THREE classic linker errors, and the fix ===

// (A) UNDEFINED REFERENCE — declared, used, never defined.
//     int compute();          // declaration only
//     int main(){ compute(); } // link error:
//     undefined reference to 'compute()'
//   FIX: provide a definition AND compile/link its .cpp:
int compute() { return 42; }   // <- the missing body

// (B) MULTIPLE DEFINITION — same symbol defined in two TUs.
//     A pl
...

#include <iostream>
using namespace std;

// === ABI = Application Binary Interface ===
// The ABI is the BINARY contract two object files must agree on:
//   * how names are mangled
//   * how function arguments are passed (registers / stack)
//   * how a class / struct is laid out (size, member offsets, vtable)
//   * how std::string, std::vector, etc. are structured internally
//
// Compile-time API compatibility is NOT enough — the BINARY layout must
// match too. Two pieces of code only lin
...