На языках, которые не допускают подчеркивания в целочисленных константах, является ли хорошей практикой создание константы для 1 миллиарда?

На языках, которые не допускают подчеркивания в целочисленных литералах , это хорошая идея, чтобы создать константу за 1 миллиард? например, в C ++:

size_t ONE_BILLION = 1000000000;

Конечно, мы не должны создавать константы для небольших чисел, таких как 100. Но с 9 нулями, возможно, легко обнулить ноль или добавить дополнительный в коде так:

tv_sec = timeInNanosec / 1000000000;
tv_nsec = timeInNanosec % 1000000000;

Большинство языков имеют своего рода экспоненциальные обозначения. Миллион есть 1e6(имеется в виду 1 раз 10 к степени 6). Это в основном решает проблему даже лучше, чем большинство предложений здесь.

Однако во многих C-подобных языках научная нотация определяет тип с плавающей запятой , что не очень хорошо, если вам действительно нужен int. Однако вы можете легко привести эту константу к типу, чтобы избежать неявных преобразований в формуле.

n / int(1e9) разделил бы на миллиард.

В вашем примере, касающемся физических величин (время в наносекунде), я обычно спрашиваю себя, является ли целое число правильным типом. Фактически, плавающая точка doubleможет быть лучше приспособлена для работы с измеримыми величинами (хотя, конечно, есть случаи, когда вы бы предпочли a long long).

Создайте один с именем NANOSECONDS_IN_ONE_SECOND вместо того, что он представляет.

Или более короткое, лучшее имя, если вы можете придумать одно.

Константы предназначены для придания значениям чисел. Существует не любой дополнительный смысл в ONE_BILLIONк 1000000000. На самом деле, это делает его более запутанным, потому что в разных естественных языках миллиард означает что-то другое (тысяча миллионов или миллион миллионов)! Если вы хотите написать его короче, есть хороший шанс , что ваши языка программирования позволяет использовать научные обозначения, то есть 1e9. В противном случае я согласен с @JohnB, что это число действительно означает количество наносекунд в секунду, поэтому назовите его так.

Для одного или двух употреблений я бы использовал соглашение:

tv_sec = timeInNanosec / (1000 * 1000 * 1000);
tv_nsec = timeInNanosec % (1000 * 1000 * 1000);

Это совершенно очевидно, компилируется в константу, и это трудно испортить.

Кроме того, это очень полезно в таких случаях, как:

var Time = 24 * 60 * 60;

где легко увидеть, что мы говорим об одном дне в секундах.

Длина значения не является тем, что определяет, нужна ли константа или нет.

Вы используете константы, чтобы избежать магических чисел , а не чтобы печатать.

Например, это совершенно корректные константы:

public static final int CLOSE_CURSORS_AT_COMMIT = 1;
public static final int CONCUR_READ_ONLY = 2;
public static final int CONCUR_UPDATABLE = 3;
public static final int FETCH_FORWARD = 4;
public static final int FETCH_REVERSE = 5; 
public static final int FETCH_UNKNOWN = 6;
public static final int HOLD_CURSORS_OVER_COMMIT = 7;
public static final int TYPE_FORWARD_ONLY = 8;
public static final int TYPE_SCROLL_INSENSITIVE = 9;
public static final int TYPE_SCROLL_SENSITIVE = 10;

Использование:

public static final int NANOSECS_PER_SECOND = 1000000000;

(примеры кода на Java, перевод на ваш любимый язык)

Американский или европейский миллиард?

(или с технической точки зрения, миллиард в коротком или длинном масштабе - один - 1000 миллионов, другой - миллион).

Учитывая это заблуждение, я бы сказал, что да - имеет смысл определить его один раз и придерживаться его, также относится к любой константе, с которой вам нужно согласовать определение - определите его один раз.

Причины не

Во-первых, вот причина, по которой вы не пишете подчеркивания или не используете какой-либо трюк для его симуляции: это затрудняет поиск констант в коде. Предположим, что какая-то программа показывает где-то в своей работе жестко закодированное значение 1500000 для некоторого параметра. Я хочу знать, где в исходном коде программы это на самом деле происходит, поэтому я набираю код 1500000и ничего не нахожу. Зачем? Это может быть в шестнадцатеричном (но почему для такого круглого десятичного числа). Без моего ведома, константа на самом деле записывается как 1_500_000. Мне нужно регулярное выражение 1_?500_?000.

Руководящие символы в комментарии

Тот факт, что один вид визуального пособия недоступен или мы не хотим использовать его по вышеуказанной причине, не означает, что мы не можем воспользоваться двумя измерениями текстового файла для создания альтернативного визуального средства:

foo = bar / 1000000000;
//           --^--^--^  

При этом мы можем легко убедить себя, что есть три группы из трех нулей. Тем не менее, мы все еще можем 1000000000найти исходный код и найти его.

Синтаксис Раскраска

Текстовый редактор с программируемой синтаксической окраской может быть сделан для цветовых групп чисел в числовых константах с чередующимися цветами для лучшей читаемости. Нам не нужно ничего делать в коде.

Предварительная обработка: C, C ++, Objective C

Теперь, если нам действительно нужны запятые между цифрами, в C и C ++ мы можем использовать некоторую предварительную обработку:

/* Four digit base TH-ousand constant macro */
/* Condensed using Horner's rule */
#define TH(A,B,C,D) ((((((A) * 1000) + (B)) * 1000) + (C)) * 1000 + D)

