Archives de catégorie : C / C++

C, C++, le framework Qt, Arduino et tout ce qui tourne autour du langage C.

Plus de folie avec les QThread

Publié dans C / C++ | Laisser un commentaire

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

Logo OpenSSL

OpenSSL et i2d_PublicKey

Publié dans C / C++ | Laisser un commentaire

Dans OpenSSL, il y a des pièges ! Petit exemple avec i2d_PrivateKey et i2d_PublicKey :

i2d_PrivateKey(EVP_PKEY *, uchar **), comme escompté, prend en paramètre une paire de clé source EVP_PKEY et un tableau d’octet en destination. La clé privé est extraite de la paire de clé et envoyé au format DER / ASN 1 dans le tableau d’octet.

i2d_PublicKey(EVP_PKEY *, uchar **) a la même signature, une paire de clé source EVP_PKEY et un tableau d’octet en destination. La clé publique est extraite de la paire de clé, mais cette fois-ci elle est envoyé sous forme d’un EC point dans le tableau d’octet ! Piège !

L’équivalent de i2d_PublicKey(EVP_PKEY *, uchar **) est en réalité i2d_PUBKEY(EVP_PKEY *, uchar **) ! Et c’est la même chose pour d2i_PublicKey/PUBKEY. Comme quoi… « rien n’est jamais facile » !

La déclaration anticipée en C++

Publié dans C / C++ | Laisser un commentaire

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

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

Installer Qt pour développer en 32bits et 64bits

Publié dans C / C++ | Un commentaire

Comment installer plusieurs versions de Qt en même temps, et surtout, comment gérer une cross-compilation 32bits / 64bits ? Voilà un problème qui peut prendre des heures à régler… C’est possible, autant sous Windows que sous Linux.

Pour ma part, je compile sous Debian testing (jessie) pour Qt5.3 ou Qt5.4 en 32bits ou 64bits, et grâce à Wine, je compile aussi pour Windows pour Qt5.1, Qt5.3 ou  Qt5.4 en 64bits. Je garde toujours un Qt5.1 sous Windows car c’est la dernière version à fonctionner convenablement pour Windows XP.

Compiler est une chose, et je ne m’y attarderai pas trop dans ce billet, mais installer est la première étape. La méthode 1 ne fonctionne que sous Linux (et ne marche pas d’ailleurs). La méthode 2 conviendra à Windows et Linux.

Continuer la lecture

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

Publié dans C / C++ | Laisser un commentaire

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

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

Dessiner des graphiques avec Qt

Publié dans C / C++ | Laisser un commentaire

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

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

Les pointeurs intelligents C++ avec Qt

Publié dans C / C++ | Laisser un commentaire

J’entends parler de pointeurs intelligents (ou smart pointers) en C++ depuis pas mal de temps. N’étant pas encore tout à fait à l’aise avec cette notion, je me suis fait une petit séance d’état de l’art. Je compte utiliser des shared pointers tout bientôt, ce qui devrait me permettre d’acquérir d’avantage d’expérience sur le sujet.

Oh le joli pointeur intelligent !

Oh le joli pointeur intelligent !

L’idée qui se cache derrière, c’est de faciliter la gestion mémoire, et d’éviter les fuites mémoires par la même occasion. Je ne sais pas quand l’idée est apparue, mais pour bien comprendre l’état actuel de ce domaine, il faut savoir que les premières implémentations n’ont pas tout de suite été disponibles nativement dans le langage C++. La librairie Boost propose différentes sortes de pointeurs intelligents, tout comme le framework Qt. Il en existe d’autres bien assurément.
Je crois qu’aujourd’hui depuis C++11 (??? à vérifier), trois types de smart pointers sont disponibles nativement.
Continuer la lecture