c++ - 带有模板参数的函数指针

Question

现在我有一个智能指针的类模板，它有一个成员函数指针，因为当用基函数类型声明类时，我需要调用派生类的析构函数。函数指针声明为:

void (*d)(const void*);

定义者:

template<typename T> void DefaultDeleter(const void *p) { delete static_cast<T*>(const_cast<void*>(p)); }

初始化为:

d = &DefaultDeleter<U>;

调用方式:

d(static_cast<const void*>(px));

我想更改它，这样我就不必一直转换指针，因为我认为它可能会搞砸。我想将定义更改为:

template<typename T> void DefaultDeleter(T *p) { delete p; }

将由以下人员声明:

template<typename U> void (*d)(U*);

不过这行不通。有没有人对解决这个问题有任何想法？提前致谢!

这些类的测试有效:

class Base1 {
    protected:
        Base1() : derived_destructor_called(false) {
            printf("Base1::Base1()\n");
        }
    private:
        Base1(const Base1 &); // Disallow.
        Base1 &operator=(const Base1 &); // Disallow.
    protected:
        ~Base1() {
            printf("Base1::~Base1()\n");
            assert(derived_destructor_called);
        }
    protected:
        bool derived_destructor_called;
};

class Derived : public Base1 {
        friend void basic_tests_1();
    private:
        Derived() {}
        Derived(const Derived &); // Disallow.
        Derived &operator=(const Derived &); // Disallow.
    public:
        ~Derived() {
            printf("Derived::~Derived()\n");
            derived_destructor_called = true;
        }
        int value;
};

但是，我得到关于 Derived_mi 类无效指针的内存错误，我能想到的唯一原因是它在转换过程中发生了一些事情:

class Base2 {
    protected:
        Base2() : derived_destructor_called(false) {
            printf("Base2::Base2()\n");
        }
    private:
        Base2(const Base2 &); // Disallow.
        Base2 &operator=(const Base2 &); // Disallow.
    protected:
        ~Base2() {
            printf("Base2::~Base2()\n");
            assert(derived_destructor_called);
        }
    protected:
        bool derived_destructor_called;
};

class Derived_mi : public Base1, public Base2 {
        friend void basic_tests_1();
    private:
        Derived_mi() {}
        Derived_mi(const Derived_mi &); // Disallow.
        Derived_mi &operator=(const Derived_mi &); // Disallow.
    public:
        ~Derived_mi() {
            printf("Derived_mi::~Derived_mi()\n");
            Base1::derived_destructor_called = true;
            Base2::derived_destructor_called = true;
        }
        int value;
};

Answer 1

你不能有一个模板化的函数指针，只是因为函数模板的不同实例化是不同的函数，不能全部由同一个指针指向。

查看std::shared_ptr 很有启发意义，巧合的是有一个类型特定的删除器回调。工作方式是创建删除器针对特定类型，而不是针对任何类型。即 shared_ptr<Foo>有一个删除器，但它是一个删除器- Foo s，不能用于删除 Bar秒。

除了实际编译之外，它还具有允许创建用于特定类型的删除器的优点。因此，在您的情况下，我建议您不要尝试更改 d 的类型;相反，您应该更改 d 的结构存储在中，因此它可以容纳特定类型的删除器而不是通用删除器。