Pourquoi le caractère d'espace n'a-t-il pas été choisi pour les séparateurs de 14 chiffres C++?

La raison évidente de ne pas utiliser d'espace blanc est qu'une nouvelle ligne est également espace blanc, et que C++ traite tous les espaces blancs de manière identique. Et off main, Je ne connais aucune langue qui accepte des espaces blancs arbitraires comme un séparateur.

On peut supposer que Unicode 0xA0 (espace insécable) pourrait être utilisé-c'est la solution la plus largement utilisée lors de la composition. Je vois deux problèmes avec cela, cependant: d'abord, ce n'est pas dans le jeu de caractères de base, et deuxièmement, il n'est pas visuellement distinctif; vous ne pouvez pas voir que ce n'est pas un espace par il suffit de regarder le texte dans un éditeur normal.

Au-delà, il n'y a pas beaucoup de choix. Vous ne pouvez pas utiliser la virgule, puisque c'est déjà un jeton légal (et quelque chose comme 1,234 est actuellement juridique c++, avec le sens 234). Et dans un contexte où cela pourrait se produire dans le code juridique, par exemple a[1,234]. Alors que je ne peux pas imaginer tout réel code en utilisant cela, il y a une règle de base qu'aucun programme juridique, peu importe comment absurde, devrait changer silencieusement sémantique.

Des considérations similaires signifient que _ ne peut pas être utilisé non plus; s'il y a un #define _234 * 2, alors a[1_234] changerait silencieusement le sens de code.

Je ne peux pas dire que je suis particulièrement satisfait du choix de ', mais il a l'avantage d'être utilisé en Europe continentale, au moins dans certains types de textes. (Je me souviens de l'avoir vu en allemand, pour exemple, bien que dans le texte courant typique, allemand, comme la plupart des autres langues, utilisera un point ou un non la rupture de l'espace. Mais c'était peut-être Le Suisse Allemand. Le problème avec ' est l'analyse; la séquence '1' est déjà légal, tout comme '123'. Donc quelque chose comme 1'234 pourrait être un 1, suivi par le début d'une constante de caractère; Je ne sais pas jusqu'où vous avoir à l'avance pour prendre la décision. Il n'y a pas de séquence de C++ dans lequel une constante intégrale peut être suivie d'un caractère constante, donc il n'y a pas de problème avec la rupture du code légal, mais cela signifie ce balayage lexical soudainement devient très dépendant du contexte.

(en ce qui concerne votre commentaire: il n'y a pas de logique dans le choix d'un décimal ou un séparateur de milliers. Un séparateur décimal, par exemple, est certainement pas un arrêt complet. Ce ne sont que des conventions arbitraires.)

De wiki , nous avons un bel exemple:

auto floating_point_literal = 0.000'015'3;

Ici, nous avons l'opérateur . et puis si un autre opérateur devait être rencontré, mes yeux attendraient quelque chose de visible, comme une virgule ou quelque chose, pas un espace.

Donc une apostrophe fait beaucoup mieux ici qu'un espace.

Avec les espaces, ce serait

auto floating_point_literal = 0.000 015 3;

Ce qui ne semble pas aussi juste que le cas avec les apostrophes.

Dans le même esprit de Albert Réponse de Renshaw , je pense que l'apostrophe est plus claire que l'espace proposé par les courses de légèreté en orbite.

type a = 1'000'000'000'000'000'544'445'555;
type a = 1 000 000 000 000 000 544 445 555;

L'espace est utilisé pour beaucoup de choses, comme la concaténation de chaînes mentionnée dans L'OP, contrairement à l'apostrophe, qui dans ce cas le rend clair pour quelqu'un qui est utilisé pour séparer les chiffres.

Lorsque les lignes de code deviennent nombreuses, je pense que cela améliorera la lisibilité, mais je doute que ce soit la raison pour laquelle ils le choisissent.

A propos des espaces, il cela pourrait valoir la peine de jeter un oeil à cette question C , qui dit:

Le langage n'autorise pas int i = 10 000; (un littéral entier est un jeton, l'espace blanc intervenant le divise en deux jetons) mais il y a généralement peu ou pas de dépenses encourues en exprimant l'initialiseur comme une expression qui est un calcul de littéraux:

int i = 10 * 1000; /* ten thousand */

Il est vrai que je ne vois aucune signification pratique à:

if (a == 1 1 1 1 1) ...

Ainsi, les chiffres peuvent être fusionnés sans ambiguïté réelle mais qu'en un nombre hexadécimal?

0 x 1 a B 2 3

Il N'y a aucun moyen de désambiguïser à partir d'une faute de frappe (normalement, nous devrions voir une erreur)

Je suppose que c'est parce que, en écrivant du code, si vous atteignez la fin d'une "ligne" (la largeur de votre écran), un saut de ligne automatique (ou "Word wrap") se produit. Cela ferait que votre int soit divisé en deux, la moitié serait sur la première ligne, la seconde moitié sur la seconde... de cette façon, tout reste ensemble en cas de word-wrap.

float floating_point_literal = 0.0000153;   /* C, C++*/

auto floating_point_literal = 0.0000153;    // C++11

auto floating_point_literal = 0.000'015'3;  // C++14

Commenter ne fait pas mal:

/*  0. 0000 1530 */ 
float floating_point_literal = 0.00001530; 

Les chaînes binaires peuvent être difficiles à analyser:

long bytecode = 0b1111011010011001; /* gcc , clang */  

long bytecode = 0b1111'0110'1001'1001;  //C++14
// 0b 1111 0110 1001 1001  would be better, really.
// It is how humans think.

Une macro à considérer:

#define B(W,X,Y,Z)    (0b##W##X##Y##Z)
#define HEX(W,X,Y,Z)  (0x##W##X##Y##Z)
#define OCT(O)        (0##O)



long z = B(1001, 1001, 1020, 1032 ); 

// result :  long z = (0b1001100110201032);

 long h = OCT( 35); 

// result :  long h  = (035); // 35_oct => 29_dec

 long h = HEX( FF, A6, 3B, D0 ); 

// result :  long h  = (0xFFA6BD0);

Cela a à voir avec la façon dont la langue est analysée. Il aurait été difficile pour les auteurs du compilateur de réécrire leurs produits pour accepter des littéraux délimités par des espaces.

En outre, Je ne pense pas que séparer les chiffres avec des espaces soit très commun. Ce que j'ai vu, ce sont toujours des caractères non-espaces, même dans différents pays.