C++ 更改哈希映射的Qt信号

我在Qt串行终端程序中有一个hashmapReferenceMap

程序以引用后跟值的形式接收引用映射的键。然后，它使用Qt hashmap insert函数插入该值。这是非常整洁，我想保留这一部分的计划

问题是，当不同的新价值观出现时，我想做不同的事情。因此，当与referencemap中的特殊位置关联的值发生更改时，我希望发出一个信号

根据下面的指南，可以轻松创建发出信号的对象。

不过，我想我找到了一个解决办法，我想讨论一下这是不是一个好办法

我可以像这样创建一个类

class Sfloat : public QObject
{
    Q_OBJECT
public:
    explicit Sfloat(QObject *parent = 0);

    float Get();
    void SetValue(float value);

private:
float MyFloat;


signals:
void ValueChanged(float newValue);

public slots:

};

然后可以将ReferenceMap设置为包含对SFloat对象的引用，如

ReferenceMap（键和SFloat）

---

当我有了键，我可以得到对象引用，调用SetValue（），然后会发出一个信号。然而，这是解决问题的最好办法吗

我认为这不是个好主意。你正在用一个QObject来包装你散列的每一个浮点数，我觉得这个QObject很重

您可以将整个HashMap放在QObject中，当您感兴趣的值发生变化时，从那里发出信号

class MyHashMap : public QObject
{
    Q_OBJECT
public:
    explicit MyHashMap(QObject *parent = 0);

    float Get(const QString& key) const;
    void SetValue(const QString& key, float value)
    {
      // only emit value changed if the value has actually changed
            QHashMap<QString, float>::iterator it = myHashMap.find(key);
            if(it != myHashMap.end()){
                if(it.value != value){
                    myHashMap[key] = value;
                    emit ValueChanged(key, value);
                }
            }
    }

private:
QHashMap<QString, float> myHashMap;

signals:
void ValueChanged(const QString& key, float newValue);
};

类MyHashMap:公共QObject
{
Q_对象
公众：
显式MyHashMap（QObject*parent=0）；
浮点获取（常量QString&key）常量；
无效设置值（常量字符串和键，浮点值）
{
//仅当值已实际更改时，发射值才会更改
迭代器it=myHashMap.find（键）；
if（it！=myHashMap.end（））{
if（it.value！=值）{
myHashMap[key]=值；
发出值已更改（键、值）；
}
}
}
私人：
QHashMap-myHashMap；
信号：
无效值已更改（常量字符串和键，浮动新值）；
};

根据您的评论，您希望在值更改时更新标签。只需将所有标签添加到QHashMap，然后将ValueChanged信号连接到更新正确标签的插槽：

class MyWidget : public QWidget
{
    Q_OBJECT
public:
    explicit MyWidget(QWidget *parent = 0)
        {
            ...
            ...
            myLabels["label1"] = myLabel1;
            myLabels["label2"] = myLabel2;
            QObject::connect(myLabels, SIGNAL(ValueChanged(const QString&, float)), 
                this, OnValueChanged(const QString&, float));
        }

public slots:
    void OnValueChanged(const QString& key, float newValue){
        QHashMap<QString, QLabel*>::iterator it = myLabels.find(key);
        if(it != myLabels.end()){
            it.value()->setText(QString::number(newValue));
        }
    }

private:
QHashMap<QString, QLabel*> myLabels;
};

classmywidget:publicqwidget
{
Q_对象
公众：
显式MyWidget（QWidget*parent=0）
{
...
...
myLabels[“label1”]=myLabel1；
myLabels[“label2”]=myLabel2；
QObject:：connect（myLabels，信号（ValueChanged（const-QString&，float）），
这个，OnValueChanged（const-QString&，float））；
}
公众时段：
void OnValueChanged（常量QString&key，float newValue）{
迭代器it=myLabels.find（键）；
if（it！=myLabels.end（））{
it.value（）->setText（QString:：number（newValue））；
}
}
私人：
QHashMap-myLabels；
};

