C / C++ Interoperability

#include <iostream>
using namespace std;

// C++ "mangles" function names to encode their argument types, which is
// how overloading works. C does NOT mangle — a function is just its name.
// extern "C" says: "give this C-linkage, the plain unmangled name."

// A single function with C linkage:
extern "C" int add(int a, int b) {
    return a + b;
}

// A whole BLOCK of functions with C linkage — the usual style:
extern "C" {
    int square(int x)  { return x * x; }
    int cube(int x)    { retu
...

#include <iostream>
using namespace std;

// THE portable header pattern. A real project puts this in mathlib.h so
// BOTH a C compiler and a C++ compiler can include the same file.
//
//   #ifndef MATHLIB_H
//   #define MATHLIB_H
//
//   #ifdef __cplusplus      // __cplusplus is defined ONLY by C++ compilers
//   extern "C" {            // so C++ sees: wrap these in C linkage
//   #endif
//
//       int add(int a, int b);          // plain C declarations
//       double average(const int* v, in
...

#include <iostream>
using namespace std;

int main() {
    // 🎯 YOUR TURN — give two functions C linkage so a C program could
    // link against them. Replace each ___ then press "Try it Yourself".
    return run();
}

// 1) Wrap this function so its name is NOT mangled.
//    👉 put  extern "C"  in front of the return type
___ int multiply(int a, int b) {
    return a * b;
}

// 2) Wrap a whole block of two functions with C linkage.
//    👉 the block opens with  extern "C" {
___ {
    int ne
...

#include <iostream>
#include <cstring>
using namespace std;

// Across the C boundary you may only pass PLAIN DATA: numbers, pointers,
// and "POD" structs (plain-old-data — no methods, no constructors).

// A POD struct both C and C++ agree on, byte for byte:
struct Point {
    double x;
    double y;
};

// C-style API: take a POINTER to the struct (C has no references),
// fill it in by writing through the pointer.
extern "C" void makePoint(Point* p, double x, double y) {
    p->x = x;       
...

#include <iostream>
#include <stdexcept>
using namespace std;

// A C++ function that can THROW. C code cannot survive a C++ exception,
// so we never let it cross the boundary.
double cppDivide(int a, int b) {
    if (b == 0) throw runtime_error("divide by zero");
    return static_cast<double>(a) / b;
}

// The C-facing wrapper: it CATCHES everything and reports errors the
// C way — a return code (0 = ok, non-zero = error) plus an out-param.
extern "C" int safe_divide(int a, int b, double* re
...

#include <iostream>
using namespace std;

// A C++ helper. It uses C++ features, so it must stay behind a wrapper.
int cppFactorial(int n) {
    int result = 1;
    for (int i = 2; i <= n; i++) result *= i;
    return result;
}

// 🎯 YOUR TURN — finish the C-facing wrapper.
// 1) Give it C linkage so a C program can call it.
//    👉 prefix the line with  extern "C"
___ int c_factorial(int n) {
    // 2) Report invalid input the C way: return -1 instead of throwing.
    //    👉 replace ___ wit
...

#include <iostream>
#include <cstring>   // C string functions: strlen, strcpy, strcmp...
#include <cstdlib>   // C memory + utilities: malloc, free, qsort, atoi
using namespace std;

// C library headers in C++ get a 'c' prefix and drop the .h:
//   <string.h> -> <cstring>,  <stdlib.h> -> <cstdlib>
// They already wrap their declarations in extern "C" for you.

int compareInts(const void* a, const void* b) {
    // qsort hands you void*; cast back to the real type, then compare.
    int x = *st
...