C++ 模板化的手动析构函数调用不起作用

我想销毁模板对象，但保留分配的内存以供填充。不幸的是，该对象的析构函数从未被调用，并且单步执行代码时，它跳过了手动调用

#include <iostream>

template <typename type> class TestClass
{
    private:

        type *data;

    public:

        TestClass();
        ~TestClass();

        template <typename T> void Set(T &&element);
        void Replace();
};


template <typename type> TestClass<type>::TestClass()
{
    data = reinterpret_cast<type *>(new char[sizeof(type)]);;
}

template <typename type> TestClass<type>::~TestClass()
{
}

template <typename type> template <typename T> void TestClass<type>::Set(T &&element)
{
    new(data) type(static_cast<T &&>(element));
}

template <typename type> void TestClass<type>::Replace()
{
    type *pointer = reinterpret_cast<type *>(&data[0]);
    pointer->~type();

    //Fill with data
}

class MyClass
{
    public:

        MyClass()
        {
        }

        ~MyClass()
        {
            std::cout << "Called" << "\n";
        }
};

int main()
{
    MyClass *myClass = new MyClass();

    TestClass<MyClass *> myObject;

    myObject.Set(myClass);
    myObject.Replace();

    return 0;
}

我在VS 2017和在线C++编译器中测试过。两者都跳过指针->~类型；当单步执行时，不会调用析构函数

---

编辑：重写代码，该代码现在会复制错误。

它会调用析构函数

#include <iostream>

class Type
{
    public:
    ~Type()
    {
        std::cout<< __FUNCTION__ << "\n";
    }
};


template <typename type> class MyClass
{
    private:

        type *data;

    public:

        MyClass();
        ~MyClass(){}

        void Replace();
};


template <typename type> MyClass<type>::MyClass()
{
    data =  reinterpret_cast<type *>(new char[sizeof(type)]);;
}


template <typename type> void MyClass<type>::Replace()
{
    type *pointer = &data[0];
    pointer->~type();

    //Fill with replacement data
}
int main()
{

    MyClass<Type> myClass;

    std::cout <<"Before destruction\n";
myClass.Replace();
std::cout << "After destruction\n";
    return 0;

}

---

<> >允许模板通常处理类型，C++允许Obj.~类型或PTR>>类型语法，即使类型不是类类型，但不适合数组类型。其含义与该类型的自动对象在其作用域末尾发生的任何事情相同：如果它是类类型，则调用析构函数，如果不是，则不会发生任何事情。对于类型不是类类型的情况，此语法称为

现在来看您的示例，您正在使用类模板专门化TestClass。因此，在TestClass:：Replace成员定义的实例化中，type是MyClass*的别名。声明

type *pointer = reinterpret_cast<type *>(&data[0]);

pointer->~type();

表示销毁指针指向的类型的对象。也就是说，它表示销毁MyClass*类型的对象，即*指针。MyClass*不是类类型；它是指针类型。这是对伪析构函数的调用，绝对不会发生任何事情

---

没有足够的上下文来确定如何解决这个问题，但也许您需要使用TestClass而不是TestClass？另外，在实际代码中，不要忘记五条规则/三条规则。

我们可以得到一个吗？我已经更新了代码，显示了一个精简版本，但就能够编译它而言，恐怕需要一些工作。谢谢你的回复。您的代码确实有效，因此我设法拼凑了一个在多个编译器上重现错误的示例。这非常有意义，并且解释了很多。谢谢。