Mengapa menulis 1.000.000.000 sebagai 1000 * 1000 * 1000 dalam C?

Dalam kode yang dibuat oleh Apple, ada baris ini:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

Apakah ada alasan untuk mengekspresikan 1,000,000,000sebagai 1000*1000*1000?

Kenapa tidak 1000^3?

Salah satu alasan untuk mendeklarasikan konstanta dengan cara multiplikatif adalah untuk meningkatkan keterbacaan, sementara kinerja run-time tidak terpengaruh. Juga, untuk menunjukkan bahwa penulis sedang berpikir secara berganda tentang nomor tersebut.

Pertimbangkan ini:

double memoryBytes = 1024 * 1024 * 1024;

Ini jelas lebih baik daripada:

double memoryBytes = 1073741824;

karena yang terakhir tidak terlihat, pada pandangan pertama, kekuatan ketiga 1024.

Seperti yang disebutkan Amin Negm-Awad, ^operatornya adalah biner XOR. Banyak bahasa tidak memiliki operator eksponensial built-in, waktu kompilasi, sehingga multiplikasi.

Mengapa tidak 1000^3?

Hasilnya 1000^3adalah 1003. ^adalah operator bit-XOR.

Meskipun tidak berurusan dengan Q itu sendiri, saya menambahkan klarifikasi. x^ytidak tidak selalu mengevaluasi x+yseperti dalam contoh penanya. Anda harus xor setiap bit. Dalam hal contoh:

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

Tapi

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

Ada alasan untuk tidak menggunakannya 1000 * 1000 * 1000.

Dengan 16-bit int, 1000 * 1000meluap. Jadi menggunakan 1000 * 1000 * 1000mengurangi portabilitas.

Dengan 32-bit int, baris kode berikut berikut meluap.

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

Sarankan bahwa nilai timbal cocok dengan jenis tujuan untuk keterbacaan, portabilitas dan kebenaran.

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

Juga dapat menggunakan enotasi sederhana untuk nilai-nilai yang secara tepat dapat direpresentasikan sebagai a double. Tentu saja hal ini mengarah pada mengetahui apakah doubledapat secara tepat merepresentasikan nilai angka keseluruhan - sesuatu yang berkaitan dengan nilai lebih besar dari 1e9. (Lihat DBL_EPSILONdan DBL_DIG).

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

Agar mudah dibaca.

Menempatkan koma dan spasi di antara nol ( 1 000 000 000atau 1,000,000,000) akan menghasilkan kesalahan sintaks, dan memiliki 1000000000dalam kode membuatnya sulit untuk melihat dengan tepat berapa banyak nol yang ada.

1000*1000*1000membuatnya jelas bahwa ini 10 ^ 9, karena mata kita dapat memproses potongan lebih mudah. Juga, tidak ada biaya runtime, karena kompiler akan menggantinya dengan konstanta 1000000000.

Agar mudah dibaca. Sebagai perbandingan, Java mendukung _dalam jumlah untuk meningkatkan keterbacaan (pertama kali diusulkan oleh Stephen Colebourne sebagai balasan untuk PROPOSAL Derek Foster: Binary Literals untuk Project Coin / JSR 334). Orang akan menulis di 1_000_000_000sini.

Secara kronologis, mulai dari dukungan terlama hingga terbaru:

• XPL: "(1)1111 1111"( tampaknya bukan untuk nilai desimal, hanya untuk bitstring yang mewakili nilai biner, kuartal, oktal, atau heksadesimal )
• PL / M: 1$000$000
• Ada: 1_000_000_000
• Perl: juga
• Ruby: juga
• Fantom (sebelumnya Fan): juga
• Java 7: juga
• Swift: (sama?)
• Python 3.6
• C ++ 14: 1'000'000'000

Ini adalah fitur yang relatif baru bagi bahasa untuk menyadari bahwa mereka harus mendukung (dan kemudian ada Perl). Seperti dalam jawaban yang sangat baik chux @, 1000*1000...adalah solusi parsial tetapi membuka programmer hingga bug dari meluap penggandaan bahkan jika hasil akhirnya adalah tipe besar.

Mungkin lebih mudah untuk membaca dan mendapatkan beberapa asosiasi dengan 1,000,000,000formulir.

Dari aspek teknis saya kira tidak ada perbedaan antara angka langsung atau perkalian. Kompilator akan menghasilkannya sebagai angka miliar konstan.

Jika Anda berbicara tentang objektif-c, maka 1000^3tidak akan berfungsi karena tidak ada sintaks untuk pow (itu adalah xor). Sebaliknya, pow()fungsi bisa digunakan. Tetapi dalam kasus itu, itu tidak akan optimal, itu akan menjadi panggilan fungsi runtime bukan kompiler yang dihasilkan konstan.

Untuk mengilustrasikan alasan pertimbangkan program uji berikut:

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

Cara lain untuk mencapai efek yang sama dalam C untuk angka desimal adalah dengan menggunakan notasi floating point literal - asalkan dobel dapat mewakili angka yang Anda inginkan tanpa kehilangan presisi.

IEEE 754 64-bit double dapat mewakili integer non-negatif <= 2 ^ 53 tanpa masalah. Biasanya, panjang ganda (80 atau 128 bit) bisa lebih jauh dari itu. Konversi akan dilakukan pada waktu kompilasi, jadi tidak ada overhead runtime dan Anda mungkin akan mendapatkan peringatan jika ada kehilangan presisi yang tidak terduga dan Anda memiliki kompiler yang baik.

long lots_of_secs = 1e9;