Archives par mot-clé : C

Plus de folie avec les QThread

Publié dans C / C++ | Laisser un commentaire
07 Déc 2022

La programmation avec des threads est complexe et ne doit jamais être prise à la légère. Tête froide, mutex et variables atomiques sont de rigueur si on veut s’éviter les affres de l’horreur.

Qt peut nous simplifier la vie. Il peut nous y aider en tout cas. Mais. Oui il y a un mais. En regardant la documentation disponible sur Internet, c’est le bazar car : il y a bien longtemps, entre Qt 4.4 et Qt 4.7, on utilisait les mêmes noms de méthodes (run) pour quelque chose de différent ! Du coup, même aujourd’hui on trouve de tout sur le Web.

Voici quelques conseils en vrac avant de pointer vers de la documentation intéressante.

Conseils en vrac

  • Si cela ne vous parle pas, allez regarder les définitions de thread-safe et re-entrant. En fait, renseignez-vous sur les threads avant d’utiliser les QThreads, vous gagnerez du temps.
  • Un QObject appartient au thread dans lequel il est créé, ou dans lequel il est déplacé (mais dans ce cas, il ne peut avoir de parents)
    • Corolaire : les enfants d’un QObject vivent dans le même thread que leur parent. Mais attention, les variables membres ne deviennent pas automatiquement enfant de leur QObject ! (bigre)
  • Si la notion de QEventLoop Qt ne vous parle pas, renseignez-vous !
  • De manière assez logique, on peut appeler tranquillement un QObject via plusieurs thread, donc la même fonction d’une même classe peut être appelée par différents threads. En général on évite. Pour faire de la communication inter-thread, le plus safe est d’utiliser les signaux / slots en mode QueueConnection (mode par défaut dans ce cas). Si le thread A émet un signal variableChanged(int), ce signal peut être catché par une classe dans le thread principal via un slot handleVariableChanged(int). Voir QueuedConnection
  • En fait, si on ne fait pas gaffe, notamment si on n’utilise pas les signaux / slots, ou si on utilise le mode DirectConnection, on peut sans se rendre compte avoir plusieurs threads qui modifient en même temps la même donnée. Le mécanisme de protection de base, c’est les mutex (QMutexLocker et QMutex sont vos amis). Mais on peut aussi jouer avec les variables atomiques. Plus difficile, pas toujours possible, mais indispensable si on veut éviter de manière fiable les interlocks.
  • Pour utiliser les signaux / slots entre thread, il faut au préalable s’assurer que les paramètres des signaux soient bien enregistrés avec Q_DECLARE_METATYPE(Type) et qRegisterMetaType<Type>(). Sans cela, en QueuedConnection le slot ne serait juste pas appelé (dommage, try again).
  • D’une manière générale, je préconise d’utiliser QConcurrent et QFutureWatcher qui encapsule le comportement des QThreads. C’est mieux, plus simple et presque toujours possible. Je ne suis pas le seul à le préconiser, c’est la doc Qt qui le dit.
  • Si on doit utiliser directement QThread, alors la lecture de la doc Qt et des articles de Maya et FabienPN est fortement encourager.

Continuer la lecture →

La déclaration anticipée en C++

Publié dans C / C++ | Laisser un commentaire
30 Mai 2018

Un problème de référence croisée / inclusion croisée / cross reference en C++ ? Utilisez la déclaration anticipée ! Ou forward declaration dans la langue de Shakespear !

Qu’est-ce qu’une référence croisée ?

Une référence croisée, ce sont tout simplement 2 classes qui dépendent l’une de l’autre. MyClassA dépend de MyClassB et vice-versa. On devrait alors inclure le header de l’un dans celui de l’autre et le compilateur ne sait pas par quel bout commencer. Ce problème apparemment rarement avec seulement deux classes, mais plus souvent dans un cycle : MyClassA <- MyClassB <- … <-MyClassZ <- MyClassA.

Exemple de référence croisée simple entre 3 classes

La solution

La solution : déclaration anticipée ou forward declaration.

Continuer la lecture →

Structure d’un projet Qt

Publié dans C / C++ | Un commentaire
15 Avr 2015

Note: c’est un brouillon 🙂

Ma grande question du moment, comment architecture un projet Qt pour :

  • avoir une bonne structure de dossier,
  • pouvoir gérer plusieurs modules, et choisir ceux à utiliser lors de la compilation,
  • séparer le code source du code des tests unitaires,
  • choisir lors de la compilation de lancer les tests ou non.

Structure

