Oliver a écrit 243 commentaires

image rectangulaire qui n'est pas détourée

Je ne suis pas sûr de comprendre de quelles images tu veux parler…
Peux-tu donner des exemple d'images carrés que tu aimerai voir détourées ?

Ce sondage est surtout pour donner des consignes aux rédacteurs qui créent de nouveaux dessins pour illustrer leur dépêche, et j'en fais parti.

Personnellement, j'hésite entre de beaux PNG mais qui pèsent un petit mégaoctet, ou du WebP qui permet le même rendu pour un poids 10 fois plus petit mais malheureusement Firefox ne le prend pas encore en charge, ou convertir en SVG mais le rendu du texte dépend des polices de caractères disponibles (sans parler que Firefox ne prend pas encore en charge les attributs letter-spacing et word-spacing) à moins de convertir le texte en chemin mais alors la taille du fichier est multipliée… ou aussi toutes les autres possibilités mentionnées dans ce sondage.

Jusqu'à maintenant, j'essayais de privilégier la taille des fichiers.

Pour une image matricielle, j'opte pour du PNG avec une palette de 4 ou 8 couleurs (couleurs indexées), un fond transparent sur un bit (pas de joli canal alpha en dégradé), et un contour blanc des traits noirs au cas où le CSS utiliserait un fond de couleur foncé. Voici un exemple :

Pour une image vectorielle, j'opte pour du SVG avec la police de caractères Purisa (maintenue par Theppitak Karoonboonyanan sous licence GPL2) car c'est la seule police de caractères sympathique qui est installée par défaut sur Ubuntu. Malheureusement, cette police n'est pas installée par défaut sur Fedora, ni Windows (pour ce que j'ai testé) et le dessin ne donne pas le même rendu. En plus, pour obtenir des SVG de petite taille, avec Inkscape, je vais dans le menu Fichier -> Nettoyer, puis j'enregistre en SVG Simple, puis j'utilise un script sed maison pour les arrondis, puis une passe avec le script python scour pour virer les trucs inutiles laissés par Inkscape, et enfin, je termine à la main en éditant directement le SVG. Voici un exemple dont vous pourrez admirer le code source :

Je remarque que de nombreux lecteurs veulent du beau PNG bien lourd ou du SVG. OK, je vais aller dans ce sens là.

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

La fonctionnalité "Inspect Element (Q)" de Firefox permet effectivement de montrer que le bouton est bien présent dans le HTML. Par contre, impossible de cliquer dessus.

Le seul contournement que j'ai trouvé et de rajouter /reorganize à la fin de l'URL.

Le bouton HTML a l'attribut unique class="reorganize".
Une solution pour afficher ce bouton à tout le monde consisterait à modifier le CSS pour afficher/activer ce bouton.

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Merci Jabbounet.
Oui c'est ça : du parlé hexadécimal :-)

Peux-tu nous fournir des exemples en langue française ?

Si tu trouves un moyen de les articuler ensemble pour faire des jeux de mots, alors tu auras une grande chance de gagner au concours.   ^-^

Bonne fêtes de fin d'année,
Et bonne inspiration à tous les participants

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Oui, tu as raison, une bonne façon de faire est de créer un Adaptateur. Mais le sujet de mon commentaire était de surligner l'intérêt des fonctions libres qui permettent d'étendre un objet de l'extérieur. Donc, j'avais volontairement omis les autres possibilités qui nécessitent plus de code, plus de relecture, plus de test, plus de maintenance… ;-) (bon oui, je l'accorde pas tellement plus)

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Je complète l’excellent commentaire de lmg HS pour indiquer que nous avons encore beaucoup de dépêches concernant C++17 à sortir, mais nous n'arrivons pas à tenir le rythme de rédaction de dépêches de qualité. Alors, n'hésitez pas à nous donner un coup de main comme lmg HS. Ne vous privez pas, on cherche à créer ces dépêches de qualité sous les noms des nouveaux contributeurs.

De mon côté, en parallèle du C++, j'ai déjà prévue une série de dépêches sur les Bons Tests Unitaires (C++/Java/Python/Go), sur les KISS/SOLID/…, sur CMake et d'autres sujets qui n'ont pas grand chose à voir comme le danger des brevets logiciels… Si un lecteur souhaite se lancer dans un sujet qui lui semble important, mon conseil et de commencer à apprendre par lui même, de prendre des notes, de la consolider, puis de les partager avec la communauté LinuxFr.org sous la forme d'une dépêche.

Pour ceux qui apprécient, CMake, les IDE libres et l’auto-complétion, sachez que CMake va embarquer un mode "serveur". C'est à dire que l'IDE pourra lancer ce "démon CMake" et lui envoyer des requêtes pour connaître des détails de compilation que seul CMake connaissait seul jusque là. Et c'est QtCreator-4.3 qui devrait être le premier IDE à en profiter. Conjugué aux améliorations de Clang pour la prochaine version, nous allons connaître une expérience "développeur assisté" que nous envions à nos amis Java/C#/Go/… Vive 2017 :-)

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

chuuuuuuuuut… faut pas l'dire que c'est une blague…
Car les blagues de "code source écrit bizarrement" sont exceptionnellement autorisées dans le cadre des jeux de mots de code source. Non ?
Vite vite, cliquons sur "inutile" pour faire disparaître ces messages ;-)

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Pas mal du tout, je rajouterai une petite contribution sur la dernière ligne : l'opérateur --> qui est valide en C

