Навіщо писати 1 000 000 000 як 1000 * 1000 * 1000 в C?

У коді, створеному Apple, є такий рядок:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

Чи є якась причина виразити 1,000,000,000як 1000*1000*1000?

Чому б не 1000^3з цього питання?

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

Врахуйте це:

double memoryBytes = 1024 * 1024 * 1024;

Це явно краще, ніж:

double memoryBytes = 1073741824;

оскільки останній, на перший погляд, не виглядає третьою силою 1024 року.

Як згадував Амін Негм-Авад, ^оператор є двійковим XOR. У багатьох мовах не вистачає вбудованого оператора експоненції часу компіляції, отже, множення.

Чому ні 1000^3?

Результат 1000^31003. ^Оператор біт-XOR.

Навіть це не стосується самого Q, я додаю уточнення. x^yце НЕ завжди обчислюватися , x+yяк це робить в прикладі запитувача в. Доводиться ходити по шматочках. У випадку прикладу:

1111101000₂ (1000₁₀)
0000000011₂ (3₁₀)
1111101011₂ (1003₁₀)

Але

1111101001₂ (1001₁₀)
0000000011₂ (3₁₀)
1111101010₂ (1002₁₀)

Є причини не використовувати 1000 * 1000 * 1000.

З 16-біт int, 1000 * 1000переливається. Тож використання 1000 * 1000 * 1000зменшує мобільність.

У 32-розрядному intваріанті наступний перший рядок коду переповнюється.

long long Duration = 1000 * 1000 * 1000 * 1000;  // overflow
long long Duration = 1000000000000;  // no overflow, hard to read

Запропонуйте, щоб значення провідних даних відповідало типу призначення для читабельності, переносимості та правильності.

double Duration = 1000.0 * 1000 * 1000;
long long Duration = 1000LL * 1000 * 1000 * 1000;

Також можна було б просто використовувати eпозначення для значень, які точно представлені як a double. Звичайно, це призводить до того, чи doubleможна точно представляти ціле число значення - щось, що стосується значень більше 1e9. (Див. DBL_EPSILONІ DBL_DIG).

long Duration = 1000000000;
// vs.
long Duration = 1e9;

Для читабельності.

Розміщення коми і пробілів між нулями ( 1 000 000 000або 1,000,000,000) призведе до синтаксичної помилки, а наявність 1000000000у коді ускладнює точне визначення кількості нулів.

1000*1000*1000стає очевидним, що це 10 ^ 9, тому що наші очі можуть легше обробляти шматки. Крім того, немає витрат на виконання, оскільки компілятор замінить його постійним 1000000000.

Для читабельності. Для порівняння, Java підтримує _чисельність для поліпшення читабельності (вперше запропонована Стівеном Колбурном як відповідь на Пропозиція Дерека Фостера: Бінарні літерали для проектної монети / JSR 334). Тут можна було б написати 1_000_000_000.

Приблизно в хронологічному порядку, від найдавнішої підтримки до найновішої:

• XPL: "(1)1111 1111"( мабуть, не для десяткових значень, лише для біткових рядків, що представляють двійкові, четвертинні, вісімкові або шістнадцяткові значення )
• PL / M: 1$000$000
• Ада: 1_000_000_000
• Perl: так само
• Рубі: так само
• Fantom (раніше вентилятор): аналогічно
• Java 7: аналогічно
• Свіфт: (те саме?)
• Пітон 3.6
• C ++ 14: 1'000'000'000

Це відносно нова функція для мов зрозуміти, що вони повинні підтримувати (і тоді є Perl). Як і в чудовій відповіді chux @, 1000*1000...це часткове рішення, але відкриває програмісту помилки від переповнення множення, навіть якщо кінцевий результат великого типу.

Можливо, простіше читати і отримувати деякі асоціації з 1,000,000,000формою.

З технічного аспекту, я думаю, немає різниці між прямим числом чи множенням. Компілятор все одно генерує його як постійне мільярдне число.

Якщо ви говорите про aim-c, то 1000^3це не спрацює, оскільки немає такого синтаксису для pow (це xor). Натомість pow()функцію можна використовувати. Але в цьому випадку це не буде оптимальним, це буде виклик функції виконання, а не константа, створена компілятором.

Для ілюстрації причин розглянемо наступну програму тестування:

$ cat comma-expr.c && gcc -o comma-expr comma-expr.c && ./comma-expr
#include <stdio.h>

#define BILLION1 (1,000,000,000)
#define BILLION2 (1000^3)

int main()
{
        printf("%d, %d\n", BILLION1, BILLION2);
}
0, 1003
$

Ще один спосіб досягти подібного ефекту в C для десяткових чисел - це використання буквальних позначень з плаваючою комою - до тих пір, поки подвійний може представляти потрібне вам число без втрати точності.

64-розрядний подвійний IEEE 754 може представляти будь-яке невід'ємне ціле число <= 2 ^ 53 без проблем. Зазвичай довгий подвійний (80 або 128 біт) може піти навіть далі. Перетворення буде здійснено під час компіляції, тому немає накладних витрат часу, і ви, швидше за все, отримаєте попередження, якщо станеться несподівана втрата точності та у вас хороший компілятор.

long lots_of_secs = 1e9;