我想我在这里遇到了一种钻石继承问题.

Qt提供了几个旋转框,用于整数值,用于双精度以及日期/时间.它们都来自QAbstractSpinBox:

#include <QtWidgets/QSpinBox>
class QSpinBox:
    public QAbstractSpinBox {

};

#include <QtWidgets/QDoubleSpinBox>
class QDoubleSpinBox:
    public QAbstractSpinBox {

};

现在我想添加一些通用于所有旋转框的功能,在这个具体的例子中,一个按钮将旋转框恢复到最小(因此是specialValueText).所以我也从中衍生出来QAbstractSpinBox并想出了这样的东西:

class AbstractRevertibleSpinBox:
    public QAbstractSpinBox {

    public:
        RevertibleSpinBox() {
            /* Use abstract base: */
            QAction *revertAction = new QAction(this);
            QAbstractSpinBox::lineEdit()->addAction(
                revertAction, QLineEdit::TrailingAction);
            /* ... */
        }

    public slots:
        virtual void revert()  = 0;
}

这revert()包含应该实现如何恢复不同旋转框的纯净.例如,setValue(double)用于QDoubleSpinBox或setDate(QDate)用于QDateEdit.然后我以明显的方式为我需要的所有旋转框派生了相应的类,如下所示:

class RevertibleSpinBox:
    public QSpinBox,
    public AbstractRevertibleSpinBox {

    protected:
        void revert() {
            /* Revert …

在下面的例子中为什么不能T从fn签名中推断出来？

template<int I>
struct Class {
    template<typename T>
    Class &operator <<( void (*)(const Class<I> &, const T &) ) { return *this; }
};

struct Ot { };

template<int I>
void fn(const Class<I> &, const Ot &) { }

int main() {
    Class<1>() << fn;
}

相比之下,以下operator<<不是常规成员的示例是合法的:

template<int I>
struct Class {
    Class &operator <<( void (*)(const Class<I> &) ) { return *this; }
};

struct Ot { };

template<int I>
void fn(const Class<I> …

在Qt文档表明,使用QSharedDataPointer一个可见执行其劣势是不典型.

因此,根据文档中的小例子,我提出了以下来源(SSCCE).

接口:Model.h

接口是直接的,只是私有类和句柄类的前向声明,copy-ctor和d-tor声明:

#include <QtCore/QSharedDataPointer>

class ModelPrivate;
class Model {
    public:
        Model();
        Model(const Model &other);
        ~Model();

        QSharedDataPointer<ModelPrivate> d;
};

私有标题:Model_p.h

只需声明并定义劣等类.

#include <QSharedData>
class ModelPrivate:
    public QSharedData {

    public:

};

实施:Model.cc

由文档中的c-tors/d-tor实现组成.

#include "Model.h"
#include "Model_p.h"

class ModelPrivate:
    public QSharedData {

};

Model::Model():
    d(new ModelPrivate()) {

}

Model::Model(const Model &other):
    d(other.d) {

}

Model::~Model() {

}

用例:main.cc

一切都失败了.

#include <QString>
#include "Model.h"

int main(int argc, char *argv[]) {
    QString s1, s2;
    s2 = s1;

    Model …

我目前想知道如何合理地使用QObject::destroyed(QObject*) 信号.

一个观察

我注意到 - QWidget衍生物体的处理略有不同.考虑以下小型自包含和编译示例:

/* sscce.pro:
QT += core gui widgets
CONFIG += c++11
TARGET = sscce
TEMPLATE = app
SOURCES += main.cpp
*/

#include <QApplication>
#include <QPushButton>
#include <QTimer>
#include <QtDebug>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    QPushButton *button = new QPushButton;
    QObject::connect(button, &QPushButton::destroyed,
        [=](QObject *o) { qDebug() << o; });

    delete button;

    QTimer *timer = new QTimer;
    QObject::connect(timer, &QTimer::destroyed,
        [=](QObject *o) { qDebug() << o; });

    delete timer;

    return app.exec(); …

在我的应用程序中,我需要对一个相当大的数组进行排序,结果证明这是一个标准的任务,例如std::sort.

位于GUI应用程序中,我想对排序的进度给出某种响应.我的第一个尝试是弄清楚所需比较的大概数量(n*log2(n)for std::sort),然后简单地计算它们在传递给的比较函子中std::sort.这非常有效.

排序算法在单独的线程中执行以保持GUI响应.它使用Qt的信号或一些类似的线程安全机制将其进度传达给GUI.

但是,我也希望排序操作可以中断.也就是说,向用户提供按钮或类似的东西以中止整个操作.目前我只看到两个选项:

1. 抢先终止线程(pthread_cancel等)
2. 重写排序算法并插入显式取消点.

考虑到线程取消而不是最后的手段并拒绝重写标准库算法,我抓住了狼的耳朵.

考虑具有成员变量的类,如下所示:

struct A {
    int a;
    char b;
};

struct B {
    double c;
    bool d;
};

是否可以声明一个模板类,该模板类接受作为其模板参数的指针到成员对象,指向上述类中声明的任何一个成员？可以声明并使用接受通用指针到成员对象的类,如下所示:

template<typename Class, typename Type, Type (Class::*Member)>
struct Magic
{ };

// Usage:
typedef Magic<A, int, &A::a> MagicWithA_a;

不幸的是,每次都要传递Class和 Type模板参数以使最终指针工作是非常麻烦的.

例如,有没有办法让部分专业化推断出这些论点？也就是说,如何Magic声明类以使下面的定义有效？

typedef Magic<&B::c> MagicWithB_c;
typedef Magic<&A::b> MagicWithA_b;