是否可以颠倒破坏顺序?
Is it possible to invert order of destruction?
我有一个实现许多基本功能的基础 class,它需要一些 "storage"(内存块),必须由继承它的 class(或用户)提供).
class Base
{
public:
Base(void* storage, size_t storageSize) :
storage_{storage},
storageSize_{storageSize}
{
// do something with the storage...
}
~Base()
{
// do something with the storage...
}
// member functions
private:
void* storage_;
size_t storageSize_;
};
这里要注意的是这个内存块是在构造函数和析构函数中使用的。
这在 child class 使用静态存储时效果很好:
template<size_t Size>
class StaticObject : public Base
{
public:
StaticObject() :
Base{&storage, Size}
{
}
private:
typename std::aligned_storage<Size>::type staticStorage_;
};
我知道存储是在构造前(Base的构造函数结束后"constructed")和析构后(Base的析构函数开始前"destructed" 运行), 但对于琐碎的 std::aligned_storage<...>::type
这没有什么区别。
然而,当我想将它与动态分配的存储一起使用时,这个想法完全失败了:
class DynamicObject : public Base
{
public:
DynamicObject(size_t size) :
DynamicObject{std::unique_ptr<uint8_t>{new uint8_t[size]}, size}
{
}
private:
DynamicObject(std::unique_ptr<uint8_t>&& dynamicStorage, size_t size) :
Base{dynamicStorage.get(), size},
dynamicStorage_{std::move(dynamicStorage)}
{
}
std::unique_ptr<uint8_t> dynamicStorage_;
};
正如您在委托构造函数中看到的那样,我设法在存储将用于 Base
的构造函数之前创建(分配)存储 - "inverting" 一点点构造顺序。这个特定阶段也可以正常工作。问题是析构函数,因为我真的想不出任何解决我的问题的方法——在上面的代码中,动态分配的存储将在 Base
的析构函数开始 运行 之前被释放(并使用此内存块)...
现在我不得不以不同的方式解决这个问题 - 而不是继承自 Base
,DynamicObject
class 包含 unique_ptr
和 object Base
作为成员变量——这样我控制了construction/destruction的顺序,但也有一些消极的一面:
- 我必须为
Base
中的每个函数提供一个包装器,这些函数应该由派生的 classes 公开
- 我必须提供对
Base
的 (const) 引用的转换运算符,因为我想通过对基数 class[=53= 的引用来使用 objects ]
我考虑过使用多重继承,这样 DynamicObject
将从两个基础继承 - 一个将提供存储(私有继承)和 Base
(继承功能) - 这个这样我也可以获得 construction/destruction 的正确顺序,但是以使用 "evil" 多重继承为代价...
请注意,上面的例子只是一个简化。真正的用例是 objects,比如我正在编写的 RTOS 的线程和消息队列(https://github.com/DISTORTEC/distortos ) - see the Dynamic*.hpp
and Static*.hpp
objects for real examples - https://github.com/DISTORTEC/distortos/tree/master/include/distortos
有什么巧妙的技巧可以用来颠倒破坏顺序吗?类似于上面 DynamicObject
的委托构造函数的使用?也许有更好的方法可以达到同样的效果?
这避免了在完全初始化之前使用存储对象进行工作的问题。
class Base
{
public:
Base(void* storage, size_t storageSize) :
storage_{storage},
storageSize_{storageSize}
{
}
virtual ~Base()
{
}
private:
void* storage_;
size_t storageSize_;
};
class Worker
{
Worker(Base* storage)
: storage(storage)
{
// do something with the storage
}
~Worker()
{
// do something with the storage
}
Base* storage;
};
Base* storage = new FancyStorage;
Worker w(storage);
delete storage;
我避免使用智能指针以保持简单,因为我不知道您希望如何拥有您的存储对象。
听起来你真正想要的是颠倒等级制度; Base
应该有一些存储空间,而不是说 StaticObject
有 Base
。例如,这可以用泛型来实现
template< typename Storage >
class Base
{
Storage storage; // Storage could be a private base class too
public:
// Fix: use perfect forwarding
template< typename T... >
Base(T ...args):Storage(args...) { /* More initialization */ }
~Base() {
// Still safe to use storage!
}
void set_all_storate_to_zero()
{
memset(storage.ptr(), 0, storage.size());
}
};
您需要使用类型擦除删除器,其方式与 shared_ptr
相同(但不像 unique_ptr
那样,它成为类型的一部分)。
class Base
{
public:
typedef void (*StorageDeleter)(void*);
Base(void* storage, size_t storageSize, StorageDeleter deleter = nullptr) :
storage_{storage},
storageSize_{storageSize},
deleter_{deleter}
{
// do something with the storage...
}
virtual ~Base()
{
// do something with the storage...
if (deleter_) deleter_(storage_);
}
// member functions
private:
void* storage_;
size_t storageSize_;
StorageDeleter deleter_;
};
/* no changes to this one */
template<size_t Size>
class StaticObject;
class DynamicObject : public Base
{
static void array_deleter(void* p) { uint8_t* pExact = (uint8_t*)p; delete [] pExact; }
public:
DynamicObject(size_t size) :
DynamicObject{std::unique_ptr<uint8_t[]>{new uint8_t[size]}, size}
{
}
private:
DynamicObject(std::unique_ptr<uint8_t[]>&& dynamicStorage, size_t size) :
Base{dynamicStorage.get(), size, &DynamicObject::array_deleter},
{
dynamicStorage.release();
}
};
请注意,删除器是一个静态成员函数 -- 它不需要 DynamicObject
的实时派生实例即可正确运行。
我还修复了 std::unique_ptr
的用法,以便在构造 Base
期间抛出异常时使用数组释放器(构造后,删除函数负责)。
现在,考虑(pointer+deleter)已经存在,形式为std::unique_ptr<T, Deleter>
。所以你可以这样做:
class Base
{
typedef void (*StorageDeleter)(void*);
typedef std::unique_ptr<void, StorageDeleter> AutofreePtr;
public:
Base(AutofreePtr&& storage, size_t storageSize) :
storage_{std::move(storage)},
storageSize_{storageSize}
{
// do something with the storage...
}
virtual ~Base()
{
// do something with the storage...
}
// member functions
private:
AutofreePtr storage_;
size_t storageSize_;
};
template<size_t Size>
class StaticObject : public Base
{
static void no_delete(void*) {}
public:
StaticObject() :
Base{{&storage, &StaticObject::no_delete}, Size}
{
}
private:
typename std::aligned_storage<Size>::type staticStorage_;
};
class DynamicObject : public Base
{
static void array_deleter(void* p) { uint8_t* pExact = (uint8_t*)p; delete [] pExact; }
public:
DynamicObject(size_t size) :
DynamicObject{{new uint8_t[size], &DynamicObject::array_deleter}, size}
{
}
};
我有一个实现许多基本功能的基础 class,它需要一些 "storage"(内存块),必须由继承它的 class(或用户)提供).
class Base
{
public:
Base(void* storage, size_t storageSize) :
storage_{storage},
storageSize_{storageSize}
{
// do something with the storage...
}
~Base()
{
// do something with the storage...
}
// member functions
private:
void* storage_;
size_t storageSize_;
};
这里要注意的是这个内存块是在构造函数和析构函数中使用的。
这在 child class 使用静态存储时效果很好:
template<size_t Size>
class StaticObject : public Base
{
public:
StaticObject() :
Base{&storage, Size}
{
}
private:
typename std::aligned_storage<Size>::type staticStorage_;
};
我知道存储是在构造前(Base的构造函数结束后"constructed")和析构后(Base的析构函数开始前"destructed" 运行), 但对于琐碎的 std::aligned_storage<...>::type
这没有什么区别。
然而,当我想将它与动态分配的存储一起使用时,这个想法完全失败了:
class DynamicObject : public Base
{
public:
DynamicObject(size_t size) :
DynamicObject{std::unique_ptr<uint8_t>{new uint8_t[size]}, size}
{
}
private:
DynamicObject(std::unique_ptr<uint8_t>&& dynamicStorage, size_t size) :
Base{dynamicStorage.get(), size},
dynamicStorage_{std::move(dynamicStorage)}
{
}
std::unique_ptr<uint8_t> dynamicStorage_;
};
正如您在委托构造函数中看到的那样,我设法在存储将用于 Base
的构造函数之前创建(分配)存储 - "inverting" 一点点构造顺序。这个特定阶段也可以正常工作。问题是析构函数,因为我真的想不出任何解决我的问题的方法——在上面的代码中,动态分配的存储将在 Base
的析构函数开始 运行 之前被释放(并使用此内存块)...
现在我不得不以不同的方式解决这个问题 - 而不是继承自 Base
,DynamicObject
class 包含 unique_ptr
和 object Base
作为成员变量——这样我控制了construction/destruction的顺序,但也有一些消极的一面:
- 我必须为
Base
中的每个函数提供一个包装器,这些函数应该由派生的 classes 公开
- 我必须提供对
Base
的 (const) 引用的转换运算符,因为我想通过对基数 class[=53= 的引用来使用 objects ]
我考虑过使用多重继承,这样 DynamicObject
将从两个基础继承 - 一个将提供存储(私有继承)和 Base
(继承功能) - 这个这样我也可以获得 construction/destruction 的正确顺序,但是以使用 "evil" 多重继承为代价...
请注意,上面的例子只是一个简化。真正的用例是 objects,比如我正在编写的 RTOS 的线程和消息队列(https://github.com/DISTORTEC/distortos ) - see the Dynamic*.hpp
and Static*.hpp
objects for real examples - https://github.com/DISTORTEC/distortos/tree/master/include/distortos
有什么巧妙的技巧可以用来颠倒破坏顺序吗?类似于上面 DynamicObject
的委托构造函数的使用?也许有更好的方法可以达到同样的效果?
这避免了在完全初始化之前使用存储对象进行工作的问题。
class Base
{
public:
Base(void* storage, size_t storageSize) :
storage_{storage},
storageSize_{storageSize}
{
}
virtual ~Base()
{
}
private:
void* storage_;
size_t storageSize_;
};
class Worker
{
Worker(Base* storage)
: storage(storage)
{
// do something with the storage
}
~Worker()
{
// do something with the storage
}
Base* storage;
};
Base* storage = new FancyStorage;
Worker w(storage);
delete storage;
我避免使用智能指针以保持简单,因为我不知道您希望如何拥有您的存储对象。
听起来你真正想要的是颠倒等级制度; Base
应该有一些存储空间,而不是说 StaticObject
有 Base
。例如,这可以用泛型来实现
template< typename Storage >
class Base
{
Storage storage; // Storage could be a private base class too
public:
// Fix: use perfect forwarding
template< typename T... >
Base(T ...args):Storage(args...) { /* More initialization */ }
~Base() {
// Still safe to use storage!
}
void set_all_storate_to_zero()
{
memset(storage.ptr(), 0, storage.size());
}
};
您需要使用类型擦除删除器,其方式与 shared_ptr
相同(但不像 unique_ptr
那样,它成为类型的一部分)。
class Base
{
public:
typedef void (*StorageDeleter)(void*);
Base(void* storage, size_t storageSize, StorageDeleter deleter = nullptr) :
storage_{storage},
storageSize_{storageSize},
deleter_{deleter}
{
// do something with the storage...
}
virtual ~Base()
{
// do something with the storage...
if (deleter_) deleter_(storage_);
}
// member functions
private:
void* storage_;
size_t storageSize_;
StorageDeleter deleter_;
};
/* no changes to this one */
template<size_t Size>
class StaticObject;
class DynamicObject : public Base
{
static void array_deleter(void* p) { uint8_t* pExact = (uint8_t*)p; delete [] pExact; }
public:
DynamicObject(size_t size) :
DynamicObject{std::unique_ptr<uint8_t[]>{new uint8_t[size]}, size}
{
}
private:
DynamicObject(std::unique_ptr<uint8_t[]>&& dynamicStorage, size_t size) :
Base{dynamicStorage.get(), size, &DynamicObject::array_deleter},
{
dynamicStorage.release();
}
};
请注意,删除器是一个静态成员函数 -- 它不需要 DynamicObject
的实时派生实例即可正确运行。
我还修复了 std::unique_ptr
的用法,以便在构造 Base
期间抛出异常时使用数组释放器(构造后,删除函数负责)。
现在,考虑(pointer+deleter)已经存在,形式为std::unique_ptr<T, Deleter>
。所以你可以这样做:
class Base
{
typedef void (*StorageDeleter)(void*);
typedef std::unique_ptr<void, StorageDeleter> AutofreePtr;
public:
Base(AutofreePtr&& storage, size_t storageSize) :
storage_{std::move(storage)},
storageSize_{storageSize}
{
// do something with the storage...
}
virtual ~Base()
{
// do something with the storage...
}
// member functions
private:
AutofreePtr storage_;
size_t storageSize_;
};
template<size_t Size>
class StaticObject : public Base
{
static void no_delete(void*) {}
public:
StaticObject() :
Base{{&storage, &StaticObject::no_delete}, Size}
{
}
private:
typename std::aligned_storage<Size>::type staticStorage_;
};
class DynamicObject : public Base
{
static void array_deleter(void* p) { uint8_t* pExact = (uint8_t*)p; delete [] pExact; }
public:
DynamicObject(size_t size) :
DynamicObject{{new uint8_t[size], &DynamicObject::array_deleter}, size}
{
}
};