Статическое и динамическое связывание в C++

// Пример статического связывания в C++
// Файл main.cpp
#include <iostream>
#include "mymath.h"
 
int main() {
    int result = add(5, 3);
    std::cout << "Результат: " << result << std::endl;
    return 0;
}
 
// Файл mymath.h
#ifndef MYMATH_H
#define MYMATH_H
 
int add(int a, int b);
 
#endif
 
// Файл mymath.cpp
#include "mymath.h"
 
int add(int a, int b) {
    return a + b;
}

// Сравним размеры:
// Статически связанная программа
$ g++ hello.cpp -o hello_static -static
$ ls -lh hello_static
-rwxr-xr-x 1 user group 856K Jun 5 10:15 hello_static
 
// Динамически связанная программа
$ g++ hello.cpp -o hello_dynamic
$ ls -lh hello_dynamic
-rwxr-xr-x 1 user group 16K Jun 5 10:16 hello_dynamic

// Пример инлайн-функции
inline int square(int x) {
    return x * x;
}
 
int main() {
    int result = square(5);  // Компилятор может заменить на: int result = 5 * 5;
    return result;
}

// platform_specific.h
#ifdef _WIN32
    // Windows-специфичный код
    #define PLATFORM_NEWLINE "\r\n"
#elif defined(__APPLE__)
    // MacOS-специфичный код
    #define PLATFORM_NEWLINE "\r"
#else
    // Linux и другие UNIX-подобные системы
    #define PLATFORM_NEWLINE "\n"
#endif
 
// Использование
#include <iostream>
#include "platform_specific.h"
 
int main() {
    std::cout << "Привет, мир!" << PLATFORM_NEWLINE;
    return 0;
}

// template_example.h
#ifndef TEMPLATE_EXAMPLE_H
#define TEMPLATE_EXAMPLE_H
 
template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}
 
#endif
 
// file1.cpp
#include "template_example.h"
 
void func1() {
    int result = max(5, 10);  // Генерируется max<int>
}
 
// file2.cpp
#include "template_example.h"
 
void func2() {
    double result = max(3.14, 2.71);  // Генерируется max<double>
    int result2 = max(42, 24);  // Генерируется ещё один экземпляр max<int>
}

// template_impl.cpp
#include "template_example.h"
 
// Явная инстанциация для часто используемых типов
template int max<int>(int, int);
template double max<double>(double, double);

// file1.cpp
int global_counter = 0;
 
void increment() {
    global_counter++;
}
 
// file2.cpp
int global_counter = 0;  // Второе определение той же переменной!
 
void reset() {
    global_counter = 0;
}

// counter.h
#ifndef COUNTER_H
#define COUNTER_H
 
extern int global_counter;  // Объявление без определения
 
void increment();
void reset();
 
#endif
 
// counter.cpp
#include "counter.h"
 
int global_counter = 0;  // Единственное определение
 
void increment() {
    global_counter++;
}
 
void reset() {
    global_counter = 0;
}

// module1.cpp
namespace {
    int internal_counter = 0;  // Видно только внутри этого cpp-файла
}
 
void module1_function() {
    internal_counter++;
}
 
// module2.cpp
namespace {
    int internal_counter = 0;  // Другая переменная, нет конфликта с module1.cpp
}
 
void module2_function() {
    internal_counter++;
}

// Пример использования динамической библиотеки
#include <iostream>
#include <dlfcn.h> // Для работы с динамическими библиотеками в UNIX-системах
 
typedef int (*AddFunc)(int, int); // Объявление типа указателя на функцию
 
int main() {
    // Загрузка библиотеки
    void* handle = dlopen("libmath.so", RTLD_LAZY);
    if (!handle) {
        std::cerr << "Ошибка загрузки библиотеки: " << dlerror() << std::endl;
        return 1;
    }
 
    // Получение адреса функции
    AddFunc add = (AddFunc)dlsym(handle, "add");
    if (!add) {
        std::cerr << "Ошибка получения функции: " << dlerror() << std::endl;
        dlclose(handle);
        return 1;
    }
 
    // Использование функции
    std::cout << "Результат: " << add(5, 3) << std::endl;
 
    // Выгрузка библиотеки
    dlclose(handle);
    return 0;
}

