给定对象初始化如下:
Base* a = new Derived();
Container<Base> c(a);
,
class Base {
...
protected:
~Base();
}
class Derived : public Base {...};
template <typename T>
class Container {
private:
T* object;
public:
Container(T* o) : object(o) {}
void deleteObject() {
delete object; // Object must be casted to (unknown) derived type to call destructor.
}
};
显然,这是非常简化的实际代码,但问题是我如何将object
从其模板类型转换为其实际的派生类型(如果它们不同),这是未知的?
我不能修改Base
或Derived
,甚至任何调用Container
的代码,只能修改Container
类本身。
您需要模板化构造函数并存储类型擦除的删除器。shared_ptr
就是这样做的。
template <typename T>
class Container {
private:
T* object;
std::function<void(T*)> deleter;
public:
template<typename U> Container(U* o) : object(o) {
deleter = [](T* ptr) { delete static_cast<U*>(ptr); };
}
void deleteObject() {
deleter(object);
}
};
如果您能够更改创建代码,您可能会这样做:
template<class T>
void deleter(void* p){
delete static_cast<T*>(p);
}
template<class T>
class Container{
private:
T* obj;
typedef void (*deleter_func)(void*);
deleter_func obj_deleter;
public:
Container(T* o, deleter_func df)
: obj(o), obj_deleter(df) {}
void deleteObject(){ obj_deleter(obj); }
};
在调用代码中:
Base* a = new Derived();
Container<Base> c(a, &deleter<Derived>);
提示(因为这是作业):查找关键字virtual
如果不能同时更改Base或Derived或使析构函数为虚函数,则可以使deleteObject成为模板函数
template <typename T>
class Container {
private:
T* object;
public:
Container(T* o) : object(o) {}
template <typename U>
void deleteObject() {
U* c = static_cast<U*>(object);
delete c;
}
};
int main(void)
{
Base* a = new Derived();
Container<Base> *b = new Container<Base>(a);
b->deleteObject<Derived>();
return 0;
}
编辑:我不知道你也不能修改Container
签名…
如果你可以修改你的deleteObject
:
template <typename T>
class Container {
private:
T* object;
public:
Container(T* o) : object(o) {}
template< typename PDerived >
void deleteObject() {
delete static_cast< PDerived* >( object );
}
};
Base* a = new Derived();
Container<Base> c(a);
c.deleteObject<Derived>();
编辑:之前有人贴过同样的解决方案