C ++析构函数

Question

考虑这种情况：我需要为某些设置创建一个ui。 由于数据和ui在理论上应该分开，因此我定义了一个单独的类来处理配置数据。 我的问题是如何在设置类中实例化数据类。

一种方法是在调用方对象中创建数据类，我的意思是调用设置菜单类的对象。

我的问题所涉及的另一种方法是在settings类中创建一个DATA类变量。 我怀疑当设置类被破坏时会发生什么！ 设置类中的数据类对象也会被破坏吗？ 如果它被定义为设置类的静态成员怎么办？

#ifndef SETTINGSWINDOW_H

#define SETTINGSWINDOW_H

#include <QMainWindow>
#include <QModelIndex>

#include <QSignalMapper>
#include <QRadioButton>
#include <QSpinBox>
#include <QTimer>

#include "cameracommands.h"

struct Config
{
    /* General Options */
    QString general_key_lock;
    QString general_back_light;
};

//class IConfigSource
//{
//public:
//    virtual Config config() const;
//    virtual void setConfig(const Config& cfg);
//};

class ConfigSource /* : public IConfigSource*/
{
    public:

    ConfigSource() {

        config_.general_back_light         = "OFF";
        config_.general_key_lock           = "OFF";
    }

    Config config() const {return config_;}

    void setConfig(const Config& cfg) {config_ = cfg;}

    private:

    Config config_;
};

class ConfigUpdater : public QObject
{
    Q_OBJECT
public:
    ConfigUpdater(ConfigSource& src) : src_(src) {}

public slots:

    void apply () {src_.setConfig(tempConfig_);}
    void cancel() {tempConfig_ = src_.config();}

public:

    void updateGeneralBackLight(QString s)             {tempConfig_.general_back_light         = s; qDebug() << "BackLight updated :)";}
    void updateGeneralKeyLock(QString s)               {tempConfig_.general_key_lock           = s; qDebug() << "KeyLock updated :)";}

    Config tempConfig_;
    ConfigSource& src_;
};

//----------------------------

namespace Ui {
    class SettingsWindow;
}

class SettingsWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit SettingsWindow(QWidget *parent = 0);

    ~SettingsWindow();

signals:
    void clicked(const QString &text);
    void sendToPLC(QByteArray );

public slots:
    void updateGeneralBackLight();
    void updateGeneralKeyLock();

    void getRow(QModelIndex);
    void MySlot(QString);

private slots:
    void on_pushButton_5_clicked();
    void on_pushButton_3_clicked();

private:

    void set_mappings();

    Ui::SettingsWindow *ui;
    ConfigUpdater      *config_updater;
    QSignalMapper      *mapper;
};

#endif // SETTINGSWINDOW_H

这是来源：

QMainWindow(parent),
ui(new Ui::SettingsWindow)

{/ *初始化* /

ui->setupUi(this);

ConfigSource src;

config_updater = new ConfigUpdater(src);

Answer 1

这取决于您需要如何使用它。

• 方案1.程序运行时，需要将设置保存在内存中。

• 方案2.设置需要立即保存到光盘中，然后将按需读取。

在方案1中 ，您需要始终能够访问内存中的数据。 因此，最好将settingsUI类和settingsData类分开，以便您可以访问后者。

class settingsUI
{
<...>
private:
    settingsData * data;//pointer to the data object
}

class settingsData
{
}

在方案2中 ，可以将settingsData聚合到settingsUI ，并在销毁UI时将数据保存到文件中。

class settingsUI
{
public:
    <...>
    ~settingsUI();

private:
    class settingsData
    {
    <..>
    }data;
<...>
}

class settingsUI::~settingsUI()
{
    data.saveToFile();
}

是的，如果您将设置聚合到用户界面中，则在销毁用户界面时，设置也将被销毁。 将数据保存为静态成员并不是最好的主意，最好将数据与可视表示形式（在您的情况下为UI类）分开。

UPD ：

如果您要一直保留它直到程序退出，则建议您保留指向UI类中数据的静态指针。 这是带有原始指针的示例，但是您也可以使用智能指针ofc。

class data
{
}

class UI
{
private:
    static data * data_;
}
data* UI::data_;

程序启动时，为数据分配内存： UI::data_ = new data() ，程序结束时（或者如果不再需要数据），释放内存： delete UI::data_ 。 再一次，最好使用智能指针，因此这只是一个例子。

Answer 2

是的，当销毁设置对象时，数据对象将被销毁。 如果将其设为静态成员，则不会。 但这可能不是一个好主意。 更好的方法是将数据对象持久保存到文件中（例如）。 您可以在设置对象构造函数中读取文件，并在设置对象析构函数中写入文件。

编辑

class SettingsWindow : public QMainWindow
{
Q_OBJECT

public:
    explicit SettingsWindow(ConfigSource& src , QWidget *parent = 0);
...
}

SettingsWindow::SettingsWindow(ConfigSource& src , QWidget *parent)
    QMainWindow(parent),
    ui(new Ui::SettingsWindow)
{
    ui->setupUi(this);
    config_updater = new ConfigUpdater(src);
    ...
}

谢谢，这是正确的。 当我尝试将以下变量传递给用户定义的函数时，程序终止：（内部标头）

void print_config（Config cfg）;

Ui :: SettingsWindow * ui; ConfigUpdater * config_updater;

内部cpp：

void SettingsWindow::print_config(Config config)
{
    qDebug() << config.general_back_light;
    qDebug() << config.general_key_lock;

}

void SettingsWindow::on_sendToMainButton_clicked() /* cancel */
{
   print_config(config_updater->tempConfig_);
   print_config(config_updater->src_.config());
}

首先，对于tempConfig_，print_config指令工作正常，但是当我在第二条语句中传递src_时，它会跳出程序。

// ------------

我知道问题的根源，但我无法解决，希望能对您有所帮助：

class ConfigUpdater : public QObject
{
    Q_OBJECT
public:
    ConfigUpdater(ConfigSource& src) : src_(src) {}

public slots:

    void apply () {src_.setConfig(tempConfig_);}
    void cancel() {tempConfig_ = src_.config();}

public:

    Config tempConfig_;
    ConfigSource& src_;
};

在这里，即使在“设置”窗口的构造器中，src_仍通过引用传递。 当我尝试在内存中访问程序时，该程序失败，例如：

config_updater->cancel();

这样做：void cancel（）{tempConfig_ = src_.config（）;}

Answer 3

如果settings类仅由UI使用，则将其保留在UI类中是有意义的：

class Settings {
    int a;
    int b;
};

class Ui {
private:
    Settings settings;
};

Ui毁灭期间， settings将被破坏。

如果您在许多地方都使用Settings对象，则保持指向它的共享指针更为有意义：

class Ui {
public:
    Ui(std::shared_ptr<Settings> someSettings)
        : settings(someSettings)
    {}
private:
    std::shared_ptr<Settings> settings;
};

当shared_ptr的最后一个所有者被销毁时，此Settings对象将被销毁。