事件注册中可变参数模板转可变参数函数的类型转换错误求解

首先，咱们来拆解下你遇到的核心问题：你想要实现类型安全的事件注册（比如registerEvent<Event::Resize>(callback)这种调用，能确保回调函数的签名和事件类型匹配），同时需要在EventHolder中统一存储不同事件类型的My_Event实例，但编译时因为固定参数函数指针无法隐式转换为可变参数函数指针报错。

错误根源分析 #

编译错误无法将参数2从“void (__cdecl *)(unsigned int,unsigned int)”转换为“void (__cdecl *)(...)”的原因是：C++不允许隐式将固定参数的函数指针转换为可变参数的函数指针——这是类型安全的限制，避免错误调用导致的未定义行为。

你尝试的两种方案的问题：

• 全局registerEvent改成可变参数函数：会丢失类型检查，任何函数都能注册到任意事件，违背了你想要的类型安全需求；
• EventRegistry::registerEvent改成可变参数模板：你误以为My_Event需要整体模板化，但其实完全可以让My_Event保持非模板类，只在存储和调用时做类型转换的安全处理。

修正后的完整实现 #

下面是调整后的可编译代码，核心思路是用void*存储不同类型的函数指针，同时通过模板函数维持类型安全的注册和调用：

#include <iostream>
#include <cstdlib>
#include <cstring>

enum class Event { None, Resize, /*Some Other Events*/ };

// 事件回调类型的验证器，确保不同事件对应正确的回调签名
template<Event Type, typename...> struct validator;
template<Event Type> using eventor = typename validator<Type>::type;

template<> struct validator<Event::Resize> { 
    using type = void(*)(unsigned int, unsigned int); 
};

struct My_Event {
    unsigned int size;
    void** funcs;
    const Event m_ev;  // 改为值存储，避免引用悬空问题

    // 构造函数改为接收void*存储函数指针
    My_Event(Event ev, void* f) : m_ev(ev), size(1), funcs(new void*[size]) { 
        *funcs = f; 
    }

    // 模板化的注册方法，确保传入的回调类型匹配事件要求
    template<Event Type>
    void reg(eventor<Type> f) {
        // 先验证当前事件类型和注册的类型一致
        if (m_ev != Type) {
            std::cerr << "Event type mismatch!" << std::endl;
            return;
        }
        // 扩容函数指针数组
        void** new_funcs = new void*[size + 1];
        std::memcpy(new_funcs, funcs, size * sizeof(void*));
        new_funcs[size] = reinterpret_cast<void*>(f);
        delete[] funcs;
        funcs = new_funcs;
        size++;
    }

    // 模板化的调用方法，安全转换回对应类型的函数指针并调用
    template<Event Type, typename... Args>
    void invoke(Args&&... args) {
        if (m_ev != Type) {
            std::cerr << "Event type mismatch when invoking!" << std::endl;
            return;
        }
        using FuncType = eventor<Type>;
        for (unsigned int i = 0; i < size; ++i) {
            auto func = reinterpret_cast<FuncType>(funcs[i]);
            func(std::forward<Args>(args)...);
        }
    }

    // 析构函数，避免内存泄漏
    ~My_Event() {
        delete[] funcs;
    }
};

struct EventHolder {
    unsigned int size;
    My_Event** events;

    EventHolder() : size(0), events(nullptr) {}

    void add(Event ev, void* f) {
        // 扩容事件数组
        My_Event** new_events = new My_Event*[size + 1];
        if (size > 0) {
            std::memcpy(new_events, events, size * sizeof(My_Event*));
        }
        new_events[size] = new My_Event(ev, f);
        delete[] events;
        events = new_events;
        size++;
    }

    // 查找对应事件的My_Event实例
    My_Event* findEvent(Event ev) {
        for (unsigned int i = 0; i < size; ++i) {
            if (events[i]->m_ev == ev) {
                return events[i];
            }
        }
        return nullptr;
    }

    ~EventHolder() {
        for (unsigned int i = 0; i < size; ++i) {
            delete events[i];
        }
        delete[] events;
    }
};

struct EventRegistry {
    EventHolder holder;

    // 基础注册方法，接收void*
    void registerEvent(Event ev, void* f) {
        My_Event* existing = holder.findEvent(ev);
        if (existing) {
            // 如果事件已存在，直接注册回调
            // 这里需要根据事件类型调用对应的reg模板方法，我们可以通过重载或者模板特化处理
            // 为了简化，这里以Resize为例，实际可以用模板函数封装
            if (ev == Event::Resize) {
                existing->reg<Event::Resize>(reinterpret_cast<eventor<Event::Resize>>(f));
            }
            // 其他事件类型同理添加
        } else {
            holder.add(ev, f);
        }
    }
} events;

// 类型安全的注册入口模板函数，确保回调类型匹配事件
template<Event Type> 
void registerEvent(eventor<Type> f) {
    events.registerEvent(Type, reinterpret_cast<void*>(f));
}

// 测试回调函数
void callback(unsigned int width, unsigned int height) {
    std::cout << "Resize event triggered: " << width << "x" << height << std::endl;
}

int main() {
    // 类型安全的注册
    registerEvent<Event::Resize>(callback);

    // 模拟触发Resize事件
    My_Event* resize_ev = events.holder.findEvent(Event::Resize);
    if (resize_ev) {
        resize_ev->invoke<Event::Resize>(1920, 1080);
    }

    return 0;
}

关键修改点说明 #

1. My_Event存储方式调整：将原来的void(**)(...)改为void**，用void*存储不同类型的函数指针，绕过了固定参数和可变参数函数指针的转换限制；
2. 类型安全的注册与调用：通过模板化的reg和invoke方法，在编译时确保回调函数的签名和事件类型匹配，运行时再将void*转换回对应的函数指针；
3. 内存安全优化：修复了原代码中malloc/free和new混用的问题，添加了析构函数避免内存泄漏；
4. 事件复用处理：新增findEvent方法，避免重复创建相同事件的My_Event实例，直接在已有事件上注册新回调。

验证功能 #

编译运行上述代码，会输出：

Resize event triggered: 1920x1080

说明事件注册和调用都正常工作，同时保持了类型安全——如果你尝试传入错误签名的函数到registerEvent<Event::Resize>，编译时会直接报错。

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