GCC 15.1 vient d'�tre publi� en tant que nouvelle version annuelle de la GNU Compiler Collection. Cette premi�re version stable de GCC 15 apporte un compilateur COBOL frontal, de nombreuses am�liorations dans le support des langages C et C++, le support de nouveaux processeurs et de nouvelles capacit�s ISA, un meilleur support du langage de programmation Rust, des am�liorations dans le d�bogage, et bien d'autres choses encore.GCC est une collection de compilateurs du projet GNU qui prend en charge diff�rents langages de programmation, architectures mat�rielles et syst�mes d'exploitation. La Free Software Foundation (FSF) distribue GCC en tant que logiciel libre sous la licence publique g�n�rale GNU (GNU GPL). GCC est un composant cl� de la cha�ne d'outils GNU, utilis�e pour la plupart des projets li�s � GNU et au noyau Linux. Avec environ 15 millions de lignes de code en 2019, GCC est l'un des plus grands programmes libres existants. Il a jou� un r�le important dans la croissance du logiciel libre, � la fois comme outil et comme exemple.
La nouvelle version GCC 15.1 propose une interface pour le langage COBOL, diverses am�liorations de la convivialit�, de nombreuses am�liorations du langage de programmation Rust pour gccrs, le passage de la version par d�faut du langage C � C23, des am�liorations de la cible AMD Zen 5 � znver5 � parmi d'autres nouvelles optimisations de la cible AMD Zen, le ciblage des Intel Xeon 7 Diamond Rapids, la prise en charge de l'Intel AVX10. 2 pour la nouvelle r�vision de 512 bits seulement, plus d'activations Intel Advanced Performance Extensions � APX �, la suppression du support Xeon Phi, des am�liorations OpenMP offloading, et beaucoup d'autres changements du support mat�riel aux caract�ristiques du langage.
Le back-end AMDGPU pour les processeurs graphiques AMD prend d�sormais en charge la biblioth�que C++ standard (libstdc++), la prise en charge exp�rimentale des p�riph�riques g�n�riques et le retrait de la prise en charge du GPU Fiji. De m�me, le back-end NVIDIA NVPTX avec GCC15 prend �galement en charge libstdc++.
Les interfaces des langages D et Modula-2 de GCC, dont on parle moins, ont �galement fait l'objet d'un travail consid�rable, tout comme l'interface Fortran.
Fonctionnalit�s de C++26
Les fonctionnalit�s C++26 de GCC 15 comprennent l'indexation des paquets, les attributs pour les liaisons structur�es, la prise en charge am�lior�e des fonctions dont la d�finition consiste en =delete, et plus encore.
Indexation des paquets
C++11 a introduit les mod�les variadiques qui permettent au programmeur d'�crire des mod�les qui acceptent n'importe quel nombre d'arguments de mod�le. Un paquet peut repr�senter une s�rie de types ou de valeurs. Par exemple, pour imprimer des arguments arbitraires, on peut �crire :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 | template<typename T, typename... Types>
void print (T t, Types... args)
{
std::cout << t << '\n';
if constexpr (sizeof...(args) > 0)
print (args...);
}
int main ()
{
print ('a', "foo", 42);
} |
Cependant, il n'�tait pas possible d'indexer un �l�ment d'un pack, � moins que le programmeur n'ait recours � diverses astuces r�cursives qui sont g�n�ralement lentes � compiler. Avec cette fonctionnalit� du C++26, pour indexer un paquet, on peut �crire pack...[N] (o� N doit �tre une expression constante). L'index d'un paquet se comporte alors exactement comme si l'expression r�sultante �tait utilis�e. Un paquet vide ne peut pas �tre index�. Le programme suivant imprimera a :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 | template<typename... Types>
void print (Types... args)
{
std::cout << args...[0] << '\n';
}
int main ()
{
print ('a', "foo", 42);
} |
Attributs pour les liaisons structur�es
Cette proposition permet d'ajouter un attribut � chacune des liaisons structur�es introduites, comme dans l'exemple suivant :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 | struct S { int a, b; };
void
g (S& s)
{
auto [ a, b [[gnu::deprecated]] ] = s;
} |
=delete avec une raison
Le C++11 prend en charge les fonctions supprim�es, c'est-�-dire les fonctions dont la d�finition consiste en =delete. Les fonctions supprim�es participent � la r�solution des surcharges, mais leur appel constitue une erreur. Cela remplace l'ancien m�canisme qui consistait � d�clarer les fonctions membres sp�ciales comme private.
En C++26, il est possible de fournir un message expliquant pourquoi la fonction est marqu�e comme supprim�e : =delete(� reason �). Le programme suivant :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 | void oldfn(char *) = delete("unsafe, use newfn");
void newfn(char *);
void g ()
{
oldfn ("bagel");
} |
provoquera l'�mission par le compilateur du message suivant :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 | q.C: In function �void g()�:
q.C:7:9: error: use of deleted function �void oldfn(char*)�: unsafe, use newfn
7 | oldfn ("bagel");
| ~~~~~~^~~~~~~~~
q.C:1:6: note: declared here
1 | void oldfn(char *) = delete("unsafe, use newfn");
| ^~~~~ |
Amis variadiques
La fonctionnalit� suivante permet d'utiliser une d�claration friend avec un paquet de param�tres :
| Code : | S�lectionner tout |
1 2 3 4 | template<class... Ts>
class Foo {
friend Ts...;
}; |
Un exemple o� cette fonctionnalit� peut �tre utilis�e en pratique est l'idiome Passkey :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | template<typename... Ts>
class Passkey {
friend Ts...;
Passkey() {}
};
class A;
class B;
struct Widget {
// Only callable from A and B.
void secret (Passkey<A, B>);
};
class A {
void doit (Widget& w) {
w.secret ({}); // OK
}
};
class B {
void doit (Widget& w) {
w.secret ({}); // OK
}
};
class D {
void doit (Widget& w) {
w.secret ({}); // won't compile!
}
}; |
Placement constexpr new
Le C++20 a ajout� la possibilit� d'utiliser new dans un contexte constexpr :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
constexpr void use (int *) { }
constexpr int
foo ()
{
auto *p = new int[]{1, 2, 3};
use (p);
delete[] p;
return 1;
}
int main ()
{
constexpr auto r = foo ();
} |
GCC a mis en �uvre la proposition dans GCC 10. Cependant, constexpr placement new n'�tait pas encore possible. Le C++26 rectifie cette situation et permet au programmeur d'�crire du code comme :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | #include <memory>
constexpr int foo ()
{
std::allocator<int> alloc;
auto p = alloc.allocate (16);
new (p) int(42);
alloc.deallocate (p, 16);
return 1;
}
int main ()
{
constexpr int r = foo ();
} |
D�claration de liaison structur�e en tant que condition
La fonctionnalit� des liaisons structur�es a �t� ajout�e en C++17, et GCC la supporte depuis longtemps. GCC 15 impl�mente P0963R3, qui permet la d�claration de liaisons structur�es dans les conditions if/while/for/switch ; auparavant, ce n'�tait pas possible.
Si une liaison structur�e est utilis�e dans un contexte de condition, sa variable de d�cision est la variable artificielle sous-jacente cr��e par le compilateur. Cette variable doit �tre convertible en bool (sauf lorsqu'elle est utilis�e dans une instruction switch). En voici un exemple :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 8 9 10 11 | struct S {
int a, b;
explicit operator bool () const noexcept { return a != b; }
};
void use (int, int);
void g (S s)
{
if (auto [ a, b ] = s)
use (a, b);
} |
Dans l'exemple pr�c�dent, use sera appel� lorsque a et b, d�compos�s � partir de s, ne sont pas �gaux. La variable artificielle utilis�e comme variable de d�cision a un nom unique et son type est ici S.
Suppression d'un pointeur sur un type incomplet
Le C++26 a clairement indiqu� que les fonctions delete et delete[] sur un pointeur vers un type de classe incomplet ne sont pas valides. Auparavant, cela invoquait un comportement ind�fini � moins que la classe n'ait un destructeur trivial et pas de d�sallocateur personnalis�. Par cons�quent, GCC 15 �mettra une erreur en mode C++26, ou un avertissement dans les modes plus anciens pour cet exemple :
| Code : | S�lectionner tout |
1 2 3 4 5 6 | struct S;
void foo (S *p)
{
delete p;
} |
Virgule variadique d'Oxford
L'utilisation d'une ellipse variadique sans virgule pr�c�dente en C++26 est d�pr�ci�e dans cet article. Cela signifie que GCC 15, lorsqu'il compilera le cas de test suivant de la proposition, �mettra trois avertissements en mode C++26 :
| Code : | S�lectionner tout |
1 2 3 4 5 6 7 8 | void d_depr(auto......); // deprecated void d_okay(auto..., ...); // OK void g_depr(int...); // deprecated void g_okay(int, ...); // OK void h_depr(int x...); // deprecated void h_okay(int x, ...); // OK |
Les utilisateurs peuvent activer l'avertissement dans les modes plus anciens en sp�cifiant ...
La fin de cet article est r�serv�e aux abonn�s. Soutenez le Club Developpez.com en prenant un abonnement pour que nous puissions continuer � vous proposer des publications.