return (avenir --> C);

Pour info, l'opérateur --> veut dire "aller jusqu'à" :

int main()
{
    int C = 11;
    int D;
    while (C --> 0)
        D += C;
    return D;
}

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Très bonne idée l'arrière plan transparent.

Pour les fichiers PNG : Je vais laisser une aura blanche autours des traits noirs, et ce blanc va s'estomper (être de plus en plus transparent) au fur et à mesure de l'éloignement du trait noir. J'avais déjà fait cela pour du WebP, mais malheureusement Firefox ne prend pas encore en charge ce format :-(
https://github.com/cpp-frug/materials/blob/gh-pages/images/README.md#c17-sauve-une-%C3%A9coli%C3%A8re

Le choix va aussi dépendre de la taille du fichier. Actuellement j'arrive à produire des fichiers de quelques dizaines de Ko. Il ne faudrait pas que cela deviennent des centaines de Ko… J'ai été traumatisé par mon mobile qui essayait désespéramment de télécharger des images dans les transports parisiens !

Pour les fichiers SVG : Je mets, en arrière plan, un rectangle blanc de la taille de l'image avec opacity=30%. Et quand j'y pense, je rajoute un fin trait blanc autour des caractères…

Si vous avez des astuces, des techniques, des conseils… pour faire cela, merci de partager ;-)

Merci pour le retour d'expérience

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Je modifie mon dernier paragraphe :

Notons que std::optional a été adopté pour C++14, puis retiré, et en ce moment il est à nouveau adopté pour C++17, malgré de vives polémiques… Voir à ce propos le très bon journal de Guillaum (septembre 2016, CC BY-SA 4.0) :
http://linuxfr.org/users/guillaum/journaux/gestion-de-l-erreur-c-std-optional
Une dépêche plus complète sur ce sujet est prévue pour l'année prochaine ;-)

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Après une petite recherche, j'ai trouvé ce chapitre :
https://wg21.link/p0096#recs.removed

3.9 Features published and later removed

3.9.1 Features removed from C++14

Features in the first CD of C++14, subsequently removed to a Technical Specification

TS	Title
N3639	Runtime-sized arrays with automatic storage duration
N3672	A proposal to add a utility class to represent optional objects
N3662	C++ Dynamic Arrays

The intention is that an implementation which provides runtime-sized arrays as specified in the first CD should define __cpp_runtime_arrays as 201304. The expectation is that a later document specifying runtime-sized arrays will specify a different value for __cpp_runtime_arrays.

Donc ni les VLA, ni les std::dynarray, n'ont été intégrés au final dans C++14 (ni d'ailleurs dans C++17).

Notons que std::optional a été adopté pour C++14, puis retiré, et en ce moment il est à nouveau adopté pour C++17, malgré de vives polémiques… Une dépêche sur ce sujet est prévue pour l'année prochaine ;-)

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Espérons que d'autres lecteurs apprécient ces dessins car je passe beaucoup de temps à les retoucher sur GIMP pour m'assurer que l'arrière plan est bien blanc, réfléchir aux textes, les retoucher… c'est du temps en moins sur la dépêche.

Sur la prochaine dépêche, on demandera aux lecteurs de LinuxFr.org de donner leur avis (du moins, ceux qui ont un compte).

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Pour information, VLA est le nom pour le langage C. En C++, nous devrions dire Runtime-Sized Arrays.
Mais bon, VLA est le nom le plus connu. Même les membres du comité de normalisation du C++ disent VLA.
Du coup, moi aussi je dis VLA (ne multiplions pas les noms qui désignent un peu près la même chose).

En 2013, le comité a d'abord adopté les VLA (appelé Runtime-sized arrays with automatic storage duration)
https://isocpp.org/blog/2013/04/n3639-runtime-sized-arrays-with-automatic-storage-duration

Et puis finalement, retour en arrière. Il me semble que les VLA n'ont pas été intégrés car le risque est trop grand d'allouer plus d'espace que l'espace libre disponible dans la pile d'appel.

