How to transfer parameter from constructor into slot? - c++

Question

I am doing a small exercise with Qt. As I know, slot save_clicked brings only type of parameter. So how can I transfer userid into slot save_clicked in file MyClass.cpp for processing below ?
MyClass.h
class MyClass : public QWidget
{
Q_OBJECT
public:
MyClass(QString userid, QString lastname, QString firstname, QWidget *parent = 0);
~MyClass();
public slots:
void save_clicked(QString userid);
private:
Ui::MyClass ui;
};
#endif // MYCLASS_H
MyClass.cpp
MyClass::MyClass(QString userid, QString lastname, QString firstname, QWidget *parent)
: QWidget(parent)
{
ui.setupUi(this);
...........
...........
connect(ui.save, SIGNAL(clicked()), this, SLOT(save_clicked(QString)));
}
void MyClass::save_clicked(QString userid)
{
// process userid here
}

Answer 1

First of all, there have already been suggestions that userid doesn't need to be passed to a slot. Declaring it as a member of MyClass and simply using it in MyClass::save_clicked() will do just fine.
If you still want to know how to handle the case where you need to pass arguments to a slot not provided by the signal, there are mutiple ways to achieve that and they depend on the version of Qt you're using.
In general, the following from the Qt5 docs holds for Qt5 and Qt4:
The signature of a signal must match the signature of the receiving
slot. (In fact a slot may have a shorter signature than the signal it
receives because it can ignore extra arguments.)
Given that fact, you have to either use what the signal provides (or don't - depends on if you need it at all) or get your data somewhere else. A slot is just a regular function (a little more constrained in Qt4 but in Qt5, you can basically connect anything that's callable to a signal) and in that function, you can get the data you need from anywhere your design permits. The member variable approach is common, but you can also call another member function of any other object, free function or simply compute whatever you need inside the slot.
Note: Handling a signal doesn't necessarily mean you need any data - it's common, yes, but you could also do something simple as bring up a QMessageBox with some hard-coded text or simply clear some text edit (think something like a button doing Clear Console) or execute some external process or what have you.
If you need your slot to actually receive data when it is invoked, you have multiple options:
use everything or a subset of what the signal provides
use QSignalMapper to establish a mapping with limited control over your slot arguments
use the, IMHO, superior approach of using a function object that stores what you need, i.e. either a functor you provide directly or as a lambda or a function object returned from std::bind
For the latter to work you need C++11support , but by now, that shouldn't be a problem.
In your above example, you could do something like this in the most basic approach (UNTESTED - Please report compile errors so I can fix the answer):
MyClass::MyClass(QString userid, QString lastname, QString firstname, QWidget *parent)
: QWidget(parent)
{
...
connect (
ui.save,
&QPushButton::clicked,
std::bind (&MyClass::save_clicked, this, userid)
);
...
}
I the above case, when clicked() is emitted by ui.save, the function call wrapper returned by std::bind will be call, which in turn will call MyClass::save_clicked on this instance of MyClass and pass userid to save_clicked().
The above is basically what you wanted to achieve initially. However, this is just the tip of the iceberg. You can go much, much further with this and, for instance, bind anything you want.
For instance, suppose you connected to another signal provided by your button, toggled(bool checked). If you wanted to receive both the check status as a bool and a number of arguments you provide yourself, for instance the userid, you can extend the above call to std::bind with an appropriate placeholder:
connect (
ui.save,
&QPushButton::toggled,
std::bind (&MyClass::save_clicked, this, _1, userid /*, ... more args here*/)
);
You would now have the following signature for save_clicked():
save_clicked(bool, QString);
On emission of toggled(bool) by ui.save, the function call wrapper returned by std::bind will then call MyClass::save_clicked with both the bool in place of _1 and the QString you provided as the 4th argument to std::bind.

Answer 2

Better than use signals/slots just use a variable. It's the goal of a class. Add something like :
private:
QString userId;
And in your constructor add :
MyClass::MyClass(QString userid, QString lastname, QString firstname, QWidget *parent)
: QWidget(parent)
{
ui.setupUi(this);
this.userId=userid;
}
Like this you can use userId like you want and where you want into your class.
EDIT :
add in your .h
private slots:
void on_saveButton_clicked();
and in your .cpp
void MyClass::on_saveButton_clicked()
{
// you can use userId here
}
If you use Qt Creator those functions can add automatically in the UI design interface