Depuis sa création, C++ a été le premier choix pour la création d'applications gourmandes en performances. Mais le langage comporte encore des pratiques obsolètes causées par sa « conception par comité ».

Le 19 juillet 2022, lors de la conférence CPP North C++ à Toronto, l'ingénieur Google Chandler Carruth a présenté Carbon.

Découvrez ce qu'est Carbon et comment il entend succéder au C++.

Qu'est-ce que le carbone ?

Les ingénieurs de Google ont développé le Carbone langage de programmation pour combler les lacunes de C++.

De nombreux existants des langues comme Golang et Rust existent déjà qui reflètent les performances de C++ sans ses défauts. Malheureusement, ces langages présentent des obstacles importants à la migration des bases de code C++ existantes.

Le carbone vise à être ce que TypeScript est à JavaScript, et Kotlin est à Java. Ce n'est pas un remplacement, mais un langage successeur conçu autour de l'interopérabilité avec C++. Il vise une adoption et une migration à grande échelle pour les bases de code et les développeurs existants.

instagram viewer

Principales caractéristiques du carbone

Certaines des fonctionnalités clés de Carbon incluent l'interopérabilité C++, les génériques modernes et la sécurité de la mémoire.

Interopérabilité avec C++

Carbon vise à fournir une courbe d'apprentissage en douceur aux développeurs C++, avec un ensemble standard et cohérent de constructions de langage.

Prenons par exemple ce code C++ :

// C++ :
#comprendre
#comprendre
#comprendre
#comprendre
structureCercle {
flotteur r;
};


annulerPrintTotalArea(std::envergure cercles){
flotteur zone = 0;


pour (constante Cercle& c: cercles) {
 aire += M_PI * c.r * c.r ;
 }


std::écoute << "Superficie totale: " << superficie << fin;
}


autoprincipale(entier argc, carboniser** argv) ->; entier {
std::vecteur cercles = {{1.0}, {2.0}};
// Construit implicitement `span` à partir de `vector`.
 PrintTotalArea (cercles);
revenir0;
}

Traduit en Carbone, il devient :

// Carbone :
forfait API de géométrie ;
importerMath;
classerCercle{
var r: f32 ;
}


fn PrintTotalArea(cercles: tranche (cercle)) {
var zone: f32 = 0;


for (c: Cercle dans cercles) {
 zone += Math.Pi * c.r * c.r ;
 }


Imprimer("Superficie totale: {0}", Région);
}


fn Principal() ->; i32 {
// Un tableau dimensionné dynamiquement, comme `std:: vector`.
var cercles: Déployer(Cercle) = ({.r = 1.0}, {.r = 2.0});
// Construit implicitement `Slice` à partir de `Array`.
 PrintTotalArea (cercles);
revenir0;
}

Vous pouvez également migrer une seule bibliothèque C++ vers Carbon dans une application ou ajouter un nouveau code Carbon en plus du code C++ existant. Par exemple:

// Code C++ utilisé à la fois dans Carbon et C++ :
structureCercle {
flotteur r;
};
// Carbon expose une fonction pour C++ :
paquet Geometry api;
importer bibliothèque cpp"cercle.h" ;
importer Math;


fn PrintTotalArea(cercles: Tranche (Cpp. Cercle)){
 zone var: f32 = 0;


pour (c: Cpp. Cercle dans les cercles) {
 aire += Math. Pi * c.r * c.r ;
 }


Imprimer("Surface totale: {0}", Région);
}


// C++ appelant Carbon :
#comprendre
#comprendre "cercle.h"
#comprendre "géométrie.carbone.h"


autoprincipale(entier argc, carboniser** argv) ->; entier {
std::vecteur cercles = {{1.0}, {2.0}};
// Le `Slice` de Carbon prend en charge la construction implicite à partir de `std:: vector`,
// similaire à `std:: span`.
 Géométrie:: PrintTotalArea (cercles);
revenir0;
}

Un système de génériques moderne

Carbon fournit un système de génériques moderne avec des définitions vérifiées. Mais il prend toujours en charge les modèles opt-in pour une interopérabilité C++ transparente.

Ce système de génériques offre de nombreux avantages aux templates C++ :

  • Vérifications de type pour les définitions génériques. Cela évite le coût au moment de la compilation de revérifier les définitions pour chaque instanciation.
  • Interfaces solides et contrôlées. Ceux-ci réduisent les dépendances accidentelles sur les détails de mise en œuvre et créent un contrat plus explicite.

Sécurité de la mémoire

Carbon cherche à résoudre la sécurité de la mémoire, un problème clé qui afflige C++, en :

  • Meilleur suivi des états non initialisés, renforcement de l'application de l'initialisation et renforcement contre les bogues d'initialisation.
  • Concevoir des API et des idiomes fondamentaux pour prendre en charge les contrôles de limites dynamiques dans les versions de débogage et renforcées.
  • Avoir un mode de construction de débogage par défaut qui est plus complet que les modes de construction existants de C++.

Premiers pas avec le carbone

Vous pouvez explorer Carbon dès maintenant en consultant la base de code et en utilisant l'explorateur Carbon :

# Installez bazelisk en utilisant Homebrew.
$ brew installer bazelisk
# Installez Clang/LLVM en utilisant Homebrew.
# De nombreuses versions de Clang/LLVM ne sont pas construites avec les options sur lesquelles nous comptons.
$ brasser installer llvm
$ exporter CHEMIN="$(brew --prefix llvm)/bin :${CHEMIN}"


# Téléchargez le code de Carbon.
$ git cloner https://github.com/carbon-language/carbon-lang
$ CD carbone-lang
# Construisez et exécutez l'explorateur.
$ bazel run //explorer -- ./explorer/testdata/imprimer/format_only.carbon

La feuille de route de Carbon révèle une réflexion à long terme

Selon la feuille de route Carbon, Google rendra l'expérience publique avec la sortie d'une version de travail de base (0.1) d'ici la fin de 2022. Ils prévoient de suivre cela avec une version 0.2 en 2023 et une version 1.0 complète en 2024-2025.

Reste à savoir si Google pourra reproduire le succès de ses autres langages, Golang et Kotlin.