Por que escrever 1.000.000.000 como 1000 * 1000 * 1000 em C?

No código criado pela Apple, existe esta linha:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

Existe algum motivo para expressar 1,000,000,000como 1000*1000*1000?

Por que não 1000^3?

Um motivo para declarar constantes de maneira multiplicativa é melhorar a legibilidade, enquanto o desempenho em tempo de execução não é afetado. Além disso, para indicar que o escritor estava pensando de maneira multiplicativa sobre o número.

Considere isto:

double memoryBytes = 1024 * 1024 * 1024;

É claramente melhor que:

double memoryBytes = 1073741824;

como este último não parece, à primeira vista, o terceiro poder de 1024.

Como Amin Negm-Awad mencionou, o ^operador é o binário XOR. Muitos idiomas não possuem o operador interno de exponenciação em tempo de compilação, daí a multiplicação.

Por que não 1000^3?

O resultado de 1000^3é 1003. ^é o operador bit-XOR.

Mesmo que não lide com o próprio Q, acrescento um esclarecimento. x^yse não sempre avaliar a x+ycomo faz no exemplo do questionador. Você tem que xor todo. No caso do exemplo:

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

Mas

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

Existem razões para não usar 1000 * 1000 * 1000.

Com 16 bits int, 1000 * 1000estouros excessivos. Portanto, o uso 1000 * 1000 * 1000reduz a portabilidade.

Com 32 bits int, a primeira linha de código a seguir é excedida.

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

Sugira que o valor do lead corresponda ao tipo de destino para legibilidade, portabilidade e correção.

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

Também poderia usar a enotação simples para valores que são exatamente representáveis ​​como a double. É claro que isso leva a saber se doublepode representar exatamente o valor do número inteiro - algo preocupante com valores maiores que 1e9. (Veja DBL_EPSILONe DBL_DIG).

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

Para legibilidade.

Colocar vírgulas e espaços entre os zeros ( 1 000 000 000ou 1,000,000,000) produziria um erro de sintaxe, e ter 1000000000no código dificulta a visualização exata de quantos zeros existem.

1000*1000*1000torna aparente que é 10 ^ 9, porque nossos olhos podem processar os pedaços mais facilmente. Além disso, não há custo de tempo de execução, porque o compilador o substituirá pela constante 1000000000.

Para legibilidade. Para comparação, o Java suporta _números para melhorar a legibilidade (proposto pela primeira vez por Stephen Colebourne como resposta à PROPOSTA de Derek Foster: Literais binários para o Project Coin / JSR 334). Alguém escreveria 1_000_000_000aqui.

Em ordem cronológica, do suporte mais antigo ao mais recente:

• XPL: "(1)1111 1111"( aparentemente não para valores decimais, apenas para cadeias de bits que representam valores binários, quartais, octais ou hexadecimais )
• PL / M: 1$000$000
• Ada: 1_000_000_000
• Perl: da mesma forma
• Ruby: da mesma forma
• Fantom (anteriormente fã): da mesma forma
• Java 7: da mesma forma
• Swift: (o mesmo?)
• Python 3.6
• C ++ 14: 1'000'000'000

É um recurso relativamente novo para os idiomas perceberem que eles devem suportar (e então há o Perl). Como na excelente resposta do chux @, 1000*1000...é uma solução parcial, mas abre o programador para que os erros ultrapassem a multiplicação, mesmo que o resultado final seja do tipo grande.

Pode ser mais simples de ler e obter algumas associações com o 1,000,000,000formulário.

Do ponto de vista técnico, acho que não há diferença entre o número direto ou a multiplicação. O compilador irá gerá-lo como um número constante de bilhões de qualquer maneira.

Se você falar sobre o objetivo-c, 1000^3não funcionará porque não existe essa sintaxe para o pow (é xor). Em vez disso, a pow()função pode ser usada. Mas, nesse caso, não será o ideal, será uma chamada de função de tempo de execução, não uma constante gerada pelo compilador.

Para ilustrar os motivos, considere o seguinte programa de teste:

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

Outra maneira de obter um efeito semelhante em C para números decimais é usar a notação literal de ponto flutuante - desde que um duplo possa representar o número desejado sem perda de precisão.

O IEEE 754 de 64 bits duplo pode representar qualquer número inteiro não negativo <= 2 ^ 53 sem problemas. Normalmente, o duplo longo (80 ou 128 bits) pode ir ainda mais longe. As conversões serão feitas em tempo de compilação, portanto, não haverá sobrecarga de tempo de execução e você provavelmente receberá avisos se houver uma perda inesperada de precisão e você tiver um bom compilador.

long lots_of_secs = 1e9;