tag:linuxfr.org,2005:/forums/programmation-cLinuxFr.org : le forum Programmation.c++2024-03-11T20:05:54+01:00/favicon.pngtag:linuxfr.org,2005:Post/441462024-03-11T20:05:54+01:002024-03-11T20:05:54+01:00Cherche freelance pour un coup de main en open source<p>Bonjour,<br>
Je cherche un freelance pour une tache payé, pour résoudre les bugs dans CatchChallenger a cause de la migration de tiled 2021 à une version plus moderne:<br>
- map2png crash quand je change de layer un object <a href="https://github.com/alphaonex86/CatchChallenger/blob/master/tools/map2png/map2png.cpp#L823">https://github.com/alphaonex86/CatchChallenger/blob/master/tools/map2png/map2png.cpp#L823</a><br>
- <a href="https://github.com/alphaonex86/CatchChallenger/blob/master/client/qtopengl/catchchallenger-qtopengl.pro">https://github.com/alphaonex86/CatchChallenger/blob/master/client/qtopengl/catchchallenger-qtopengl.pro</a> no centre plus la vue sur le joueur<br>
Merci d'avance pour aider ce projet open source</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/cherche-freelance-pour-un-coup-de-main-en-open-source.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/135101/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/cherche-freelance-pour-un-coup-de-main-en-open-source#comments">ouvrir dans le navigateur</a>
</p>
alpha_one_x86https://linuxfr.org/nodes/135101/comments.atomtag:linuxfr.org,2005:Post/441262024-02-29T17:15:43+01:002024-02-29T19:26:34+01:00Tiled pour CatchChallenger <p>Bonjour,<br>
J'ai besoin d'un coup de main pour actualiser la lib tiled sur CatchChallenger (open source, creer en 2011, on est a la 3eme version), je manque de temps, j'ai viré la lib tiled embeded de 2011 et je link sur la de debian 12, je pense avoir bien corrigé tout les problèmes de compilation, mais:<br>
- <a href="https://github.com/alphaonex86/CatchChallenger/blob/master/tools/map2png/map2png.cpp#L823">https://github.com/alphaonex86/CatchChallenger/blob/master/tools/map2png/map2png.cpp#L823</a> l'activation de ces lignes fait un crash (et actuellement les bots ne sont pas sur le nouveau layer généré donc au mauvais niveau)<br>
- <a href="https://github.com/alphaonex86/CatchChallenger/blob/master/client/qtopengl/catchchallenger-qtopengl.pro">https://github.com/alphaonex86/CatchChallenger/blob/master/client/qtopengl/catchchallenger-qtopengl.pro</a> le client principal ne centre plus la vu sur le joueur (et il y as peu être d'autre bug graphique lié a tiled)<br>
Si quelqu'un se motive ca aiderai fortement le projet un coup de main sur la partie tiled<br>
Il y as eu pas mal d'avancé ces dernières années, je ferai peu être une news compléte. Modularisation et API, nettoyage, …</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/tiled-pour-catchchallenger.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/135006/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/tiled-pour-catchchallenger#comments">ouvrir dans le navigateur</a>
</p>
alpha_one_x86https://linuxfr.org/nodes/135006/comments.atomtag:linuxfr.org,2005:Post/435732023-04-12T16:08:01+02:002023-04-12T22:21:28+02:00Positions/vitesses initiales de satellites pour observer leurs trajectoires<p>Bonjour, </p>
<p>J'ai réaliser un programme permettant la visualisation d'orbite de satellites géostationnaire autour de la Terre, mais malheureusement, je n'arrive pas à obtenir de bonne conditions initiales afin que celui-ci m'offre des résultats cohérent. Pour un système terre/lune, mes CI marchent très bien, mais dès que je passe aux satellites plus rien. </p>
<p>J'utilise la méthode de Verlet afin d'obtenir de nouvelles positions en fonction du temps, je me disais aussi que c'était peut être le pas de temps qui était mauvais. </p>
<p>Je vous envoie en photo le code, et si jamais quelqu'un aurait une idée sur quoi changer (CI ou pas de temps ou ???) pour obtenir des trajectoires exploitables avec des satellites.</p>
<p>En vous remerciant,<br>
BosonXYZT ;)</p>
<p>Voici mon code (désolé je n'ai pas réussir à mettre de photo)</p>
<pre><code class="c++"><span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><cmath></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><fstream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><iomanip></span><span class="cp"></span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">std</span><span class="p">;</span>
<span class="kt">void</span> <span class="nf">Satellites</span><span class="p">(</span><span class="kt">int</span><span class="o">&</span> <span class="n">choix</span><span class="p">,</span> <span class="kt">double</span><span class="o">&</span> <span class="n">m</span><span class="p">,</span> <span class="kt">double</span><span class="o">&</span> <span class="n">X</span><span class="p">,</span> <span class="kt">double</span><span class="o">&</span> <span class="n">Y</span><span class="p">,</span> <span class="kt">double</span><span class="o">&</span> <span class="n">Z</span><span class="p">,</span> <span class="kt">double</span><span class="o">&</span> <span class="n">VX</span><span class="p">,</span> <span class="kt">double</span><span class="o">&</span> <span class="n">VY</span><span class="p">,</span> <span class="kt">double</span><span class="o">&</span> <span class="n">VZ</span><span class="p">)</span> <span class="c1">//fonction définissant la Terre et les satelittes</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">choix</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span> <span class="c1">// TERRE</span>
<span class="p">{</span>
<span class="n">m</span> <span class="o">=</span><span class="mf">5.9736E+24</span><span class="p">;</span> <span class="c1">//masse</span>
<span class="n">X</span><span class="o">=-</span><span class="mf">1.315839435E+11</span><span class="p">;</span> <span class="n">Y</span><span class="o">=</span><span class="mf">6.763707294E+10</span><span class="p">;</span> <span class="n">Z</span> <span class="o">=</span> <span class="mf">4.136174231E+05</span><span class="p">;</span> <span class="c1">//positions initiales</span>
<span class="n">VX</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">VY</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">VZ</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="c1">//vitesses initiales</span>
<span class="p">}</span>
<span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">choix</span> <span class="o">==</span> <span class="mi">3</span><span class="p">)</span> <span class="c1">// Lune</span>
<span class="p">{</span>
<span class="n">m</span> <span class="o">=</span><span class="mf">7.3477E+22</span><span class="p">;</span>
<span class="n">X</span><span class="o">=-</span><span class="mf">1.319042007E+11</span><span class="p">;</span> <span class="n">Y</span><span class="o">=</span><span class="mf">6.786886988E+10</span><span class="p">;</span> <span class="n">Z</span> <span class="o">=-</span><span class="mf">1.649538549E+07</span><span class="p">;</span>
<span class="n">VX</span><span class="o">=-</span><span class="mf">614.453</span><span class="p">;</span> <span class="n">VY</span><span class="o">=-</span><span class="mf">783.202</span><span class="p">;</span> <span class="n">VZ</span><span class="o">=</span><span class="mf">79.439</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">choix</span> <span class="o">==</span> <span class="mi">2</span><span class="p">)</span> <span class="c1">// SATELLITES</span>
<span class="p">{</span>
<span class="n">m</span> <span class="o">=</span><span class="mi">1000</span><span class="p">;</span>
<span class="n">X</span><span class="o">=-</span><span class="mi">36000000</span><span class="p">;</span> <span class="n">Y</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">Z</span> <span class="o">=</span><span class="mi">0</span><span class="p">;</span>
<span class="n">VX</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="n">VY</span><span class="o">=</span><span class="mi">3074</span><span class="p">;</span> <span class="n">VZ</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">else</span>
<span class="p">{</span>
<span class="n">cout</span><span class="o"><<</span><span class="s">"Veuillez réessayer"</span><span class="o"><<</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="nf">CalculForces</span><span class="p">(</span><span class="kt">double</span> <span class="n">FX</span><span class="p">[],</span><span class="kt">double</span> <span class="n">FY</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">FZ</span><span class="p">[],</span><span class="kt">double</span> <span class="n">X</span><span class="p">[],</span><span class="kt">double</span> <span class="n">Y</span><span class="p">[],</span><span class="kt">double</span> <span class="n">Z</span><span class="p">[],</span><span class="kt">double</span> <span class="n">m</span><span class="p">[],</span><span class="kt">int</span> <span class="n">N</span><span class="p">)</span> <span class="c1">//fonction définissant les forces qui s'éxercent sur les différents objets célestes</span>
<span class="p">{</span>
<span class="kt">double</span> <span class="n">G</span><span class="o">=</span><span class="mf">6.6743e-11</span><span class="p">;</span> <span class="c1">//constante gravitationnelle</span>
<span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">i</span><span class="o"><</span><span class="n">N</span><span class="p">;</span><span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">FX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span> <span class="c1">// on initialise les forces à 0</span>
<span class="n">FY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
<span class="n">FZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
<span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">j</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span><span class="n">j</span><span class="o"><</span><span class="n">N</span><span class="p">;</span><span class="n">j</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">i</span><span class="o">!=</span><span class="n">j</span><span class="p">)</span>
<span class="p">{</span>
<span class="kt">double</span> <span class="n">d</span> <span class="o">=</span> <span class="n">pow</span><span class="p">(</span><span class="n">X</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-</span><span class="n">X</span><span class="p">[</span><span class="n">j</span><span class="p">],</span><span class="mi">2</span><span class="p">)</span><span class="o">+</span><span class="n">pow</span><span class="p">(</span><span class="n">Y</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-</span><span class="n">Y</span><span class="p">[</span><span class="n">j</span><span class="p">],</span><span class="mi">2</span><span class="p">)</span><span class="o">+</span><span class="n">pow</span><span class="p">(</span><span class="n">Z</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">-</span><span class="n">Z</span><span class="p">[</span><span class="n">j</span><span class="p">],</span><span class="mi">2</span><span class="p">);</span>
<span class="n">d</span> <span class="o">=</span> <span class="n">pow</span><span class="p">(</span><span class="n">d</span><span class="p">,</span><span class="mf">1.5</span><span class="p">);</span>
<span class="n">FX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+=</span><span class="n">G</span><span class="o">*</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">m</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">/</span><span class="n">d</span><span class="o">*</span><span class="p">(</span><span class="n">X</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">-</span><span class="n">X</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span> <span class="c1">//formules des forces sur chaque directions</span>
<span class="n">FY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+=</span><span class="n">G</span><span class="o">*</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">m</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">/</span><span class="n">d</span><span class="o">*</span><span class="p">(</span><span class="n">Y</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">-</span><span class="n">Y</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
<span class="n">FZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">+=</span><span class="n">G</span><span class="o">*</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">m</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">/</span><span class="n">d</span><span class="o">*</span><span class="p">(</span><span class="n">Z</span><span class="p">[</span><span class="n">j</span><span class="p">]</span><span class="o">-</span><span class="n">Z</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="nf">Verlet</span><span class="p">(</span><span class="kt">double</span> <span class="n">X</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">Y</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">Z</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">VX</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">VY</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">VZ</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">FX</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">FY</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">FZ</span><span class="p">[],</span> <span class="kt">double</span> <span class="n">m</span><span class="p">[],</span> <span class="kt">int</span> <span class="n">N</span><span class="p">,</span> <span class="kt">double</span> <span class="n">h</span><span class="p">)</span> <span class="c1">//algorithme de propagation avec la methode de verlet</span>
<span class="p">{</span>
<span class="n">CalculForces</span><span class="p">(</span><span class="n">FX</span><span class="p">,</span><span class="n">FY</span><span class="p">,</span><span class="n">FZ</span><span class="p">,</span><span class="n">X</span><span class="p">,</span><span class="n">Y</span><span class="p">,</span><span class="n">Z</span><span class="p">,</span><span class="n">m</span><span class="p">,</span><span class="n">N</span><span class="p">);</span> <span class="c1">//on appelle la fonction qui calcule les forces</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">N</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">X</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">X</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="n">VX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">h</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">FX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">pow</span><span class="p">(</span><span class="n">h</span><span class="p">,</span><span class="mi">2</span><span class="p">);</span> <span class="c1">//fonction qui calcul les nouvelles positions en fonction du temps</span>
<span class="n">Y</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">Y</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="n">VY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">h</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">FY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">pow</span><span class="p">(</span><span class="n">h</span><span class="p">,</span><span class="mi">2</span><span class="p">);</span>
<span class="n">Z</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">Z</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="n">VZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">h</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">FZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">*</span><span class="n">pow</span><span class="p">(</span><span class="n">h</span><span class="p">,</span><span class="mi">2</span><span class="p">);</span>
<span class="n">VX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">VX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">h</span><span class="o">*</span><span class="n">FX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">//fonction qui calcul les nouvelles vitesses une première fois en fonction du temps</span>
<span class="n">VY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">VY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">h</span><span class="o">*</span><span class="n">FY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<span class="n">VZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">VZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">h</span><span class="o">*</span><span class="n">FZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<span class="p">}</span>
<span class="n">CalculForces</span><span class="p">(</span><span class="n">FX</span><span class="p">,</span><span class="n">FY</span><span class="p">,</span><span class="n">FZ</span><span class="p">,</span><span class="n">X</span><span class="p">,</span><span class="n">Y</span><span class="p">,</span><span class="n">Z</span><span class="p">,</span><span class="n">m</span><span class="p">,</span><span class="n">N</span><span class="p">);</span> <span class="c1">// on rappelle la fonction qui calcule les forces</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">N</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">VX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">VX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">h</span><span class="o">*</span><span class="n">FX</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">//fonction qui calcul les nouvelles vitesses une deuxième fois en fonction du temps</span>
<span class="n">VY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">VY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">h</span><span class="o">*</span><span class="n">FY</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<span class="n">VZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">VZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">+</span> <span class="mf">0.5</span><span class="o">*</span><span class="n">h</span><span class="o">*</span><span class="n">FZ</span><span class="p">[</span><span class="n">i</span><span class="p">]</span><span class="o">/</span><span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<span class="p">}</span>
<span class="n">enregistrer</span><span class="p">(</span><span class="n">N</span><span class="p">,</span><span class="n">X</span><span class="p">,</span><span class="n">Y</span><span class="p">,</span><span class="n">Z</span><span class="p">);</span> <span class="c1">//on enregistre les valeurs des positions dans un fichier</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">int</span> <span class="n">N</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"Combien de satellites voulez-vous visualiser ?"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cin</span> <span class="o">>></span> <span class="n">N</span><span class="p">;</span> <span class="c1">//on choisit combien de satelittes on veut étudier</span>
<span class="kt">int</span> <span class="n">choix</span><span class="p">[</span><span class="n">N</span><span class="p">];</span>
<span class="kt">double</span> <span class="n">X</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">Y</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">Z</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">VX</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">VY</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">VZ</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">FX</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">FY</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">FZ</span><span class="p">[</span><span class="n">N</span><span class="p">],</span> <span class="n">m</span><span class="p">[</span><span class="n">N</span><span class="p">]</span> <span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">N</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"Satellites "</span> <span class="o"><<</span> <span class="n">i</span><span class="o">+</span><span class="mi">1</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="k">do</span> <span class="p">{</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"choisir :"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"1 : Terre"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"2 : 1 satellites"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"3 : 2 satellites"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"4 : 3 satellites"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"5 : 4 satellites"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"6 : 5 satellites"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cout</span> <span class="o"><<</span> <span class="s">"7 : 6 satellites"</span> <span class="o"><<</span> <span class="n">endl</span><span class="p">;</span>
<span class="n">cin</span> <span class="o">>></span> <span class="n">choix</span><span class="p">[</span><span class="n">i</span><span class="p">];</span> <span class="c1">//choix de l'utilisateur</span>
<span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="n">choix</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o"><</span><span class="mi">1</span> <span class="o">||</span> <span class="n">choix</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">></span> <span class="mi">7</span><span class="p">);</span>
<span class="n">Satellites</span><span class="p">(</span><span class="n">choix</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">m</span><span class="p">[</span><span class="n">i</span><span class="p">],</span> <span class="n">X</span><span class="p">[</span><span class="n">i</span><span class="p">],</span><span class="n">Y</span><span class="p">[</span><span class="n">i</span><span class="p">],</span><span class="n">Z</span><span class="p">[</span><span class="n">i</span><span class="p">],</span><span class="n">VX</span><span class="p">[</span><span class="n">i</span><span class="p">],</span><span class="n">VY</span><span class="p">[</span><span class="n">i</span><span class="p">],</span><span class="n">VZ</span><span class="p">[</span><span class="n">i</span><span class="p">]);</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="n">dt</span> <span class="o">=</span> <span class="mi">100</span><span class="p">;</span> <span class="c1">//intervalle de temps entre chaque point</span>
<span class="n">fstream</span> <span class="n">f</span><span class="p">;</span> <span class="c1">//ouverture du ficher où l'on ecrira l'énergie totale ainsi que les aires calculée</span>
<span class="n">f</span><span class="p">.</span><span class="n">open</span><span class="p">(</span><span class="s">"etot.txt"</span><span class="p">,</span> <span class="n">ios</span><span class="o">::</span><span class="n">out</span><span class="p">);</span> <span class="c1">//on ouvre un fichier pour rentrer les valeurs de l'énergie totale ainsi que celles obtenues avec la loi des aires</span>
<span class="kt">double</span> <span class="n">C</span><span class="o">=</span><span class="mi">0</span><span class="p">;</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">t</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">t</span> <span class="o"><=</span><span class="mi">3600</span><span class="o">*</span><span class="mi">24</span><span class="o">*</span><span class="mi">10</span><span class="p">;</span> <span class="n">t</span> <span class="o">=</span> <span class="n">t</span> <span class="o">+</span> <span class="n">dt</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">Verlet</span><span class="p">(</span><span class="n">X</span><span class="p">,</span><span class="n">Y</span><span class="p">,</span><span class="n">Z</span><span class="p">,</span><span class="n">VX</span><span class="p">,</span><span class="n">VY</span><span class="p">,</span><span class="n">VZ</span><span class="p">,</span><span class="n">FX</span><span class="p">,</span><span class="n">FY</span><span class="p">,</span><span class="n">FZ</span><span class="p">,</span><span class="n">m</span><span class="p">,</span><span class="n">N</span><span class="p">,</span><span class="n">dt</span><span class="p">);</span> <span class="c1">//on appelle l'algorithme de Verlet pour calculer positions et vitesses</span>
<span class="k">if</span> <span class="p">(</span><span class="n">t</span><span class="o">%</span><span class="mi">10</span><span class="o">==</span><span class="mi">0</span><span class="p">)</span> <span class="c1">//intervalle de temps pour calculer l'énergie totale ainsi que la loi des aires, on prend tout les points ayant un rest de divisiob euclidienne par 10 égal à 0</span>
<span class="p">{</span>
<span class="kt">double</span> <span class="n">EC</span> <span class="o">=</span> <span class="n">Ec</span><span class="p">(</span><span class="n">VX</span><span class="p">,</span> <span class="n">VY</span><span class="p">,</span> <span class="n">VZ</span><span class="p">,</span> <span class="n">m</span><span class="p">,</span> <span class="n">N</span><span class="p">);</span> <span class="c1">//on calcul l'énergie cinétique</span>
<span class="kt">double</span> <span class="n">EP</span> <span class="o">=</span> <span class="n">Ep</span><span class="p">(</span><span class="n">X</span><span class="p">,</span> <span class="n">Y</span><span class="p">,</span> <span class="n">Z</span><span class="p">,</span> <span class="n">m</span><span class="p">,</span> <span class="n">N</span><span class="p">);</span><span class="c1">//on calcul l'énergie potentielle</span>
<span class="kt">double</span> <span class="n">Etot</span> <span class="o">=</span> <span class="n">EC</span> <span class="o">+</span> <span class="n">EP</span><span class="p">;</span> <span class="c1">//calcul énergie totale</span>
<span class="n">f</span><span class="o"><<</span><span class="n">Etot</span><span class="o"><<</span><span class="sc">'\t'</span><span class="p">;</span> <span class="c1">//ecriture de l'énergie totale dans le fichier</span>
<span class="n">C</span><span class="o">=</span><span class="n">loi_aire</span><span class="p">(</span><span class="n">m</span><span class="p">,</span><span class="n">VX</span><span class="p">,</span><span class="n">VY</span><span class="p">,</span><span class="n">VZ</span><span class="p">,</span><span class="n">X</span><span class="p">,</span><span class="n">Y</span><span class="p">,</span><span class="n">Z</span><span class="p">);</span> <span class="c1">//on appelle la fonction qui calcul la loi des aires</span>
<span class="n">f</span><span class="o"><<</span><span class="n">C</span><span class="o"><<</span><span class="n">endl</span><span class="p">;</span> <span class="c1">//ecriture des valeurs calculée par la loi des aires</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="n">f</span><span class="p">.</span><span class="n">close</span><span class="p">();</span> <span class="c1">//fermeture du fichier</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/positions-vitesses-initiales-de-satellites-pour-observer-leurs-trajectoires.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/130907/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/positions-vitesses-initiales-de-satellites-pour-observer-leurs-trajectoires#comments">ouvrir dans le navigateur</a>
</p>
BosonXYZThttps://linuxfr.org/nodes/130907/comments.atomtag:linuxfr.org,2005:Post/435552023-03-30T16:07:24+02:002023-03-30T16:07:24+02:00impossible de faire un grep sur la sortie de clang-tidy<p>Salut, <br>
pour les besoins d'un script gitlab ci, je voudrais faire un grep (reverse) sur la sortie (stdout ?) d'une commande clang-tidy.<br>
Ma commande est la suivante : </p>
<pre><code class="bash">$ clang-tidy -p<span class="o">=</span>build --config-file<span class="o">=</span>_clang-tidy --quiet file.hxx <span class="p">|</span> grep -Pvi <span class="s2">"^[[:digit:]]*\swarnings\sgenerated"</span></code></pre>
<p>Le problème, c'est que quand je fais ça, je vois quand même apparaitre les warnings de clang-tidy du type </p>
<pre><code class="bash"><span class="m">31198</span> warnings generated.</code></pre>
<p>Mais si je fais,</p>
<pre><code class="bash"><span class="nb">echo</span> <span class="s2">"31198 warnings generated."</span> <span class="p">|</span> grep -Pvi <span class="s2">"^[[:digit:]]*\swarnings\sgenerated"</span></code></pre>
<p>la sortie est bien vide, ce qui est le résultat que j'attends… </p>
<p>Est-ce que vous pouvez m'expliquer, s'il vous plait, ce que je ne fais pas bien…</p>
<p>Merci d'avance pour votre aide.</p>
<p>Olivier </p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/impossible-de-faire-un-grep-sur-la-sortie-de-clang-tidy.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/130780/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/impossible-de-faire-un-grep-sur-la-sortie-de-clang-tidy#comments">ouvrir dans le navigateur</a>
</p>
Olivier LEMAIREhttps://linuxfr.org/nodes/130780/comments.atomtag:linuxfr.org,2005:Post/434022023-01-13T17:14:16+01:002023-01-14T10:48:04+01:00question sur mon architecture logiciel<p>Bonjour a tous :)</p>
<p>j ai une IHM qui doit afficher deux int32_t venant de mon processus processMain. Dans processMain j ai créé 2 shared memory de cette facon:</p>
<pre><code class="C"><span class="kt">int</span> <span class="n">fd</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
<span class="k">if</span><span class="p">(</span> <span class="p">(</span><span class="n">fd</span><span class="o">=::</span><span class="n">shm_open</span><span class="p">(</span><span class="s">"ma_variable1"</span><span class="p">,</span> <span class="n">O_RDWR</span> <span class="o">|</span> <span class="n">O_CREAT</span><span class="p">,</span> <span class="mo">0644</span><span class="p">))</span> <span class="o"><</span> <span class="mi">0</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"shm_open error, "</span> <span class="o"><<</span> <span class="n">strerror</span><span class="p">(</span><span class="n">errno</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">size_t</span> <span class="n">sizeOfMy_variable1</span> <span class="o">=</span> <span class="o">::</span><span class="k">sizeof</span><span class="p">(</span><span class="kt">int32_t</span><span class="p">);</span>
<span class="k">if</span><span class="p">(</span> <span class="o">::</span><span class="n">truncate</span><span class="p">(</span><span class="s">"/dev/shm/ma_variable1"</span><span class="p">,</span> <span class="n">sizeOfMy_variable1</span> <span class="p">)</span> <span class="o"><</span> <span class="mi">0</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"truncate error, "</span> <span class="o"><<</span> <span class="n">strerror</span><span class="p">(</span><span class="n">errno</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">int32_t</span><span class="o">*</span> <span class="n">ptr</span> <span class="o">=</span> <span class="n">static_cast</span><span class="o"><</span><span class="kt">int32_t</span><span class="o">*></span><span class="p">(</span> <span class="o">::</span><span class="n">mmap</span><span class="p">(</span><span class="n">nullptr</span><span class="p">,</span> <span class="n">sizeOfMy_variable</span><span class="p">,</span> <span class="n">PROT_READ</span> <span class="o">|</span> <span class="n">PROT_WRITE</span><span class="p">,</span> <span class="n">MAP_SHARED</span><span class="p">,</span> <span class="n">fd</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="p">);</span>
<span class="k">if</span><span class="p">(</span> <span class="n">ptr</span> <span class="o">==</span> <span class="n">nullptr</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"mmap error, "</span> <span class="o"><<</span> <span class="n">strerror</span><span class="p">(</span><span class="n">errno</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="o">*</span><span class="n">ptr</span> <span class="o">=</span> <span class="mi">66</span><span class="p">;</span></code></pre>
<p>Je peux ainsi récupérer la valeur de variable1 et variable2 a partir de n importe quel autre processus.<br>
Le probleme est que dans mon IHM je n ai aucun moyen de savoir quand est ce que cette variable est modifiée. j ai donc ajouté des futex pour me notifier quand les variables sont changées, un thread de mon IHM agit comme :</p>
<pre><code class="sh"><span class="k">while</span><span class="o">(</span><span class="nb">true</span><span class="o">)</span>
<span class="o">{</span>
//futex qui bloque jusqu a que processMain wake mon futex
int32_t <span class="nv">variablle1</span> <span class="o">=</span> *ptr<span class="p">;</span>
//je fais des choses
<span class="o">}</span></code></pre>
<p>ca fonctionne mais j ai donc 2 threads qui run en parallele juste pour etre notifié que les variables sont changées. Bref ca m'a l'air bien pourri comme fonctionnement car si j avais N variables a lire j aurais N threads qui run avec N futex.</p>
<p>Avez vous une idee de comment je pourrais améliorer la chose?<br>
Merci d avance</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/question-sur-mon-architecture-logiciel.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/129989/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/question-sur-mon-architecture-logiciel#comments">ouvrir dans le navigateur</a>
</p>
cosmoffhttps://linuxfr.org/nodes/129989/comments.atomtag:linuxfr.org,2005:Post/432302022-10-31T11:31:10+01:002022-11-12T22:56:51+01:00[Résolu] Compiler wesnoth-1.2<p>Bonjour à tous,<br>
Je vous parle à vous, barbus assis dans vos fauteuils.<br>
J'ai comme projet de compiler toutes les versions de <a href="https://wesnoth.org">la Bataille pour Wesnoth</a> pour l'architecture arm64. Je fais tout sur un Raspberry Pi 4B 4Go, et ça marche pas trop mal pour l'instant.</p>
<p><em>- Mais, si ça marche, pourquoi tu postes dans le forum ?</em></p>
<p>Parce que ça marchait bien pour les dernières versions, soit 1.16-1.17.<br>
J'ai décidé ensuite de commencer du début, avec la 1.0. Pour l'instant tout va bien.<br>
Du coup, je tente naïvement la 1.2. Ça foire monumentalement.<br>
C'est écrit en c++, un langage auquel je ne comprends goutte.<br>
J'ai donc ouvert une entrée sur le forum du jeu, là, <a href="https://forums.wesnoth.org/viewtopic.php?t=56352">ici</a>.<br>
Comme vous pouvez le voir, on s'émerveille de l'évolution des langages, on tente un patch, on propose des solutions. La meilleure pour l'instant est je trouve de compiler le bazar avec un g++ d'époque (soit fin 2007 début 2008).<br>
Vous vous doutez bien que c'est compliqué de trouver un truc aussi vieux, compilé pour l'arm64 (ou même armhf).<br>
Je me tourne donc vers vous, chers linuxiens, pour trouver une solution.<br>
Si vous avez une idée, arrivez à corriger le bug de manière 'propre', ou que sais-je encore, merci de nous le partager ici même.</p>
<p>Sinon, vous pouvez toujours aller voir des <a href="https://c.xkcd.com/random/comic/">jolies nimages</a>. (et en plus c'est drôle !)</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/resolu-compiler-wesnoth-1-2.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/129165/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/resolu-compiler-wesnoth-1-2#comments">ouvrir dans le navigateur</a>
</p>
alberic89 🐧https://linuxfr.org/nodes/129165/comments.atomtag:linuxfr.org,2005:Post/431752022-09-28T18:49:48+02:002022-09-28T19:34:10+02:00[résolu] a:b ??<p>Salut les gens !</p>
<p>J'ai besoin de comprendre vite fait un petit bout de code C++, vu que j'en ai pas fait depuis 25.000 ans environ, et que je trouve rien sur l'internet des tutoriaux, je me permet de poser la question ici.</p>
<p>Dans le code suivant :</p>
<pre><code class="c++"><span class="k">struct</span> <span class="nl">a</span> <span class="p">:</span> <span class="n">b</span> <span class="p">{</span>
<span class="kt">int</span> <span class="n">bli</span><span class="p">,</span> <span class="n">bla</span><span class="p">,</span> <span class="n">blou</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<p>qu'est ce que sont <strong>a</strong> et <strong>b</strong>, s'il vous plait ? =D</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/resolu-a-b.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/128896/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/resolu-a-b#comments">ouvrir dans le navigateur</a>
</p>
WrathOfThePixelhttps://linuxfr.org/nodes/128896/comments.atomtag:linuxfr.org,2005:Post/428842022-05-12T08:59:13+02:002022-05-12T21:46:10+02:00application de convention d'écriture<p>Bonjour à tous,<br>
je suis à la recherche d'un ou plusieurs outils pour donner à l'utilisateur la possibilité de vérifier que son code est conforme et pourra être déposé sur notre dépôt git. </p>
<h2 id="toc-contexte">contexte</h2>
<p>Je travaille sur le développement d'un logiciel d'acquisition, visualisation, analyse et diagnostic de données provenant du système d'acquisition d'un imageur médical. Jusqu'à présent je travaillais seul sur ce projet, mais à l'avenir des collègues vont me prêter main forte car le projet commence à grossir et les demandes utilisateurs aussi :) C'est évidement une excellente nouvelle !</p>
<p>Comme je travaillais seul, j'avais la quasi-certitude que les conventions étaient respectées; je connais bien le dev et sa rigueur personnelle :) Mais maintenant que l'équipe grossit il faut mettre en place des outils pour s'assurer de la cohérence du code. </p>
<p>Le projet est écrit en c++ et utilise Qt et root (cern).</p>
<p>Pour la mise en forme du code j'utilise clang-format. Ça, c'est carrément un outil génial et qui marche bien. Je suis parfois bluffé par sa puissance.</p>
<p>J'utilise aussi cppcheck pour faire de l'analyse statique de code. </p>
<p>Il n'y a pas de code coverage et le code est versionné avec git/gitlab.</p>
<h2 id="toc-ma-recherche">ma recherche</h2>
<p>Je cherche un outil qui me permette de mettre en place des règles simples et peu nombreuses dont voici un sous ensemble.<br>
* snake_case PARTOUT (nom de fichier, variable, fonction, classe, enum… TOUT !!!)<br>
* pas de préfixe my<br>
* extension des fichiers<br>
* nom des fichiers <br>
* utilisation de caractères ascii (regexp [a-z0-9])</p>
<p>J'ai fait des recherches, mais je ne converge pas vraiment et c'est pour ça que je me permets de venir vous voir pour trouver de l'aide.</p>
<p>Je vous remercie d'avance pour votre aide.</p>
<p>Olivier </p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/application-de-convention-d-ecriture.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/127719/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/application-de-convention-d-ecriture#comments">ouvrir dans le navigateur</a>
</p>
Olivier LEMAIREhttps://linuxfr.org/nodes/127719/comments.atomtag:linuxfr.org,2005:Post/427572022-03-14T15:02:15+01:002022-03-14T15:02:15+01:00Quelles ressources pour apprendre sérieusement ?<p>Bonjour,</p>
<p>TL;DR : Je cherche une ressource fiable, gratuite ou non, prioritairement en français (mais si anglais, pas de souci), pour apprendre convenablement et avec des bonnes pratiques / manières de faire le C++ <strong>moderne</strong>.</p>
<hr>
<p>En plus long et avec du contexte :</p>
<p>Je souhaite me pencher sur le langage C++ après quelques temps passé sur du Python (des scripts dans un contexte sysadmin) et un peu de Go (principalement pour des serveurs HTTP dans un cadre K8S). Le code n'est pas mon métier, juste un divertissement qui m'apprend plein de choses (et ça tombe bien, j'adore apprendre des trucs).</p>
<p>J'en ai marre de bidouiller et je trouve la polyvalence du C++ intéressante moyennant un gros investissement (ça a l'air clairement plus bas niveau que Go, donc plus de maitrise au risque de faire n'importe quoi, donc potentiellement, ça m'apprendra bien plus de choses). Le but de cet apprentissage est pour un plaisir personnel, et non d'une utilité professionnelle.</p>
<p>Naïvement j'ai jeté un œil sur le tuto d'Openclassroom histoire de voir du code simple et compréhensible mais au final j'ai pas tellement vu de différence avec le C. Je me suis donc renseigné sur la ressource en question qui a l'air de <a href="https://informaticienzero.github.io/c++-avec-openclassrooms-ou-comment-perdre-son-temps/">faire débat</a>.</p>
<p>Le tuto chez <a href="https://zestedesavoir.com/tutoriels/822/la-programmation-en-c-moderne/">ZdS</a> m'a l'air déjà meilleur (il y a du <em>auto</em>, pas de <em>using namespace</em>, etc) mais n'étant pas sachant sur le langage, il est facile de berner le chaland en quête de connaissances.</p>
<p>J'ai regardé également du côté de chez developpez.com pour voir leur ressources, la majorité date d'avant 2010, donc sans doute de la vieille norme.</p>
<p>Au final, je suis perdu. J'ai bien trouvé des choses réputées comme fiables que je garde sous le coude comme <a href="https://en.cppreference.com/w/">cppreference</a> ou <a href="http://cplusplus.com">cplusplus</a> mais ce n'est pas très didactique.</p>
<p>Selon vous, quelle serait la ou les meilleures ressources actuellement pour apprendre le C++ <strong>moderne</strong> (ie c++17 ou c++20 je suppose) ? Idéalement en français, mais je suis preneur d'un contenu anglais s'il est didactique et un peu fun (le langage est, selon plusieurs retours, assez ardu à appréhender). J'aime aussi les livres (<a href="https://www.eyrolles.com/Informatique/Livre/programmer-en-c-moderne-9782212678956/">Delannoy ?</a>). Ça ne me dérange pas de mettre raisonnablement la main à la poche si nécessaire et si la qualité est au rendez-vous (cours en ligne payant par exemple ou bouquins).</p>
<p>Le but étant d'apprendre correctement, avec des bonnes pratiques et manières de faire, et d'aller faire un peu d'Exercism, d'Advent of Code ou Codingame pour mettre tout ça en pratique de manière rigolote dans un premier temps et forcément rencontrer des problèmes pour avancer dans le langage par la suite, bref, apprendre et pratiquer autant que possible.</p>
<p>Plus largement, si quelques gourous du C++ passent par ici, à quoi un débutant dans le langage doit-il faire attention quand il suit un tuto ou toute ressources pour savoir s'il se fait berner avec un mauvais enseignement ou un enseignement un peu trop "daté" ?</p>
<p>Je vous remercie par avance de vos lumières moulesques (un genre de euprymna scolopes mais version mollusque bivalve /o\).</p>
<p>Bien à vous</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/quelles-ressources-pour-apprendre-serieusement.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/127180/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/quelles-ressources-pour-apprendre-serieusement#comments">ouvrir dans le navigateur</a>
</p>
Pwaythttps://linuxfr.org/nodes/127180/comments.atomtag:linuxfr.org,2005:Post/427172022-02-22T14:49:46+01:002022-02-22T16:04:26+01:00renommage de fichiers en masse<p>Salut à tous,<br>
ça fait un petit moment que je bute sur un problème qui m'avait semblé simple au départ mais que j'ai l'impression d'avoir sous-estimé. </p>
<h2 id="toc-contexte">Contexte</h2>
<p>J'appends le c++ depuis un peu plus d'un an. Pour ca j'ai entrepris d'écrire une application dans le cadre de mon travail pour analyser des données venant d'un détecteur. Le logiciel fonctionne et il est utilisé par mes collègues dans le cadre du développement de notre projet.</p>
<p>Pour améliorer mes connaissances j'ai aussi entrepris de réécrire mes scripts (python, bash, perl) en c++. C'est peut être pas malin mais ça me fait un exercice…</p>
<p>Le premier que j'ai souhaité réécrire c'est un petit script qui s'appelle formatname dont l'objectif est de mettre les noms de fichiers d'un dossier ou d'un seul fichier sous une forme simple qui pourrait peut être se résumer par [a-z0-9_.]*</p>
<h2 id="toc-le-problème">Le problème</h2>
<p>En fait je bloque sur la partie caractères étendus. Toutes ces lettres accentuées qui font la richesse de nos langues mais qui font mon malheur. Dans mon script bash j'avais utilisé une fonction écrite par Christophe Blaess et que je reproduis ci-dessous</p>
<pre><code class="bash"> <span class="c1">#</span>
<span class="c1"># author Christophe Blaess</span>
<span class="c1"># link https://www.blaess.fr/christophe/livres/scripts-shell-linux-et-unix/</span>
<span class="c1">#</span>
<span class="k">function</span> latin_to_ascii <span class="o">{</span>
<span class="nb">local</span> result
<span class="nv">result</span><span class="o">=</span><span class="k">$(</span><span class="nb">echo</span> <span class="s2">"</span><span class="nv">$1</span><span class="s2">"</span> <span class="p">|</span>
sed -e <span class="s1">'s/[ÀÁÂÃÄÅ]/A/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/Æ/AE/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/Ç/C/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[ÈÉÊË]/E/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[ÌÍÎÏ]/I/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/Ñ/N/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[ÒÓÔÕÖØ]/O/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[ÙÚÛÜ]/U/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/Ý/Y/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[àáâãä]/a/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/æ/ae/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/ç/c/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[èéêë]/e/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[ìíîï]/i/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/ñ/n/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[òóôöø]/o/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/[ùúûü]/u/g'</span> <span class="p">|</span>
sed -e <span class="s1">'s/ý/y/g'</span><span class="k">)</span>
<span class="nb">echo</span> <span class="s2">"</span><span class="nv">$result</span><span class="s2">"</span>
<span class="o">}</span></code></pre>
<p>J'ai essayé de faire pareil en c++ en utilisant les expressions régulières mais sans succès. Mes premières recherches semblent montrer que c'est un problèmes d'encodage. Si j'ai bien compris les caractères accentués sont stockés sur 2 octets et ca fout le bazar pour ce type de conversion. </p>
<pre><code class="cpp"> <span class="n">std</span><span class="o">::</span><span class="n">regex</span> <span class="n">re</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"input string: "</span> <span class="o"><<</span> <span class="n">s</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">re</span> <span class="o">=</span> <span class="s">"[éèëěê]"</span><span class="p">;</span>
<span class="n">s</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">regex_replace</span> <span class="p">(</span><span class="n">s</span><span class="p">,</span> <span class="n">re</span><span class="p">,</span> <span class="s">"e"</span><span class="p">,</span><span class="n">std</span><span class="o">::</span><span class="n">regex_constants</span><span class="o">::</span><span class="n">format_default</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"output string: "</span> <span class="o"><<</span> <span class="n">s</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span></code></pre>
<p>On m'a aussi conseillé d'essayer libiconv mais j'y arrive pas non plus. Pourtant ça à l'air simple mais je dois pas être doué :)</p>
<pre><code class="c++"><span class="cp">#include</span> <span class="cpf"><cctype></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><cstddef></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><cstring></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><filesystem></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><ios></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><iconv.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><filesystem></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><cstdio></span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">main</span> <span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">*</span><span class="n">argv</span><span class="p">[])</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">argc</span> <span class="o">></span> <span class="mi">1</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="n">i</span> <span class="o"><</span> <span class="n">argc</span><span class="p">;</span> <span class="o">++</span><span class="n">i</span><span class="p">)</span>
<span class="p">{</span>
<span class="kt">char</span><span class="o">*</span> <span class="n">origin</span> <span class="o">=</span> <span class="n">argv</span><span class="p">[</span><span class="n">i</span><span class="p">];</span>
<span class="kt">size_t</span> <span class="n">ol</span> <span class="o">=</span> <span class="n">strlen</span> <span class="p">(</span><span class="n">origin</span><span class="p">);</span>
<span class="kt">char</span> <span class="n">destination</span><span class="p">[</span><span class="mi">100</span><span class="p">];</span>
<span class="kt">size_t</span> <span class="n">dl</span> <span class="o">=</span> <span class="n">strlen</span> <span class="p">(</span><span class="n">destination</span><span class="p">);</span>
<span class="n">memset</span><span class="p">(</span><span class="n">destination</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">100</span><span class="p">);</span>
<span class="kt">char</span> <span class="o">*</span> <span class="n">pin</span> <span class="o">=</span> <span class="n">origin</span><span class="p">;</span>
<span class="kt">char</span> <span class="o">*</span> <span class="n">pout</span> <span class="o">=</span> <span class="n">destination</span><span class="p">;</span>
<span class="n">iconv_t</span> <span class="n">conv</span> <span class="o">=</span> <span class="n">iconv_open</span> <span class="p">(</span><span class="s">"ASCII"</span><span class="p">,</span> <span class="s">"UTF-8"</span><span class="p">);</span>
<span class="kt">int</span> <span class="n">ret</span> <span class="o">=</span> <span class="n">iconv</span><span class="p">(</span><span class="n">conv</span><span class="p">,</span> <span class="o">&</span><span class="n">pin</span><span class="p">,</span> <span class="o">&</span><span class="n">ol</span><span class="p">,</span> <span class="o">&</span><span class="n">pout</span><span class="p">,</span> <span class="o">&</span><span class="n">dl</span><span class="p">);</span>
<span class="n">iconv_close</span> <span class="p">(</span><span class="n">conv</span><span class="p">);</span>
<span class="n">fprintf</span><span class="p">(</span><span class="n">stderr</span><span class="p">,</span><span class="s">"out: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span><span class="n">destination</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"longeur origin: "</span> <span class="o"><<</span> <span class="n">ol</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"longeur destination: "</span> <span class="o"><<</span> <span class="n">strlen</span><span class="p">(</span><span class="n">destination</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"origin: "</span> <span class="o"><<</span> <span class="n">origin</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"destination: "</span> <span class="o"><<</span> <span class="n">destination</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">else</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"no argument provided"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<p>En tout cas, merci d'avance pour votre aide. </p>
<p>Olivier </p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/renommage-de-fichiers-en-masse-1ca4d046-887b-4f19-a9ac-d24068518614.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126991/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/renommage-de-fichiers-en-masse-1ca4d046-887b-4f19-a9ac-d24068518614#comments">ouvrir dans le navigateur</a>
</p>
Olivier LEMAIREhttps://linuxfr.org/nodes/126991/comments.atomtag:linuxfr.org,2005:Post/426802022-02-04T18:22:29+01:002022-02-05T11:52:52+01:00Erreur de compilation 'Aucun fichier ou dossier de ce type' [RESOLU]<p>Bonjour,<br>
je fait face à un bug dont je n'arrive pas à trouver la source.<br>
Depuis très longtemps j'ai un petit script qui récupère la branche master de QElectroTech puis le compil et l'installe pour finir. Tout fonctionnais très bien depuis des années jusqu'à il y a trois jours.</p>
<p>J'ai donc fait les choses à la main, et j’obtiens cette erreur :</p>
<pre><code>In file included from ../sources/ui/configpage/configpages.cpp:25:
../../compil_master/../qetapp.h:21:10: fatal error: ElementsCollection/elementslocation.h: Aucun fichier ou dossier de ce type
21 | #include "ElementsCollection/elementslocation.h"
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
</code></pre>
<p>Je tient à préciser que le fichier en question est bien présent.</p>
<p>La où ça devient étrange c'est qu'en passant par Qt creator (l'ide que j'utilise) ça compile très bien aussi bien avec gcc que clang.<br>
Après avoir mis à jour gcc, g++, clang, make, qmake, toutes leur dépendances, et profité pour faire du nettoyage et virer les anciennes version de clang, gcc, g++, idem impossible de compiler j'ai la même erreur, mais dans Qt creator ça fonctionne.</p>
<p>Comme j'ai timeshift d'installer j'ai fait un cliché actuel, puis une restauration à une date très ancienne où je suis sure que les choses marchais bien, mais idem.</p>
<p>Du coup je suis revenue avec timeshift sur le cliché actuel.<br>
Au vue de ce qui se passe j'ai un doute… je crée un nouvel utilisateur et la tout marche bien.</p>
<p>Je me pose la question, cela viendrais d'une config de ma session, mais quoi ?<br>
Avez vous des pistes ?</p>
<p>Pour info voici les commande que j'effectue</p>
<pre><code>git clone git://git.tuxfamily.org/gitroot/qet/qet.git /chemin/vers/qelectrotech
cd /chemin/vers/qelectrotech
mkdir build
cd build
qmake ../qelectrotech.pro
make -j16
</code></pre>
<p>C'est lors du make que je me paie l'erreur.</p>
<p>Merci d'avance.</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/erreur-de-compilation-aucun-fichier-ou-dossier-de-ce-type-resolu.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126811/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/erreur-de-compilation-aucun-fichier-ou-dossier-de-ce-type-resolu#comments">ouvrir dans le navigateur</a>
</p>
joshuahttps://linuxfr.org/nodes/126811/comments.atomtag:linuxfr.org,2005:Post/426362022-01-14T15:19:50+01:002022-01-14T20:08:34+01:00probleme de compréhension sur les rvalue et std::move<p>bonjours à tous,</p>
<p>Dans le code ci-dessous, j'ai l'impression que la lvalue est copié au lieu d'etre déplacé car le pointeur ou se trouve la chaine de caractere "Salut" n'est plus la meme avant et apres le std::move<br>
voici mon code :</p>
<pre><code class="C"><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">str</span> <span class="o">=</span> <span class="s">"Salut"</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">string</span><span class="o">></span> <span class="n">v</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"str.data() = "</span> <span class="o"><<</span> <span class="p">(</span><span class="kt">void</span><span class="o">*</span><span class="p">)</span><span class="n">str</span><span class="p">.</span><span class="n">data</span><span class="p">()</span> <span class="o"><<</span> <span class="s">"; str.size() = "</span> <span class="o"><<</span> <span class="n">str</span><span class="p">.</span><span class="n">size</span><span class="p">()</span> <span class="o"><<</span> <span class="s">" ; str = "</span> <span class="o"><<</span> <span class="n">str</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">//renvoie str.data() = 0x7ffcce8b6560; str.size() = 5 ; str = Salut</span>
<span class="k">const</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">pStr</span> <span class="o">=</span> <span class="n">str</span><span class="p">.</span><span class="n">data</span><span class="p">();</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"myPrintf = %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">pStr</span><span class="p">);</span> <span class="c1">// renvoie Salut</span>
<span class="n">v</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">move</span><span class="p">(</span><span class="n">str</span><span class="p">));</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"v[0].data() = "</span> <span class="o"><<</span> <span class="p">(</span><span class="kt">void</span><span class="o">*</span><span class="p">)</span><span class="n">v</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="n">data</span><span class="p">()</span> <span class="o"><<</span> <span class="s">"; v[1] = "</span> <span class="o"><<</span> <span class="n">v</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">//renvoie v[1].data() = 0x562d71ada2e0; v[1] = Salut</span>
<span class="n">pStr</span> <span class="o">=</span> <span class="n">str</span><span class="p">.</span><span class="n">data</span><span class="p">();</span><span class="c1">//renvoie str.data() = 0x7ffcce8b6560; str.size() = 0 ; str =</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"myPrintf = %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">pStr</span><span class="p">);</span> <span class="c1">//renvoie myPrintf =</span></code></pre>
<p>On voit bien que str n'existe plus, mais n'a rien a été déplacé, il y a eu copie. Je comprend vraiment pas l'utilité des lvalue</p>
<p>Merci d'avance pour vos éclaircissements :)</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/probleme-de-comprehension-sur-les-rvalue-et-std-move.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126574/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/probleme-de-comprehension-sur-les-rvalue-et-std-move#comments">ouvrir dans le navigateur</a>
</p>
cosmoffhttps://linuxfr.org/nodes/126574/comments.atomtag:linuxfr.org,2005:Post/425922021-12-30T19:14:47+01:002021-12-30T19:14:47+01:00conteneur en retour de fonction<p>bonjour,<br>
je ne suis plus novice en c++, et pourtant j'en apprends chaque jour.<br>
Je viens de tomber sur une erreur sympa, qui après avoir été isolée, s'est avérée quelque peu incompréhensible.<br>
peut-on retourner un conteneur depuis une fonction getConteneur?<br>
Voici mon exemple:</p>
<pre><code> class Foo{
public:
Foo(){
i.push_back(1);
i.push_back(2);
i.push_back(3);
}
std::vector<int> getvect()
{
return i;
}
private:
std::vector<int> i;
};
int main(int argc, char** argv)
{
Foo a;
for(auto it = a.getvect().begin(); it != a.getvect().end(); it++)
std::cout << (*it);
return EXIT_SUCCESS;
}
</code></pre>
<p>Est-ce quelqu'un pourrait m'expliquer à quoi rime le résultat?<br>
merci!!!!</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/conteneur-en-retour-de-fonction.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126400/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/conteneur-en-retour-de-fonction#comments">ouvrir dans le navigateur</a>
</p>
gunsailorhttps://linuxfr.org/nodes/126400/comments.atomtag:linuxfr.org,2005:Post/425782021-12-20T21:13:08+01:002021-12-20T21:14:45+01:00Fonction standard : vérifier si des entiers sont consécutif.<p>Bonjour,<br>
je cherche à savoir si il existe une fonction standard qui vérifie que les int d'un conteneur sont consécutif ? J'ai cherché mais pas trouver (peut être mal cherché…)<br>
En attendant j'utilise ce bout de code qui marche, à la condition que les entiers soient non signés.</p>
<pre><code class="ruby"><span class="n">const</span> <span class="n">std</span><span class="o">::</span><span class="n">vector</span> <span class="n">vector_</span><span class="p">{</span><span class="mi">1</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">9</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">};</span>
<span class="n">const</span> <span class="n">auto</span> <span class="n">count_</span> <span class="o">=</span> <span class="n">vector_</span><span class="o">.</span><span class="n">size</span><span class="p">();</span>
<span class="n">const</span> <span class="n">auto</span> <span class="n">min_max</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">minmax_element</span><span class="p">(</span><span class="n">vector_</span><span class="o">.</span><span class="n">begin</span><span class="p">(),</span> <span class="n">vector_</span><span class="o">.</span><span class="n">end</span><span class="p">());</span>
<span class="k">if</span> <span class="p">((</span><span class="o">*</span><span class="n">min_max</span><span class="o">.</span><span class="n">second</span> <span class="o">-</span> <span class="o">*</span><span class="n">min_max</span><span class="o">.</span><span class="n">first</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">!=</span> <span class="n">count_</span><span class="p">)</span> <span class="p">{</span>
<span class="k">return</span> <span class="kp">false</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">return</span> <span class="kp">true</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<p>Merci.</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/fonction-standard-verifier-si-des-entiers-sont-consecutif.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126339/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/fonction-standard-verifier-si-des-entiers-sont-consecutif#comments">ouvrir dans le navigateur</a>
</p>
joshuahttps://linuxfr.org/nodes/126339/comments.atomtag:linuxfr.org,2005:Post/425282021-11-30T05:36:12+01:002021-11-30T05:36:12+01:00Je souhaite apprendre le C++<p>Coucou.</p>
<p>Pour ma thèse en physique je dois manipuler le matlab de la mécanique des fluides numériques : OpenFoam. C'est une grosse librairie en C++.</p>
<p>Le problème c'est que c'est compliqué. Je renvoie vers un fichiers au hasard :<br>
<a href="https://www.openfoam.com/documentation/guides/latest/api/fvMesh_8C_source.html">https://www.openfoam.com/documentation/guides/latest/api/fvMesh_8C_source.html</a></p>
<p>Y a 10 000 constructeurs pour chaque objet, des templates de templates de templates de classes. J'utilise seulement python comme un scientifique modeste et je ne comprends pas grand chose.</p>
<p>Par quoi est-ce que je dois commencer ? Avez vous des ressources/tuto à conseiller ? Comment vous avez fait pour apprendre le C++ ?</p>
<p>Merci.</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/je-souhaite-apprendre-le-c.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/126106/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/je-souhaite-apprendre-le-c#comments">ouvrir dans le navigateur</a>
</p>
Joallandhttps://linuxfr.org/nodes/126106/comments.atomtag:linuxfr.org,2005:Post/422292021-07-03T15:26:25+02:002021-07-03T15:26:25+02:00error: expected identifier before ‘&’ token<p>Salutations !<br>
Je (re)débute en C++, j'essaye un peu des trucs, et je suis tombé sur une erreur que je comprends pas trop…</p>
<p>le code suivant</p>
<pre><code class="c++"><span class="k">class</span> <span class="nc">A</span> <span class="p">{</span>
<span class="p">};</span>
<span class="k">class</span> <span class="nc">B</span> <span class="p">{</span>
<span class="n">B</span><span class="p">(</span><span class="n">A</span><span class="o">*</span> <span class="n">a</span><span class="p">)</span> <span class="p">{</span>
<span class="p">}</span>
<span class="p">};</span>
<span class="k">class</span> <span class="nc">C</span> <span class="p">{</span>
<span class="n">A</span> <span class="n">a</span><span class="p">;</span>
<span class="n">B</span> <span class="nf">b</span><span class="p">(</span><span class="o">&</span><span class="n">a</span><span class="p">);</span>
<span class="p">};</span></code></pre>
<p>me retourne à la compilation</p>
<pre><code>$ gcc test.cpp
test.cpp:13:9: error: expected identifier before ‘&’ token
13 | B b(&a);
| ^
</code></pre>
<p>et je comprends pas bien ce qu'il veut… Si quelqu'un peux m'expliquer, merci d'avance :D</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/error-expected-identifier-before-token.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/124768/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/error-expected-identifier-before-token#comments">ouvrir dans le navigateur</a>
</p>
WrathOfThePixelhttps://linuxfr.org/nodes/124768/comments.atomtag:linuxfr.org,2005:Post/421842021-06-08T17:01:33+02:002021-06-08T21:28:40+02:00Client udp qui écoute plusieurs ports en utilisant boost<p>Bonjour à tous, </p>
<p>ça fait un petit moment que je galère et je n'arrive pas à m'en sortir. Je dois<br>
écrire un client qui reçoit des données en udp. La connexion se fait en point à<br>
point. Mon pc à une certaine IP qui permet au serveur de me reconnaître. Les<br>
données sont envoyées sur 5 ports différents<br>
- 50000/54000 début/fin de daq <br>
- 51000/53000 début/fin de tranche<br>
- 52000 données utiles du système </p>
<p>J'ai besoin de récupérer toutes les données et de les écrire dans le fichier.</p>
<p>Préalablement j'avais fait un petit client sur un seul port et j'avais testé<br>
avec netcat; ça fonctionnait plutôt bien. Au passage de 1 vers 5 sockets… J'y<br>
arrive plus. L'envoie des requêtes vers le serveur fonctionne toujours<br>
correctement mais la réception ne fonctionne pas; je n'entre jamais dans les<br>
handlers…</p>
<p>Ce que je sais par contre c'est que les données sont bien envoyées car ce que je<br>
vois ensuite à partir du paquet 6 est exactement ce que je dois recevoir.</p>
<p>Je n'y arrive pas, je suis perdu… Est-ce qu'une ame charitable pourrait me<br>
mettre sur la voie ?</p>
<p>Merci d'avance pour votre aide.</p>
<p>Olivier </p>
<p>Ci-dessous, un extrait de ce que wireshark voit<br>
<code>markdown<br>
| 1 | 0 | 192.168.0.254 | 192.168.0.1 | UDP | 50 | 49890 → 5 Len=8 | 1 |<br>
| 2 | 1.0876E-05 | 192.168.0.254 | 192.168.0.1 | UDP | 50 | 49890 → 5 Len=8 | 2 |<br>
| 3 | 1.3583E-05 | 192.168.0.254 | 192.168.0.1 | UDP | 50 | 49890 → 5 Len=8 | 3 |<br>
| 4 | 1.5884E-05 | 192.168.0.254 | 192.168.0.1 | UDP | 50 | 49890 → 5 Len=8 | 4 |<br>
| 5 | 1.7992E-05 | 192.168.0.254 | 192.168.0.1 | UDP | 50 | 49890 → 5 Len=8 | 5 |<br>
| 6 | 4.5684E-05 | 192.168.0.1 | 192.168.0.254 | UDP | 60 | 50000 → 32776 Len=8 | 6 |<br>
| 7 | 4.5781E-05 | 192.168.0.1 | 192.168.0.254 | UDP | 74 | 51000 → 32776 Len=32 | 7 |<br>
| 8 | 8.7986E-05 | 192.168.0.254 | 192.168.0.1 | ICMP | 102 | Destination unreachable (Communication administratively filtered) | 8 |<br>
| 9 | 0.000107264 | 192.168.0.1 | 192.168.0.254 | UDP | 486 | 52000 → 32776 Len=444 | 9 |<br>
| 10 | 0.000115677 | 192.168.0.254 | 192.168.0.1 | ICMP | 514 | Destination unreachable (Communication administratively filtered) | 10 |<br>
| 12 | 0.014089529 | 192.168.0.1 | 192.168.0.254 | UDP | 466 | 52000 → 32776 Len=424 | 12 |<br>
| 13 | 0.014131458 | 192.168.0.254 | 192.168.0.1 | ICMP | 494 | Destination unreachable (Communication administratively filtered) | 13 |<br>
| 14 | 0.034794761 | 192.168.0.1 | 192.168.0.254 | UDP | 474 | 52000 → 32776 Len=432 | 14 |<br>
| 15 | 0.034836852 | 192.168.0.254 | 192.168.0.1 | ICMP | 502 | Destination unreachable (Communication administratively filtered) | 15 |<br>
| 17 | 0.071217607 | 192.168.0.1 | 192.168.0.254 | UDP | 474 | 52000 → 32776 Len=432 | 17 |<br>
| 18 | 0.071260595 | 192.168.0.254 | 192.168.0.1 | ICMP | 502 | Destination unreachable (Communication administratively filtered) | 18 |<br>
| 19 | 0.080098375 | 192.168.0.1 | 192.168.0.254 | UDP | 190 | 52000 → 32776 Len=148 | 19 |<br>
| 20 | 0.080098482 | 192.168.0.1 | 192.168.0.254 | UDP | 74 | 53000 → 32776 Len=32 | 20 |<br>
| 21 | 0.080098503 | 192.168.0.1 | 192.168.0.254 | UDP | 74 | 51000 → 32776 Len=32 | 21 |<br>
| 22 | 0.080149978 | 192.168.0.254 | 192.168.0.1 | ICMP | 218 | Destination unreachable (Communication administratively filtered) | 22 |<br>
| 24 | 0.160146554 | 192.168.0.1 | 192.168.0.254 | UDP | 486 | 52000 → 32776 Len=444 | 24 |<br>
</code></p>
<p>et ici le code </p>
<pre><code class="c++"><span class="cp">#include</span> <span class="cpf">"udp_client.hxx"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><fstream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><functional></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><vector></span><span class="cp"></span>
<span class="c1">//#include <thread></span>
<span class="cp">#include</span> <span class="cpf"><boost/bind/bind.hpp></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><boost/asio.hpp></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><ctime></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><boost/date_time/posix_time/posix_time.hpp></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">"udp_constants.hxx"</span><span class="cp"></span>
<span class="k">using</span> <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">udp</span><span class="p">;</span>
<span class="n">udp_client</span><span class="o">::</span><span class="n">udp_client</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">io_context</span> <span class="o">&</span><span class="n">io</span><span class="p">)</span> <span class="o">:</span>
<span class="n">strand</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">make_strand</span><span class="p">(</span><span class="n">io</span><span class="p">)),</span>
<span class="n">socket_data</span><span class="p">(</span><span class="n">io</span><span class="p">,</span> <span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">v4</span><span class="p">(),</span> <span class="n">udp_constants</span><span class="o">::</span><span class="n">ports</span><span class="o">::</span><span class="n">data</span><span class="p">)),</span>
<span class="n">socket_daq_start</span><span class="p">(</span><span class="n">io</span><span class="p">,</span> <span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">v4</span><span class="p">(),</span> <span class="n">udp_constants</span><span class="o">::</span><span class="n">ports</span><span class="o">::</span><span class="n">daq_start</span><span class="p">)),</span>
<span class="n">socket_daq_stop</span><span class="p">(</span><span class="n">io</span><span class="p">,</span> <span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">v4</span><span class="p">(),</span> <span class="n">udp_constants</span><span class="o">::</span><span class="n">ports</span><span class="o">::</span><span class="n">daq_stop</span><span class="p">)),</span>
<span class="n">socket_slice_start</span><span class="p">(</span><span class="n">io</span><span class="p">,</span> <span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">v4</span><span class="p">(),</span> <span class="n">udp_constants</span><span class="o">::</span><span class="n">ports</span><span class="o">::</span><span class="n">slice_start</span><span class="p">)),</span>
<span class="n">socket_slice_stop</span><span class="p">(</span><span class="n">io</span><span class="p">,</span> <span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">v4</span><span class="p">(),</span> <span class="n">udp_constants</span><span class="o">::</span><span class="n">ports</span><span class="o">::</span><span class="n">slice_stop</span><span class="p">)),</span>
<span class="n">socket_tx</span><span class="p">(</span><span class="n">io</span><span class="p">),</span>
<span class="n">timer</span><span class="p">{</span><span class="n">strand</span><span class="p">}</span>
<span class="p">{</span>
<span class="n">socket_daq_start</span><span class="p">.</span><span class="n">connect</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">address</span><span class="o">::</span><span class="n">from_string</span><span class="p">(</span><span class="s">"192.168.0.1"</span><span class="p">),</span> <span class="mi">50000</span><span class="p">));</span>
<span class="n">socket_daq_stop</span><span class="p">.</span><span class="n">connect</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">address</span><span class="o">::</span><span class="n">from_string</span><span class="p">(</span><span class="s">"192.168.0.1"</span><span class="p">),</span> <span class="mi">54000</span><span class="p">));</span>
<span class="n">socket_slice_start</span><span class="p">.</span><span class="n">connect</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">address</span><span class="o">::</span><span class="n">from_string</span><span class="p">(</span><span class="s">"192.168.0.1"</span><span class="p">),</span> <span class="mi">51000</span><span class="p">));</span>
<span class="n">socket_slice_stop</span><span class="p">.</span><span class="n">connect</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">address</span><span class="o">::</span><span class="n">from_string</span><span class="p">(</span><span class="s">"192.168.0.1"</span><span class="p">),</span> <span class="mi">53000</span><span class="p">));</span>
<span class="n">socket_data</span><span class="p">.</span><span class="n">connect</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">address</span><span class="o">::</span><span class="n">from_string</span><span class="p">(</span><span class="s">"192.168.0.1"</span><span class="p">),</span> <span class="mi">52000</span><span class="p">));</span>
<span class="n">datagrams</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span><span class="p">{</span><span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x01</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">});</span>
<span class="n">datagrams</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span><span class="p">{</span><span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x01</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x01</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x7a</span><span class="p">,</span> <span class="mh">0x11</span><span class="p">,</span> <span class="mh">0xfe</span><span class="p">});</span>
<span class="n">datagrams</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span><span class="p">{</span><span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x01</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x02</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x7a</span><span class="p">,</span> <span class="mh">0x11</span><span class="p">,</span> <span class="mh">0xfe</span><span class="p">});</span>
<span class="n">datagrams</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span><span class="p">{</span><span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x01</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x03</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x05</span><span class="p">});</span>
<span class="n">datagrams</span><span class="p">.</span><span class="n">push_back</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span><span class="p">{</span><span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x01</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x00</span><span class="p">,</span> <span class="mh">0x01</span><span class="p">});</span>
<span class="n">set_acquisition_and_get_data</span><span class="p">(</span><span class="n">datagrams</span><span class="p">);</span>
<span class="n">filename</span><span class="o">=</span><span class="s">"/home/lemaire/data.dat"</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">udp_client</span><span class="o">::~</span><span class="n">udp_client</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">socket_daq_start</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">socket_slice_start</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">socket_slice_stop</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">socket_daq_stop</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">socket_data</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="c1">// close file</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="c1">// inform user</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"udp server destructor"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="cm">/**</span>
<span class="cm"> * @brief udp_client::get_time_stamp</span>
<span class="cm"> * @return</span>
<span class="cm"> *</span>
<span class="cm"> * @note je ne sais pas pour l'instant si c'est bien pertinent mais</span>
<span class="cm"> * l'objet c'était d'avoir un getter...</span>
<span class="cm"> */</span>
<span class="kt">uint64_t</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">get_timestamp</span><span class="p">()</span>
<span class="p">{</span>
<span class="k">return</span> <span class="n">create_timestamp</span><span class="p">();</span>
<span class="p">}</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span> <span class="n">udp_client</span><span class="o">::</span><span class="n">ui64_to_vector</span><span class="p">(</span><span class="kt">uint64_t</span> <span class="n">w</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span> <span class="n">vec</span><span class="p">(</span><span class="mi">8</span><span class="p">,</span> <span class="mh">0x0</span><span class="p">);</span>
<span class="kt">char</span> <span class="n">c</span><span class="p">;</span>
<span class="kt">size_t</span> <span class="n">d</span><span class="p">{</span><span class="mi">0</span><span class="p">};</span>
<span class="k">for</span><span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">{</span><span class="mi">0</span><span class="p">};</span> <span class="n">i</span><span class="o"><</span><span class="mi">8</span><span class="p">;</span> <span class="n">i</span><span class="o">++</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">d</span> <span class="o">=</span> <span class="p">(</span><span class="mi">8</span><span class="o">-</span><span class="mi">1</span><span class="o">-</span><span class="n">i</span><span class="p">)</span><span class="o">*</span><span class="mi">8</span><span class="p">;</span>
<span class="n">c</span> <span class="o">=</span> <span class="k">static_cast</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">></span><span class="p">(</span><span class="n">w</span> <span class="o">>></span> <span class="n">d</span><span class="p">);</span>
<span class="n">vec</span><span class="p">[</span><span class="n">i</span><span class="p">]</span> <span class="o">=</span> <span class="n">c</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">vec</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">bool</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">send_data</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">>>&</span> <span class="n">datagrams</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">using</span> <span class="n">udp</span> <span class="o">=</span> <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">udp</span><span class="p">;</span>
<span class="k">auto</span> <span class="n">endpoint</span> <span class="o">=</span> <span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="p">(</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">address</span><span class="o">::</span><span class="n">from_string</span><span class="p">(</span><span class="n">udp_constants</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">fpga</span><span class="p">),</span>
<span class="n">udp_constants</span><span class="o">::</span><span class="n">ports</span><span class="o">::</span><span class="n">configuration</span><span class="p">);</span>
<span class="k">try</span>
<span class="p">{</span>
<span class="n">socket_tx</span><span class="p">.</span><span class="n">open</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">ip</span><span class="o">::</span><span class="n">udp</span><span class="o">::</span><span class="n">v4</span><span class="p">());</span>
<span class="k">for</span><span class="p">(</span><span class="k">auto</span> <span class="nl">datagram</span><span class="p">:</span> <span class="n">datagrams</span><span class="p">)</span>
<span class="n">socket_tx</span><span class="p">.</span><span class="n">send_to</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">buffer</span><span class="p">(</span><span class="n">datagram</span><span class="p">),</span> <span class="n">endpoint</span><span class="p">);</span>
<span class="n">socket_tx</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="p">}</span>
<span class="k">catch</span> <span class="p">(</span><span class="k">const</span> <span class="n">boost</span><span class="o">::</span><span class="n">system</span><span class="o">::</span><span class="n">system_error</span><span class="o">&</span> <span class="n">e</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">e</span><span class="p">.</span><span class="n">what</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">bool</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">set_acquisition_and_get_data</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="kt">unsigned</span> <span class="kt">char</span><span class="o">>>&</span> <span class="n">datagrams</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" begin"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">start_receive</span><span class="p">();</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" start receive launched"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">send_data</span><span class="p">(</span><span class="n">datagrams</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" instructions sent"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">return</span> <span class="nb">true</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">start_receive</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">open</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span><span class="o">::</span><span class="n">out</span> <span class="o">|</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span><span class="o">::</span><span class="n">trunc</span> <span class="o">|</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span><span class="o">::</span><span class="n">binary</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">vector</span><span class="o"><</span><span class="n">udp</span><span class="o">::</span><span class="n">endpoint</span><span class="o">></span> <span class="n">endpoints</span><span class="p">(</span><span class="mi">5</span><span class="p">);</span>
<span class="n">socket_daq_start</span><span class="p">.</span><span class="n">async_receive</span>
<span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">buffer</span><span class="p">(</span><span class="n">buffer_daq_start</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="mi">16</span><span class="p">),</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">bind_executor</span>
<span class="p">(</span><span class="n">strand</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">bind</span>
<span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_daq_start</span><span class="p">,</span>
<span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">bytes_transferred</span>
<span class="p">)</span>
<span class="p">)</span>
<span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" socket daq start started"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// --</span>
<span class="n">socket_slice_start</span><span class="p">.</span><span class="n">async_receive</span>
<span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">buffer</span><span class="p">(</span><span class="n">buffer_slice_start</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="mi">64</span><span class="p">),</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">bind_executor</span>
<span class="p">(</span><span class="n">strand</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">bind</span>
<span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_slice_start</span><span class="p">,</span>
<span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">bytes_transferred</span>
<span class="p">)</span>
<span class="p">)</span>
<span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" socket slice start started"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// --</span>
<span class="n">socket_slice_stop</span><span class="p">.</span><span class="n">async_receive</span>
<span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">buffer</span><span class="p">(</span><span class="n">buffer_slice_stop</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="mi">64</span><span class="p">),</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">bind_executor</span>
<span class="p">(</span><span class="n">strand</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">bind</span>
<span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_slice_stop</span><span class="p">,</span>
<span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">bytes_transferred</span>
<span class="p">)</span>
<span class="p">)</span>
<span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" socket slice stop started"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// --</span>
<span class="n">socket_daq_stop</span><span class="p">.</span><span class="n">async_receive</span>
<span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">buffer</span><span class="p">(</span><span class="n">buffer_daq_stop</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="mi">16</span><span class="p">),</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">bind_executor</span>
<span class="p">(</span><span class="n">strand</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">bind</span>
<span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_daq_stop</span><span class="p">,</span>
<span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">bytes_transferred</span>
<span class="p">)</span>
<span class="p">)</span>
<span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" socket slice stop started"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="c1">// --</span>
<span class="n">socket_data</span><span class="p">.</span><span class="n">async_receive</span>
<span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">buffer</span><span class="p">(</span><span class="n">buffer_data_1</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="mi">16</span><span class="p">),</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">bind_executor</span>
<span class="p">(</span><span class="n">strand</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">bind</span>
<span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_data</span><span class="p">,</span>
<span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">bytes_transferred</span>
<span class="p">)</span>
<span class="p">)</span>
<span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="s">" socket data started"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">handle_daq_start</span><span class="p">(</span><span class="k">const</span> <span class="n">boost</span><span class="o">::</span><span class="n">system</span><span class="o">::</span><span class="n">error_code</span><span class="o">&</span> <span class="n">error</span><span class="p">,</span> <span class="c1">// Result of operation.</span>
<span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">bytes_transferred</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">__PRETTY_FUNCTION__</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">error</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// write the data</span>
<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">output_stream</span><span class="p">.</span><span class="n">is_open</span><span class="p">())</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">open</span><span class="p">(</span><span class="n">filename</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span><span class="o">::</span><span class="n">out</span> <span class="o">|</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span><span class="o">::</span><span class="n">trunc</span> <span class="o">|</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span><span class="o">::</span><span class="n">binary</span><span class="p">);</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">write</span><span class="p">(</span><span class="n">buffer_daq_start</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">bytes_transferred</span><span class="p">);</span>
<span class="n">timer</span><span class="p">.</span><span class="n">expires_after</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">chrono</span><span class="o">::</span><span class="n">milliseconds</span><span class="p">(</span><span class="n">timeout</span><span class="p">));</span>
<span class="n">timer</span><span class="p">.</span><span class="n">async_wait</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_timeout</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">));</span>
<span class="p">}</span>
<span class="k">else</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"handle daq start error"</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"message : "</span> <span class="o"><<</span> <span class="n">error</span><span class="p">.</span><span class="n">message</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">handle_slice_start</span><span class="p">(</span><span class="k">const</span> <span class="n">boost</span><span class="o">::</span><span class="n">system</span><span class="o">::</span><span class="n">error_code</span> <span class="o">&</span><span class="n">error</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">bytes_transferred</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">error</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// add time to the timeout timer</span>
<span class="n">timer</span><span class="p">.</span><span class="n">expires_after</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">chrono</span><span class="o">::</span><span class="n">milliseconds</span><span class="p">(</span><span class="n">timeout</span><span class="p">));</span>
<span class="n">timer</span><span class="p">.</span><span class="n">async_wait</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_timeout</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">));</span>
<span class="c1">// write the data</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">write</span><span class="p">(</span><span class="n">buffer_slice_start</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">bytes_transferred</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">else</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"handle daq start error"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="n">error</span><span class="p">.</span><span class="n">message</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">handle_slice_stop</span><span class="p">(</span><span class="k">const</span> <span class="n">boost</span><span class="o">::</span><span class="n">system</span><span class="o">::</span><span class="n">error_code</span> <span class="o">&</span><span class="n">error</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">bytes_transferred</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">error</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// add time to the timeout timer</span>
<span class="n">timer</span><span class="p">.</span><span class="n">expires_after</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">chrono</span><span class="o">::</span><span class="n">milliseconds</span><span class="p">(</span><span class="n">timeout</span><span class="p">));</span>
<span class="n">timer</span><span class="p">.</span><span class="n">async_wait</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_timeout</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">));</span>
<span class="c1">// write the data</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">write</span><span class="p">(</span><span class="n">buffer_slice_start</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">bytes_transferred</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">else</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"handle daq start error"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="n">error</span><span class="p">.</span><span class="n">message</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">handle_data</span><span class="p">(</span><span class="k">const</span> <span class="n">boost</span><span class="o">::</span><span class="n">system</span><span class="o">::</span><span class="n">error_code</span><span class="o">&</span> <span class="n">error</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">bytes_transferred</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">error</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// add time to the timeout timer</span>
<span class="n">timer</span><span class="p">.</span><span class="n">expires_after</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">chrono</span><span class="o">::</span><span class="n">milliseconds</span><span class="p">(</span><span class="n">timeout</span><span class="p">));</span>
<span class="n">timer</span><span class="p">.</span><span class="n">async_wait</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_timeout</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">));</span>
<span class="c1">// write the data</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">write</span><span class="p">(</span><span class="n">buffer_slice_start</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">bytes_transferred</span><span class="p">);</span>
<span class="c1">// receive_data();</span>
<span class="p">}</span>
<span class="k">else</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="s">"handle daq start error"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="n">error</span><span class="p">.</span><span class="n">message</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">receive_data</span><span class="p">();</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">receive_data</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">socket_data</span><span class="p">.</span><span class="n">async_receive</span>
<span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">buffer</span><span class="p">(</span><span class="n">buffer_data_1</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">buffer_data_1</span><span class="p">.</span><span class="n">size</span><span class="p">()),</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">bind_executor</span>
<span class="p">(</span><span class="n">strand</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">bind</span>
<span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_data</span><span class="p">,</span>
<span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">bytes_transferred</span>
<span class="p">)</span>
<span class="p">)</span>
<span class="p">);</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">handle_daq_stop</span><span class="p">(</span><span class="k">const</span> <span class="n">boost</span><span class="o">::</span><span class="n">system</span><span class="o">::</span><span class="n">error_code</span> <span class="o">&</span><span class="n">error</span><span class="p">,</span>
<span class="n">std</span><span class="o">::</span><span class="kt">size_t</span> <span class="n">bytes_transferred</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span><span class="p">(</span><span class="o">!</span><span class="n">error</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// add time to the timeout timer</span>
<span class="n">timer</span><span class="p">.</span><span class="n">expires_after</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">chrono</span><span class="o">::</span><span class="n">milliseconds</span><span class="p">(</span><span class="n">timeout</span><span class="p">));</span>
<span class="n">timer</span><span class="p">.</span><span class="n">async_wait</span><span class="p">(</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&</span><span class="n">udp_client</span><span class="o">::</span><span class="n">handle_timeout</span><span class="p">,</span> <span class="k">this</span><span class="p">,</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">error</span><span class="p">));</span>
<span class="c1">// write the data</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">write</span><span class="p">(</span><span class="n">buffer_daq_stop</span><span class="p">.</span><span class="n">data</span><span class="p">(),</span> <span class="n">bytes_transferred</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">const</span> <span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">get_data_file_name</span><span class="p">()</span>
<span class="p">{</span>
<span class="k">return</span> <span class="n">filename</span><span class="o">+</span><span class="n">std</span><span class="o">::</span><span class="n">to_string</span><span class="p">(</span><span class="n">file_index</span><span class="p">)</span><span class="o">+</span><span class="s">".dat"</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">void</span> <span class="n">udp_client</span><span class="o">::</span><span class="n">handle_timeout</span><span class="p">(</span><span class="k">const</span> <span class="n">boost</span><span class="o">::</span><span class="n">system</span><span class="o">::</span><span class="n">error_code</span><span class="o">&</span> <span class="n">e</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">e</span> <span class="o">!=</span> <span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">error</span><span class="o">::</span><span class="n">operation_aborted</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// close sockets</span>
<span class="n">socket_daq_start</span><span class="p">.</span><span class="n">shutdown</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">socket</span><span class="o">::</span><span class="n">shutdown_both</span><span class="p">);</span>
<span class="n">socket_slice_start</span><span class="p">.</span><span class="n">shutdown</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">socket</span><span class="o">::</span><span class="n">shutdown_both</span><span class="p">);</span>
<span class="n">socket_slice_stop</span><span class="p">.</span><span class="n">shutdown</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">socket</span><span class="o">::</span><span class="n">shutdown_both</span><span class="p">);</span>
<span class="n">socket_daq_stop</span><span class="p">.</span><span class="n">shutdown</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">socket</span><span class="o">::</span><span class="n">shutdown_both</span><span class="p">);</span>
<span class="n">socket_data</span><span class="p">.</span><span class="n">shutdown</span><span class="p">(</span><span class="n">udp</span><span class="o">::</span><span class="n">socket</span><span class="o">::</span><span class="n">shutdown_both</span><span class="p">);</span>
<span class="n">output_stream</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"file written and closed, socket closed"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span></code></pre>
<pre><code class="c++"> <span class="cp">#include</span> <span class="cpf">"udp_client.hxx"</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><boost/asio.hpp></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><signal.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><chrono></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><boost/thread/thread.hpp></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><boost/asio/thread_pool.hpp></span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="k">try</span>
<span class="p">{</span>
<span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">io_context</span> <span class="n">io</span><span class="p">;</span>
<span class="n">udp_client</span> <span class="n">client</span><span class="p">(</span><span class="n">io</span><span class="p">);</span>
<span class="n">boost</span><span class="o">::</span><span class="kr">thread</span> <span class="n">t</span><span class="p">{</span><span class="n">boost</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="o">&</span><span class="n">boost</span><span class="o">::</span><span class="n">asio</span><span class="o">::</span><span class="n">io_context</span><span class="o">::</span><span class="n">run</span><span class="p">,</span> <span class="o">&</span><span class="n">io</span><span class="p">)};</span>
<span class="n">io</span><span class="p">.</span><span class="n">run</span><span class="p">();</span>
<span class="n">t</span><span class="p">.</span><span class="n">join</span><span class="p">();</span>
<span class="p">}</span>
<span class="k">catch</span> <span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">exception</span><span class="o">&</span> <span class="n">e</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"erreur"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cerr</span> <span class="o"><<</span> <span class="n">e</span><span class="p">.</span><span class="n">what</span><span class="p">()</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/client-udp-qui-ecoute-plusieurs-ports-en-utilisant-boost.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/124537/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/client-udp-qui-ecoute-plusieurs-ports-en-utilisant-boost#comments">ouvrir dans le navigateur</a>
</p>
Olivier LEMAIREhttps://linuxfr.org/nodes/124537/comments.atomtag:linuxfr.org,2005:Post/421512021-05-28T10:44:42+02:002021-05-28T10:44:42+02:00Petite question de c++ pour égayer votre vendredi<p>Bonjour,<br>
je suis en train de coder une toute petite librairie et je bute sur un petit problème.<br>
voici le code actuel (simplifié):</p>
<pre><code class="cpp"><span class="k">template</span> <span class="o"><</span><span class="k">typename</span> <span class="n">A</span><span class="p">,</span> <span class="k">typename</span> <span class="n">B</span><span class="o">></span>
<span class="k">class</span> <span class="nc">Function</span> <span class="p">{</span>
<span class="k">public</span><span class="o">:</span>
<span class="n">Function</span><span class="p">()</span> <span class="p">{</span>
<span class="n">register_inputs</span><span class="p">();</span>
<span class="p">}</span>
<span class="n">Input</span><span class="o"><</span><span class="n">A</span><span class="o">></span> <span class="n">in0</span><span class="p">;</span>
<span class="n">Input</span><span class="o"><</span><span class="n">B</span><span class="o">></span> <span class="n">in1</span><span class="p">;</span>
<span class="kt">void</span> <span class="nf">register_inputs</span><span class="p">()</span> <span class="p">{</span>
<span class="n">inputs</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="o">&</span><span class="n">in0</span><span class="p">);</span>
<span class="n">inputs</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="o">&</span><span class="n">in1</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">private</span><span class="o">:</span>
<span class="n">std</span><span class="o">::</span><span class="n">unordered_set</span><span class="o"><</span><span class="n">InputBase</span><span class="o">*></span> <span class="n">inputs</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<p>Ca marche comme ça, mais j'aimerais pouvoir faire ceci, avec une macro (ou autre) :</p>
<pre><code class="cpp"><span class="n">CREATE_INPUT</span><span class="p">(</span><span class="n">A</span><span class="p">,</span> <span class="n">in0</span><span class="p">);</span>
<span class="n">CREATE_INPUT</span><span class="p">(</span><span class="n">B</span><span class="p">,</span> <span class="n">in1</span><span class="p">);</span></code></pre>
<p>qui me générerait cette partie automatiquement :</p>
<pre><code class="cpp"> <span class="n">Input</span><span class="o"><</span><span class="n">A</span><span class="o">></span> <span class="n">in0</span><span class="p">;</span>
<span class="n">Input</span><span class="o"><</span><span class="n">B</span><span class="o">></span> <span class="n">in1</span><span class="p">;</span>
<span class="kt">void</span> <span class="nf">register_inputs</span><span class="p">()</span> <span class="p">{</span>
<span class="n">inputs</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="o">&</span><span class="n">in0</span><span class="p">);</span>
<span class="n">inputs</span><span class="p">.</span><span class="n">insert</span><span class="p">(</span><span class="o">&</span><span class="n">in1</span><span class="p">);</span>
<span class="p">}</span></code></pre>
<p>Histoire de ne pas oublier de mettre les "inputs" dans le conteneur. Et puis c'est plus joli.</p>
<p>Je cherche un peu à me couper les cheveux en 4, mais c'est aussi un exercice pour apprendre de nouvelles choses en C++. J'ai d'ailleurs découvert les <a href="https://en.wikipedia.org/wiki/X_Macro">X_Macro</a> qui pourraient peut-être résoudre mon problème mais je suis un peu bloqué.</p>
<p>j'ai aussi découvert m4 qui pourrait résoudre mon problème en l'utilisant comme pré-préprocesseur (lol), mais j'aimerais savoir si c'est possible de le faire uniquement en c++.</p>
<p>Merci, bon dredi</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/petite-question-de-c-pour-egayer-votre-vendredi.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/124416/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/petite-question-de-c-pour-egayer-votre-vendredi#comments">ouvrir dans le navigateur</a>
</p>
max22https://linuxfr.org/nodes/124416/comments.atomtag:linuxfr.org,2005:Post/419162021-03-02T11:06:53+01:002021-03-02T11:32:53+01:00Comment synchroniser environnement de développement entre machines ?<p>Bonjour,</p>
<p>Dans ma boîte, on développe différents logiciels pour de l'embarqué qui sont compilés sur différentes machines (station de travail, environnement d'intégration continue etc).<br>
Entre les bouts de code en C/C++, python, JS, etc, la gestion des librairies commence à se compliquer et comme tout est fait à la main pour synchroniser les environnement de développement, c'est un peu pénible à court terme et je pense très hasardeux à long terme.</p>
<p>On a également plusieurs projets en parallèle, donc le besoin de basculer assez facilement de l'un à l'autre. Actuellement par chance, les dépendances sont à peut-près compatibles mais ça va pas durer.</p>
<p>Jusqu'à présent, on utilise une Machine Virtuelle mais c'est très gros à échanger et pratiquement jamais mis à jour correctement alors j'essaye de migrer ça vers des environnement virtuels et des containers qui pourront être archivés via git etc.</p>
<p>Pour les parties python, je mets en place des environnements virtuels python qui me semblent être la méthode assez classique.</p>
<p>Plus globalement et pour les parties C/C++, je suis parti sur des containers qui contiennent les libs et les compilos/interpréteurs. Les sources sont accessibles par l'intermédiaire d'un volume et j'ai fait quelques bidouilles pour avoir les mêmes UID/GID que l'utilisateur de l'hôte.<br>
Ça marche assez bien pour avoir un environnement pour builder une version "officielle" (un clique et ça sort un package tout chaud) mais je suis moins convaincu pour la phase développement avec ses erreurs de compile, les phases de debug, etc. On utilise Eclipse principalement et quelques outils graphiques.</p>
<p>Je voyais deux options mais aucune ne me satisfait vraiment:<br>
1. Installer Eclipse (et autres outils graphique) côté hôte pour travailler sur le code et lancer uniquement la compilation dans le container. Je trouve ça assez bien car très peut de différences par rapport au monde sans container. Là où ça me semble tordu, c'est que je vais avoir des erreurs de compile qui vont me donner des chemins correspondants au monde du container et pas de l'hôte par exemple. <br>
2. Installer Eclipse côté container. Là, les messages d'erreur pointeront bien sur les fichiers, mais par contre il faudra lancer tous les outils en "export display" ou via une console dans le container, ce qui me semble beaucoup moins transparent à l'utilisation.</p>
<p>Alors voilà (enfin) ma question:<br>
Quelles sont les bonnes pratiques et quelles autres options existent pour "dupliquer" des environnements de développement entre plusieurs machines?</p>
<p>Merci d'avance</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/comment-synchroniser-environnement-de-developpement-entre-machines.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/123450/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/comment-synchroniser-environnement-de-developpement-entre-machines#comments">ouvrir dans le navigateur</a>
</p>
ykronshttps://linuxfr.org/nodes/123450/comments.atomtag:linuxfr.org,2005:Post/418572021-02-08T21:40:09+01:002021-02-08T21:40:09+01:00try catch et sigsegv<p>Bonjour à tous,</p>
<p>voila je m'interroge sur le fonctionne du try catch. Est ce que ca utilise l' appelle systeme sigaction qui permet d'attraper un signal. Si le signal et SIGSEGV alors on saute dans une méthode handler. Puis on retourne à l'instruction suivant apres le try..catch ? Le compilateur C++ gere donc l'implémentation automatique du handler pour attraper le signal sigsegv ?</p>
<p>autre question :<br>
J'ai souvent vu dans certain code assez bien fait (comme Qt) le systeme de property, par exemple,</p>
<pre><code>union type myValue = 6;
myObject.setProperty("myValue", myValue)
</code></pre>
<p>et pour récupérer la valeur :<br>
<code><br>
int value = myObject.property("ma variable");<br>
</code>cette facon de faire est un design pattern ? des fois j'ai meme vu le type myValue = void* : myObject::setProperty(char*, void*) ce qui permet de prendre n'importe quel type.<br>
quelqu'un peut il m'expliquer l'utilité d'une telle chose ?</p>
<p>Merci d'avance pour votre aide</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/try-catch-et-sigsegv.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/123250/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/try-catch-et-sigsegv#comments">ouvrir dans le navigateur</a>
</p>
cosmoffhttps://linuxfr.org/nodes/123250/comments.atomtag:linuxfr.org,2005:Post/415562020-11-02T16:16:30+01:002020-11-04T19:08:24+01:00Création de procédures en texte simple<p>Bonjour à tous, <br>
je suis en train d'écrire un petit logiciel qui sert à piloter et à configurer des circuits intégrés. Ces circuits intégrés sont ce qu'on appelle des ASICs, c'est à dire qu'ils ont été spécifiquement conçus pour l'expérience pour laquelle je travaille. Ce ne sont donc pas des composants "standards", mais ça n'est pas vraiment important.</p>
<p>Avec ce petit logiciel nous sommes capables, entre autre chose de stocker une valeur dans un registre de configuration, relire cette valeur, injecter un signal sur le circuit, lire la ou les valeurs qui sortent du circuit suite à cette injection et les afficher dans de beaux histogrammes et plein d'autres choses, La liste est longue :)</p>
<p>J'écris ce logiciel en Qt5/C++ pour avoir une interface graphique, c'est franchement plus simple en période de test. J'ai pris soin de séparer la partie graphique et les autres parties, comme par exemple la communication, les calculs…</p>
<p>Le graphique c'est bien mais des fois on voudrait bien automatiser certaines taches ou créer des procédures et surtout que n'importe qui puisse écrire des procédures. L'idée c'est d'avoir une sorte de langage très simple pour écrire des suites d'instructions, éventuellement une instruction if/else, boucle type for. Un petit interpréteur rudimentaire va lire ces suites d'instructions depuis un fichier texte et exécuter ces suite d'instructions. Par exemple :<br>
- écrire_dans_registre, adresse_registre, données_registre;<br>
- attendre, temps attente;<br>
- lire_registre, adresse_registre, afficher_valeur;<br>
- injecter_sur_circuit, adresse_circuit, valeur_injection;<br>
- lire_valeur_codée_par_adc, stocker_dans_vecteur valeur_codée_par_adc<br>
- tracer_vecteur_dans_graph;<br>
- …</p>
<p>J'ai pensé à plusieurs chose comme par exemple du yaml ou peut être du xml mais je ne sais pas si c'est le mieux pour faire ca… Dans tous les cas faut que ca reste simple, à faire et à prendre en main car ni moi, ni les gens qui vont utiliser cette fonctionnalité ne sommes codeurs. On maîtrise tous, à des degrés différents, l'outil informatique mais on est pas des experts de haut vol, juste des gens motivés pour faire le travail au mieux :)</p>
<p>Je me tourne vers vous pour avoir votre avis et savoir comment vous vous y prendriez pour faire une telle chose car je sèche un peu.</p>
<p>Merci d'avance pour votre aide et vos réponse. </p>
<p>Bonne journée</p>
<p>Olivier</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/creation-de-procedures-en-texte-simple.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/122088/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/creation-de-procedures-en-texte-simple#comments">ouvrir dans le navigateur</a>
</p>
Olivier LEMAIREhttps://linuxfr.org/nodes/122088/comments.atomtag:linuxfr.org,2005:Post/412262020-06-11T16:28:14+02:002020-06-11T16:28:14+02:00ESP32 : envoyer du son vers un haut-parleur bluetooth<p>Bonjour,<br>
je cherche à envoyer du son (PCM, peu importe le format) depuis un ESP32 vers un haut-parleur bluetooth. Dans l'idéal ça fonctionnerait avec le framework arduino sous platformio :)<br>
J'ai fouillé pas mal de trucs, j'ai essayé des exemples en allant voir dans les headers car certains trucs ne correspondaient pas à la doc officielle (pas la même version sans doute), etc.<br>
Là j'ai un truc qui compile avec arduino, mais la fonction <em>esp_bt_controller_init</em> me retourne un code d'erreur 259 sur le moniteur série.<br>
Je soupçonne le fait qu'on ne puisse pas aller configurer le bluetooth avec <em>make menuconfig</em> comme dans ESP-IDF. Mais je ne suis pas sûr du tout…</p>
<p>Au lieu d'avoir un haut parleur branché sur le DAC 8 bits de l'esp32, je voudrais juste que ça passe par le bluetooth.<br>
Pour le DAC, on utilise dacWrite, ça prend une ligne de code. Mais le bluetooth ça prend des jours :(</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/esp32-envoyer-du-son-vers-un-haut-parleur-bluetooth.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/120756/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/esp32-envoyer-du-son-vers-un-haut-parleur-bluetooth#comments">ouvrir dans le navigateur</a>
</p>
max22https://linuxfr.org/nodes/120756/comments.atomtag:linuxfr.org,2005:Post/412232020-06-10T20:49:23+02:002020-06-10T20:52:15+02:00Bizarrerie opérateur ternaire (?:)<p>Je suis tombé sur un comportement concernant l'opérateur ternaire C++ (<code>?:</code>) qui (me) semble bizarre. Il est peut-être tout à fait normal, compte tenu que trois compilateurs différents ont le même comportement, mais je ne trouve pas d'explication satisfaisante.</p>
<p>Il porte sur le passage, en tant que paramètres d'un opérateur ternaire, d'un objet déjà instancié, et de l'instanciation à la volée d'un objet du même type. Le destructeur de l'objet déjà instancié est appelé à priori sans que cela ai lieu d'être.</p>
<p>Voici le source d'un programme mettant ce comportement en exergue :</p>
<pre><code class="C++"><span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="k">class</span> <span class="nc">my_class</span> <span class="p">{</span>
<span class="k">protected</span><span class="o">:</span>
<span class="kt">char</span> <span class="n">c_</span><span class="p">;</span>
<span class="k">public</span><span class="o">:</span>
<span class="n">my_class</span><span class="p">(</span><span class="kt">char</span> <span class="n">c</span><span class="p">)</span> <span class="p">{</span>
<span class="n">c_</span> <span class="o">=</span> <span class="n">c</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Ctor: "</span> <span class="o"><<</span> <span class="n">c_</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">flush</span><span class="p">;</span>
<span class="p">}</span>
<span class="o">~</span><span class="n">my_class</span><span class="p">()</span> <span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"Dtor: "</span> <span class="o"><<</span> <span class="n">c_</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">flush</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">};</span>
<span class="cp">#define M(e)\</span>
<span class="cp"> std::cout << std::endl << "true ? " << #e << std::endl << std::flush;\</span>
<span class="cp"> (true ? e)</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span> <span class="p">{</span>
<span class="n">my_class</span> <span class="n">A</span><span class="p">(</span><span class="sc">'A'</span><span class="p">),</span> <span class="n">B</span><span class="p">(</span><span class="sc">'B'</span><span class="p">);</span>
<span class="n">M</span><span class="p">(</span><span class="nl">A</span> <span class="p">:</span> <span class="n">B</span><span class="p">);</span>
<span class="n">M</span><span class="p">(</span> <span class="nl">A</span> <span class="p">:</span> <span class="n">my_class</span><span class="p">(</span><span class="sc">'C'</span><span class="p">)</span> <span class="p">);</span>
<span class="n">M</span><span class="p">(</span> <span class="n">my_class</span><span class="p">(</span><span class="sc">'D'</span><span class="p">)</span> <span class="o">:</span> <span class="n">A</span> <span class="p">);</span>
<span class="n">M</span><span class="p">(</span> <span class="n">my_class</span><span class="p">(</span><span class="sc">'E'</span><span class="p">)</span> <span class="o">:</span> <span class="n">my_class</span><span class="p">(</span><span class="sc">'F'</span><span class="p">)</span> <span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="s">"End"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">flush</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<p>Voici le résultat de ce programme. On y voit les paramètres de l'opérateur ternaire, et les éventuels appels aux constructeurs et/ou aux destructeurs.</p>
<p>Le texte <strong><em>en gras et italique</em></strong> est de mon fait, pour signaler là où je vois un problème.</p>
<blockquote>
<p>Ctor: A<br>
Ctor: B</p>
<p>true ? A : B</p>
<p>true ? A : my_class('C')<br>
Dtor: A <strong><em>--> Pourquoi le destructeur de l'objet <code>A</code> est-il appelé ?</em></strong></p>
<p>true ? my_class('D') : A<br>
Ctor: D<br>
Dtor: D</p>
<p>true ? my_class('E') : my_class('F')<br>
Ctor: E<br>
Dtor: E</p>
<p>End<br>
Dtor: B<br>
Dtor: A</p>
</blockquote>
<p>Si vous voulez constater ce comportement de visu, il suffit de suivre ce lien : <a href="https://repl.it/@AtlasTK/C-bug">https://repl.it/@AtlasTK/C-bug</a></p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/bizarrerie-operateur-ternaire.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/120744/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/bizarrerie-operateur-ternaire#comments">ouvrir dans le navigateur</a>
</p>
Claude SIMONhttps://linuxfr.org/nodes/120744/comments.atomtag:linuxfr.org,2005:Post/407212019-12-13T14:55:45+01:002019-12-13T16:10:17+01:00std::bind: réduire les arguments<p>Bonjour,</p>
<p>J’ai un système d’interface avec une fonction contenant 2 arguments, je voudrais envoyer vers une fonction avec 1 seul argument. Je sais le faire avec une lambda, mais y a t’il une possibilité avec <code>std::bind</code>. Je prends l’exemple pour <code>add</code> et <code>mult</code>.</p>
<pre><code class="c++"><span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><functional></span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">record_callback</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">function</span><span class="o"><</span><span class="kt">int</span><span class="p">(</span><span class="kt">int</span><span class="p">,</span><span class="kt">int</span><span class="p">)</span><span class="o">></span> <span class="n">callback</span><span class="p">,</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">int</span> <span class="n">b</span><span class="p">)</span>
<span class="p">{</span>
<span class="c1">// Real code here.</span>
<span class="k">return</span> <span class="n">callback</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">);</span>
<span class="p">}</span>
<span class="cm">/* a+b*c */</span>
<span class="kt">int</span> <span class="nf">formule</span><span class="p">(</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">int</span> <span class="n">b</span><span class="p">,</span> <span class="kt">int</span> <span class="n">c</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">return</span> <span class="n">a</span><span class="o">+</span><span class="n">b</span><span class="o">*</span><span class="n">c</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">id</span> <span class="p">(</span><span class="kt">int</span> <span class="n">a</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">return</span> <span class="n">a</span><span class="p">;</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="c1">// a + b * 1 == a + b</span>
<span class="k">auto</span> <span class="n">add</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="n">formule</span><span class="p">,</span><span class="n">std</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">_1</span><span class="p">,</span><span class="n">std</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">_2</span><span class="p">,</span><span class="mi">1</span><span class="p">);</span>
<span class="c1">// 0 + b * c == b * c</span>
<span class="k">auto</span> <span class="n">mult</span> <span class="o">=</span> <span class="n">std</span><span class="o">::</span><span class="n">bind</span><span class="p">(</span><span class="n">formule</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="n">std</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">_1</span><span class="p">,</span><span class="n">std</span><span class="o">::</span><span class="n">placeholders</span><span class="o">::</span><span class="n">_2</span><span class="p">);</span>
<span class="c1">// Comment définir avec std::bind ?</span>
<span class="c1">//auto add0_or_mult1 = std::bind(id,std::placeholders::_1,???);</span>
<span class="c1">// Implémentation avec lambda</span>
<span class="k">auto</span> <span class="n">add0_or_mult1</span> <span class="o">=</span> <span class="p">[](</span><span class="kt">int</span> <span class="n">a</span><span class="p">,</span> <span class="kt">int</span> <span class="n">b</span><span class="p">){</span><span class="k">return</span> <span class="n">id</span><span class="p">(</span><span class="n">a</span><span class="p">);};</span>
<span class="kt">int</span> <span class="n">a</span><span class="o">=</span><span class="mi">2</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">b</span><span class="o">=</span><span class="mi">3</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"add(a,b) = "</span> <span class="o"><<</span> <span class="n">add</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"mult(a,b) = "</span> <span class="o"><<</span> <span class="n">mult</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"add0_or_mult1(a,b) = "</span> <span class="o"><<</span> <span class="n">add0_or_mult1</span><span class="p">(</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">std</span><span class="o">::</span><span class="n">cout</span> <span class="o"><<</span> <span class="s">"add(a,b) = "</span> <span class="o"><<</span> <span class="n">record_callback</span><span class="p">(</span><span class="n">add</span><span class="p">,</span><span class="n">a</span><span class="p">,</span><span class="n">b</span><span class="p">)</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span></code></pre>
<p>Je n’ai finalement utilisé la fonction <code>record_callback</code> qu’une fois dans l’exemple. Mais voilà, je voudrais pouvoir définir <code>add0_or_mult1</code> en utilisant <code>std::bind</code> plutôt que la lambda.</p>
<p>Y-a-t’il une solution ?</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/std-bind-reduire-les-arguments.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118900/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/std-bind-reduire-les-arguments#comments">ouvrir dans le navigateur</a>
</p>
Anthony Jaguenaudhttps://linuxfr.org/nodes/118900/comments.atomtag:linuxfr.org,2005:Post/406682019-11-21T14:27:09+01:002019-11-21T14:27:09+01:00IDE C++ simple (pour remplacer jGRASP)<p>Bonjour,</p>
<p>On utilise jGRASP en cours pour apprendre le c++, mais je souhaiterais utiliser un IDE libre sur mon ordinateur personnel. Avez-vous un IDE à me conseiller ou déconseiller?</p>
<div><a href="https://linuxfr.org/forums/programmation-c/posts/ide-c-simple-pour-remplacer-jgrasp.epub">Télécharger ce contenu au format EPUB</a></div> <p>
<strong>Commentaires :</strong>
<a href="//linuxfr.org/nodes/118687/comments.atom">voir le flux Atom</a>
<a href="https://linuxfr.org/forums/programmation-c/posts/ide-c-simple-pour-remplacer-jgrasp#comments">ouvrir dans le navigateur</a>
</p>
tedhttps://linuxfr.org/nodes/118687/comments.atom