src
   module1/
      src/
      test/
      module1.pro
   module2/
      src/
      test/
      module2.pro
   communication
   data
   service
   util
   ui/
      project.cpp
      project.h
      project.ui
      ui.pro
   main.cpp
   src.pro
test/
   testcase/
      MyGreatTest.cpp
      MyGreatTest.h
   test.pro
   IUnitTestCase.h
   TestRunner.cpp
   TestRunner.h
vendor/
   ...
   vendor.pri
.pro

En général, j’ai plusieurs projets liés entre eux qui partagent des fichiers. Si on passe donc un cran en dessous, j’ai quelque chose du style :

project1/
project2/
vendor/
   ...
   vendor.pri
release/

Quelques informations sur les les .pro et les .pri

Ah, et il est normal qu’un message s’affiche 3 fois dans les logs (lorsqu’on utilise les commandes « message » ou « system »), puisqu’il y a 3 Makefile à générer, donc le fichier .pro est consulté 3 fois.

Inspiration

Etude – Lire un document Word, OpenDocument, PDF avec Qt (ou autre)

Publié dans C / C++ | Laisser un commentaire
09 Sep 2014

Lire un document Office, OpenDocument ou PDF, ou autre format riche  programmatiquement en Qt / C++ / autre… comme il fallait s’y attendre, ce n’est pas de la tarte ! Apparemment, il est relativement faisable d’afficher un document PDF, Office ou LibreOffice directement via un objet Qt, ou une bibliothèque. Mais ici, je cherche à lire le contenu, afin de pouvoir en extraire des morceaux suivant un patron (vous l’aurez deviné, c’est un document de norme, dont j’aimerai extraire la liste des exigences ><).

Voici une liste des ressources que j’ai pu trouver sur le sujet. Je n’ai rien testé pour l’instant.

Continuer la lecture →

Architecture de tests en C++ avec Qt

Publié dans C / C++ | Laisser un commentaire
27 Août 2014

Si vous êtes développeur, je pense que vous avez surement entendu parler des tests unitaires (unit test) et j’espère que vous êtes convaincu de leur utilité ! Tester unitairement un morceau de code, c’est vérifier que celui-ci fait ce que l’on souhaite dans de multiples situations. Ensuite, on peut passer sereinement aux tests d’intégration qui vont tester plusieurs morceaux de codes (ou d’applications) entre eux. On peut encore raffiner avec des tests de performances, tests système, etc, etc… Tout dépend jusqu’où on souhaite aller.

Si on est capable de lancer régulièrement l’exécution de nos tests unitaires, alors on est capable de dire que notre code continue de fonctionner comme voulu malgré les mises à jours ou les refactoring. Cela n’empêche pas les erreurs ni les bugs, car on ne peut pas tester tout notre code unitairement, ou cela peut lamentablement planter lors de l’intégration. Néanmoins, on sait qu’une base solide « fonctionne comme prévu », ce qui facilite grandement la correction d’une erreur.

Pour des myriades de raisons :
tester son code c’est génial !!!

Des études prouvent même qu’une bonne gestion des tests permet au final de gagner du temps. Si vous n’y croyez pas, je vous invite sérieusement à reconsidérer votre opinion.

Ce que j’ai déjà vu dans certains environnements et ce que j’aimerai reproduire dans mon environnement Qt / C++, se résume ainsi :

Continuer la lecture →

Corriger une string JSON en Qt

Publié dans Snippet | Laisser un commentaire
26 Mar 2014

La méthode ci-dessous permet d’autoriser une syntaxe moins rigoureuse en prenant soin de modifier les petites erreurs qui ont pu être commises. 

/**
 * Clean a string
 * * Remove comments ("//" and "/*")
 * * Add first and last braces ("{" and "}") if missing
 * * Remove unauthorized commas
 *
 * @param data Almost JSON string that will be cleaned to become a valid JSON string
 * @return Valid JSON string (or at least, a more valid one)
 */
QString cleanJsonString(QString data)
{
    // Remove inline comms
    QRegExp pattern = QRegExp("(^|\\[|\\{|,|\\n|\\s)//.*($|\\n)");
    pattern.setMinimal(true); //ungreedy
    data.replace(pattern, "\\1\n");
    data.replace(pattern, "\\1\n"); //2 times, I am not sure why...
    // Remove bloc comms
    pattern = QRegExp("/\\*.*\\*/");
    pattern.setMinimal(true); //ungreedy
    data.replace(pattern, "");
    // Add first and last brace
    if (!data.startsWith("{")) {
        data = "{\n"+data;
    }
    if (!data.endsWith("}")) {
        data += "\n}";
    }
    // Remove commas before } or ]
    pattern = QRegExp(",(\\s*[}\\]])");
    pattern.setMinimal(true); //non-greedy
    data.replace(pattern, "\\1");
    return data;
}

