"Cahier de bouts de codes"?

Bonjour,

Dans un actuel projet Qt lancé comme développeur du dimanche, j’ai quelque fois besoin de dupliquer un bout de code qu’il n’est pas possible de factoriser dans une fonction/méthode.
Par exemple la création et le paramétrage d’un QMessageBox, ou encore la définition d’un QFileDialog personnalisé.
A chaque fois que j’ai besoin de ces quelques lignes je dois me replonger dans la doc ou rechercher une fonction qui les contient déjà.

Alors j’ai pensé à utiliser une sorte de « cahier numérique de bouts de code » dans lequel je collerais des exemples de ces bouts de codes.

Il me semble que Visual Studio offrait ce type de facilité. En explorant QtCreator j’ai trouvé quelque chose qui pourrait y ressembler : « Outils/Collage de code/ ». Mais je crois comprendre qu’il s’agirait plutôt d’un partage de code à durée déterminée sur la toile.

J’ai pensé aussi à créer un nouveau projet qui inclurait ces bouts de codes dans des fichiers thématiques… mais bof…

Existe-t-il une solution à ce type de besoin, notamment en Qt ?

@ssylvain
Ca ressemble à la création de macros. La plupart des précompilateurs autorisent cela.

Bonjour et merci pour la réponse,

Effectivement je pourrais définir en C++ une macro avec #define. Mais il me semble que le père Stroustrup décourage ce genre de pratique :wink:
Plus sérieusement, voici trois exemples de bouts de code que j’aimerais garder de côté pour réutilisation ultérieure via une adaptation au contexte :

QApplication::setOverrideCursor(Qt::WaitCursor);
—un traitement long—
QApplication::restoreOverrideCursor();

QMessageBox msgBox;
msgBox.setText(tr(« Echec de la sauvegarde. »));
msgBox.setInformativeText(monObjet.get_nom_fichier_lu() + tr(" non sauvegardé."));
msgBox.setStandardButtons(QMessageBox::Close);
msgBox.setIcon(QMessageBox::Critical);
msgBox.exec();

QFileDialog qfd(this,QString(tr(« Sauvegarder la basse sous… »)));
qfd.setFileMode(QFileDialog::AnyFile);
qfd.setViewMode(QFileDialog::Detail);
qfd.setNameFilter(tr(« Feuille de données (*.xlsx *.csv) »));
qfd.selectFile(monObjet->get_rep_nom_fichier_lu());
qfd.setOptions(QFileDialog::ReadOnly);
qfd.setAcceptMode(QFileDialog::AcceptSave);
qfd.setLabelText(QFileDialog::FileName,tr(« Nom du fichier : »));
qfd.setLabelText(QFileDialog::FileType,tr(« Types de fichiers : »));
qfd.setLabelText(QFileDialog::LookIn,tr(« Répertoire : »));
qfd.setLabelText(QFileDialog::Accept,tr(« Accepter »));
qfd.setLabelText(QFileDialog::Reject,tr(« Annuler »));
if (!qfd.exec()) return;

Difficile, je crois, dans ces cas de recourir aux macros.

je pourrais définir en C++ une macro avec #define . Mais il me semble que le père Stroustrup décourage ce genre de pratique

@ssylvain,
Bjarne Stroustrup le décourage car dupliquer du code n’est généralement pas une bonne solution mais c’était ton besoin exprimé. De plus, l’ouvrage de Bjarne Stroustrup est rédigé sur un style universitaire assez élitiste. Il faut savoir relativiser, prendre du recul car si ce n’est pas une bonne solution en matière d’optimisation de la taille du code, avec les tailles mémoire gigantesques actuelle, ce ne devrait poser aucun problème sur une station de travail classique.

Je me suis sans doute mal exprimé…
Ce ne serait pas la première fois, désolé…

En fait une macro n’irait pas car il ne s’agit pas simplement de recopier plusieurs lignes de code identiques, car si les appels de méthodes sont les mêmes il est tout de même nécessaires d’adapter les paramètres au contexte.

Aussi, j’imaginerais volontiers une fonctionnalité de l’IDE style « presse-papier », ou encore « post-it », qui permettrait de conserver ces enchaînements de lignes de codes dans des « cases » étiquetées.

J’ai trouvé un presse papier-sympa pour Linux qui facilite un peut les choses (CopyQ), mais c’est un presse papier pour Linux qui récolte donc tous les copiés-collés… pas seulement ceux de l’IDE.
Je vais maintenant gratter du côté des logiciels de post-it. Je n’y ai pensé qu’en écrivant ces lignes…

Bon week-end !

Dans ce cas, il ne s’agit pas de macros mais de commandes. Regardez sur https://learn.microsoft.com/fr-fr/visualstudio/extensibility/visualstudio.extensibility/command/command?view=vs-2022

Salut
je trouve ça intéressant, mais je ne vois pas comment l’utiliser réellement.

Imaginons que tu ais 500 codes de côté, comment tu choisis le bon? Perso je les renomme et les met dans des dossiers, et je prie le dieu bash et ses anges grep et find de les retrouver.