// Пример для Windows
#include <windows.h>
#include <iostream>
 
typedef int (*AddFunc)(int, int);
 
int main() {
    // Загрузка DLL
    HINSTANCE hLib = LoadLibrary("math.dll");
    if (!hLib) {
        std::cerr << "Ошибка загрузки DLL: " << GetLastError() << std::endl;
        return 1;
    }
 
    // Получение адреса функции
    AddFunc add = (AddFunc)GetProcAddress(hLib, "add");
    if (!add) {
        std::cerr << "Ошибка получения функции: " << GetLastError() << std::endl;
        FreeLibrary(hLib);
        return 1;
    }
 
    // Использование функции
    std::cout << "Результат: " << add(5, 3) << std::endl;
 
    // Выгрузка DLL
    FreeLibrary(hLib);
    return 0;
}

// mathlib.h - заголовочный файл нашей библиотеки
#ifdef _WIN32
  #define EXPORT __declspec(dllexport)
#else
  #define EXPORT __attribute__((visibility("default")))
#endif
 
extern "C" {
    EXPORT int add(int a, int b);
    EXPORT int subtract(int a, int b);
}
 
// mathlib.cpp - реализация нашей библиотеки
#include "mathlib.h"
 
int add(int a, int b) {
    return a + b;
}
 
int subtract(int a, int b) {
    return a - b;
}

// version.map
LIBRARY_1.0 {
    global:
        add;
        subtract;
    local:
        *;
};
 
LIBRARY_2.0 {
    global:
        multiply;
    } LIBRARY_1.0;

std::string loadTranslation(const std::string& language, const std::string& key) {
    // Путь к библиотеке перевода для указанного языка
    std::string libPath = "translations/lib" + language + ".so";
    
    void* handle = dlopen(libPath.c_str(), RTLD_LAZY);
    if (!handle) return key; // Возвращаем ключ, если не удалось загрузить библиотеку
    
    typedef const char* (*GetTranslationFunc)(const char*);
    GetTranslationFunc getTranslation = 
        (GetTranslationFunc)dlsym(handle, "getTranslation");
    
    if (!getTranslation) {
        dlclose(handle);
        return key;
    }
    
    std::string result = getTranslation(key.c_str());
    dlclose(handle);
    return result;
}

// Приложение A ожидает такой интерфейс
// math.h, версия 1.0
int calculate(int a, int b); // В этой версии функция складывает числа
 
// Приложение B ожидает такой интерфейс
// math.h, версия 2.0
int calculate(int a, int b); // В этой версии функция умножает числа

// Оригинальная функция в библиотеке
int original_malloc_size = 0;
void* malloc(size_t size) {
    original_malloc_size += size;
    // ...реализация malloc...
}
 
// Наша перехватывающая функция
void* my_malloc(size_t size) {
    printf("Выделено %zu байт памяти\n", size);
    return real_malloc(size); // Вызов оригинальной функции
}
 
// Как осуществить перехват в Linux
#include <dlfcn.h>
 
typedef void* (*MallocFunc)(size_t);
MallocFunc real_malloc;
 
void init_interception() {
    // Получаем адрес оригинальной функции
    real_malloc = (MallocFunc)dlsym(RTLD_NEXT, "malloc");
}

// В библиотеке
extern "C" {
    EXPORT void riskyFunction() {
        try {
            // Код, который может бросить исключение
            throw std::runtime_error("Ошибка в библиотеке");
        } catch(const std::exception& e) {
            // Обработка внутри библиотеки
            // Не позволяем исключению "убежать" из библиотеки
        }
    }
}
 
// В приложении
try {
    riskyFunction(); // Безопасно, исключения не выйдут из библиотеки
} catch(...) {
    // Этот блок не будет выполнен для исключений из библиотеки
}

// В библиотеке
static int counter = 0;
 
extern "C" {
    EXPORT void increment() {
        counter++;
    }
    
    EXPORT int getValue() {
        return counter;
    }
}
 
// В приложении
increment(); // counter становится 1
increment(); // counter становится 2
printf("%d\n", getValue()); // Выводит 2

// Интерфейс плагина
class ImageFilter {
public:
    virtual ~ImageFilter() {}
    virtual std::string getName() const = 0;
    virtual void apply(Image& image) = 0;
};
 
