C++

L'avenir de C ++ / CLI et de .NET Core 3

Soumis par fredericmazue le

A l'occasion de la disponibilité de .NET Core 3, de nombreux développeurs se sont interrogés en ce qui concerne l'avenir de C++/CLI. Dans un billet, Microsoft leur répond.

Premièrement, nous souhaitons que tout le monde sache que nous sommes déterminés à prendre en charge C ++ / CLI pour .NET Core pour permettre une interopérabilité aisée entre les bases de code C ++ et les technologies .NE T telles que WPF et Windows Forms

Microsoft précise que cette prise en charge n'est pas prêt avec .NET Core 3. Elle le sera avec .NET Core 3.1, qui sera livré avec Visual Studio 2019 16.4.

Microsoft précise encore : C ++ / CLI aura un support IDE complet pour cibler .NET Core 3.1 et supérieur. Cette assistance comprendra des projets, IntelliSense et le débogage en mode mixte (IJW) sous Windows. Mais nous n'avons pas encore de plans pour C ++ / CLI pour cibler macOS ou Linux. De plus, la compilation avec “/ clr: pure” et “/ clr: safe” ne sera pas prise en charge pour .NET Core.

Sortie de CLion 2019.1

Soumis par fredericmazue le
IDE
Image

Encore une nouvelle version majeure d'un IDE de JetBrains. CLion est un environnement de développement intégré dédié aux langages C et C++.

CLion est un outil 'à la JetBrains', dans lequel on remarque son analyse de code à la volée qui détecte les problèmes potentiels et son analyse de flux qui permet de détecter du code inaccessible ou des récursions infinies. CLion, c'est aussi un débogage facile avec GDB ou LLDB pour du débogage local ou à distance.

La nouvelle mouture CLion 2019.1 est très riche, comme pour toutes les moutures 2019.1 de JetBrains. Nous remarquons notamment un éditeur plus réactif grâce à une intégration plus poussée du moteur Clangd. JetBrains a aussi réduit le temps d’indexation initial lorsque vous créez un projet ou l’ouvrez pour la première fois. L’idée générale est que CLion peut désormais réutiliser les symboles déjà créés pour d’autres projets ouverts récemment, à condition qu’ils soient adaptés au projet en cours. Les bibliothèques STL ou Boost sont des cas typiques.

En ce qui concerne le développement embarqué, si vous développez du code pour les cartes STMicroelectronics, vous serez heureux d’apprendre que CLion s’intègre désormais avec STM32CubeMX :

  • Le nouvel assistant de projet de CLion vous suggère de créer un projet STM32CubeMX (.ioc) ou vous pouvez ouvrir un projet existant de ce type dans CLion.
  • Par la suite, vous pouvez démarrer STM32CubeMX directement depuis CLion à tout moment pour mettre à jour les paramètres de la carte et générer du code.
  • CLion génère également le fichier CMake adapté à votre projet .ioc et vous demande de sélectionner la configuration de la carte.

Pour ceux qui aiment le code bien formaté, ClangFormat est désormais intégré dans CLion. Ainsi, lorsque vous ouvrez ce type de projet dans CLion, l’EDI détecte le fichier de configuration .clang-format et propose de basculer vers ClangFormat.

Clion 2019.1 améliore aussi beaucoup le débogage. Vous pouvez désormais faire un dump de mémoire brute derrière un pointeur en cours de débogage. Par ailleurs, si vous ouvrez une vue de la mémoire pendant le débogage vous pouvez suivre les modifications apportées à la mémoire pendant l’exécution étape par étape.

CLion 2019.1 est disponible pour Windows, Linux et macOS. Il peut être téléchargé depuis son site officiel. Les versions d'évaluation sont valables 30 jours.

Les fonctionnalités de C++20 sont définies

Soumis par fredericmazue le

Après une réunion parmi les plus grandes en 29 ans d'histoire, le comité ISO C++ a figé les fonctionnalités de C++20 nous apprend un billet d'Herb Sutter, gourou du C++.