@vbreton
J’ai tourné la page Microsoft il y a huit ans. Pour utiliser ses produits de temps à autre à l’extérieur, je suis très heureux de l’avoir fait.
La solution que tu proposes ressemble furieusement aux QAction de Qt, ces derniers me paraissant tout de même plus simple d’emploi. Par ailleurs c’est du C# a priori et la solution semble fortement adhérente à Microsoft. Or je souhaite la portabilité : travailler sous Linux et pouvoir porter sous Windows si besoin.
Quand bien même : l’emploi des commandes Microsoft que tu suggères nécessite qu’elles soient paramétrées pour s’adapter à leur contexte. Aussi, pour le troisième exemple ci-dessus concernant un QFileDialog, il correspond à une fenêtre de sélection pour la sauvegarde d’un fichier. J’ai répété ailleurs la même suite de lignes de code en modifiant les paramètres pour sélectionner un fichier à lire. Quant au deuxième exemple il est évident : l’ensemble des paramètres doit être adapté à chaque fois. Reste que la succession de commandes à écrire est toujours la même et que je cherche un moyen de la sauvegarder pour éviter de tout redécouvrir à chaque fois et de la retrouver plus vite.
L’idée n’est pas de moi car, comme écrit dans mon premier message, je crois avoir vu cette fonctionnalité dans Visual Studio.

@dindoun
Tout à fait d’accord, et c’est en ça que j’aime bien le presse-papier que j’ai installé (CopyQ) car il permet d’étiqueter les copies. Mais ce système aurait sûrement ses limites dans ton cas, avec 500 bouts de code…
Il faudrait un bon système de classement (hiérarchique ?).

genre juste pour les scripts python pour blender :
find « tous les pythons blender/ » |wc
3220 13719 317461

Après quelques réflexions nocturnes (et complètement sobres…) je me suis demandé s’il existait des gestionnaires de citations. En effet, dans les dicos de citations, elles sont référencées suivant plusieurs entrées. Un bout de code serait alors une citation particulière.

En cherchant un peu je suis tombé sur Zotero, qui m’a l’air très puissant mais très orienté littérature.
Malgré tout il m’a l’air de répondre au besoin. Voici une capture d’écran d’un test avec les exemples ci-dessus.
Zotero pour le codage

Ce n’est pas intégré à l’IDE, mais ça à l’air de répondre à mon besoin… à voir à l’usage.

pas con
mais dans ton exemple les guillemets " sont changées en guillement << ce qui pose problème si ça n’est pas configurable

et faut voir les modes de recherche : perso , la puissance des grep me suffit même si ce n’est pas très sympa à utiliser.

Bonjour @ssylvain,

D’où ma réponse… Je pensais, à tort, que vous souhaitiez uniquement faire appel à Visual Studio en le citant. Visual Studio demeure cependant un très bon produit même si des IDE ou des éditeurs et autres outils plus simples présentent l’avantage d’être plus libre, plus ouvert…

Je ne pense pas que les QAction de Qt soient plus simples, ou plus précisément cela dépend de votre expérience et de votre niveau sur Qt et sur C#. Pour information C# présente une certaine portabilité avec le projet mono.

Par rapport au QActions de Qt, intervenir au niveau de Visual Studio présente l’avantage de généraliser la solution à d’autres langages mais en contrepartie il est nécessaire d’écrire du C# tout en étant quand même lié à Microsoft, ne serait-ce que par la documentation et leurs exemples et sans même parler des mises à jours de leurs produits. Le choix d’un IDE est crutial

Sous l’environnement TeXWorks pour LaTeX, on a la possibilité de créer ses propres commandes; je me suis gardé de le citer auparavant car il n’est pas approprié à Qt mais il montre ce qui se fait généralement pour une volumétrie de quelques dizaines de commandes, et qui suffit amplement même après quelques décennies d’utilisation.

Pour une volumétrie plus importante, ce qui ne semble pas être votre cas , ne serait-ce qu’en lisant votre premier message, mais pour répondre à @dindoun tout en vous apportant quelques pistes de réflexion ou éveiller votre curiosité, l’usage d’une solution d’autocomplétion et d’une base de données me parait le plus approprié. La solution de luxe consisterait à faire appel à un framework tel que par exemple Django (Python) ou Symfony (PHP) pour développer rapidement une application en ligne ou dans son navigateur. Cela reste cependant un luxe car le développement rapide ne peut se faire qu’après un très long apprentissage…

On peut bien évidemment s’appuyer sur des solutions intermédiaires reposant sur des scripts et des outils tels que find, grep, sed ou ed, awk par exemple. Une autre façon de faire ou complémentaire pourrait aussi consister à se pencher sur la puissance des éditeurs vi ou emacs; cela vaut la peine d’investir du temps dans ces outils et dans au moins l’un de ces éditeurs dotés de puissants raccourcis si l’on souhaite évoluer vers plus de développements d’outils ou de productivité et de portabilité sous Linux.

