Что нужно учитывать при взаимодействии библиотек C и C++?

Взаимодействие библиотек C и C++

Это критическая тема в профессиональной backend-разработке. Много production кода зависит от C библиотек, и нужно знать подводные камни.

Проблема: Name Mangling

C++ использует name mangling для поддержки перегрузки функций. C этого не поддерживает.

// C++ компилятор преобразует имена функций:
void print(int);      // _Z5printi
void print(double);   // _Z5printd

// C компилятор просто:
int add(int, int);    // add

Если C++ код пытается вызвать C функцию, компилятор будет искать mangled имя, которое не существует.

Решение: extern "C"

// c_library.h (может быть включен из C и C++)
#ifdef __cplusplus
extern "C" {
#endif

void c_function(int x);
int get_value(void);

#ifdef __cplusplus
}
#endif

Это говорит C++ компилятору: не использовать name mangling для этих символов.

// c_library.c (чистый C код)
void c_function(int x) {
    printf("Value: %d\n", x);
}

int get_value(void) {
    return 42;
}

// main.cpp (C++ код)
extern "C" {
#include "c_library.h"
}

int main() {
    c_function(10);  // Вызовет именно функцию "c_function", без mangling
    return 0;
}

Проблема: Calling Convention

Calling convention — это соглашение о том, как передаются аргументы и возвращаются результаты.

• cdecl (по умолчанию на x86/x64): аргументы в стеке, вызывающий очищает
• stdcall (Windows): аргументы в стеке, вызываемая функция очищает
• fastcall (Windows): первые аргументы в регистрах
• System V AMD64 ABI (Linux/Unix x64): первые 6 аргументов в регистрах

Обычно это работает автоматически, если обе стороны используют одну систему. Но если смешиваешь old-style code, проблемы возможны.

// Явный контроль calling convention (Windows)
extern "C" __cdecl int my_c_function(int a, int b);  // cdecl
extern "C" __stdcall int another_function(void);     // stdcall

Проблема: Заголовки и включение

Хорошая практика: заголовок, который работает с C и C++

// math_lib.h
#ifndef MATH_LIB_H
#define MATH_LIB_H

#ifdef __cplusplus
extern "C" {
#endif

int add(int a, int b);
int multiply(int a, int b);

#ifdef __cplusplus
}
#endif

#endif // MATH_LIB_H

// main.cpp
#include "math_lib.h"

int main() {
    int result = add(5, 3);  // Работает!
    return 0;
}

А если забудешь extern "C":
undefined reference to 'add' — потому что компилятор ищет _Z3addii.

Проблема: C++ features в C

C библиотеки не понимают C++ features:

• Классы → невозможно
• Исключения → невозможно (нужна обработка через return codes)
• Templates → невозможно
• std:: контейнеры → невозможно передавать

// ПЛОХО
extern "C" {
void process(std::vector<int>& data);  // Ошибка!
}

// ХОРОШО
extern "C" {
void process(int* data, int size);  // C будет рад
}

Проблема: Память

Если C код выделяет память malloc(), а C++ пытается удалить delete — проблемы.

// C библиотека
char* create_string(void) {
    return malloc(100);
}

void free_string(char* str) {
    free(str);
}

// C++ использование — ПЛОХО
char* str = create_string();
delete str;  // ОШИБКА! Используется delete вместо free

// ХОРОШО
char* str = create_string();
free_string(str);  // Используем функцию, которая знает, как очистить

Лучше обёртка:

class CString {
private:
    char* ptr;
public:
    CString() : ptr(nullptr) {}
    
    ~CString() {
        if (ptr) free_string(ptr);  // Используем C функцию
    }
    
    void create() {
        ptr = create_string();  // Используем C функцию
    }
    
    char* get() { return ptr; }
};

Проблема: Структуры и выравнивание

C и C++ могут по-разному выравнивать структуры.

// C структура
struct Point {
    char x;
    // 3 байта padding (может быть!)
    int y;
};

// C++ может пересчитать размер и alignment
// Решение: явное указание

#pragma pack(1)  // Или __attribute__((packed))
struct Point {
    char x;
    int y;
};
#pragma pack()  // Вернуть default

Лучше быть явным:

#include <cstdint>

#ifdef _MSC_VER
#pragma pack(push, 1)
struct Point {
    int8_t x;
    int32_t y;
};
#pragma pack(pop)
#elif __GNUC__
struct Point {
    int8_t x;
    int32_t y;
} __attribute__((packed));
#endif

Проблема: Статические переменные

С++ имеет static инициализацию, C нет.

// C++ статическая инициализация работает:
static std::string g_name = "global";  // Вызывает конструктор

// C этого не понимает:
extern "C" void setup_name(const char* name);  // Инициализируй вручную

Лучшие практики

1. RAII wrapper'ы для C ресурсов

class FileHandle {
private:
    FILE* fp;
public:
    FileHandle(const char* path) {
        fp = fopen(path, "r");  // C функция
        if (!fp) throw std::runtime_error("Cannot open file");
    }
    
    ~FileHandle() {
        if (fp) fclose(fp);  // Гарантирует cleanup
    }
    
    // Запретить копирование
    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;
};

2. Thin C++ layer над C функциями

// Исходная C API
extern "C" {
void* create_context(void);
void destroy_context(void* ctx);
int execute(void* ctx, const char* cmd);
}

// C++ обёртка
class Context {
private:
    void* impl;
public:
    Context() : impl(create_context()) {}
    ~Context() { destroy_context(impl); }
    
    int execute(const std::string& cmd) {
        return ::execute(impl, cmd.c_str());
    }
};

3. Чистые интерфейсы

// c_interface.h — может быть включен и из C, и из C++
extern "C" {

// Только простые типы
int c_add(int a, int b);
char* c_get_version(void);  // Вызывающий не должен удалять!
void c_free_string(char* s);  // Явная очистка

}

4. Документирование владения памятью

// C библиотека должна ясно документировать:
/**
 * Создаёт новый контекст. Вызывающий должен освободить через destroy_context().
 * Возвращает NULL если ошибка.
 */
void* create_context(void);

/**
 * Возвращает статическую строку. Не освобождать!
 */
const char* get_name(void* ctx);

Компиляция и linking

# Компилировать C код
gcc -c math_lib.c -o math_lib.o

# Компилировать C++ код с включением C заголовков
g++ -c main.cpp -o main.o

# Linker объединит всё
g++ main.o math_lib.o -o program

Основное правило: linker смешивает C и C++ объектные файлы спокойно, если имена функций совпадают (благодаря extern "C").

Вывод

Взаимодействие C и C++ безопасно, если помнить:

1. extern "C" — обязательно для всех C функций, видимых из C++
2. Простые типы — передавай в C функции
3. RAII wrapper'ы — оборачивай C ресурсы в C++ объекты
4. Документируй владение — кто выделяет, кто освобождает
5. Тестируй на обеих платформах — Windows и Linux могут отличаться

Это позволяет использовать мощные C библиотеки (OpenSSL, curl, PostgreSQL) в C++ коде без проблем.