Selon Herb Sutter, les deux fonctionnalités les plus importantes du standard C++20 sont les modules et les coroutines. Les modules constituent une nouvelle alternative aux fichiers d’en-tête qui apporte un certain nombre d’améliorations clés, notamment en isolant les effets des macros et en permettant des compilations évolutives, explique Herb qui ajoute qu'en 35 ans c'est première fois que C ++ ajoute une nouvelle fonctionnalité permettant aux utilisateurs de définir une limite d’encapsulation nommée.

Les coroutines sont elles aussi une fonctionnalité à remarquer. Une coroutine est une unité de traitement qui s'apparente à une fonction (ou routine) avec cette différence que si une sortie du corps d'une fonction met fin à l'exécution de celle-ci, la sortie de la coroutine suspend seulement son traitement qui peut ensuite reprendre, l'état du traitement à la sortie étant conservée. Une coroutine peut être vue comme un morceau de programme qui conserve son état, mais qui n'a pas de thread d'exécution. Les coroutines peuvent notamment être utilisées pour des itérateurs et des générateurs.

Par exemple, soit une coroutine en pseudo code :

function Generator() {
  for (i = 0 to 100)
    produce i
} 

Cette coroutine peut être implémentée et utilisée comme ceci en C++20

#include <iostream>

template <typename T>
generator<int> range(T first, T last)
{
  while (first != last)
  {
    co_yield first++;
  }
}


int main()
{
  for (int i : range(0, 100))
  {
    std::cout << i << std::endl;
  }
  return 0;
}

Les coroutines ne se résument pas à un simple générateur. Il est possible d'attendre une coroutine dans une coroutine avec l'instruction co_yield, ce qui permet de définir une logique entre plusieurs coroutines.

Le premier brouillon (draft) de la spécification C++20 doit être publié en juillet 2019. GCC à partir de sa version 8.1 et Visual Studio 2019 propose déjà un premier support expérimental de C++20.

JSCPP : un interpréteur C++ écrit en JavaScript

Soumis par fredericmazue le

Il s'agit d'un interpréteur développé pour un cours MOOC, donc au départ uniquement à des fins pédagogiques. Partant du constat que jusque là, pour mettre un environnement d'exécution C++ en ligne il était nécessaire d'utiliser des serveurs compilant le code C++ à exécuter, l'auteur propose JSCPP, un interpréteur C++ qui peut travailler avec un serveur node.js, ou même de manière totalement autonome dans un navigateur.

JSCPP est un interpréteur C++ écrit en JavaScript. Certes en l'état, il est bien loin de prendre en charge l'intégralité du standard C++, mais il a le mérite d'exister et une utilisation dans un cadre pédagogique, disons pour prendre contact avec C++ sans devoir compiler du code à chaque fois paraît intéressante.

Obtenir un navigateur qui interprète du C++ est tout simple. On doit simplement charger le code JavaScript de l'interpréteur et mettre C++ à interpréter dans une chaine de caractère. Par exemple comme ceci :

<script src="JSCPP.es5.min.js"></script>
<script type="text/javascript">
           var code =            "#include <iostream>"+
                                            "using namespace std;"+
                                            "int main() {"+
                                            "    int a;"+
                                            "    cin >> a;"+
                                            "    cout << a << endl;"+
                                           "    return 0;"+
                                            "}"
           ;
           var input = "4321";
           var output = "";
           var config = {
                      stdio: {
                                 write: function(s) {
                                            output += s;
                                 }
                      }
           };
           var exitCode = JSCPP.run(code, input, config);
           alert(output + "\nprogram exited with code " + exitCode);
</script>

Cette approche permet de modifier le code C++ dans le navigateur et de tester immédiatement le résultat.  

Une démonstration en ligne de JSCPP est disponible ici.

JSCPP est open source. Son code est disponible sur GitHub.

Sortie de GCC 8.1

Soumis par fredericmazue le

L'équipe du célèbre compilateur GNU GCC vient d'annoncer la sortie de la version 8.1 stable. Il s'agit d'une version majeure en raison du nombre de ses apports.