Par contre, le std::dynarray a bien été adopté pour C++14 et permet aussi d'allouer sur la pile.

Ce qu'il faut retenir, c'est que le comité de normalisation du C++ a tendance à ne pas intégrer ce qui est bugogène (error prone).

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

As-tu lu le paragraphe Notation ?

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Oui, c’est une très bonne idée.
Il faut absolument que tu nous donnes un coup de main pour nous aider en amont.
=> Lors de la rédaction des dépêches.
Rendez-vous sur cette page :
http://linuxfr.org/redaction/news/c-point-de-rassemblement-des-contributeurs-aux-depeches-c

David Marec a écrit :
D’après ce que j’ai compris, c++17 va garantir l’élision par défaut.

Et ne vend pas trop la mèche sur la prochaine dépêche, chut c’est une surprise ;-)

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Merci pour la coquille ;-)
As-tu des idées pour les illustrations ?
On ne sait pas dessiner (on débute) et on aimerait illustrer chaque dépêche avec un petit truc sympa.
Merci de nous aider à améliorer cet aspect esthétique des dépêches C++.

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Bonjour,

Merci pour tes encouragements.
Je ne sais pas si cela peut te rassurer, mais, nous non plus, nous ne connaissons pas grand chose à la norme C++.

Pour l’anecdote, un journaliste avait demandé à Bjarne Stroustrup, le fondateur du C++ et membre assidu du comité de normalisation du C++, quel était son niveau de connaissance de la norme. Il avait alors répondu 6 sur 10. Personnellement, je pense que la plupart des personnes qui se disent expert en C++ doivent avoir un niveau de connaissance inférieur à 20 %.

Pour te rassurer, sache que les membres du comité de normalisation font très attention à ne pas rajouter de complexité inutile au langage. Si une fonctionnalité peut entraîner de mauvaises pratiques de code, alors elle est retravaillée ou écartée. C’est par exemple, le cas du Variable Length Array présent dans le langage C, mais pas dans le C++. C’est aussi pourquoi certaines fonctionnalités très attendues sont encore et encore repoussées, comme import std.string; qui devrait devenir une alternative à #include <string>. La norme C++ se bonifie avec le temps, plus intuitive, moins de pièges.

Nous allons continuer nos petites dépêches pédagogiques afin de démystifier les template. Objectif pour le 30 novembre 2017 à minuit : ne plus en avoir peur.

N’hésite pas à nous donner un coup de main ;-)
(surtout si tu as envie de dessiner)

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Merci pour ton aide sur une dépêche en cours de rédaction :

• http://linuxfr.org/news/c-se-court-circuite-le-constructeur-par-copie
• http://linuxfr.org/news/le-c-17-garantit-le-court-circuit-du-constructeur-de-copie

Pour nous aider, le mieux est d'éditer directement ces dépêches.
N'hésite pas à corriger directement la dépêche quand tu es sûre de toi.
Sinon, tu peux écrire dans la dépêche quelque chose en Markdown comme cela :

------------------------------------------------------------------------------
------------------------------------------------------------------------------
TODO: Le paragraphe suivant me semble maladroit car ceci et cela
========================================================================
------------------------------------------------------------------------------
------------------------------------------------------------------------------
À mon avis, il faudrait plutôt écrire:
ceci
et cela

------------------------------------------------------------------------------
------------------------------------------------------------------------------

Ce qui s'affichera comme cela :

---

---

TODO: Le paragraphe suivant me semble maladroit car ceci et cela

---

---

À mon avis, il faudrait plutôt écrire:
ceci
et cela

---

---

Et si tu as vraiment la flegme, écris juste un message sur la tribune, c'est en haut à droite pour ceux qui ont un écran large.
Sur les petits écrans des téléphones portables, la tribune s'affiche en bas, après la dépêche.

Merci encore pour ton aide, nous en avons bien besoin ;-)
Oliver

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

On a calé sur la dépêche du court-circuit du constructeur par copie car on l'a reformulé à plusieurs reprises afin d'obtenir une dépêche à la fois pédagogique (facile à comprendre) et sans erreurs techniques (C++). Ces deux objectifs ne sont pas simples à atteindre, et ce serait cool si tu pouvais nous aider :
http://linuxfr.org/redaction/news/cpp17-court-circuite-le-constructeur-par-copie

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Oui, c'était disponible dans le standard C depuis le siècle dernier (C99).

Pour nourrir le troll, voici mon humour :

int C = NULL;
auto avenir  =   C + + 17   +    0xC00L;

Qui dit mieux ?

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Oui, tu as raison whity, merci. Je corrige :-)

Je résume le commentaire de lmg HS qui en bref disait que nous avons le choix entre :

