C++：如何打造一個動態連結函式庫

#ifndef _BACKPACK_HPP
#define _BACKPACK_HPP

#include <cstddef>
#include <utility>
#include <vector>

namespace mylib
{

    class Backpack
    {
    public:
        Backpack(std::size_t max_size);
        ~Backpack();
        void push(const std::byte *ptr, std::size_t size);
        void pop();
        std::pair<std::byte *, std::size_t> access(std::size_t idx) const;
        std::size_t size() const;

    private:
        std::size_t max_size;
        std::byte *data;
        std::vector<std::size_t> prefix_sum;
    };

}

#endif

#include <stdexcept>
#include <cstring>

#include "backpack.hpp"

namespace mylib
{
    Backpack::Backpack(std::size_t max_size) : prefix_sum(1, 0)
    {
        this->max_size = max_size;
        data = new std::byte[max_size];
    }

    Backpack::~Backpack()
    {
        if (data != nullptr)
        {
            delete[] data;
            data = nullptr;
        }
    }

    void Backpack::push(const std::byte *ptr, std::size_t size)
    {
        const size_t offset = prefix_sum.back();
        if (offset + size >= max_size)
        {
            throw std::length_error("Exceed max size");
        }
        memcpy(data + offset, ptr, size);
        prefix_sum.push_back(offset + size);
    }

    void Backpack::pop()
    {
        if (prefix_sum.size() == 1)
        {
            throw std::out_of_range("Backpack is empty");
        }
        prefix_sum.pop_back();
    }

    std::pair<std::byte *, std::size_t> Backpack::access(std::size_t idx) const
    {
        if (idx + 1 >= prefix_sum.size())
        {
            throw std::out_of_range("Index out of bound");
        }
        const std::size_t offset = prefix_sum[idx];
        const std::size_t size = prefix_sum[idx + 1] - prefix_sum[idx];
        return {data + offset, size};
    }

    std::size_t Backpack::size() const
    {
        return prefix_sum.size() - 1;
    }
}

#ifndef _MYLIB_HPP
#define _MYLIB_HPP

#ifdef MYLIB_SHARED
    #ifdef MYLIB_EXPORTS
        #ifdef _WIN32
            #define MYLIB_API __declspec(dllexport)
        #else
            #define MYLIB_API __attribute__((visibility("default")))
        #endif
    #else
        #ifdef _WIN32
            #define MYLIB_API __declspec(dllimport)
        #else
            #define MYLIB_API
        #endif
    #endif
#else
    #define MYLIB_API
#endif

#ifdef __cplusplus
extern "C"
{
#endif

    typedef struct BackpackHandle BackpackHandle;

    typedef enum
    {
        MYLIB_SUCCESS = 0,
        MYLIB_OUT_OF_BOUND,
        MYLIB_EMPTY,
        MYLIB_EXCEED_MAX_SIZE,
        MYLIB_UNKNOWN_ERROR,
        MYLIB_NULL_POINTER,
    } MyLibErrorCode;

    MYLIB_API BackpackHandle *create_backpack(const size_t max_size);
    MYLIB_API void destroy_backpack(BackpackHandle *handle);
    MYLIB_API MyLibErrorCode add_item(const BackpackHandle *handle, const void *buf, size_t size);
    MYLIB_API MyLibErrorCode remove_last_item(const BackpackHandle *handle);
    MYLIB_API MyLibErrorCode get_item_size(const BackpackHandle *handle, const size_t idx, size_t *size);
    MYLIB_API MyLibErrorCode get_item(const BackpackHandle *handle, const size_t idx, void *buf);
    MYLIB_API MyLibErrorCode get_size(const BackpackHandle *handle, size_t *size);
    MYLIB_API const char *get_error_string(MyLibErrorCode code);

#ifdef __cplusplus
}
#endif

#endif

#include <stdexcept>
#include <vector>
#include <cstring>

#include "backpack.hpp"
#include "mylib.h"