Notamment le frontal C++ supporte quelques-unes des nouvelles fonctionnalités du standard à venir C++ 2a. Pour activer ce support, il faut donner les commutateurs -std=c++2a et -std=gnu++2a lors de la compilation. De son côté, la bibliothèque standard (libstdc++) implémente quelques-unes des fonctionnalités des drafts des standards C++17 et C++ 2a.

Le compilateur supporte de nouveaux processeurs et architectures :

  • Cannonlake, la génération de processeurs Intel succédant à Coffee Lake / Kaby Lake Refresh
  • Icelake, la génération de processeurs Intel qui suivra CannonLake
  • Qualcomm Saphira, microarchitecture qui succède à Falkor
  • Armv8.4-A
  • ARM Cortex-A75 et ARM Cortex-A55 

En revanche, GCC 8.1 ne supporte plus la programamtion parallèle avec Cilk Plus, cette technologie étant dépréciée par Intel depuis l'année dernière.

Toutes les nouveautés de GCC 8.1 sont récapitulées dans sa note de version.

Le standard C++17 est officialisé

Soumis par fredericmazue le

Depuis le moi de mai de cette année, la norme C++17 du langage C++ était complète. Son officialisation était attendue pour la fin de cette année. C'est désormais chose faite. La nouvelle norme s'appelle SO/IEC 14882:2017. Elle est disponible sur iso.org.

C++17, pendant un temps appelé C++1z, est une évolution majeure du langage, comme l'ont été C++11 et C++98 en leur temps.

C++17 veut faire de C++ un langage moins lourd, plus facile à manier dans certaines situations, et plus moderne. Pour prendre un exemple, la nouvelle construction if-constexpr permet d'éviter de se lancer dans la grosse meta-programmation à base de templates.

Avant, pour obtenir le nième élément d'une liste variadique générique, il fallait écrire ceci.

template<unsigned n>
                           struct Arg {
                            template<class X, class...Xs>
                            constexpr auto operator()(X x, Xs...xs) {
                              return Arg<n - 1>{}(xs...);
                            }
                           };                          

template<>
                           struct Arg<0> {
                            template<class X, class...Xs>
                            constexpr auto operator()(X x, Xs...) {
                              return x;
                            }
                           };

                          

template<unsigned n>                       
                           constexpr auto arg = Arg<n>{};                          

// arg<2>(0, 1, 2, 3, 4, 5) == 2

Avec C++17, le code devient :

template<unsigned n>
                           struct Get {
                            template<class X, class…Xs>
                            constexpr auto operator()(X x, Xs…xs) {
                              if constexpr(n > sizeof…(xs) ) {
                                return;
                              } else if constexpr(n > 0) {

                                return Get<n-1>{}(xs…);
                              } else {

                                return x;
                              }
                            }
                           };

C++17 apporte de nouvelles fonctionnalités très intéressantes. Par exemple le support des caractères littéraux au format Unicode 8 bits, les variables inline, les expressions de réductions (fold expressions), les liaisons structurées (structured bindings) la parallélisation des algorithmes de la bibliothèque standard STL, etc.

La liste des nouveautés du langage peut être consultée ici.

Côté compilateur, GCC et LLVM/Clang offrent déjà un support complet de C++17. Microsoft travaille activement à la prise en charge du nouveau standard dans Visual Studio 2017, donc la version 15.5 en supporte déjà une grande partie.

SILKAN lance eVariX, un compilateur Matlab/Scilab vers C++

Soumis par fredericmazue le

SILKAN présente eVariX, un compilateur qui transforme automatiquement les scripts Matlab et Scilab en codes C++ optimisés et parallélisés. L'éditeur assure que par ce moyen l'exécution est plusieurs centaines de fois plus rapide.

eVariX permet à l’ingénieur métier de disposer à tout moment d’un exécutable autonome implémentant son modèle : il peut évaluer ce dernier en situation représentative sans jamais sortir du langage Matlab.

