Siden starten har C++ vært det første valget for å bygge ytelsesintensive applikasjoner. Men språket har fortsatt noen utdaterte praksiser forårsaket av dets "design av komité".

19. juli 2022, under CPP North C++-konferansen i Toronto, introduserte Google-ingeniøren Chandler Carruth Carbon.

Finn ut hva Carbon er og hvordan det har til hensikt å lykkes med C++.

Hva er karbon?

Google-ingeniører utviklet Karbon programmeringsspråk for å løse manglene ved C++.

Mange eksisterende språk som Golang og Rust eksisterer allerede som gjenspeiler ytelsen til C++ uten dens mangler. Dessverre utgjør disse språkene betydelige barrierer for migrering av eksisterende C++-kodebaser.

Karbon har som mål å være hva TypeScript er for JavaScript, og Kotlin er til Java. Det er ikke en erstatning, men et etterfølgerspråk designet rundt interoperabilitet med C++. Det tar sikte på storskala adopsjon og migrering for eksisterende kodebaser og utviklere.

Nøkkelegenskapene til karbon

Noen av Carbons nøkkelfunksjoner inkluderer C++ interoperabilitet, moderne generikk og minnesikkerhet.

Interoperabilitet med C++

Carbon har som mål å gi en skånsom læringskurve for C++-utviklere, med et standard, konsistent sett med språkkonstruksjoner.

Ta for eksempel denne C++-koden:

// C++:
#inkludere
#inkludere
#inkludere
#inkludere
strukturSirkel {
flyte r;
};


tomromPrintTotalArea(std:: span sirkler){
flyte område = 0;


til (konst Sirkel& c: sirkler) {
 område += M_PI * c.r * c.r;
 }


std::cout << "Totalt område: " << område << endl;
}


autohoved-(int argc, røye** argv) ->; int {
std::vektor sirkler = {{1.0}, {2.0}};
// Konstruerer implisitt `span` fra `vektor`.
 PrintTotalArea (sirkler);
komme tilbake0;
}

Oversatt til Carbon blir det:

// Karbon:
pakke Geometri API;
importMatte;
klasseSirkel{
var r: f32;
}


fn PrintTotalArea(sirkler: Slice (sirkel)) {
var område: f32 = 0;


for (c: Sirkel i sirkler) {
 område += Matte.Pi * c.r * c.r;
 }


Skrive ut("Totalt areal: {0}", område);
}


fn Hoved() ->; i32 {
// En matrise med dynamisk størrelse, som `std:: vektor`.
var sirkler: Array(Sirkel) = ({.r = 1.0}, {.r = 2.0});
// Konstruerer implisitt `Slice` fra `Array`.
 PrintTotalArea (sirkler);
komme tilbake0;
}

Du kan også migrere et enkelt C++-bibliotek til Carbon i en applikasjon eller legge til ny Carbon-kode på toppen av eksisterende C++-kode. For eksempel:

// C++-kode brukt i både Carbon og C++:
strukturSirkel {
flyte r;
};
// Karbon som eksponerer en funksjon for C++:
pakken Geometri api;
import Cpp-bibliotek"sirkel.h";
import Matte;


fn PrintTotalArea(sirkler: Slice (Cpp. Sirkel)){
 var område: f32 = 0;


til (c: Cpp. Sirkel i sirkler) {
 område += Matematikk. Pi * c.r * c.r;
 }


Print("Totalt areal: {0}", område);
}


// C++ kaller Carbon:
#inkludere
#inkludere "sirkel.h"
#inkludere "geometri.karbon.h"


autohoved-(int argc, røye** argv) ->; int {
std::vektor sirkler = {{1.0}, {2.0}};
// Carbons `Slice` støtter implisitt konstruksjon fra `std:: vector`,
// ligner på `std:: span`.
 Geometri:: PrintTotalArea (sirkler);
komme tilbake0;
}

Et moderne generisk system

Carbon gir et moderne generisk system med sjekkede definisjoner. Men den støtter fortsatt opt-in maler for sømløs C++ interoperabilitet.

Dette generiske systemet gir mange fordeler til C++-maler:

  • Typesjekker for generiske definisjoner. Dette unngår kompileringstidskostnadene ved å kontrollere definisjoner på nytt for hver instansiering.
  • Sterke, kontrollerte grensesnitt. Disse reduserer utilsiktede avhengigheter av implementeringsdetaljer og skaper en mer eksplisitt kontrakt.

Minnesikkerhet

Carbon søker å adressere minnesikkerhet, et nøkkelproblem som plager C++, ved å:

  • Spore uinitialiserte tilstander bedre, øker håndhevelsen av initialisering og herding mot initialiseringsfeil.
  • Utforming av grunnleggende API-er og idiomer for å støtte dynamiske grensekontroller i feilsøking og herdede bygg.
  • Å ha en standard debug byggemodus som er mer omfattende enn C++s eksisterende byggemoduser.

Komme i gang med karbon

Du kan utforske Carbon akkurat nå ved å sjekke ut kodebasen og bruke Carbon Explorer:

# Installer bazelisk med Homebrew.
$ brew install bazelisk
# Installer Clang/LLVM med Homebrew.
# Mange Clang/LLVM-utgivelser er ikke bygget med alternativer vi stoler på.
$ brew install llvm
$ eksport PATH="$(brew --prefix llvm)/bin:${PATH}"


# Last ned Carbons kode.
$ git klone https://github.com/carbon-language/carbon-lang
$ cd karbon-lang
# Bygg og kjør utforskeren.
$ bazel run //explorer -- ./explorer/testdata/skrive ut/format_only.carbon

Carbons veikart avslører langsiktig tenkning

I følge Carbon roadmap vil Google gjøre eksperimentet offentlig med utgivelsen av en kjernearbeidsversjon (0.1) innen utgangen av 2022. De planlegger å følge dette med en 0.2-versjon i 2023 og en full 1.0-utgivelse i 2024–2025.

Om Google klarer å gjenskape suksessen til deres andre språk, Golang og Kotlin, gjenstår å se.