Imaginez que j'ai le code:
vector<int> temp = vector<int>(1 000 000 000);
Ce qui précède ne sera pas compilé car le compilateur se plaindra des espaces. Est-il possible d'indiquer à C++ d'omettre ces espaces lors de la compilation ou de rendre le numéro plus facile à lire?
Essayez le séparateur de chiffres:
int i = 1'000'000'000;
Cette fonctionnalité est introduite depuis C++ 14 . Il utilise guillemet simple ('
) comme séparateur de chiffres.
Regarde aussi:
Lorsque j'ai fait la même chose sur des plates-formes sans C++ 14 (généralement pour les microprocesseurs), j'ai représenté un grand nombre en le décomposant par multiplication:
int i = (1000 * 1000 * 1000);
Ajoutez UL
ou L
postfixes au goût
L'avantage ici est qu'il est compatible avec pratiquement toute plate-forme prenant en charge C89 (et probablement plus tôt).
En règle générale, il est probablement prudent de supposer que les opérateurs de multiplication tomberont au moment de la compilation, mais si vous utilisez des constantes de ce type dans une boucle, il peut être intéressant de vérifier à nouveau.
J'ai l'habitude de #définir des constantes à cette fin, car cela évite de compter les zéros et explique très clairement ce que vous voulez dire à quiconque visualise le code. Par exemple
#define THOUSAND 1000
#define MILLION 1000000
vector<int> temp = vector<int>(THOUSAND * MILLION);
Cela signifie clairement que je veux dire vraiment un milliard et que je n'ai pas mal calculé les zéros
Évidemment, vous pouvez utiliser des enums si vous préférez.
Si vous n'utilisez pas C++ 14, une autre option consisterait à utiliser une sorte de classe héritée par chaîne avec une conversion int implicite et peut-être une vérification de la regex dans le constructeur pour limiter les nombres. J'utilise CString pour un exemple simple.
class NumString : public CString
{
public:
NumString(CString number) : num(number) { } //maybe insert some regex-check here
operator long() const
{
CString tmp = num;
tmp.Remove(' ');
return atol(tmp);
}
private:
CString num;
};
NumString a = "1 000 000 000";
int b = a;
bool test = b == 1000000000;
//test will be true
Comme cela me rappelle le regroupement des chiffres, ma première approche maladroite sans C++ 14
serait
#define INTGROUPED1(a) (a%1000)
#define INTGROUPED2(a,b) (a%1000*1000 + b%1000)
#define INTGROUPED3(a,b,c) (a%1000*1000000 + b%1000*1000 + c%1000)
int v1 = INTGROUPED1( 123);
int v2 = INTGROUPED2( 123,123);
int v3 = INTGROUPED3( 23,123,123);
mais j'utiliserais plutôt ces astuces dans un contexte privé.
Pensez à quelqu'un qui écrit
INTGROUPED3(1234,1234,1234); //This would be (234,234,234) without a compiler complaining
EDIT1:
Peut-être qu'une meilleure approche consisterait à utiliser l'opérateur de préprocesseur ##
#define NUM_GROUPED_4ARGS(a,b,c,d) (##a##b##c##d)
int num = NUM_GROUPED_4ARGS(-2,123,456,789); //int num = (-2123456789);
Cela ressemble plus à WYSIWYG mais pas à l’abri des abus. Par exemple. vous pouvez vous plaindre du compilateur
int num = NUM_GROUPED_4ARGS(-2,/123,456,789); //int num = (-2/123456789);
mais ce ne sera pas.
Une autre idée pourrait être:
#define _000 *1000
int k = 1 _000 _000;