eVariX est disponible sur Windows et Linux et, jusqu’en décembre 2017, accessible gratuitement pour évaluation sur www.evarix.eu

Firefox 52 supporte WebAssembly

Soumis par fredericmazue le

La fondation Mozilla vient de publier Firefox 52, une mouture de son navigateur riche en nouveautés comme à chaque fois, mais qui se fait tout particulièrement remarquer par le support de WebAssembly.

JavaScript le langage commun à tous les navigateurs, est un souci constant. Prévu au départ pour de petits scripts d'accompagnement des pages web, par exemple pour vérifier la validité de la saisie dans un formulaire, JavaScript pose des problèmes de sûreté au niveau de la programmation et des performances pour les gros projets. Que dire alors des jeux 3D qui veulent décoiffer ?

De nombreuses tentatives ont été faites pour remédier à ces problèmes. En ce qui concerne les performances brutes, WebAssembly est une initiative très intéressante. Contrairement à de nombreux projets, WebAssembly ne se pose pas en remplaçant de JavaScript mais plutôt en un complément. WebAssembly est un projet open source sur GitHub, auquel Google et Microsoft participent, aux côtés de Mozilla.

WebAssembly ou wasm est un format de fichier binaire généré par un compilateur et destiné à être exécuté dans les navigateurs, avec des performances proches du code natif. Un fichier wasm contient d'une part un code-byte annoncé comme au moins 20 fois plus rapide à parser que du code asm.js et des informations de débogage d'autre part. Il est donc théoriquement possible de déboguer une application wasm après compilation.

La compilation, quant à elle, convertit le code source d'un langage en ce byte-code wasm. Pour l'instant il s'agit de code C/C++, mais de nombreux autres langages devraient être supportés ultérieurement. Rust, Go  et C# les langages maisons des trois contributeurs, sont pressentis au moins.

Comment cela passe-t-il si un navigateur ne supporte pas wasm ? Le projet WebAssembly inclut le développement d'une libraire polyfill qui convertira le code-byte wasm en JavaScript. Même dans ces conditions le gain de performances apporté par wasm doit être non négligeable. Toutefois cette solution 'compliquée' ne doit être que temporaire. L'idée directrice du projet est que wasm soit supporté à relativemenr court terme par tous les navigateurs. 

Firefox 52 est le premier des navigateurs à supporter officiellement WebAssembly.

Vous pouvez en apprendre plus sur WebAssembly avec la première vidéo ci-dessous, ou vous faire une idée de ses performances en regardant la deuxième video ci-dessous, qui est une démonstration de WebAssembly publiée au mois de mars de l'année dernière.

[video:https://www.youtube.com/watch?v=MaJCfdmr9Wg autoplay:0]

[video:https://www.youtube.com/watch?v=hSeB9I_mK6A autoplay:0]

Visual Studio 2015 Update 2 : un support de C++ amélioré

Soumis par fredericmazue le

A la fin du mois de mars, Microsoft a rendu disponible Visual Studio 2015 Update 2. 

Cette mouture apporte comme il se doit de nombreuses améliorations, parmi lesquelles nous remarquons un support de C++ amélioré.

Le compilateur C++, mis à jour, supporte C++11 et C++14, ainsi que certaines fonctionnalités de C++17 dont Microsoft s'attend à ce qu'elles fassent partie du prochain standard. Dans ce dernier cas il s'agit d'un support préliminaire, donc expérimental.

Le compilateur de Visual Studio 2015 Update 2 supporte les Variable Templates et les constexpr. La déclaration constexpr permet d'évaluer une variable ou une fonction au moment de la compilation.

Par ailleurs le support des coroutines atteint une qualité convenant au code de production. Les coroutines à la différence des routines qui suspendent le flux d'exécution principal de l'application jusqu'à la fin de leur traitement, peuvent suspendre leur exécution en gardant leur contexte pour reprendre plus tard. Ce qui permet un contrôle du flux d'exécution d'une application beaucoup plus riche.