Qt 5.7 : connexions et qOverload

Petite mise à jour par rapport aux connexions avec Qt 5.7 par rapport aux fonctions surchargées. Pour les détails, cf http://guillaume.belz.free.fr/doku.php?id=les_signaux_et_slots_dans_qt5 (cet article a besoin d’une bonne réécriture, en particulier pour présenter en premier la syntaxe a utiliser et pas les anciennes syntaxes).

Fonctions surchargées

Des fonctions sont pas surchargées lorsqu’elles existent en plusieurs versions dans une classe :

class Object 
{
public:
    void f();
    void f(int);
    void f(QString);
};

Lorsqu’il existe plusieurs fonctions surchargées, le compilateur ne sait pas quelle fonction doit être utilisée. Il faut donc donner explicitement la signature de la fonction, en effectuant une conversion.

Il est possible de faire une conversion explicite (cast) avec static_cast pour spécifier quelle version utiliser :

static_cast<void (CLASS::*)(PARAMETERS)>(&CLASS::FUNCTION)

Par exemple pour la classe précédente :

static_cast<void (Object ::*)()>(&Object ::f)
static_cast<void (Object ::*)(int)>(&Object ::f)
static_cast<void (Object ::*)(QString)>(&Object ::f)

Autre exemple, pour connecter les fonctions QComboBox::currentIndexChanged(int) ou
QComboBox::currentIndexChanged(QString), il est possible d’écrire :

QPointer<QComboBox> comboBox = new QComboBox;
 
// utilisation de : void currentIndexChanged(int index)
connect(
    comboBox,
    static_cast<void (QComboBox::*)(int)>(
        &QComboBox::currentIndexChanged),
        /* ... */);
 
// utilisation de : void currentIndexChanged(const QString & text)
connect(
    comboBox.data(),
    static_cast<void (QComboBox::*)(const QString &)>(
        &QComboBox::currentIndexChanged),
        /* ... */);

Il est également possible d’utiliser à partir de Qt 5.7 la fonction qOverload en C++14 ou la classe QOverload en C++11.

struct Foo {
    void overloadedFunction();
    void overloadedFunction(int, QString);
};
 
// C++14
qOverload<>(&Foo:overloadedFunction)
qOverload<int, QString>(&Foo:overloadedFunction)
 
// C+11 
QOverload<>::of(&Foo:overloadedFunction)
QOverload<int, QString>::of(&Foo:overloadedFunction)

Lorsqu’il existe des surcharges de fonctions constante et non constante, il faut utiliser les fonctions qConstOverload et qNonConstOverloaden C++14 et QConstOverload et QNonConstOverload en C++11.

struct Foo {
    void overloadedFunction(int, QString);
};
 
// C++14
qConstOverload<>(&Foo:overloadedFunction)
qNonConstOverload<int, QString>(&Foo:overloadedFunction)
 
// C+11 
QConstOverload<>::of(&Foo:overloadedFunction)
QNonConstOverload<int, QString>::of(&Foo:overloadedFunction)

Advertisements

Laisser un commentaire

Entrez vos coordonnées ci-dessous ou cliquez sur une icône pour vous connecter:

Logo WordPress.com

Vous commentez à l'aide de votre compte WordPress.com. Déconnexion / Changer )

Image Twitter

Vous commentez à l'aide de votre compte Twitter. Déconnexion / Changer )

Photo Facebook

Vous commentez à l'aide de votre compte Facebook. Déconnexion / Changer )

Photo Google+

Vous commentez à l'aide de votre compte Google+. Déconnexion / Changer )

Connexion à %s