tv_sec = nanoseconds / TH(1,000,000,000)

Работает на номера, как TH(1,234,567,890).

Макрос, подобный TH, также может работать с вставкой токена, а не с арифметикой. В препроцессоре C бинарный ##оператор («вставка токена») может использоваться в теле макроса для вставки двух операндов в один токен. Один или оба операнда могут быть макро-аргументами. Недостатком (создающим для нас риск) является то, что если полученная цепочка не является допустимым токеном, поведение не определено.

#define TOK4(A, B, C, D) A ## B ## C ## D

В настоящее время

TOK4(1,000,000,000)       /* produces the single token 1000000000 */
TOK4(1,123,000,000.0E+2)  /* produces the single token 1123000000.0E+2 */
TOK4(pr,in,t,f)           /* produces the token printf */
TOK4(#,*,a,b)             /* undefined behavior, #*ab is not valid token syntax */

Программы на C, которые вставляют идентификаторы и используют результаты для именования глобальных переменных и функций, существуют и с ними ужасно работать, потому что они невосприимчивы к таким инструментам, как GNU id-utils и ctags.

Да, это звучит как разумная идея. Ошибки DIGIT в режиме «один на один» даже хуже, чем печально известные ошибки «один на один». Хотя это может создать путаницу для других людей (в том числе и для вашего будущего), читающих код.

Более объяснительное имя, такое как NANOSEC_PER_SEC, кажется хорошим, поскольку оно добавит ясности, где оно используется для времени. Однако не имеет смысла использовать его в других контекстах, кроме времени, и было бы нецелесообразно создавать отдельный 1 000 000 000 для каждой ситуации.

Что вы действительно хотите сделать, глупо, как кажется на первый взгляд, это «разделить на секунду». Это оставляет NANO_PER, который не только не зависит от языка (10 ^ 9 в Америке и Европе), но также не зависит от ситуации (не ограничивает единицы), и его легко набирать и читать.

В общем, плохая идея использовать скалярные константы для преобразования единиц, и если вы обнаруживаете, что создаете константы для таких вещей, вы выполняете преобразование в слишком многих местах.

Когда у вас есть количество в одну единицу (скажем, 10 секунд), и вы хотите преобразовать в другую единицу (например, наносекунды); это именно то время, чтобы использовать систему типов вашего языка, чтобы гарантировать, что единицы измерения действительно масштабируются так, как вы хотите.

Сделайте свою функцию взять Nanosecondsпараметр, и обеспечивают операторы преобразования и / или конструктор в этом классе Seconds, Minutesили что-у-вы. Это где ваш const intили #defineили 1e9видел в других ответах принадлежит.

Это позволяет избежать наличия переменных неоднозначных единиц, плавающих вокруг вашего кода; и предотвращает целые серии ошибок, из-за которых было применено неправильное умножение / деление, или оно уже было применено, или количество фактически было расстоянием, а не временем, или ...

Кроме того, в таких классах хорошо делать конструкцию из простого скалярного частного и использовать статический «MakeSeconds (int)» или аналогичный, чтобы не использовать небрежное использование непрозрачных чисел.

Более конкретно к вашему примеру, в C ++ посмотрите Boost.Chrono .

Я лично не считаю хорошей практикой создавать константу, если она не должна быть константой. Если он будет в нескольких местах и ​​определен в верхней части файла для модификации / или тестирования, это будет полезно, тогда абсолютно.

Если его просто потому, что его неудобно печатать? Тогда нет.

Лично, если я получил чей-то код с определенной константой, я, как правило, считаю это важным аспектом кода. Например, tcp поддерживает таймеры, максимально допустимое количество соединений. Если бы мне пришлось отлаживать его, я бы, вероятно, уделил ему слишком много внимания, пытаясь выяснить, почему / где он используется.

Когда вы думаете о том, почему вы написали «1 миллиард» вместо «1000000000» в заголовке вопроса, вы поймете, почему ответ «да».

Не создавайте константу для ваших больших литералов. Вам понадобится константа для каждого такого литерала, что является (на мой взгляд) полной шуткой. Если вам отчаянно нужно сделать свои литералы более понятными без помощи таких вещей, как подсветка синтаксиса, вы можете (хотя я бы не стал) создавать функции или макросы, чтобы сделать вашу жизнь «проще»:

#define SPLIT3(x, y, z) x##y##z

int largeNumber1 = SPLIT3(123,456,789);
int largeNumber2 = 123456789;

Я бы сделал это:

const int Million = 1000 * 1000;
const int Billion = 1000 * Million;

или

const int SciMega = 1000 * 1000; const int SciGiga = 1000 * SciMega;

Что касается количества наносекунд в секунду: нано является «инверсией» гига.

Kilo  Mega  Giga   etc.
10^3  10^6  10^9
Milli Micro Nano   etc.
10^-3 10^-6 10^-9

Обратите внимание на «Sci» - для научных, как и в компьютерах, значения кило, мега, гига и т. Д. Различны: 1024 (2 ^ 10), 1024 * 1024 (2 ^ 20) и т. Д. 2 мегабайта - это не 2 000 000 байт ,

ОБНОВЛЕНИЕ Комментатор отметил, что существуют специальные условия для цифровых показателей 2: http://en.wikipedia.org/wiki/Mebibyte