Мови, які не дозволяють підкреслити цілі константи, чи є хорошою практикою створення константи на 1 мільярд?

Мови, які не дозволяють підкреслити цілі літерали , чи гарна ідея створити константу на 1 мільярд? наприклад, в C ++:

size_t ONE_BILLION = 1000000000;

Звичайно, ми не повинні створювати константи для малих чисел, таких як 100. Але з 9 нулями, можливо, просто залишити нуль або додати додатковий у такому коді:

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

Більшість мов мають якесь експоненціальне позначення. Мільйон - це 1e6(означає 1 раз 10 на потужність 6). Це в основному вирішує питання навіть краще, ніж більшість пропозицій тут.

У багатьох мовах, схожих на С, однак наукове позначення визначає тип плаваючої крапки , що шкода, якщо вам справді потрібен інт. Однак ви можете легко набрати цю константу, щоб уникнути неявних перетворень у формулі.

n / int(1e9) ділиться на мільярд.

У вашому прикладі, маючи справу з фізичними величинами (час у наносекунд), я взагалі запитаю себе, чи є ціле число правильним типом. Насправді плаваюча точка doubleможе бути краще підходить при роботі з вимірюваними кількостями (хоча, звичайно, є випадки, коли ви вважаєте за краще б 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 ++, ціль 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, також може працювати з вставкою лексеми, а не арифметикою. У препроцесорі С двійковий ##оператор ("лексема вставки") може використовуватися в макроконтролі, щоб склеїти два операнди в один маркер. Один або обидва операнди можуть бути макроаргументами. Мінус тут (створюючи для нас ризик) полягає в тому, що якщо результуюча катенація не є дійсним маркером, поведінка не визначається.

#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, які склеюють ідентифікатори та використовують результати для іменування глобальних змінних та функцій, існують і з ними жахливо працювати, оскільки вони непроникні для таких інструментів, як id-утиліти та ctag GNU.

Так, це звучить як розумна ідея. Помилки 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 байт .

UPDATE Commenter зазначив, що існують спеціальні терміни для цифрових експонентів 2: http://en.wikipedia.org/wiki/Mebibyte