QList 的多态 class 与 copy-on-write?
QList of a polymorphic class with copy-on-write?
我正在尝试创建一个仍然使用 Qt implicit sharing 的多态类型的 QList。
我的具体用例是将 QList 中保存的项目传递给 QtConcurrent::mapped。这些项目都来自一个基 class,它定义了一个 QtConcurrent::mapped 将调用的虚函数。大多数存储的数据将是 child class 特定的。这些项目可以在线程开始后进行编辑,给我留下两个主要选项,锁定或复制数据。我不想锁定,因为这会消除使用额外线程的大部分目的。另外,制作我的数据的完整副本似乎也很不可取。相反,我想使用 Qt 的隐式共享来只复制我更改的数据项,但是我似乎无法制作仍然使用隐式共享的多态类型的 QList。
QList by default uses implicit sharing,所以乍一看好像我们已经完成了。
QList<Base> list;
Derived derived_obj;
list.append(derived_obj); // this fails
然而,将 child class 附加到 parent class 的 QList 将不起作用, standard answer 将改为使用 QList指向基 class 的 QSharedPointers,它将接受附加指向 child class 的指针。
QList<QSharedPointer<Base> > pointer_list;
QSharedPointer<Derived> derived_pointer;
pointer_list.append(derived_pointer); // this works but there is no copy-on-write
如果我使用 QSharedPointer 的 QList,将被复制的是 QSharedPointer 而不是我的多态 class,这意味着我已经失去了我想要的 copy-on-write 功能。
我也看过使用 QSharedDataPointers 的 QList。
QList<QSharedDataPointer<Base> > data_pointer_list;
QSharedDataPointer<Derived> derived_data_pointer;
list.append(derived_data_pointer); // this fails
然而,就像 QList 本身一样,QSharedDataPointers 似乎不接受多态类型。
这失败了:
QList<QSharedDataPointer<Base>> list;
QSharedDataPointer<Derived> derived(new Derived);
list.append(derived);
注意 下面的另一种方法是合并 PolymorphicShared
和 PolymorphicSharedBase
以直接向 QSharedDataPointer
添加多态支持,无需对 QSharedData
派生类型提出特殊要求(例如,它不需要明确支持 clone
)。这需要更多的工作。以下只是一种工作方法。
QSharedDataPointer
确实是你要找的答案,绝对可以保持多态QSharedData
。您需要将类型分成基于 QSharedData
的层次结构和另一个包装 QSharedDataPointer
的并行层次结构。 QSharedDataPointer
通常不打算由 class 的最终用户直接使用。它是一个实现细节,可用于实现隐式共享 class.
为了效率起见,QSharedDataPointer
是一个可以在位级别移动的小型类型。当存储在各种容器中时,它非常有效 - 特别是在可以利用类型特征来了解这一点的 Qt 容器中 属性。 class 使用 QSharedDataPointer
的大小通常会加倍,如果我们使它本身多态,因此不这样做会有所帮助。当然,指向的数据类型可以是多态的。
首先,让我们定义一个相当通用的基础 class PIMPL,您将在其上构建层次结构。 PIMPL class 可以转储到调试流中并进行克隆。
// https://github.com/KubaO/Whosebugn/tree/master/questions/implicit-list-44593216
#include <QtCore>
#include <type_traits>
class PolymorphicSharedData : public QSharedData {
public:
virtual PolymorphicSharedData * clone() const = 0;
virtual QDebug dump(QDebug) const = 0;
virtual ~PolymorphicSharedData() {}
};
xxxData
类型是 PIMPL,不适合最终用户使用。用户应该使用 xxx
类型本身。这个共享类型然后包装多态 PIMPL 并使用 QSharedDataPointer
来存储 PIMPL。它公开了 PIMPL 的方法。
类型本身不是多态的,为了节省虚拟table指针的大小。通过将多态性重定向到 PIMPL,as()
函数的作用与 dynamic_cast()
相同。
class PolymorphicShared {
protected:
QSharedDataPointer<PolymorphicSharedData> d_ptr;
PolymorphicShared(PolymorphicSharedData * d) : d_ptr(d) {}
public:
PolymorphicShared() = default;
PolymorphicShared(const PolymorphicShared & o) = default;
PolymorphicShared & operator=(const PolymorphicShared &) = default;
QDebug dump(QDebug dbg) const { return d_ptr->dump(dbg); }
template <class T> typename
std::enable_if<std::is_pointer<T>::value, typename
std::enable_if<!std::is_const<typename std::remove_pointer<T>::type>::value, T>::type>
::type as() {
if (dynamic_cast<typename std::remove_pointer<T>::type::PIMPL*>(d_ptr.data()))
return static_cast<T>(this);
return {};
}
template <class T> typename
std::enable_if<std::is_pointer<T>::value, typename
std::enable_if<std::is_const<typename std::remove_pointer<T>::type>::value, T>::type>
::type as() const {
if (dynamic_cast<const typename std::remove_pointer<T>::type::PIMPL*>(d_ptr.data()))
return static_cast<T>(this);
return {};
}
template <class T> typename
std::enable_if<std::is_reference<T>::value, typename
std::enable_if<!std::is_const<typename std::remove_reference<T>::type>::value, T>::type>
::type as() {
Q_UNUSED(dynamic_cast<typename std::remove_reference<T>::type::PIMPL&>(*d_ptr));
return static_cast<T>(*this);
}
template <class T> typename
std::enable_if<std::is_reference<T>::value, typename
std::enable_if<std::is_const<typename std::remove_reference<T>::type>::value, T>::type>
::type as() const {
Q_UNUSED(dynamic_cast<const typename std::remove_reference<T>::type::PIMPL&>(*d_ptr));
return static_cast<T>(*this);
}
int ref() const { return d_ptr ? d_ptr->ref.load() : 0; }
};
QDebug operator<<(QDebug dbg, const PolymorphicShared & val) {
return val.dump(dbg);
}
Q_DECLARE_TYPEINFO(PolymorphicShared, Q_MOVABLE_TYPE);
#define DECLARE_TYPEINFO(concreteType) Q_DECLARE_TYPEINFO(concreteType, Q_MOVABLE_TYPE)
template <> PolymorphicSharedData * QSharedDataPointer<PolymorphicSharedData>::clone() {
return d->clone();
}
一个帮助程序,可以轻松地将抽象基础 class 与派生数据类型一起使用。它将 d-ptr 转换为正确的派生 PIMPL 类型,并将构造函数参数转发给 PIMPL 的构造函数。
template <class Data, class Base = PolymorphicShared> class PolymorphicSharedBase : public Base {
friend class PolymorphicShared;
protected:
using PIMPL = typename std::enable_if<std::is_base_of<PolymorphicSharedData, Data>::value, Data>::type;
PIMPL * d() { return static_cast<PIMPL*>(&*this->d_ptr); }
const PIMPL * d() const { return static_cast<const PIMPL*>(&*this->d_ptr); }
PolymorphicSharedBase(PolymorphicSharedData * d) : Base(d) {}
template <typename T> static typename std::enable_if<std::is_constructible<T>::value, T*>::type
construct() { return new T(); }
template <typename T> static typename std::enable_if<!std::is_constructible<T>::value, T*>::type
construct() { return nullptr; }
public:
using Base::Base;
template<typename ...Args,
typename = typename std::enable_if<std::is_constructible<Data, Args...>::value>::type
> PolymorphicSharedBase(Args&&... args) :
Base(static_cast<PolymorphicSharedData*>(new Data(std::forward<Args>(args)...))) {}
PolymorphicSharedBase() : Base(construct<Data>()) {}
};
现在拥有 PIMPL 类型及其运营商的平行层次结构是一件简单的事情。首先,我们的层次结构中的一个基本抽象类型添加了两个方法。请注意 PolymorphicSharedBase
如何添加正确类型的 d()
访问器。
class MyAbstractTypeData : public PolymorphicSharedData {
public:
virtual void gurgle() = 0;
virtual int gargle() const = 0;
};
class MyAbstractType : public PolymorphicSharedBase<MyAbstractTypeData> {
public:
using PolymorphicSharedBase::PolymorphicSharedBase;
void gurgle() { d()->gurgle(); }
int gargle() const { return d()->gargle(); }
};
DECLARE_TYPEINFO(MyAbstractType);
然后,一个没有添加新方法的具体类型:
class FooTypeData : public MyAbstractTypeData {
protected:
int m_foo = 0;
public:
FooTypeData() = default;
FooTypeData(int data) : m_foo(data) {}
void gurgle() override { m_foo++; }
int gargle() const override { return m_foo; }
MyAbstractTypeData * clone() const override { return new FooTypeData(*this); }
QDebug dump(QDebug dbg) const override {
return dbg << "FooType-" << ref << ":" << m_foo;
}
};
using FooType = PolymorphicSharedBase<FooTypeData, MyAbstractType>;
DECLARE_TYPEINFO(FooType);
还有一种添加方法的类型。
class BarTypeData : public FooTypeData {
protected:
int m_bar = 0;
public:
BarTypeData() = default;
BarTypeData(int data) : m_bar(data) {}
MyAbstractTypeData * clone() const override { return new BarTypeData(*this); }
QDebug dump(QDebug dbg) const override {
return dbg << "BarType-" << ref << ":" << m_foo << "," << m_bar;
}
virtual void murgle() { m_bar++; }
};
class BarType : public PolymorphicSharedBase<BarTypeData, FooType> {
public:
using PolymorphicSharedBase::PolymorphicSharedBase;
void murgle() { d()->murgle(); }
};
DECLARE_TYPEINFO(BarType);
我们要验证 as()
方法是否按需要抛出:
template <typename F> bool is_bad_cast(F && fun) {
try { fun(); } catch (std::bad_cast) { return true; }
return false;
}
隐式共享类型的使用与 Qt 自己的此类类型的使用没有什么不同。我们也可以使用 as
而不是 dynamic_cast
.
进行转换
int main() {
Q_ASSERT(sizeof(FooType) == sizeof(void*));
MyAbstractType a;
Q_ASSERT(!a.as<FooType*>());
FooType foo;
Q_ASSERT(foo.as<FooType*>());
a = foo;
Q_ASSERT(a.ref() == 2);
Q_ASSERT(a.as<const FooType*>());
Q_ASSERT(a.ref() == 2);
Q_ASSERT(a.as<FooType*>());
Q_ASSERT(a.ref() == 1);
MyAbstractType a2(foo);
Q_ASSERT(a2.ref() == 2);
QList<MyAbstractType> list1{FooType(3), BarType(8)};
auto list2 = list1;
qDebug() << "After copy: " << list1 << list2;
list2.detach();
qDebug() << "After detach: " << list1 << list2;
list1[0].gurgle();
qDebug() << "After list1[0] mod: " << list1 << list2;
Q_ASSERT(list2[1].as<BarType*>());
list2[1].as<BarType&>().murgle();
qDebug() << "After list2[1] mod: " << list1 << list2;
Q_ASSERT(!list2[0].as<BarType*>());
Q_ASSERT(is_bad_cast([&]{ list2[0].as<BarType&>(); }));
auto const list3 = list1;
Q_ASSERT(!list3[0].as<const BarType*>());
Q_ASSERT(is_bad_cast([&]{ list3[0].as<const BarType&>(); }));
}
输出:
After copy: (FooType-1:3, BarType-1:0,8) (FooType-1:3, BarType-1:0,8)
After detach: (FooType-2:3, BarType-2:0,8) (FooType-2:3, BarType-2:0,8)
After list1[0] mod: (FooType-1:4, BarType-2:0,8) (FooType-1:3, BarType-2:0,8)
After list2[1] mod: (FooType-1:4, BarType-1:0,8) (FooType-1:3, BarType-1:0,9)
列表复制很浅,项目本身没有被复制:引用计数都是 1
。分离后,所有数据项都被复制,但因为它们是隐式共享的,所以它们只增加了它们的引用计数。最后,一个item被修改后,自动detach,引用计数降回1。
我正在尝试创建一个仍然使用 Qt implicit sharing 的多态类型的 QList。
我的具体用例是将 QList 中保存的项目传递给 QtConcurrent::mapped。这些项目都来自一个基 class,它定义了一个 QtConcurrent::mapped 将调用的虚函数。大多数存储的数据将是 child class 特定的。这些项目可以在线程开始后进行编辑,给我留下两个主要选项,锁定或复制数据。我不想锁定,因为这会消除使用额外线程的大部分目的。另外,制作我的数据的完整副本似乎也很不可取。相反,我想使用 Qt 的隐式共享来只复制我更改的数据项,但是我似乎无法制作仍然使用隐式共享的多态类型的 QList。
QList by default uses implicit sharing,所以乍一看好像我们已经完成了。
QList<Base> list;
Derived derived_obj;
list.append(derived_obj); // this fails
然而,将 child class 附加到 parent class 的 QList 将不起作用, standard answer 将改为使用 QList指向基 class 的 QSharedPointers,它将接受附加指向 child class 的指针。
QList<QSharedPointer<Base> > pointer_list;
QSharedPointer<Derived> derived_pointer;
pointer_list.append(derived_pointer); // this works but there is no copy-on-write
如果我使用 QSharedPointer 的 QList,将被复制的是 QSharedPointer 而不是我的多态 class,这意味着我已经失去了我想要的 copy-on-write 功能。
我也看过使用 QSharedDataPointers 的 QList。
QList<QSharedDataPointer<Base> > data_pointer_list;
QSharedDataPointer<Derived> derived_data_pointer;
list.append(derived_data_pointer); // this fails
然而,就像 QList 本身一样,QSharedDataPointers 似乎不接受多态类型。
这失败了:
QList<QSharedDataPointer<Base>> list;
QSharedDataPointer<Derived> derived(new Derived);
list.append(derived);
注意 下面的另一种方法是合并 PolymorphicShared
和 PolymorphicSharedBase
以直接向 QSharedDataPointer
添加多态支持,无需对 QSharedData
派生类型提出特殊要求(例如,它不需要明确支持 clone
)。这需要更多的工作。以下只是一种工作方法。
QSharedDataPointer
确实是你要找的答案,绝对可以保持多态QSharedData
。您需要将类型分成基于 QSharedData
的层次结构和另一个包装 QSharedDataPointer
的并行层次结构。 QSharedDataPointer
通常不打算由 class 的最终用户直接使用。它是一个实现细节,可用于实现隐式共享 class.
为了效率起见,QSharedDataPointer
是一个可以在位级别移动的小型类型。当存储在各种容器中时,它非常有效 - 特别是在可以利用类型特征来了解这一点的 Qt 容器中 属性。 class 使用 QSharedDataPointer
的大小通常会加倍,如果我们使它本身多态,因此不这样做会有所帮助。当然,指向的数据类型可以是多态的。
首先,让我们定义一个相当通用的基础 class PIMPL,您将在其上构建层次结构。 PIMPL class 可以转储到调试流中并进行克隆。
// https://github.com/KubaO/Whosebugn/tree/master/questions/implicit-list-44593216
#include <QtCore>
#include <type_traits>
class PolymorphicSharedData : public QSharedData {
public:
virtual PolymorphicSharedData * clone() const = 0;
virtual QDebug dump(QDebug) const = 0;
virtual ~PolymorphicSharedData() {}
};
xxxData
类型是 PIMPL,不适合最终用户使用。用户应该使用 xxx
类型本身。这个共享类型然后包装多态 PIMPL 并使用 QSharedDataPointer
来存储 PIMPL。它公开了 PIMPL 的方法。
类型本身不是多态的,为了节省虚拟table指针的大小。通过将多态性重定向到 PIMPL,as()
函数的作用与 dynamic_cast()
相同。
class PolymorphicShared {
protected:
QSharedDataPointer<PolymorphicSharedData> d_ptr;
PolymorphicShared(PolymorphicSharedData * d) : d_ptr(d) {}
public:
PolymorphicShared() = default;
PolymorphicShared(const PolymorphicShared & o) = default;
PolymorphicShared & operator=(const PolymorphicShared &) = default;
QDebug dump(QDebug dbg) const { return d_ptr->dump(dbg); }
template <class T> typename
std::enable_if<std::is_pointer<T>::value, typename
std::enable_if<!std::is_const<typename std::remove_pointer<T>::type>::value, T>::type>
::type as() {
if (dynamic_cast<typename std::remove_pointer<T>::type::PIMPL*>(d_ptr.data()))
return static_cast<T>(this);
return {};
}
template <class T> typename
std::enable_if<std::is_pointer<T>::value, typename
std::enable_if<std::is_const<typename std::remove_pointer<T>::type>::value, T>::type>
::type as() const {
if (dynamic_cast<const typename std::remove_pointer<T>::type::PIMPL*>(d_ptr.data()))
return static_cast<T>(this);
return {};
}
template <class T> typename
std::enable_if<std::is_reference<T>::value, typename
std::enable_if<!std::is_const<typename std::remove_reference<T>::type>::value, T>::type>
::type as() {
Q_UNUSED(dynamic_cast<typename std::remove_reference<T>::type::PIMPL&>(*d_ptr));
return static_cast<T>(*this);
}
template <class T> typename
std::enable_if<std::is_reference<T>::value, typename
std::enable_if<std::is_const<typename std::remove_reference<T>::type>::value, T>::type>
::type as() const {
Q_UNUSED(dynamic_cast<const typename std::remove_reference<T>::type::PIMPL&>(*d_ptr));
return static_cast<T>(*this);
}
int ref() const { return d_ptr ? d_ptr->ref.load() : 0; }
};
QDebug operator<<(QDebug dbg, const PolymorphicShared & val) {
return val.dump(dbg);
}
Q_DECLARE_TYPEINFO(PolymorphicShared, Q_MOVABLE_TYPE);
#define DECLARE_TYPEINFO(concreteType) Q_DECLARE_TYPEINFO(concreteType, Q_MOVABLE_TYPE)
template <> PolymorphicSharedData * QSharedDataPointer<PolymorphicSharedData>::clone() {
return d->clone();
}
一个帮助程序,可以轻松地将抽象基础 class 与派生数据类型一起使用。它将 d-ptr 转换为正确的派生 PIMPL 类型,并将构造函数参数转发给 PIMPL 的构造函数。
template <class Data, class Base = PolymorphicShared> class PolymorphicSharedBase : public Base {
friend class PolymorphicShared;
protected:
using PIMPL = typename std::enable_if<std::is_base_of<PolymorphicSharedData, Data>::value, Data>::type;
PIMPL * d() { return static_cast<PIMPL*>(&*this->d_ptr); }
const PIMPL * d() const { return static_cast<const PIMPL*>(&*this->d_ptr); }
PolymorphicSharedBase(PolymorphicSharedData * d) : Base(d) {}
template <typename T> static typename std::enable_if<std::is_constructible<T>::value, T*>::type
construct() { return new T(); }
template <typename T> static typename std::enable_if<!std::is_constructible<T>::value, T*>::type
construct() { return nullptr; }
public:
using Base::Base;
template<typename ...Args,
typename = typename std::enable_if<std::is_constructible<Data, Args...>::value>::type
> PolymorphicSharedBase(Args&&... args) :
Base(static_cast<PolymorphicSharedData*>(new Data(std::forward<Args>(args)...))) {}
PolymorphicSharedBase() : Base(construct<Data>()) {}
};
现在拥有 PIMPL 类型及其运营商的平行层次结构是一件简单的事情。首先,我们的层次结构中的一个基本抽象类型添加了两个方法。请注意 PolymorphicSharedBase
如何添加正确类型的 d()
访问器。
class MyAbstractTypeData : public PolymorphicSharedData {
public:
virtual void gurgle() = 0;
virtual int gargle() const = 0;
};
class MyAbstractType : public PolymorphicSharedBase<MyAbstractTypeData> {
public:
using PolymorphicSharedBase::PolymorphicSharedBase;
void gurgle() { d()->gurgle(); }
int gargle() const { return d()->gargle(); }
};
DECLARE_TYPEINFO(MyAbstractType);
然后,一个没有添加新方法的具体类型:
class FooTypeData : public MyAbstractTypeData {
protected:
int m_foo = 0;
public:
FooTypeData() = default;
FooTypeData(int data) : m_foo(data) {}
void gurgle() override { m_foo++; }
int gargle() const override { return m_foo; }
MyAbstractTypeData * clone() const override { return new FooTypeData(*this); }
QDebug dump(QDebug dbg) const override {
return dbg << "FooType-" << ref << ":" << m_foo;
}
};
using FooType = PolymorphicSharedBase<FooTypeData, MyAbstractType>;
DECLARE_TYPEINFO(FooType);
还有一种添加方法的类型。
class BarTypeData : public FooTypeData {
protected:
int m_bar = 0;
public:
BarTypeData() = default;
BarTypeData(int data) : m_bar(data) {}
MyAbstractTypeData * clone() const override { return new BarTypeData(*this); }
QDebug dump(QDebug dbg) const override {
return dbg << "BarType-" << ref << ":" << m_foo << "," << m_bar;
}
virtual void murgle() { m_bar++; }
};
class BarType : public PolymorphicSharedBase<BarTypeData, FooType> {
public:
using PolymorphicSharedBase::PolymorphicSharedBase;
void murgle() { d()->murgle(); }
};
DECLARE_TYPEINFO(BarType);
我们要验证 as()
方法是否按需要抛出:
template <typename F> bool is_bad_cast(F && fun) {
try { fun(); } catch (std::bad_cast) { return true; }
return false;
}
隐式共享类型的使用与 Qt 自己的此类类型的使用没有什么不同。我们也可以使用 as
而不是 dynamic_cast
.
int main() {
Q_ASSERT(sizeof(FooType) == sizeof(void*));
MyAbstractType a;
Q_ASSERT(!a.as<FooType*>());
FooType foo;
Q_ASSERT(foo.as<FooType*>());
a = foo;
Q_ASSERT(a.ref() == 2);
Q_ASSERT(a.as<const FooType*>());
Q_ASSERT(a.ref() == 2);
Q_ASSERT(a.as<FooType*>());
Q_ASSERT(a.ref() == 1);
MyAbstractType a2(foo);
Q_ASSERT(a2.ref() == 2);
QList<MyAbstractType> list1{FooType(3), BarType(8)};
auto list2 = list1;
qDebug() << "After copy: " << list1 << list2;
list2.detach();
qDebug() << "After detach: " << list1 << list2;
list1[0].gurgle();
qDebug() << "After list1[0] mod: " << list1 << list2;
Q_ASSERT(list2[1].as<BarType*>());
list2[1].as<BarType&>().murgle();
qDebug() << "After list2[1] mod: " << list1 << list2;
Q_ASSERT(!list2[0].as<BarType*>());
Q_ASSERT(is_bad_cast([&]{ list2[0].as<BarType&>(); }));
auto const list3 = list1;
Q_ASSERT(!list3[0].as<const BarType*>());
Q_ASSERT(is_bad_cast([&]{ list3[0].as<const BarType&>(); }));
}
输出:
After copy: (FooType-1:3, BarType-1:0,8) (FooType-1:3, BarType-1:0,8)
After detach: (FooType-2:3, BarType-2:0,8) (FooType-2:3, BarType-2:0,8)
After list1[0] mod: (FooType-1:4, BarType-2:0,8) (FooType-1:3, BarType-2:0,8)
After list2[1] mod: (FooType-1:4, BarType-1:0,8) (FooType-1:3, BarType-1:0,9)
列表复制很浅,项目本身没有被复制:引用计数都是 1
。分离后,所有数据项都被复制,但因为它们是隐式共享的,所以它们只增加了它们的引用计数。最后,一个item被修改后,自动detach,引用计数降回1。