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

Ответ 1

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

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

double memoryBytes = 1024 * 1024 * 1024;

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

double memoryBytes = 1073741824;

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

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

Ответ 2

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

Результат 1000^3 равен 1003. ^ - это оператор бит-XOR.

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

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

Но

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

Ответ 3

Есть причины не использовать 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;

Ответ 4

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

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

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

Ответ 5

Для удобства чтения. Для сравнения, Java поддерживает _ в цифрах, чтобы улучшить читаемость (сначала предложенный Стивеном Коулбурном как ответ Дереку Фостеру ПРЕДЛОЖЕНИЕ: Бинарные литералы для Монета проекта /JSR 334). Здесь можно написать 1_000_000_000.

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

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

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

Ответ 6

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

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

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

Ответ 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
$

Ответ 8

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

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

long lots_of_secs = 1e9;