C++中为LibAV结构体扩展面向对象方法的实现问题

核心问题分析 #

你之前用继承+memcpy出现内存问题的根源在于：

1. LibAV的结构体由库自身的分配函数（如av_packet_alloc()）管理，内存大小严格对应原结构体尺寸，自定义继承类的额外成员会导致内存越界
2. C++类的布局（比如虚表指针）和C结构体不兼容，memcpy会破坏类的内部结构
3. 库的内存管理逻辑和C++的构造/析构机制混用，容易引发双释放或泄漏

推荐方案：组合模式（Composition） #

通过封装LibAV结构体指针而非继承，既能添加自定义成员方法，又能完美兼容原库函数，同时避免内存管理冲突。

示例实现（CodecContext类） #

#include <stdexcept>
#include <string>
extern "C" {
#include <libavcodec/avcodec.h>
}

class CodecContext {
private:
    AVCodecContext* ctx = nullptr;
    bool owns_memory = false; // 标记是否由本类接管内存

    // 禁止拷贝，避免双释放风险
    CodecContext(const CodecContext&) = delete;
    CodecContext& operator=(const CodecContext&) = delete;

public:
    // 从已有AVCodecContext创建（不接管内存，外部负责释放）
    explicit CodecContext(AVCodecContext* existing_ctx) 
        : ctx(existing_ctx) {}

    // 自行创建新的AVCodecContext（接管内存，析构时自动释放）
    CodecContext() {
        ctx = avcodec_alloc_context3(nullptr);
        if (!ctx) {
            throw std::runtime_error("Failed to allocate AVCodecContext");
        }
        owns_memory = true;
    }

    // 移动构造/赋值，支持资源转移
    CodecContext(CodecContext&& other) noexcept 
        : ctx(other.ctx), owns_memory(other.owns_memory) {
        other.ctx = nullptr;
        other.owns_memory = false;
    }

    CodecContext& operator=(CodecContext&& other) noexcept {
        if (this != &other) {
            // 释放当前持有的资源
            if (owns_memory && ctx) {
                avcodec_free_context(&ctx);
            }
            // 转移资源
            ctx = other.ctx;
            owns_memory = other.owns_memory;
            other.ctx = nullptr;
            other.owns_memory = false;
        }
        return *this;
    }

    // 析构函数，自动释放接管的内存
    ~CodecContext() {
        if (owns_memory && ctx) {
            avcodec_free_context(&ctx);
        }
    }

    // 提供原结构体指针，兼容LibAV原生函数
    AVCodecContext* get() { return ctx; }
    const AVCodecContext* get() const { return ctx; }

    // 自定义成员方法示例
    void openCodec(const AVCodec* codec) {
        int ret = avcodec_open2(ctx, codec, nullptr);
        if (ret < 0) {
            char err_buf[AV_ERROR_MAX_STRING_SIZE];
            av_strerror(ret, err_buf, sizeof(err_buf));
            throw std::runtime_error("Failed to open codec: " + std::string(err_buf));
        }
    }

    // 其他自定义方法，比如获取编码名称
    std::string getCodecName() const {
        if (!ctx->codec) return "";
        return avcodec_get_name(ctx->codec->id);
    }
};

使用方式 #

// 兼容原LibAV函数
CodecContext codec_ctx;
const AVCodec* codec = avcodec_find_decoder(AV_CODEC_ID_H264);
codec_ctx.openCodec(codec);

// 直接给原库函数传指针
avcodec_send_packet(codec_ctx.get(), pkt);

备选方案：谨慎使用的继承模式（不推荐） #

如果一定要模拟继承效果，需确保自定义类无虚函数，且自行分配足够内存容纳整个类（而非依赖LibAV的分配函数），但这种方式风险极高，仅适合对LibAV内存布局非常熟悉的场景：

class CodecContext : public AVCodecContext {
private:
    bool is_open = false;
    std::string codec_name;

public:
    static CodecContext* create() {
        // 分配足够容纳整个CodecContext的内存
        void* mem = av_malloc(sizeof(CodecContext));
        if (!mem) return nullptr;

        // 初始化AVCodecContext部分
        AVCodecContext* temp_ctx = avcodec_alloc_context3(nullptr);
        if (!temp_ctx) {
            av_free(mem);
            return nullptr;
        }
        memcpy(mem, temp_ctx, sizeof(AVCodecContext));
        av_free(temp_ctx);

        // 初始化自定义成员
        auto self = reinterpret_cast<CodecContext*>(mem);
        self->is_open = false;
        self->codec_name = "";
        return self;
    }

    void destroy() {
        avcodec_close(this);
        av_free(this);
    }

    void open(const AVCodec* codec) {
        int ret = avcodec_open2(this, codec, nullptr);
        if (ret >= 0) {
            is_open = true;
            codec_name = avcodec_get_name(codec->id);
        }
    }
};

关键注意事项 #

• 永远不要混用LibAV的内存管理函数（av_malloc/av_free）和C++的new/delete
• 禁止直接拷贝封装类，必须用移动语义转移资源
• 若从外部传入已有结构体指针，务必明确内存所有权，避免重复释放

内容的提问来源于stack exchange，提问作者ThomasNotTom