Зачем писать 1000000000 как 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^3- 1003. ^- это битовый оператор XOR.

Даже если это не касается самого Q, добавлю уточнение. не всегда x^yдает оценку, как в примере вопрошающего. Вы должны xor каждый бит. В случае примера: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нотацию для значений, которые точно могут быть представлены как 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 поддерживает _числа для улучшения читаемости (впервые предложено Стивеном Колебурном в ответ на ПРЕДЛОЖЕНИЕ Дерека Фостера: двоичные литералы для Project Coin / JSR 334). Здесь можно было бы написать 1_000_000_000.

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

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

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

Возможно, будет проще прочитать и вызвать ассоциации с 1,000,000,000формой.

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

Если говорить о objective-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. Как правило, long double (80 или 128 бит) может идти даже дальше. Преобразования будут выполняться во время компиляции, поэтому нет накладных расходов во время выполнения, и вы, вероятно, получите предупреждения, если произойдет неожиданная потеря точности и у вас хороший компилятор.

long lots_of_secs = 1e9;