C/C++ Interop and Foreign Function Interface: A Practical Guide

// C header: clib.h
#ifndef CLIB_H
#define CLIB_H
void c_function(int x);
#endif

// C++ file: main.cpp
#include <iostream>

extern "C" {
    #include "clib.h"
}

int main() {
    c_function(42);
    return 0;
}

// C implementation: clib.c
#include <stdio.h>
void c_function(int x) {
    printf("C function called with %d\n", x);
}

// C++ code: cpplib.cpp
#include <iostream>

class MyClass {
public:
    void greet(const char* name) {
        std::cout << "Hello, " << name << "!" << std::endl;
    }
};

// C-compatible wrapper
extern "C" {
    void* MyClass_create() {
        return new MyClass();
    }
    void MyClass_greet(void* obj, const char* name) {
        static_cast<MyClass*>(obj)->greet(name);
    }
    void MyClass_destroy(void* obj) {
        delete static_cast<MyClass*>(obj);
    }
}

// C caller: main.c
#include <stdio.h>

void* MyClass_create();
void MyClass_greet(void* obj, const char* name);
void MyClass_destroy(void* obj);

int main() {
    void* obj = MyClass_create();
    MyClass_greet(obj, "World");
    MyClass_destroy(obj);
    return 0;
}

// C++ code: math_ops.cpp
extern "C" {
    double add(double a, double b) {
        return a + b;
    }
    double multiply(double a, double b) {
        return a * b;
    }
}

// Compile: g++ -shared -o libmath.so math_ops.cpp

// Python code: use_math.py
import ctypes

lib = ctypes.CDLL('./libmath.so')
lib.add.restype = ctypes.c_double
lib.add.argtypes = [ctypes.c_double, ctypes.c_double]

result = lib.add(3.5, 2.7)
print(f"Result: {result}")

// C++ code: struct_ops.cpp
#include <cstdint>

#pragma pack(push, 1)
struct Point {
    int32_t x;
    int32_t y;
};
#pragma pack(pop)

extern "C" {
    int32_t sum_coords(Point p) {
        return p.x + p.y;
    }
}

// Python code: use_struct.py
import ctypes

class Point(ctypes.Structure):
    _fields_ = [("x", ctypes.c_int32),
                ("y", ctypes.c_int32)]

lib = ctypes.CDLL('./libstruct.so')
lib.sum_coords.argtypes = [Point]
lib.sum_coords.restype = ctypes.c_int32

p = Point(10, 20)
print(lib.sum_coords(p))

// Windows DLL: winlib.cpp
#include <windows.h>

extern "C" {
    __declspec(dllexport) int __stdcall add_stdcall(int a, int b) {
        return a + b;
    }
}

// Python ctypes with stdcall
import ctypes

lib = ctypes.WinDLL('./winlib.dll')
lib.add_stdcall.argtypes = [ctypes.c_int, ctypes.c_int]
lib.add_stdcall.restype = ctypes.c_int
print(lib.add_stdcall(3, 4))

// C++ code: safe_ops.cpp
#include <cstring>

static char last_error[256] = {0};

extern "C" {
    int divide(int a, int b, int* result) {
        if (b == 0) {
            strncpy(last_error, "Division by zero", sizeof(last_error) - 1);
            return -1;
        }
        *result = a / b;
        return 0;
    }
    const char* get_last_error() {
        return last_error;
    }
}

// Python code
import ctypes

lib = ctypes.CDLL('./liberror.so')
lib.divide.argtypes = [ctypes.c_int, ctypes.c_int, ctypes.POINTER(ctypes.c_int)]
lib.divide.restype = ctypes.c_int
lib.get_last_error.restype = ctypes.c_char_p

result = ctypes.c_int()
ret = lib.divide(10, 0, ctypes.byref(result))
if ret != 0:
    print(f"Error: {lib.get_last_error().decode()}")
else:
    print(f"Result: {result.value}")

#include <cstring>
#include <cstdio>

extern "C" {
    void safe_print(const char* msg, size_t len) {
        // Use bounded copy to avoid overflow
        char buffer[256];
        if (len >= sizeof(buffer)) {
            len = sizeof(buffer) - 1;
        }
        strncpy(buffer, msg, len);
        buffer[len] = '\0';
        printf("%s\n", buffer);
    }
}