J’ai commis une méthode similaire en PHP : Manipuler du JSON en PHP.

Attendre la fin d’un signal Qt de manière synchrone

Publié dans Snippet | Laisser un commentaire
20 Jan 2014

Ou comment attendre la fin d’une méthode asynchrone.

Snippet

/**
 * Wait synchronously for a Qt signal (+ timeout management)
 * May be useful for test purpose
 * Not recommended for production usage
 */

// -- Configure the waiting
// Signal to wait
QEventLoop loop;
QObject::connect(&anObject, SIGNAL(signalToWait()), &loop, SLOT(quit()));
// Timeout to avoid infite waiting
QTimer timer;
timer.setInterval(10*1000); //10s
timer.setSingleShot(true);
QObject::connect(&timer, SIGNAL(timeout()), &loop, SLOT(quit()));

// -- Do stuff that should trigger the signal
// ...

// -- Start to wait
// What is done after "loop.exec()" is not executed until "loop.quit()" is called
timer.start();
loop.exec();
timer.stop(); // Just in case there is no timeout

// -- Other stuff
// ...

Array en C/C++

Publié dans Snippet | Laisser un commentaire
16 Jan 2014

Static

int anArray[] = { 1, 2 };
// OR
int anArray[2] = { 1, 2 };
// OR
int anArray[2];
anArray[0] = 1;
anArray[1] = 2;

Dynamic (C++)

int anArray = new int[2]
anArray[0] = 1;
anArray[1] = 2;

Et ne pas oublier la suppression :

delete[] anArrat;

Dessiner des graphiques avec Qt

Publié dans C / C++ | Laisser un commentaire
22 Nov 2013

Dessiner des courbes, des graphiques, des histogrammes, c’est relativement faisable avec Qt. Il « suffit » d’utiliser la classe QGraphicsScene. C’est en réalité bien compliqué. Pour permettre la réutilisation (ce qui est souhaitable dans ce cas afin d’éviter les cheveux blancs précoces), il est préférable d’étendre cette classe, et d’y ajouter une méthode « addCurve » auquel il faut fournir tout ce qui est nécessaire pour dessiner une courbe (au sens mathématiques du terme ou non) : une liste de points, une formule… Une autre méthode « addAxes » pourrait permettre de dessiner les deux axes.

Bref, franchement, j’en suis à la quatrième itération d’une classe appelée CurveGraphicScene, et ce n’est pas la panacée. Oh que non ! Quand j’aurai quelque chose d’un peu plus compréhensible, je verrai ce que je peux en dire ici.
En attendant, je note deux bibliothèques Qt : Qwt et QCustomPlot. Elles permettent de faire ce genre de choses, avec normalement moins de peines. Je n’ai pu encore les tester, soit à cause d’une difficulté d’installation, un manque de documentation (et donc la crainte d’y perdre beaucoup de temps), ou à cause des conditions d’utilisation non compatibles avec mes projets du moment.

Continuer la lecture →

Qt: No matching function for call to connect

Publié dans C / C++ | Un commentaire
18 Sep 2013

Qt permet de relier facilement entre elle des classes héritant de QObject avec des liens signaux / slots. Voici un petit exemple de connexion.

class OtherQObject : public QObject
{
Q_OBJECT
public:
    OtherQObject();

signal:
    void aSuperSignal();
};

class MyQObject : public QObject
{
Q_OBJECT
public:
    MyQObject();

public slots:
    void myGreatMethod();
};

MyQObject *myClass;
OtherQObject *otherClass;
connect(otherClass, SIGNAL(aSuperSignal()), myClass, SLOT(myGreatMethod());

A de nombreuses reprises, il m’est arrivé d’être confronté à l’erreur suivante (ou similaire) : « No matching function for call to connect ». Plus précisément :

error: no matching function for call to ‘mainWindow::connect(MyQObject *&, const char [38], OtherQObject *&, const char [30])’
note: candidates are: static bool QObject::connect(const QObject*, const char*, const QObject*, const char*, Qt::ConnectionType)
note: bool QObject::connect(const QObject*, const char*, const char*, Qt::Connection

J’aimerai lister ici quelques causes possibles de ce type d’erreur. Un article sans fioriture, avec l’information brute de chez brute, mais qui sait, peut-être aurais-je un jour l’envi de peaufiner un petit peu ce bric à brac ?

Continuer la lecture →