• if constexpr pour du code simple ;
• plusieurs templates pour du code complexe mais ouvert/fermé.

Voici mon commentaire corrigé

if constexpr simplifie le code et tan pis pour le principe ouvert/fermé.
Car souvent, on préfère un code simple plutôt qu'un code complexe mais ouvert/fermé (évolutif).

L'idée est d'avoir un code simple, facile à comprendre, et le jour où on a vraiment besoin de le faire évoluer, et bien on le réécrit.
Le risque d'avoir un code complexe mais ouvert/fermé est de garder la complexité et de ne jamais profiter de son principe ouvert/fermé.

Je précise, je suis pour le principe ouvert/fermé, et c'est mieux quand on peu allier simplicité à ouvert/fermé.
Je dis juste que des fois (voir souvent) complexifier n'est pas justifié, vaut mieux avoir simple et risquer tout casser.

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Si j'ai bien compris, tu veux compiler un logiciel qui utilises __has_include(<header>) et tu ne veux pas que ce code source choisisse le <header> à inclure => tu veux forcer l'inclusion du <header> de ton choix et non pas que ce soit le code source qui gère cette décision.

Oui c'est possible, tu définis les chemins d'inclusion que tu souhaites. Par exemple, avec GCC et Clang, tu peux utiliser les options -I et -isystem (d'autres options sont disponibles pour contrôler l'inclusion des entêtes).

Est-ce que cela répond à ta question ?

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Par exemple, la fonction suivante ne fonctionne que pour les structures (classes) fournissant des fonctions membres recupere_x() et recupere_y().

template <typename T>
auto calcule (T objet)
{
  auto x = objet.recupere_x();
  auto y = objet.recupere_y();
  return (x+x) - (y*y);
}

Supposons que nous devions utiliser deux bibliothèques développées par deux entités différentes :

• Un bibliothèque fournit une structure (classe) qui ne possède pas les fonctions membres recupere_x() et recupere_y() ;
• La seconde bibliothèque fournit la fonction calcule.

On n'a pas la possibilité de modifier aucune des deux bibliothèques.
Comment faire pour passer la structure (classe) à la fonction calcule ?

---

Voyons maintenant, une implémentation de la fonction calcule utilisant cette fois-ci les fonctions libres :

template <typename T>
auto calcule (T objet)
{
  auto x = recupere_x(objet);
  auto y = recupere_y(objet);
  return (x+x) - (y*y);
}

Et c'est beaucoup plus facile de passer la structure (classe) à la fonction calcule(). Deux possibilités :

• les fonctions libres recupere_x() et recupere_y() sont déjà disponibles dans une bibliothèque ;
• ou bien nous devons les implémenter, ce qui est bien plus facile que l'exercice précédent.

C'est dans ce second paradigme que sont conçus beaucoup de langages récents comme Rust et Go.
Cela permet naturellement de respecter le principe ouvert/fermé.

---

Prenons un exemple dans un vieux langage… allez prenons Python qui doit avoir une trentaine d'années, et étudions sa fonction libre len() :

str = 'test'
r = len(str)  # retourne 4

Certains objets implémentent la fonction membre __len__() mais la convention est de passer par la fonction libre len().

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Petite précision : Si le static_assert() devait être introduit aujourd'hui dans le C++ il aurait été renommé en constexpr_assert() car en C++ on essaye de faire la distinction entre la (les) sémantique(s) portée(s) par le mot-clé static et celle de constexpr.

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

OK on rajoute ça dans le tuyau ;-)
On commencera par quelques petites dépêches sur la méta-programmation, puis on attaquera gentiment le SFINAE ^{^}
Mais soit patient, ça risque d'être pour l'année prochaine !

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)

Le code suivant est utilisé dans la dépêche, mais il est ambigu car on ne voit pas la différence au niveau de la déclaration des deux fonctions :

template<class T>
auto f(T x) -> decltype(std::enable_if_t<std::is_function_v<decltype(T::f)>,int>{})
{
  return x.f();
}

template<class T>
auto f(T x) -> decltype(std::enable_if_t<!std::is_function_v<decltype(T::f)>,int>{})
{
  return 0;
}

Merci à un modérateur de le remplacer par :

template<class T>
auto f(T x) -> decltype(std::enable_if_t<   std::is_function_v<decltype(T::f)>,int>{})
{                                      // ^---true si T::f existe et que c'est une fonction
  return x.f();
}

template<class T>
auto f(T x) -> decltype(std::enable_if_t< ! std::is_function_v<decltype(T::f)>,int>{})
{                                      // ^---le contraire
  return 0;
}

Commentaire sous licence Creative Commons Zero CC0 1.0 Universal (Public Domain Dedication)