如何从 Qt/C++ 的子函数中调用非静态父函数？

Question

我很难理解如何将父对象传递给子对象。 在 Qt 中，我有一个 MainWindow 类和一个 DoSomething() 函数。然后我在 MainWindow 中创建了一个 Job 对象，并尝试在 Job 的 DoItNow() 函数中调用 DoSomething。但我就是不知道该怎么做。

MainWindow.h

class Job;
class MainWindow : public QMainWindow
{
  Q_OBJECT

  public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

    int value;
    void DoSomething();

  private:
  Job *job;
}

MainWindow.cpp

#include "mainwindow.h"
#include "job.h"

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent),
ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    job = new Job(this);   // passing this pointer to child
}

void MainWindow::DoSomething() {  // do something }

工作.h

class Job : public QObject
{
  Q_OBJECT

  private:
    void DoItNow();

  public:
    explicit CDMcommand(QObject *parent = 0);
}

Job.cpp

#include "job.h"
#include "mainwindow.h"

Job::Job(QObject *parent) : QObject(parent)
{
  // some setups
  parent->value = 0;    // this is not working
}

void Job::DoItNow()
{
  parent->DoSomething();  // What is the pointer to MainWindow instance?
}

• 如何访问 *parent 中的非静态公共寄存器？

• 如何将 *parent 传递给作业实例中的函数？

Answer 1

也许我误解了这个问题，但我认为您对继承有点困惑。您的Job 是QObject 的子类，MainWindow 也间接继承自QObject，但MainWindow 和Job 之间没有直接关系。我对Qts的信号槽机制不是很熟悉，这里大概是走的路，但也许我可以为你提供一个不同的解决方案：

Job::Job(QObject *parent) : QObject(parent)
{
  // some setups
  parent->value = 0;    // this is not working
}

这不起作用，因为QObject 没有名为value 的成员。如果您可以使用 Jobs 构造函数而不以 QObject* 作为参数，那么只需声明一个

MainWindow* parentWindow;

作为Job 中的私有成员并将构造函数更改为

Job::Job(MainWindow *parentWindow) : QObject(parentWindow)
{
  // some setups
  parentWindow->value = 0;    // this will work now
}

然后也

void Job::DoItNow()
{
  parentWindow->DoSomething();  
}

可以正常工作。

Answer 2

如何从“子”调用 Qt“父”对象方法 对象方法？

安全又简单的方法：

void Job::DoItNow()
{
   // first evaluate the pointer: is that of type we expect?
   MainWindow* pMainWindow = qobject_cast<MainWindow*>(parent());
   if (pMainWindow)
       pMainWindow->DoSomething();  // MainWindow::DoSomething must be exposed to class Job
}

当然，让两个类相互依赖太多是违反 OOP 原则的：这两个对象现在变得紧密耦合。在 cmets 中已经有一个很好的建议：为此使用显式的信号槽机制或提供接口以在解耦对象之间进行交互。