Tam sayı sabitlerinde alt çizgi bulunmasına izin vermeyen dillerde, 1 milyar için bir sabit oluşturmak iyi bir uygulama mıdır?

Tamsayı değişmezlerin alt çizgi yapmasına izin vermeyen dillerde, 1 milyar için bir sabit oluşturmak iyi bir fikir midir? örneğin, C ++ 'da:

size_t ONE_BILLION = 1000000000;

Kuşkusuz, 100 gibi küçük sayılar için sabitler yaratmamalıyız. Fakat 9 sıfırla, sıfır gibi bırakmak ya da böyle bir kodda fazladan bir tane eklemek tartışmalı olarak kolaydır:

tv_sec = timeInNanosec / 1000000000;
tv_nsec = timeInNanosec % 1000000000;

Çoğu dilde bir çeşit üstel gösterim vardır. Bir milyon 1e6(1 ila 10, 6'nın gücüne karşılık gelir). Bu temelde meseleyi, buradaki önerilerin çoğundan daha iyi çözer.

Bir çok C-benzeri dilde, bilimsel gösterim , gerçekten bir int ihtiyacınız varsa talihsiz bir kayan nokta türü tanımlamaktadır . Ancak, formülerinizde gizli dönüşümleri önlemek için bu sabiti kolayca yazabilirsiniz.

n / int(1e9) bir milyar ile bölecekti.

Örneğinizde fiziksel niceliklerle (nanosaniye cinsinden zaman) ilgilenmekle, kendime tamsayının doğru tip olup olmadığını sordum. Aslında double, ölçülebilir miktarlarla uğraşırken kayan bir nokta daha uygun olabilir (elbette a'yı tercih ettiğiniz durumlar olsa da long long).

Temsil ettiği yerine NANOSECONDS_IN_ONE_SECOND adlı bir tane oluşturun.

Ya da daha kısa, daha iyi bir isim varsa düşünebilirsiniz.

Sabitler rakamlara anlam vermek içindir. Bunun başka bir anlamı ONE_BILLIONyok 1000000000. Aslında, daha kafa karıştırıcıdır, çünkü farklı doğal dillerde, bir milyar farklı bir şey demektir (bin milyon ya da milyon milyon)! Daha kısa yazmak istiyorsanız, programlama dilinizin bilimsel gösterimi kullanmasına izin vermesi iyi bir olasılıktır, örn 1e9. Aksi takdirde, @JoB ile aynı fikirdeyim, bu sayı gerçekten bir saniye cinsinden nanosaniye sayısı anlamına geliyor, bu yüzden bunu adlandırın.

Bir veya iki kullanım için sözleşmeyi kullanırdım:

tv_sec = timeInNanosec / (1000 * 1000 * 1000);
tv_nsec = timeInNanosec % (1000 * 1000 * 1000);

Mükemmel bir şekilde kendini açıklayıcı, sabit bir şekilde derlenmiş ve parçalanması zor.

Ayrıca, bu gibi durumlarda çok yararlıdır:

var Time = 24 * 60 * 60;

görmek kolay nerede saniyede bir gün hakkında konuşuyorsun.

Değerin uzunluğu, sabitin gerekli olup olmadığını tanımlayan şey değildir.

Sihirli sayılardan kaçınmak için sabitleri kullanırsınız , yazmaktan kaçının.

Örneğin, bunlar tamamen geçerli sabitler:

public static final int CLOSE_CURSORS_AT_COMMIT = 1;
public static final int CONCUR_READ_ONLY = 2;
public static final int CONCUR_UPDATABLE = 3;
public static final int FETCH_FORWARD = 4;
public static final int FETCH_REVERSE = 5; 
public static final int FETCH_UNKNOWN = 6;
public static final int HOLD_CURSORS_OVER_COMMIT = 7;
public static final int TYPE_FORWARD_ONLY = 8;
public static final int TYPE_SCROLL_INSENSITIVE = 9;
public static final int TYPE_SCROLL_SENSITIVE = 10;

kullanın:

public static final int NANOSECS_PER_SECOND = 1000000000;

(kod örnekleri Java’dadır, en sevdiğiniz dile çevirin)

Bir Amerikalı mı yoksa Avrupalı ​​milyar mı?

(veya teknik açıdan, kısa veya uzun ölçekte bir milyar - biri 1000 milyon, diğeri bir milyon milyondur).

Bu karışıklık göz önüne alındığında, evet derdim - bir kez tanımlamak ve onunla devam etmek mantıklıdır, aynı şekilde tanımını kabul etmek için ihtiyaç duyduğunuz herhangi bir sabit için de geçerlidir - bir kez tanımlayın.

Olmama Nedenleri

Öncelikle, burada simüle etmek için herhangi bir alt çizgi yazmamak ya da herhangi bir numara kullanmamak için bir neden: sabitleri kodda bulmayı zorlaştırıyor. Bazı programların çalışmasının bir yerinde, bazı parametreler için 1500000 kodlanmış değer gösterdiğini varsayalım. Bu programın kaynak kodunda gerçekte nerede gerçekleştiğini bilmek istiyorum, bu yüzden kodu okuyorum 1500000ve hiçbir şey bulamadım. Neden? Onaltılık (ancak böyle bir yuvarlak ondalık sayı için neden) olabilir. Bana göre, sabit aslında olarak yazılmıştır 1_500_000. Regex'e ihtiyacım vardı 1_?500_?000.

Yorumdaki Karakterleri Rehberlik Etme

Sadece bir çeşit görsel yardım bulunmadığı veya yukarıdaki nedenlerden dolayı kullanmak istemediğimizden, alternatif bir görsel yardım oluşturmak için metin dosyasının iki boyutundan yararlanamayacağımız anlamına gelmez:

foo = bar / 1000000000;
//           --^--^--^  

Bununla kendimizi üç sıfır grubun olduğu konusunda rahatlıkla ikna edebiliriz. Yine de, kaynak kodunu hala 1000000000bulabilir ve bulabiliriz.

Sözdizimi Renklendirme

Programlanabilir sözdizimi renklendirmeli bir metin editörü daha iyi okunabilmesi için basamakları nümerik sabitler halinde değişen renklerle renklendirmek için yapılabilir. Kodda hiçbir şey yapmak zorunda değiliz.

Ön işleme: C, C ++, Amaç C

Şimdi, basamaklar arasında gerçekten virgül istiyorsak, C ve C ++ 'da ön işleme kullanabiliriz:

/* Four digit base TH-ousand constant macro */
/* Condensed using Horner's rule */
#define TH(A,B,C,D) ((((((A) * 1000) + (B)) * 1000) + (C)) * 1000 + D)

tv_sec = nanoseconds / TH(1,000,000,000)

Gibi sayılar için çalışıyor TH(1,234,567,890).

TH'ye benzer bir makro da aritmetik değil, token yapıştırma ile de çalışabilir. C önişlemcisinde, ##iki işleci tek bir tonada yapıştırmak için ikili operatör ("token paste") bir makro gövdede kullanılabilir. İşlenenlerden biri veya her ikisi de makro argümanlar olabilir. Buradaki dezavantaj (bizim için bir risk oluşturmaktır) ortaya çıkan katener geçerli bir belirteç değilse, davranış tanımsızdır.

#define TOK4(A, B, C, D) A ## B ## C ## D

şimdi

TOK4(1,000,000,000)       /* produces the single token 1000000000 */
TOK4(1,123,000,000.0E+2)  /* produces the single token 1123000000.0E+2 */
TOK4(pr,in,t,f)           /* produces the token printf */
TOK4(#,*,a,b)             /* undefined behavior, #*ab is not valid token syntax */

Tanımlayıcıları bir araya getiren ve sonuçları global değişkenleri ve fonksiyonları isimlendirmek için kullanan C programları mevcuttur ve çalışmak için zordur çünkü GNU id-utils ve ctags gibi araçlara karşı hassastırlar.

Evet, makul bir fikir gibi geliyor. Off-by-one DIGIT hataları rezil off-by-one hatalarından bile daha kötü. Bununla birlikte, diğer insanların (gelecekteki benliğiniz de dahil) kodu okuması için karışıklık yaratabilir.

NANOSEC_PER_SEC gibi daha açıklayıcı bir isim, zaman için kullanıldığı yerde netlik katacağı için iyi görünüyor. Bununla birlikte, zaman dışındaki bağlamlarda kullanılmasının bir anlamı yoktur ve her durum için ayrı bir 1.000.000.000 oluşturmak pratik değildir.

Gerçekten yapmak istediğin, ilk bakışta göründüğü gibi aptalca, 's bölü bölme' olur. Bu, yalnızca dilden bağımsız (Amerika ve Avrupa'da 10 ^ 9) değil aynı zamanda durumdan bağımsız (birimler üzerinde sınırlama yoktur) ve yazması ve okuması kolay olan NANO_PER'yi bırakır.

Genel olarak birim dönüşümler için skaler sabitleri kullanmak kötü bir fikirdir ve kendinizi bu tür şeyler için sabitleştiriyorsanız çok fazla yerde dönüşüm yapıyorsunuzdur.

Bir birim miktarınız varsa (örneğin, 10 saniye) ve başka bir birime (yani nanosaniye) dönüştürmek istediğinizde; tam olarak, birimlerin gerçekten istediğiniz gibi ölçeklendirilmesini sağlamak için dilinizin tür sistemini kullanmanın tam zamanıdır.

Fonksiyonun bir alacak olun Nanosecondsparametreyi ve söz konusu sınıfta dönüşüm operatörleri ve / veya kurucular sağlamak Seconds, Minutesya da ne-si-sen. Senin burasıdır const intveya #defineveya 1e9diğer cevaplar görülen aittir.

Bu, kodunuzun etrafında yüzen belirsiz birimlerin değişkenlerinin bulunmasını önler; ve yanlış çarpma / bölmenin uygulandığı ya da zaten uygulandığı ya da miktarın zaman yerine aslında mesafe olduğu ya da ...

Ayrıca, bu tür sınıflarda düz skalerden özel yapım yapmak ve statik olmayan bir "MakeSeconds (int)" kullanmak veya opak sayıların caydırıcı olmayan özensiz kullanımına benzer.

Daha spesifik olarak, örneğinize göre, C ++ 'da Boost.Chrono'yu inceleyin .

Şahsen, sabit olması gerekmedikçe, bir sabit yaratmanın iyi bir uygulama olduğunu düşünmezdim. Birden fazla yerde olması ve dosyanın üst kısmında tanımlanması ve / veya test edilmek üzere tanımlanmış olması kesinlikle yararlı olacaktır.

Sadece onun için yazmak için garip çünkü? o zaman hayır.

Şahsen, tanımlanmış sabiti olan bir başkasının kodunu alırsam, bunun genellikle kodun önemli bir yönü olduğunu düşünüyorum. Tcp, zamanlayıcıları canlı tutar, izin verilen maksimum bağlantı sayısını sağlar. Eğer hata ayıklamak zorunda kalsaydım, neden / nerede kullanıldığını anlamaya çalışırken muhtemelen çok fazla dikkat etmem gerekirdi.

Soru başlığınızda neden "1000000000" yerine "1 Milyar" yazdığını düşündüğünüzde, cevabın neden evet olduğunu anlayacaksınız.

Büyük değişmezleriniz için bir sabit yaratmayın. Böyle bir kelimenin tam anlamıyla bir sabite ihtiyacınız olacak, (bence) tam bir şaka. Umutsuzca, sözdizimi vurgulama gibi şeylerin yardımı olmadan edebi dilinizi daha net hale getirmeniz gerekirse, ("yapmasam da) hayatınızı" kolaylaştırmak "için işlevler veya makrolar oluşturabilirsiniz:

#define SPLIT3(x, y, z) x##y##z

int largeNumber1 = SPLIT3(123,456,789);
int largeNumber2 = 123456789;

Bunu yapardım:

const int Million = 1000 * 1000;
const int Billion = 1000 * Million;

veya

const int SciMega = 1000 * 1000; const int SciGiga = 1000 * SciMega;

Saniyedeki nanosaniye sayısıyla ilgili olarak: nano, giga'nın "tersi" dir.

Kilo  Mega  Giga   etc.
10^3  10^6  10^9
Milli Micro Nano   etc.
10^-3 10^-6 10^-9

Bilimsel, "Sci" - bilgisayarlarda olduğu gibi kilo, mega, giga vb. Anlamları farklıdır: 1024 (2 ^ 10), 1024 * 1024 (2 ^ 20), vb. 2 megabayt 2.000.000 bayt değildir. .

GÜNCELLEME Yorumcu 2 dijital üsleri için özel terimlerin bulunduğunu belirtti: http://en.wikipedia.org/wiki/Mebibyte