我认为这不是个好主意。你正在用一个QObject来包装你散列的每一个浮点数，我觉得这个QObject很重

您可以将整个HashMap放在QObject中，当您感兴趣的值发生变化时，从那里发出信号

class MyHashMap : public QObject
{
    Q_OBJECT
public:
    explicit MyHashMap(QObject *parent = 0);

    float Get(const QString& key) const;
    void SetValue(const QString& key, float value)
    {
      // only emit value changed if the value has actually changed
            QHashMap<QString, float>::iterator it = myHashMap.find(key);
            if(it != myHashMap.end()){
                if(it.value != value){
                    myHashMap[key] = value;
                    emit ValueChanged(key, value);
                }
            }
    }

private:
QHashMap<QString, float> myHashMap;

signals:
void ValueChanged(const QString& key, float newValue);
};

类MyHashMap:公共QObject
{
Q_对象
公众：
显式MyHashMap（QObject*parent=0）；
浮点获取（常量QString&key）常量；
无效设置值（常量字符串和键，浮点值）
{
//仅当值已实际更改时，发射值才会更改
迭代器it=myHashMap.find（键）；
if（it！=myHashMap.end（））{
if（it.value！=值）{
myHashMap[key]=值；
发出值已更改（键、值）；
}
}
}
私人：
QHashMap-myHashMap；
信号：
无效值已更改（常量字符串和键，浮动新值）；
};

根据您的评论，您希望在值更改时更新标签。只需将所有标签添加到QHashMap，然后将ValueChanged信号连接到更新正确标签的插槽：

class MyWidget : public QWidget
{
    Q_OBJECT
public:
    explicit MyWidget(QWidget *parent = 0)
        {
            ...
            ...
            myLabels["label1"] = myLabel1;
            myLabels["label2"] = myLabel2;
            QObject::connect(myLabels, SIGNAL(ValueChanged(const QString&, float)), 
                this, OnValueChanged(const QString&, float));
        }

public slots:
    void OnValueChanged(const QString& key, float newValue){
        QHashMap<QString, QLabel*>::iterator it = myLabels.find(key);
        if(it != myLabels.end()){
            it.value()->setText(QString::number(newValue));
        }
    }

private:
QHashMap<QString, QLabel*> myLabels;
};

classmywidget:publicqwidget
{
Q_对象
公众：
显式MyWidget（QWidget*parent=0）
{
...
...
myLabels[“label1”]=myLabel1；
myLabels[“label2”]=myLabel2；
QObject:：connect（myLabels，信号（ValueChanged（const-QString&，float）），
这个，OnValueChanged（const-QString&，float））；
}
公众时段：
void OnValueChanged（常量QString&key，float newValue）{
迭代器it=myLabels.find（键）；
if（it！=myLabels.end（））{
it.value（）->setText（QString:：number（newValue））；
}
}
私人：
QHashMap-myLabels；
};

我个人喜欢它，因为存储单元只是一个存储单元。通常我有一个存储控制器类，它处理存储在哪里的内容，以及在发生更改时应该做什么。我个人喜欢它，因为存储单元只是一个存储单元。通常我有一个存储控制器类，它处理存储在哪里的内容，以及在某些内容发生更改时应该做什么！然后，我想用不同的动作连接每个ValueChanged信号，例如更改特定的文本标签。我是否应该将发出的信号中的键连接到一个hashmap上，该hashmap上的函数指针可以实现我想要的功能？或者只要调用一个函数，在每次值更改时打印MyHash中的所有值？有很多方法可以做到这些，我正在寻找“最好”的方法。我根据你的评论编辑了答案。你可能想更新这个问题。谢谢你的回答！您通常对在映射中存储函数指针的概念有何看法？我认为在映射中存储函数指针没有任何技术问题，但在我看来，可能有更好的选择。另外，在性能不重要的gui应用程序中，我更倾向于使用多态性或if/switch语句而不是函数指针！T