// В библиотеке с плагином
class BlurFilter : public ImageFilter {
public:
    std::string getName() const override {
        return "Размытие";
    }
    
    void apply(Image& image) override {
        // Реализация размытия
    }
};
 
// Функция для создания экземпляра фильтра
extern "C" EXPORT ImageFilter* createFilter() {
    return new BlurFilter();
}

std::vector<ImageFilter*> loadFilters(const std::string& pluginDir) {
    std::vector<ImageFilter*> filters;
    
    for (const auto& entry : std::filesystem::directory_iterator(pluginDir)) {
        if (entry.path().extension() != ".dll" && entry.path().extension() != ".so")
            continue;
            
        void* handle = dlopen(entry.path().c_str(), RTLD_LAZY);
        if (!handle) continue;
        
        using CreateFunc = ImageFilter* (*)();
        CreateFunc createFilter = (CreateFunc)dlsym(handle, "createFilter");
        
        if (createFilter) {
            ImageFilter* filter = createFilter();
            if (filter) {
                filters.push_back(filter);
                // Не закрываем библиотеку, так как она нужна для работы фильтра
            }
        }
    }
    
    return filters;
}

// hello.cpp
#include <iostream>
 
int main() {
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

// Размер библиотеки libcommon.so: 5 МБ
// При динамическом связывании:
// 5 приложений × (2 МБ собственного кода + ссылка на общую библиотеку) + 5 МБ библиотеки = 15 МБ
 
// При статическом связывании:
// 5 приложений × (2 МБ собственного кода + 5 МБ встроенной библиотеки) = 35 МБ

// main.cpp
extern void hello();
 
int main() {
    hello();
    return 0;
}
 
// Компиляция без hello.cpp вызовет ошибку
$ g++ main.cpp -o program
/tmp/ccwQcxPR.o: In function `main':
main.cpp:(.text+0x5): undefined reference to `hello'

// При запуске программы, использующей отсутствующую библиотеку
$ ./program
./program: error while loading shared libraries: libmissing.so: cannot open shared object file: No such file or directory

// Компонент, критичный к производительности - статически
$ g++ -c fast_component.cpp -o fast_component.o
 
// Компонент, требующий частых обновлений - динамически
$ g++ -shared -fPIC updateable_component.cpp -o libupdateable.so
 
// Финальная компоновка
$ g++ main.cpp fast_component.o -lupdateable -o program

// Динамическая загрузка модулей для параллельной обработки
void process_in_parallel(const std::vector<std::string>& modules, const Data& data) {
    std::vector<void*> handles;
    std::vector<std::thread> threads;
    
    // Загружаем модули и запускаем обработку в отдельных потоках
    for (const auto& module : modules) {
        void* handle = dlopen(module.c_str(), RTLD_NOW);
        if (!handle) continue;
        
        handles.push_back(handle);
        
        using ProcessFunc = void (*)(const Data&);
        ProcessFunc process = (ProcessFunc)dlsym(handle, "process");
        
        if (process) {
            threads.emplace_back([process, &data]() {
                process(data);
            });
        }
    }
    
    // Ждем завершения всех потоков
    for (auto& thread : threads) {
        thread.join();
    }
    
    // Выгружаем модули
    for (auto handle : handles) {
        dlclose(handle);
    }
}

// В заголовочном файле
class Widget {
public:
    Widget();
    ~Widget();
    void doSomething();
    
private:
    class Impl;
    std::unique_ptr<Impl> pImpl;
};
 
// В файле реализации
class Widget::Impl {
public:
    void doSomething() {
        // Реализация
    }
};
 
Widget::Widget() : pImpl(std::make_unique<Impl>()) {}
Widget::~Widget() = default;  // Требуется для std::unique_ptr с неполным типом
 
void Widget::doSomething() {
    pImpl->doSomething();
}

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(MyProject)
 
option(BUILD_SHARED_LIBS "Build shared libraries" ON)
 
add_library(mylib mylib.cpp)
add_executable(myapp main.cpp)
target_link_libraries(myapp mylib)

// Пример установки пути поиска в коде (Linux)
#include <dlfcn.h>
 
int main() {
    // Добавляем текущую директорию к пути поиска
    setenv("LD_LIBRARY_PATH", ".:$LD_LIBRARY_PATH", 1);
    
    void* handle = dlopen("libcustom.so", RTLD_LAZY);
    // ...
}

#include <filesystem>
#include <dlfcn.h>
 
std::string getExecutablePath() {
    char buffer[PATH_MAX];
    ssize_t count = readlink("/proc/self/exe", buffer, PATH_MAX);
    return std::string(buffer, (count > 0) ? count : 0);
}
 
void* loadPlugin(const std::string& name) {
    std::filesystem::path exePath = getExecutablePath();
    std::filesystem::path pluginPath = exePath.parent_path() / "plugins" / name;
    
    return dlopen(pluginPath.c_str(), RTLD_LAZY);
}

// Версия 1.0 библиотеки
struct Data {
    int value;
};
 
// Версия 1.1 библиотеки
struct Data {
    int value;
    bool flag;  // Добавлено новое поле
};

// Стабильный ABI с использованием паттерна pImpl
// mylib.h - публичный интерфейс
class MyClass {
public:
    MyClass();
    ~MyClass();
    void doSomething(int value);
    
private:
    struct Impl;
    std::unique_ptr<Impl> m_impl;
};
 
// mylib.cpp - реализация
struct MyClass::Impl {
    // Можно изменять без нарушения ABI
    int m_value;
    bool m_flag;
    std::vector<double> m_data;
};
 
MyClass::MyClass() : m_impl(std::make_unique<Impl>()) {}
MyClass::~MyClass() = default;
 
void MyClass::doSomething(int value) {
    m_impl->m_value = value;
    // Реализация может меняться без нарушения ABI
}

// game_engine.cpp
class Plugin {
public:
    virtual ~Plugin() = default;
    virtual void update(float deltaTime) = 0;
};
 
class PluginManager {
private:
    std::map<std::string, std::pair<void*, Plugin*>> m_plugins;
    std::filesystem::file_time_type getLastModifiedTime(const std::string& path) {
        return std::filesystem::last_write_time(path);
    }
    
public:
    void loadPlugin(const std::string& path) {
        auto it = m_plugins.find(path);
        if (it != m_plugins.end()) {
            // Библиотека уже загружена
            auto lastModified = getLastModifiedTime(path);
            auto& [handle, plugin] = it->second;
            
            if (lastModified > m_lastChecked) {
                // Библиотека изменилась, перезагружаем
                delete plugin;
                dlclose(handle);
                
                handle = dlopen(path.c_str(), RTLD_NOW);
                if (handle) {
                    auto createPlugin = (Plugin*(*)())dlsym(handle, "createPlugin");
                    if (createPlugin) {
                        plugin = createPlugin();
                    }
                }
            }
        } else {
            // Загрузка новой библиотеки
            void* handle = dlopen(path.c_str(), RTLD_NOW);
            if (handle) {
                auto createPlugin = (Plugin*(*)())dlsym(handle, "createPlugin");
                if (createPlugin) {
                    Plugin* plugin = createPlugin();
                    m_plugins[path] = {handle, plugin};
                }
            }
        }
    }
    
    void updateAll(float deltaTime) {
        for (auto& [path, pair] : m_plugins) {
            auto& [handle, plugin] = pair;
            if (plugin) {
                plugin->update(deltaTime);
            }
        }
    }
    
    ~PluginManager() {
        for (auto& [path, pair] : m_plugins) {
            auto& [handle, plugin] = pair;
            delete plugin;
            dlclose(handle);
        }
    }
    
private:
    std::filesystem::file_time_type m_lastChecked = 
        std::filesystem::file_time_type::min();
};

// Пример компиляции с усиленной безопасностью для статически связанного приложения
g++ -static -O2 -D_FORTIFY_SOURCE=2 -fstack-protector-all -Wl,-z,relro,-z,now secure_app.cpp -o secure_app

// Критичный к производительности компонент (статически)
#include "core_algo.h"
// Часто обновляемый компонент (динамически)
#include "network_layer.h"
 
int main() {
    CoreAlgo algo;  // Статически связан
    NetworkLayer* net = NetworkLayer::load();  // Загружается динамически
    
    // Использование обоих компонентов
    Data result = algo.process(net->fetchData());
    return 0;
}