De la începuturile sale, C++ a fost alegerea principală pentru construirea de aplicații cu performanță intensivă. Dar limbajul prezintă încă unele practici învechite cauzate de „proiectarea sa de către comitet”.

Pe 19 iulie 2022, în timpul conferinței CPP North C++ din Toronto, inginerul Google Chandler Carruth a prezentat Carbon.

Aflați ce este Carbon și cum intenționează să reușească C++.

Ce este Carbonul?

Inginerii Google au dezvoltat Carbon limbaj de programare pentru a rezolva deficiențele C++.

Multe existente limbi precum Golang și Rust există deja care oglindesc performanța C++ fără deficiențele sale. Din păcate, aceste limbaje prezintă bariere semnificative în migrarea bazelor de cod C++ existente.

Carbonul își propune să fie ce este TypeScript pentru JavaScript, iar Kotlin este la Java. Nu este un înlocuitor, ci un limbaj succesor conceput în jurul interoperabilității cu C++. Acesta vizează adoptarea și migrarea pe scară largă pentru bazele de cod și dezvoltatorii existente.

Caracteristicile cheie ale carbonului

instagram viewer

Unele dintre caracteristicile cheie ale Carbon includ interoperabilitatea C++, generice moderne și siguranța memoriei.

Interoperabilitate cu C++

Carbon își propune să ofere o curbă de învățare blândă pentru dezvoltatorii C++, cu un set standard și consistent de constructe de limbaj.

De exemplu, luați acest cod C++:

// C++:
#include
#include
#include
#include
structCerc {
pluti r;
};


golPrintTotalArea(std::span cercuri){
pluti zona = 0;


pentru (const Cerc& c: cercuri) {
 aria += M_PI * c.r * c.r;
 }


std::cout << "Zona totală: " << zonă << endl;
}


autoprincipal(int argc, char** argv) ->; int {
std::vector cercuri = {{1.0}, {2.0}};
// Construiește implicit `span` din `vector`.
 PrintTotalArea (cercuri);
întoarcere0;
}

Tradus în carbon, devine:

// Carbon:
pachet Geometrie api;
importMatematică;
clasăCerc{
var r: f32;
}


fn PrintTotalArea(cercuri: felie (cerc)) {
var zona: f32 = 0;


pentru (c: Cerc în cercuri) {
 zona += Matematică.Pi * c.r * c.r;
 }


Imprimare("Suprafața totală: {0}", zona);
}


fn Principal() ->; i32 {
// O matrice cu dimensiuni dinamice, cum ar fi `std:: vector`.
var cercuri: Matrice(Cerc) = ({.r = 1.0}, {.r = 2.0});
// Construiește implicit `Slice` din `Array`.
 PrintTotalArea (cercuri);
întoarcere0;
}

De asemenea, puteți migra o singură bibliotecă C++ la Carbon într-o aplicație sau puteți adăuga cod Carbon nou peste codul C++ existent. De exemplu:

// Cod C++ folosit atât în ​​Carbon cât și în C++:
structCerc {
pluti r;
};
// Carbon care expune o funcție pentru C++:
pachet Geometry api;
import biblioteca Cpp "cerc.h";
import matematică;


fn PrintTotalArea(cercuri: felie (Cpp. Cerc)){
 zona var: f32 = 0;


pentru (c: Cpp. Cercuri în cercuri) {
 zonă += Matematică. Pi * c.r * c.r;
 }


Print("Suprafața totală: {0}", zonă);
}


// C++ apelând Carbon:
#include
#include "cerc.h"
#include „geometrie.carbon.h”


autoprincipal(int argc, char** argv) ->; int {
std::vector cercuri = {{1.0}, {2.0}};
// `Slice` al lui Carbon acceptă construcția implicită din `std:: vector`,
// similar cu `std:: span`.
 Geometrie:: PrintTotalArea (cercuri);
întoarcere0;
}

Un sistem generic modern

Carbon oferă un sistem modern de generice cu definiții verificate. Dar încă acceptă șabloanele de înscriere pentru interoperabilitate C++ fără întreruperi.

Acest sistem generic oferă o mulțime de avantaje șabloanelor C++:

  • Verificări de tip pentru definiții generice. Acest lucru evită costul de compilare al verificării definițiilor pentru fiecare instanțiere.
  • Interfețe puternice, verificate. Acestea reduc dependențele accidentale de detaliile implementării și creează un contract mai explicit.

Siguranța memoriei

Carbon încearcă să abordeze siguranța memoriei, o problemă cheie care afectează C++, prin:

  • Urmărirea mai bună a stărilor neinițializate, sporind aplicarea inițializării și întărirea împotriva erorilor de inițializare.
  • Proiectarea de API-uri și idiomuri fundamentale pentru a suporta verificări dinamice ale limitelor în versiunile de depanare și întărite.
  • Având un mod implicit de compilare de depanare care este mai cuprinzător decât modurile de compilare existente ale C++.

Începeți cu Carbon

Puteți explora Carbon chiar acum, verificând baza de cod și utilizând Carbon explorer:

# Instalați bazelisk folosind Homebrew.
$ brew instalează bazelisk
# Instalați Clang/LLVM folosind Homebrew.
# Multe versiuni Clang/LLVM nu sunt construite cu opțiuni pe care ne bazăm.
$ brew install llvm
$ export PATH="$(brew --prefix llvm)/bin:${PATH}"


# Descărcați codul Carbon.
$ git clonare https://github.com/carbon-language/carbon-lang
$ CD carbon-lang
# Construiți și rulați exploratorul.
$ bazel run //explorer -- ./explorer/testdata/imprimare/format_only.carbon

Foaia de parcurs Carbon dezvăluie gândirea pe termen lung

Conform foii de parcurs Carbon, Google va face public experimentul cu lansarea unei versiuni de lucru de bază (0.1) până la sfârșitul anului 2022. Ei plănuiesc să urmeze acest lucru cu o versiune 0.2 în 2023 și o versiune completă 1.0 în 2024-2025.

Dacă Google va putea reproduce succesul celorlalte limbi ale lor, Golang și Kotlin, rămâne de văzut.