struct BackpackHandle
{
    mylib::Backpack *backpack;
};

BackpackHandle *create_backpack(const size_t max_size)
{
    mylib::Backpack *backpack;
    try
    {
        backpack = new mylib::Backpack(max_size);
    }
    catch (...)
    {
        return nullptr;
    }
    auto handle = new BackpackHandle();
    handle->backpack = backpack;
    return handle;
}

void destroy_backpack(BackpackHandle *handle)
{
    if (handle != nullptr)
    {
        delete handle->backpack;
        delete handle;
    }
}

MyLibErrorCode add_item(const BackpackHandle *handle, const void *buf, size_t size)
{
    if (handle == nullptr)
    {
        return MyLibErrorCode::MYLIB_NULL_POINTER;
    }

    try
    {
        handle->backpack->push(reinterpret_cast<const std::byte *>(buf), size);
    }
    catch (std::length_error &e)
    {
        return MyLibErrorCode::MYLIB_EXCEED_MAX_SIZE;
    }
    catch (...)
    {
        return MyLibErrorCode::MYLIB_UNKNOWN_ERROR;
    }

    return MyLibErrorCode::MYLIB_SUCCESS;
}

MyLibErrorCode remove_last_item(const BackpackHandle *handle)
{
    if (handle == nullptr)
    {
        return MyLibErrorCode::MYLIB_NULL_POINTER;
    }

    try
    {
        handle->backpack->pop();
    }
    catch (std::out_of_range &e)
    {
        return MyLibErrorCode::MYLIB_EMPTY;
    }
    catch (...)
    {
        return MyLibErrorCode::MYLIB_UNKNOWN_ERROR;
    }

    return MyLibErrorCode::MYLIB_SUCCESS;
}

MyLibErrorCode get_item_size(const BackpackHandle *handle, const size_t idx, size_t *size)
{
    if (handle == nullptr)
    {
        return MyLibErrorCode::MYLIB_NULL_POINTER;
    }

    try
    {
        auto r = handle->backpack->access(idx);
        *size = r.second;
    }
    catch (std::out_of_range &e)
    {
        return MyLibErrorCode::MYLIB_OUT_OF_BOUND;
    }
    catch (...)
    {
        return MyLibErrorCode::MYLIB_UNKNOWN_ERROR;
    }

    return MyLibErrorCode::MYLIB_SUCCESS;
}

MyLibErrorCode get_item(const BackpackHandle *handle, const size_t idx, void *buf)
{
    if (handle == nullptr)
    {
        return MyLibErrorCode::MYLIB_NULL_POINTER;
    }

    try
    {
        auto r = handle->backpack->access(idx);
        memcpy(buf, r.first, r.second);
    }
    catch (std::out_of_range &e)
    {
        return MyLibErrorCode::MYLIB_OUT_OF_BOUND;
    }
    catch (...)
    {
        return MyLibErrorCode::MYLIB_UNKNOWN_ERROR;
    }

    return MyLibErrorCode::MYLIB_SUCCESS;
}

MyLibErrorCode get_size(const BackpackHandle *handle, size_t *s)
{
    if (handle == nullptr)
    {
        return MyLibErrorCode::MYLIB_NULL_POINTER;
    }

    try
    {
        *s = handle->backpack->size();
    }
    catch (...)
    {
        return MyLibErrorCode::MYLIB_UNKNOWN_ERROR;
    }

    return MyLibErrorCode::MYLIB_SUCCESS;
}

const char *get_error_string(MyLibErrorCode code)
{
    static std::vector<const char *> error_string_arr = {
        "",
        "Out of bound",
        "Empty",
        "Exceed max size",
        "Unknown error",
        "Null pointer"};

    if (code == MyLibErrorCode::MYLIB_SUCCESS)
    {
        return "";
    }
    else if (static_cast<std::size_t>(code) >= error_string_arr.size())
    {
        return "";
    }

    return error_string_arr[code];
}