Зачем писать 1000 000 000 как 1000 * 1000 * 1000 в C?

Question

В коде, созданный Apple, есть такая строка:

CMTimeMakeWithSeconds(newDurationSeconds, 1000*1000*1000) 

Есть ли какая-либо причина, чтобы выразить 1,000,000,000 как 1000*1000*1000?

Почему нет 1000^3 в этом отношении?

Answer 1

Одна из причин объявления констант мультипликативным способом заключается в улучшении читаемости, в то время как производительность во время выполнения не изменяется. Кроме того, чтобы указать, что писатель многократно думал о количестве.

Рассмотрим это:

double memoryBytes = 1024 * 1024 * 1024; 

Это явно лучше, чем:

double memoryBytes = 1073741824; 

как последний не выглядит, на первый взгляд, третья сила 1024.

Как Амина Негм-Авад упомянул, что оператором ^ является двоичный код XOR. На многих языках отсутствует встроенный оператор экспоненциального компиляции, поэтому умножение.

Answer 2

Почему не 1000^3?

Результатом является 1000^3 1003. ^ является оператором битового исключающее ИЛИ.

Даже это не касается самой Q, я добавляю разъяснение. x^y делает не всегда оценивается до x+y, как в примере опроса. Вам нужно каждый бит. В случае примера:

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

Но

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

Answer 3

Может быть проще читать и получить какую-то ассоциацию с 1,000,000,000 формой.

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

Если вы говорите об объективе-c, то 1000^3 не будет работать, потому что нет такого синтаксиса для pow (это xor). Вместо этого можно использовать функцию pow(). Но в этом случае он не будет оптимальным, это будет вызов функции времени выполнения, а не сгенерированная константа компилятора.

Answer 4

Для удобства чтения.

Размещение запятых и пробелов между нулями (1 000 000 000 или 1,000,000,000) будет производить синтаксическую ошибку, и с 1000000000 в коде делает его трудно увидеть, как много нулей есть.

1000*1000*1000 делает очевидным, что это 10^9, потому что наши глаза легче обрабатывают куски.Кроме того, нет времени на запуск, поскольку компилятор заменит его на константу 1000000000.

Answer 5

Для удобства чтения. Для сравнения, Java поддерживает _ в цифрах, чтобы улучшить читаемость (сначала предложенный Стивеном Коулбурном как reply to Derek Foster's PROPOSAL: Binary Literals для Project Coin/JSR 334). Здесь можно было бы написать 1_000_000_000.

В примерно в хронологическом порядке, от самой старой поддержки к новым:

• XPL: "(1)1111 1111" (apparently not for decimal values, only for bitstrings representing binary, quartal, octal or hexadecimal values)
• PL/M: 1$000$000
• Ada: 1_000_000_000
• Perl: аналогично
• Ruby: также
• Fantom (ранее Fan): также
• Java 7: также
• Swift: (? Же)
• Python 3.6
• C++ 14: 1'000'000'000

Это относительно новая функция языка, чтобы понять, что они должны поддерживать (а затем есть Perl). Как и в отличном ответе chux @, 1000*1000... является частичным решением, но открывает программиста до ошибок при переполнении умножения, даже если конечный результат является большим типом.

Answer 6

Есть причины не использовать 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 обозначения для значений, которые точно представима как double. Конечно, это приводит к пониманию того, может ли double точно представлять целое числовое значение - что-то касающееся значений больше 1е9. (См. DBL_EPSILON и DBL_DIG).

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

Answer 7

Для иллюстрации причины рассмотрим следующую тестовую программу:

$ 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 
$ 

Answer 8

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

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

long lots_of_secs = 1e9;