Общая память изначально допускает только структуры POD (по сути, они могут иметь конструкторы/копии/и т. д.).
Boost.Interprocess поднимает планку, эмулируя семантику указателей поверх смещений в сегменте разделяемой памяти.
Однако виртуальный указатель — это не указатель на чистые данные, а указатель на разделы кода, и здесь все усложняется, поскольку разделы кода не обязательно сопоставляются с одним и тем же адресом из одного процесса в другой. (даже если они запускались из одного бинарника).
Итак... нет, виртуальные указатели-полиморфные объекты не могут храниться в разделяемой памяти.
Однако тот факт, что многие реализации C++ решили использовать механизм виртуальных указателей, не означает, что это единственный способ добиться полиморфного поведения. Например, в LLVM и Clang они строят свои закрытые иерархии, чтобы получить полиморфизм без виртуальных указателей (и RTTI), чтобы снизить требования к памяти. Эти объекты можно эффективно хранить в разделяемой памяти.
Итак, как добиться совместимости полиморфизма с разделяемой памятью: нам не нужно хранить указатели на таблицы/функции, однако мы можем хранить индексы.
Пример идеи, но, вероятно, можно было бы доработать.
/// In header
#include <cassert>
#include <vector>
template <class, size_t> class BaseT;
class Base {
template <class, size_t> friend class BaseT;
public:
int get() const; // -> Implement: 'int getImpl() const' in Derived
void set(int i); // = 0 -> Implement: 'void setImpl(int i)' in Derived
private:
struct VTable {
typedef int (*Getter)(void const*);
typedef void (*Setter)(void*, int);
VTable(): _get(0), _set(0) {}
Getter _get;
Setter _set;
};
static std::vector<VTable>& VT(); // defined in .cpp
explicit Base(size_t v): _v(v) {}
size_t _v;
}; // class Base
template <class Derived, size_t Index>
class BaseT: public Base {
public:
BaseT(): Base(Index) {
static bool const _ = Register();
(void)_;
}
// Provide default implementation of getImpl
int getImpl() const { return 0; }
// No default implementation setImpl
private:
static int Get(void const* b) {
Derived const* d = static_cast<Derived const*>(b);
return d->getImpl();
}
static void Set(void* b, int i) {
Derived* d = static_cast<Derived*>(b);
d->setImpl(i);
}
static bool Register() {
typedef Base::VTable VTable;
std::vector<VTable>& vt = Base::VT();
if (vt.size() <= Index) {
vt.insert(vt.end(), Index - vt.size() + 1, VTable());
} else {
assert(vt[Index]._get == 0 && "Already registered VTable!");
}
vt[Index]._get = &Get;
vt[Index]._set = &Set;
}
}; // class BaseT
/// In source
std::vector<VTable>& Base::VT() {
static std::vector<VTable> V;
return V;
} // Base::VT
int Base::get() const {
return VT()[_v]._get(this);
} // Base::get
void Base::set(int i) {
return VT()[_v]._set(this, i);
} // Base::set
Хорошо... Думаю, теперь вы цените магию компилятора...
Что касается использования, то, к счастью, все намного проще:
/// Another header
#include <Base.h>
// 4 must be unique within the hierarchy
class Derived: public BaseT<Derived, 4> {
template <class, size_t> friend class BaseT;
public:
Derived(): _i(0) {}
private:
int getImpl() const { return _i; }
void setImpl(int i) { _i = i; }
int _i;
}; // class Derived
В действии на ideone.
person
Matthieu M.
schedule
19.10.2012
