Vi introducerar Carbon, Googles experimentella efterträdare för C++

Sedan starten har C++ varit det främsta valet för att bygga prestandaintensiva applikationer. Men språket har fortfarande några föråldrade metoder orsakade av dess "design av kommitté".

Den 19 juli 2022, under CPP North C++-konferensen i Toronto, introducerade Googles ingenjör Chandler Carruth Carbon.

Ta reda på vad Carbon är och hur det avser att lyckas med C++.

Vad är kol?

Googles ingenjörer utvecklade Kol programmeringsspråk för att åtgärda bristerna i C++.

Många existerar språk som Golang och Rust finns redan som speglar prestandan för C++ utan dess brister. Tyvärr utgör dessa språk betydande hinder för migreringen av befintliga C++-kodbaser.

Carbon syftar till att vara vad TypeScript är för JavaScript, och Kotlin är till Java. Det är inte en ersättning, utan ett efterföljande språk designat kring interoperabilitet med C++. Det syftar till storskalig adoption och migrering för befintliga kodbaser och utvecklare.

Nyckelegenskaper hos kol

Några av Carbons nyckelfunktioner inkluderar C++-kompatibilitet, moderna generika och minnessäkerhet.

Interoperabilitet med C++

Carbon syftar till att tillhandahålla en mjuk inlärningskurva för C++-utvecklare, med en standard, konsekvent uppsättning språkkonstruktioner.

Ta till exempel den här C++-koden:

// C++:
#omfatta
#omfatta
#omfatta
#omfatta
strukturCirkel {
flyta r;
};
tomhetPrintTotalArea(std::spänna cirklar){
flyta område = 0;
för (konst Cirkel& c: cirklar) {
 area += M_PI * c.r * c.r;
 }
std::cout << "Total area: " << area << endl;
}
bilhuvud(int argc, röding** argv) ->; int {
std::vektor cirklar = {{1.0}, {2.0}};
// Konstruerar implicit `span` från `vektor`.
 PrintTotalArea (cirklar);
lämna tillbaka0;
}

Översatt till Carbon blir det:

// Kol:
paket Geometri api;
importeraMatematik;
klassCirkel{
var r: f32;
}
fn PrintTotalArea(cirklar: Slice (Circle)) {
var area: f32 = 0;
för (c: Cirkel i cirklar) {
 område += Matematik.Pi * c.r * c.r;
 }
Skriva ut("Total yta: {0}", område);
}
fn Main() ->; i32 {
// En array med dynamisk storlek, som `std:: vector`.
var cirklar: Array(Cirkel) = ({.r = 1.0}, {.r = 2.0});
// Konstruerar implicit `Slice` från `Array`.
 PrintTotalArea (cirklar);
lämna tillbaka0;
}

Du kan också migrera ett enda C++-bibliotek till Carbon i en applikation eller lägga till ny Carbon-kod ovanpå befintlig C++-kod. Till exempel:

// C++-kod som används i både Carbon och C++:
strukturCirkel {
flyta r;
};
// Kol som exponerar en funktion för C++:
paket Geometry api;
importera Cpp bibliotek"cirkel.h";
importera Matematik;
fn PrintTotalArea(cirklar: Slice (Cpp. Cirkel)){
 var area: f32 = 0;
för (c: Cpp. Cirkel i cirklar) {
 area += Math. Pi * c.r * c.r;
 }
Skriv ut ("Total yta: {0}", område);
}
// C++ anropar Carbon:
#omfatta
#omfatta "cirkel.h"
#omfatta "geometry.carbon.h"
bilhuvud(int argc, röding** argv) ->; int {
std::vektor cirklar = {{1.0}, {2.0}};
// Carbons `Slice` stöder implicit konstruktion från `std:: vector`,
// liknande `std:: span`.
 Geometri:: PrintTotalArea (cirklar);
lämna tillbaka0;
}

Ett modernt generiskt system

Carbon tillhandahåller ett modernt generiskt system med kontrollerade definitioner. Men det stöder fortfarande opt-in-mallar för sömlös C++-kompatibilitet.

Detta generiska system ger många fördelar för C++-mallar:

• Typkontroller för generiska definitioner. Detta undviker kompileringskostnaden för att omkontrollera definitioner för varje instansiering.
• Starka, kontrollerade gränssnitt. Dessa minskar oavsiktligt beroende av implementeringsdetaljer och skapar ett mer explicit kontrakt.

Minnessäkerhet

Carbon försöker ta itu med minnessäkerhet, en nyckelfråga som plågar C++, genom att:

• Spåra oinitierade tillstånd bättre, öka tillämpningen av initiering och hårdare mot initialiseringsbuggar.
• Utformning av grundläggande API: er och idiom för att stödja dynamiska gränskontroller i felsökning och förstärkta builds.
• Att ha ett standardfelsökningsbyggläge som är mer omfattande än C++s befintliga bygglägen.

Komma igång med kol

Du kan utforska Carbon just nu genom att kolla in kodbasen och använda Carbon Explorer:

# Installera bazelisk med Homebrew.
$ brew installera bazelisk
# Installera Clang/LLVM med Homebrew.
# Många Clang/LLVM-utgåvor är inte byggda med alternativ som vi litar på.
$ brew installera llvm
$ exportera PATH="$(brew --prefix llvm)/bin:${PATH}"
# Ladda ner Carbons kod.
$ git klona https://github.com/carbon-language/carbon-lang
$ CD kol-lang
# Bygg och kör utforskaren.
$ bazel run //explorer -- ./explorer/testdata/skriva ut/format_only.carbon

Carbons färdplan avslöjar långsiktigt tänkande

Enligt Carbon roadmap kommer Google att göra experimentet offentligt med släppet av en kärnarbetande version (0.1) i slutet av 2022. De planerar att följa detta med en 0.2-version 2023 och en fullständig 1.0-version 2024–2025.

Om Google kommer att kunna återskapa framgångarna för deras andra språk, Golang och Kotlin, återstår att se.