Neden 1.000.000.000'u 1000 * 1000 * 1000 olarak yazmalısınız?

Apple tarafından oluşturulan kodda şu satır var:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

1,000,000,000Olarak ifade etmek için herhangi bir sebep var mı 1000*1000*1000?

Neden 1000^3bu konuda olmasın?

Sabitleri çarpımsal bir şekilde bildirmenin bir nedeni, çalışma zamanı performansı etkilenmezken okunabilirliği artırmaktır. Ayrıca, yazarın sayı hakkında çarpımsal bir şekilde düşündüğünü belirtmek.

Bunu düşün:

double memoryBytes = 1024 * 1024 * 1024;

Açıkça daha iyidir:

double memoryBytes = 1073741824;

çünkü ikincisi ilk bakışta 1024'ün üçüncü gücüne bakmıyor.

Amin Negm-Awad'ın belirttiği gibi, ^operatör ikiliktir XOR. Birçok dilde yerleşik, derleme zamanı üs alma işleci yok, dolayısıyla çarpma.

Neden olmasın 1000^3?

1000^31003 sonucudur. ^Bit-XOR operatörüdür.

Q'nun kendisi ile ilgilenmese bile, bir açıklama ekliyorum. x^yyok değil her zaman için değerlendirmek x+yo sorunu olanın örnekte olduğu gibi. Her parçayı xor yapmanız gerekiyor. Örnek olması durumunda:

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

Fakat

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

Nedeni vardır değil kullanmak 1000 * 1000 * 1000.

16-bit ile int, 1000 * 1000taşıyor. Böylece kullanmak 1000 * 1000 * 1000taşınabilirliği azaltır.

32-bit ile int, aşağıdaki ilk kod satırı taşar.

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

Olası satış değerinin, okunabilirlik, taşınabilirlik ve doğruluk için hedef türüyle eşleşmesini önerin .

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

Ayrıca e, tam olarak a olarak temsil edilebilen değerler için gösterimi basit bir şekilde kullanabilir double. Elbette bu double, tam sayı değerini tam olarak temsil edip edemeyeceğini bilmeye yol açar - 1e9'dan büyük değerlerle ilgili bir şey. (Bkz. DBL_EPSILONVe DBL_DIG).

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

Okunabilirlik için.

Sıfırlar ( 1 000 000 000veya 1,000,000,000) arasına virgül ve boşluk yerleştirmek bir sözdizimi hatası oluşturur ve 1000000000koda sahip olmak, tam olarak kaç sıfır olduğunu görmeyi zorlaştırır.

1000*1000*100010 ^ 9 olduğu anlaşılıyor, çünkü gözlerimiz parçaları daha kolay işleyebiliyor. Ayrıca, çalışma zamanı maliyeti yoktur, çünkü derleyici bunu sabitle değiştirecektir 1000000000.

Okunabilirlik için. Karşılaştırma için, Java, _okunabilirliği artırmak için sayıları desteklemektedir (ilk olarak Stephen Colebourne tarafından Derek Foster'ın ÖNERİSİ: Project Coin / JSR 334 için İkili Değişmezlere cevap olarak önerilmiştir ). Biri 1_000_000_000buraya yazar.

Kabaca kronolojik sırayla, en eski destekten en yenisine:

• XPL: "(1)1111 1111"( görünüşe göre ondalık değerler için değil, yalnızca ikili, dörtlü, sekizli veya onaltılık değerleri temsil eden bit dizeleri için )
• PL / K: 1$000$000
• Ada: 1_000_000_000
• Perl: aynı şekilde
• Ruby: aynı şekilde
• Fantom (önceden Fan): aynı şekilde
• Java 7: aynı şekilde
• Swift: (aynı mı?)
• Python 3.6
• C ++ 14: 1'000'000'000

Dillerin desteklemeleri gerektiğini fark etmeleri için nispeten yeni bir özellik (ve sonra Perl var). Chux @ 'un mükemmel cevabında 1000*1000...olduğu gibi, kısmi bir çözümdür, ancak nihai sonuç büyük bir tür olsa bile, programlayıcıyı çarpımdan taşan hatalara kadar açar.

1,000,000,000Formu okumak ve formla bazı ilişkilendirmeler almak daha kolay olabilir.

Teknik açıdan, doğrudan sayı veya çarpma arasında bir fark olmadığını düşünüyorum. Derleyici yine de sabit milyar sayısı üretecektir.

Eğer objektif-c hakkında konuşursanız, o 1000^3zaman işe yaramaz çünkü pow için böyle bir sözdizimi yoktur (xor). Bunun yerine pow()işlev kullanılabilir. Ancak bu durumda, optimal olmayacak, derleyici tarafından üretilen bir sabit değil, bir çalışma zamanı işlevi çağrısı olacaktır.

Nedenleri göstermek için aşağıdaki test programını göz önünde bulundurun:

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

Ondalık sayılar için C'de benzer bir etki elde etmenin bir başka yolu, gerçek bir kayan nokta gösterimi kullanmaktır - bir çift, herhangi bir hassasiyet kaybı olmadan istediğiniz sayıyı temsil edebildiği sürece.

IEEE 754 64 bit çift, negatif olmayan herhangi bir <= 2 ^ 53 tamsayısını sorunsuz olarak temsil edebilir. Tipik olarak, uzun çift (80 veya 128 bit) bundan daha da ileri gidebilir. Dönüşümler derleme zamanında yapılacaktır, bu nedenle çalışma zamanı yükü yoktur ve beklenmedik bir hassasiyet kaybı varsa ve iyi bir derleyiciniz varsa büyük olasılıkla uyarılar alırsınız.

long lots_of_secs = 1e9;