Il est évident pour vous, pas forcément pour les autres. C’est d’ailleurs pour cela qu’une syntaxe spécifique est souvent utilisée pour représenter les arguments, les options en faisant usage par exemple de chevrons ou de crochets. L’expérience montre que l’écriture implicite n’est pas forcément la plus explicite. Une autre manière consisterait à faire usage de commentaires dans les listings si l’on ne souhaite pas toucher au code proprement dit.

Zotero est une solution prête à l’emploi. Il peut vous permettre de répondre à votre besoin pour ne vous concentrer que sur votre code Qt et vous laissez ainsi tout loisir à vous pencher à votre rythme sur le scripting bash, les commandes Linux et ses puissants outils de manipulation de fichiers et de chaînes de caractères qui vous seront toujours utiles.

les guillemets " sont changées en guillement << ce qui pose problème si ça n’est pas configurable

Bien vu. Heureusement ce n’est pas systématique et j’ai compris pourquoi : le changement de type de guillemet vient de ce site. Dans la copie d’écran j’ai en effet copié le texte du site dans l’outil. Une copie directe depuis QtCreator conserve les bons guillemets.

La puissance des grep me suffit même si ce n’est pas très sympa à utiliser.

Effectivement, quand il y a beaucoup d’entrées, il faut revoir la pertinence du soft.

Je ne pense pas que les QAction de Qt soient plus simples

Je me suis laissé emporter alors que je connais pas la solution des commandes en C#. Désolé. Toutefois, pour avoir pris le temps de comprendre comment ça marche en Qt, je trouve les QAction plutôt rapides à mettre en œuvre lorsqu’elles sont gérées par QtCreator.

Cela reste cependant un luxe car le développement rapide ne peut se faire qu’après un très long apprentissage…

En fait, je cherchais juste une solution pour remplacer mon petit cahier dans lequel je note les bouts de code dont je veux me souvenir. Comme c’est un peu pénible, surtout avec un micro à côté, je le fait rarement.

vous laissez ainsi tout loisir à vous pencher à votre rythme sur le scripting bash, les commandes Linux et ses puissants outils de manipulation de fichiers et de chaînes de caractères qui vous seront toujours utiles.

Totalement en phase avec ce que vous dites ! Depuis huit ans je retrouve dans Linux ce que j’avais aimé dans MS-DOS en 1990 : l’impression de contrôler le système, mais à un tout autre niveau avec Linux, et c’est vraiment passionnant.
Vous l’aurez compris, je ne suis pas informaticien, je reste un indécrottable amateur et je regrette parfois que la doc ne soit pas assez claire pour moi.
Pour m’expliquer, j’évoquerais systemd, udev, udisk. J’ai vraiment galéré en automne pour arriver à faire un truc a priori simple et je suis certain de n’avoir pas fait les choses correctement.

@vbreton
@dindoun

Merci à tous les deux pour vos lumières !

si je peux en rajouter :
l’une de mes meilleures solutions, est de créer des classes dans lequel je met mes bouts de code :
ça permet de programmer en gardant la même syntaxe, même quand le langage change( py2 vers py3 par exemple ) et même de changer de langage ( pour moi : php, python principalement )

Juste en passant, un regroupement de bouts de codes, ça s’appelle une librairie :slight_smile:

@Zargos

… alors il faut sans doute que j’appelle autrement « bout de code ».

Si je reprends mon exemple n° 2 ci-dessus, soit l’utilisation d’une QMessageBox pour afficher du texte et proposer des boutons d’action. J’ai successivement :

  • une instanciation ;
  • la définition du titre de la boîte de dialogue (paramètre n° 1) ;
  • la définition du message à afficher dans la boîte de dialogue (paramètre n° 2) ;
  • la définition des boutons à afficher dans la boîte de dialogue (paramètre n° 3) ;
  • la sélection de l’icône à afficher (paramètre n° 4) ;
  • le test sur le retour de la boîte de dialogue, fonction des boutons définis par le paramètre n° 3.

Soient 6 lignes de code, dont la dernière à adapter, et 4 paramètres. Si je mets tout ça dans une librairie, cela me fait une fonction avec 4 paramètres et un retour à tester. Alors oui, c’est gérable.

Mais dans le cas d’une boite de dialogue pour l’ouverture ou la sauvegarde d’un fichier (exemple n° 3 ci-dessus), le nombre des arguments est plus élevé (12). Je peux considérer les arguments de traduction en français comme invariants (6), ce qui réduit le nombre des arguments, mais je perds alors la possibilité d’adapter la langue/vocabulaire au contexte. Aussi, si je place tout ça dans une fonction d’une bibliothèque, je me retrouverais avec une fonction avec beaucoup de paramètres, style Java, dont il faudra se souvenir l’ordre et l’utilité à l’utilisation.

C’est pourquoi j’ai pensé à une solution type bloc-note où je colle des exemples d’utilisation, qui sont - pour moi - faciles à réutiliser. La limite étant sans doute quand le nombre de ces petits bouts de code devient très élevé.

Comme je l’ai dit plus haut je suis un développeur du dimanche et un indécrottable amateur, aussi, s’il y a mieux à faire, je suis preneur !

@dindoun
Là je suis perdu…
Vous auriez un exemple « simple » ?