ในภาษาที่ไม่อนุญาตขีดล่างในค่าคงที่จำนวนเต็มเป็นวิธีปฏิบัติที่ดีในการสร้างค่าคงที่ 1 พันล้านหรือไม่

ในภาษาที่ไม่อนุญาตขีดล่างเป็นตัวอักษรจำนวนเต็มคุณควรสร้างค่าคงที่ 1 พันล้านหรือไม่ เช่นใน C ++:

size_t ONE_BILLION = 1000000000;

แน่นอนว่าเราไม่ควรสร้างค่าคงที่สำหรับตัวเลขขนาดเล็กเช่น 100 แต่ด้วยค่าศูนย์ 9 มันเป็นเรื่องง่ายที่จะละทิ้งศูนย์หรือเพิ่มรหัสพิเศษในโค้ดดังนี้:

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

ภาษาส่วนใหญ่มีสัญกรณ์แบบเอ็กซ์โพเนนเชียล หนึ่งล้านคือ1e6(หมายถึง 1 คูณ 10 ต่อกำลังของ 6) วิธีนี้แก้ปัญหาได้ดีกว่าข้อเสนอส่วนใหญ่ที่นี่

ในภาษาที่มีลักษณะคล้าย C จำนวนมากสัญกรณ์ทางวิทยาศาสตร์ได้กำหนดประเภทจุดลอยตัวซึ่งเป็นโชคร้ายหากคุณต้องการใช้ int อย่างไรก็ตามคุณสามารถพิมพ์ค่าคงที่นั้นเพื่อหลีกเลี่ยงการแปลงโดยนัยในสูตรของคุณ

n / int(1e9) จะหารด้วยพันล้าน

ในตัวอย่างของคุณเกี่ยวกับปริมาณทางกายภาพ (เวลาเป็นเสี้ยววินาที) โดยทั่วไปฉันจะถามตัวเองว่าจำนวนเต็มเป็นประเภทที่ถูกต้องหรือไม่ ในความเป็นจริงแล้วจุดลอยตัวdoubleอาจเหมาะสมกว่าเมื่อจัดการกับปริมาณที่วัดได้ (แม้ว่าจะมีบางกรณีที่คุณต้องการlong long)

สร้างหนึ่งชื่อ NANOSECONDS_IN_ONE_SECOND แทนที่จะเป็นชื่อ

หรือชื่อที่สั้นกว่าและดีกว่าถ้าคุณคิดได้

ค่าคงที่มีไว้เพื่อให้ความหมายตัวเลข ไม่มีความหมายใด ๆ เพิ่มเติมในการที่จะONE_BILLION 1000000000ที่จริงแล้วมันทำให้เกิดความสับสนมากขึ้นเพราะในภาษาธรรมชาติที่แตกต่างกันพันล้านหมายถึงสิ่งที่แตกต่าง (ทั้งพันล้านหรือล้านล้าน)! 1e9หากคุณต้องการที่จะเขียนมันสั้นมีโอกาสที่ดีในการเขียนโปรแกรมภาษาของคุณช่วยให้การใช้สัญกรณ์วิทยาศาสตร์คือ มิฉะนั้นฉันเห็นด้วยกับ @JohnB ว่าตัวเลขนี้หมายถึงจำนวนนาโนวินาทีในวินาทีดังนั้นตั้งชื่อมันว่า

สำหรับประเพณีหนึ่งหรือสองฉันจะใช้การประชุม:

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

มันอธิบายตนเองได้อย่างสมบูรณ์ถูกรวบรวมเป็นค่าคงที่และยากที่จะพลาด

นอกจากนี้ยังมีประโยชน์อย่างมากในกรณีเช่น:

var Time = 24 * 60 * 60;

เราเห็นว่าเรากำลังพูดถึงหนึ่งวันในไม่กี่วินาที

ความยาวของค่าไม่ใช่สิ่งที่กำหนดว่าต้องการค่าคงที่หรือไม่

คุณใช้ค่าคงที่เพื่อหลีกเลี่ยงตัวเลขเวทย์มนตร์ไม่ใช่เพื่อหลีกเลี่ยงการพิมพ์

ตัวอย่างเช่นค่าคงที่ที่ถูกต้อง:

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;

ใช้:

public static final int NANOSECS_PER_SECOND = 1000000000;

(ตัวอย่างโค้ดอยู่ใน Java แปลเป็นภาษาที่คุณชื่นชอบ)

อเมริกันหรือยุโรปพันล้าน

(หรือในด้านเทคนิคหนึ่งพันล้านในระยะสั้นหรือยาว - หนึ่งคือ 1,000 ล้านและอีกหนึ่งล้านล้าน)

ด้วยความสับสนนี้จากนั้นฉันก็บอกว่าใช่ - มันสมเหตุสมผลแล้วที่จะนิยามมันอีกครั้งและเก็บไว้กับมันเช่นเดียวกันกับค่าคงที่ใด ๆ ที่คุณต้องเห็นด้วยกับคำนิยามบน

เหตุผลที่ไม่ควร

ประการแรกนี่คือเหตุผลที่ไม่เขียนขีดล่างหรือใช้เคล็ดลับใด ๆ ในการจำลองมันทำให้ค่าคงที่ยากต่อการค้นหาในรหัส สมมติว่ามีบางโปรแกรมจัดแสดงบางส่วนในการดำเนินงานของมูลค่า 1,500,000 รหัสยากสำหรับพารามิเตอร์บางอย่าง ฉันต้องการที่จะรู้ว่าสิ่งที่เกิดขึ้นในซอร์สโค้ดของโปรแกรมนั้นจริงดังนั้นฉันจึง grep รหัสสำหรับ1500000และหาอะไร ทำไม? อาจเป็นเลขฐานสิบหก (แต่ทำไมตัวเลขทศนิยมกลมเช่นนี้) 1_500_000ถิ่นที่ฉันคงถูกเขียนเป็นจริง ผมจำเป็นต้อง 1_?500_?000regex

แนะนำตัวละครในความคิดเห็น

เพียงเพราะ Visual Aid ประเภทหนึ่งไม่พร้อมใช้งานหรือเราไม่ต้องการใช้ด้วยเหตุผลดังกล่าวข้างต้นไม่ได้หมายความว่าเราไม่สามารถใช้ประโยชน์จากไฟล์ข้อความสองมิติเพื่อสร้างเครื่องช่วยมองเห็นทางเลือก:

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

ด้วยวิธีนี้เราสามารถโน้มน้าวตัวเองได้อย่างง่ายดายว่ามีสามกลุ่มสามศูนย์ ถึงกระนั้นเรายังสามารถ grep ซอร์สโค้ด1000000000และค้นหาได้

การระบายสีไวยากรณ์

เท็กซ์เอดิเตอร์พร้อมการกำหนดสีไวยากรณ์ที่สามารถตั้งโปรแกรมสามารถทำกับกลุ่มสีหลักในค่าคงที่ตัวเลขที่มีสีสลับเพื่อให้อ่านง่ายขึ้น เราไม่ต้องทำอะไรในรหัส

การประมวลผลล่วงหน้า: C, C ++, Objective C

ตอนนี้ถ้าเราต้องการเครื่องหมายจุลภาคระหว่างตัวเลขใน C และ C ++ เราสามารถใช้การประมวลผลล่วงหน้า:

/* 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)

TH(1,234,567,890)การทำงานสำหรับตัวเลขเช่น

แมโครที่คล้ายกับ TH สามารถทำงานกับการวางโทเค็นได้มากกว่าการคำนวณ ในตัวประมวลผลล่วงหน้า C ตัว##ดำเนินการไบนารี("โทเค็นแปะ") สามารถใช้ในเนื้อความมาโครเพื่อวางตัวถูกดำเนินการสองตัวเข้าด้วยกันในโทเค็นเดียว ตัวถูกดำเนินการหนึ่งหรือทั้งคู่สามารถเป็นอาร์กิวเมนต์ของแมโครได้ ข้อเสียที่นี่ (สร้างความเสี่ยงสำหรับเรา) คือหากการทำให้เกิดผลไม่ได้เป็นโทเค็นที่ถูกต้องพฤติกรรมจะไม่ได้กำหนด

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

ตอนนี้

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 */

โปรแกรม C ที่วางตัวระบุร่วมกันและใช้ผลลัพธ์เพื่อตั้งชื่อตัวแปรส่วนกลางและฟังก์ชันที่มีอยู่และน่ากลัวที่จะทำงานด้วยเพราะไม่สามารถใช้เครื่องมือเช่น GNU id-utils และ ctags

ใช่ฟังดูเหมือนความคิดที่สมเหตุสมผล ข้อผิดพลาด DIGIT แบบ Off-by-One นั้นเลวร้ายยิ่งกว่าข้อผิดพลาดแบบ off-by-one ที่น่าอับอาย แม้ว่ามันอาจสร้างความสับสนให้คนอื่น (รวมถึงตัวคุณในอนาคต) เพื่ออ่านรหัส

ชื่อที่อธิบายเพิ่มเติมเช่น NANOSEC_PER_SEC นั้นดูดีเพราะจะช่วยเพิ่มความชัดเจนในการใช้งานได้ตลอดเวลา อย่างไรก็ตามมันไม่มีเหตุผลที่จะใช้ในบริบทอื่นนอกเหนือจากเวลาและมันจะเป็นไปไม่ได้ที่จะสร้างแยก 1,000,000,000 สำหรับทุกสถานการณ์

สิ่งที่คุณต้องการทำอย่างโง่ ๆ อย่างที่เห็นในตอนแรกคือ 'หารด้วยวินาที' สิ่งนี้ออกจาก NANO_PER ซึ่งไม่เพียง แต่เป็นภาษาอิสระ (10 ^ 9 ในอเมริกาและยุโรป) แต่ยังเป็นสถานการณ์ที่ไม่ขึ้นอยู่กับสถานการณ์ (ไม่ จำกัด หน่วย) และสามารถพิมพ์และอ่านได้ง่าย

โดยทั่วไปเป็นความคิดที่ดีที่จะใช้ค่าคงที่สเกลาร์สำหรับการแปลงหน่วยและหากคุณพบว่าตัวเองยังคงมีค่าคงที่สำหรับสิ่งต่าง ๆ ที่คุณกำลังทำอยู่ในหลาย ๆ แปลง

เมื่อคุณมีปริมาณหนึ่งหน่วย (พูดคือ 10 วินาที) และต้องการแปลงเป็นหน่วยอื่น (เช่นนาโนวินาที) นี่เป็นเวลาที่จะใช้ระบบประเภทของภาษาของคุณเพื่อให้แน่ใจว่าหน่วยจะถูกปรับขนาดตามที่คุณต้องการ

ทำให้การทำงานของคุณจะใช้Nanosecondsพารามิเตอร์และให้ผู้ประกอบการแปลงและ / หรือการก่อสร้างงานในชั้นเรียนว่าสำหรับSeconds, Minutesหรือสิ่งที่มีคุณ นี่คือที่ของคุณconst intหรือ#defineหรือ1e9เห็นในคำตอบอื่น ๆ

วิธีนี้จะหลีกเลี่ยงการมีตัวแปรของหน่วยที่ไม่ชัดเจนซึ่งลอยอยู่รอบ ๆ โค้ดของคุณ และป้องกันมิให้มีข้อบกพร่องทั้งหมดจากจุดที่มีการใช้การคูณ / หารที่ไม่ถูกต้องหรือถูกนำไปใช้แล้วหรือปริมาณนั้นเป็นระยะทางแทนเวลาหรือ ...

นอกจากนี้ในคลาสดังกล่าวเป็นสิ่งที่ดีที่จะสร้างจากสเกลาร์ส่วนตัวแบบส่วนตัวและใช้ "MakeSeconds (int)" แบบคงที่หรือคล้ายกับการกีดกันการใช้ตัวเลขทึบแสงแบบเลอะเทอะ

โดยเฉพาะอย่างยิ่งกับตัวอย่างของคุณใน C ++ ตรวจสอบBoost.Chrono

โดยส่วนตัวฉันจะไม่คิดว่าเป็นการฝึกฝนที่ดีในการสร้างค่าคงที่เว้นแต่จะต้องเป็นค่าคงที่ ถ้ามันจะอยู่ในหลาย ๆ ที่และมันถูกกำหนดไว้ที่ด้านบนของไฟล์สำหรับการแก้ไข / หรือการทดสอบจะมีประโยชน์อย่างแน่นอน

ถ้ามันเป็นเพราะมันอึดอัดใจที่จะพิมพ์? จากนั้นไม่

โดยส่วนตัวถ้าฉันได้รหัสของคนอื่นที่มีค่าคงที่โดยทั่วไปฉันคิดว่านี่เป็นสิ่งสำคัญของรหัส เช่น TCP เก็บรักษาตัวนับมีชีวิตจำนวนการเชื่อมต่อสูงสุดที่อนุญาต หากฉันต้องแก้ไขข้อบกพร่องฉันอาจต้องให้ความสนใจอย่างไม่จำเป็นกับมันและพยายามคิดออกว่าเหตุใด / การใช้ที่ใด

เมื่อคุณคิดว่าทำไมคุณถึงเขียน "1 พันล้าน" แทนที่จะเป็น "1000000000" ในชื่อคำถามของคุณคุณจะรู้ว่าทำไมคำตอบคือใช่

อย่าสร้างค่าคงที่สำหรับตัวใหญ่ของคุณ คุณจะต้องมีค่าคงที่สำหรับแต่ละตัวอักษรซึ่งเป็น (ในความคิดของฉัน) เรื่องตลกที่สมบูรณ์ หากคุณต้องการทำให้ตัวอักษรของคุณชัดเจนขึ้นโดยปราศจากความช่วยเหลือจากสิ่งต่าง ๆ เช่นการเน้นไวยากรณ์คุณสามารถ (แม้ว่าฉันจะไม่) สร้างฟังก์ชันหรือมาโครเพื่อทำให้ชีวิตของคุณ "ง่ายขึ้น":

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

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

ฉันจะทำสิ่งนี้:

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

หรือ

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

เกี่ยวกับจำนวนนาโนวินาทีต่อวินาที: nano คือ "inverse" ของ giga

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

หมายเหตุ "Sci" - สำหรับวิทยาศาสตร์เช่นเดียวกับในคอมพิวเตอร์ความหมายของกิโลเมก้าเมก้า ฯลฯ มีความแตกต่าง: 1024 (2 ^ 10), 1024 * 1024 (2 ^ 20) ฯลฯ 2 เมกะไบต์ไม่ได้ 2,000,000 ไบต์ .

ผู้แสดงความคิดเห็นUPDATEชี้ให้เห็นว่ามีคำศัพท์พิเศษสำหรับ exponents แบบดิจิทัล 2: http://en.wikipedia.org/wiki/Mebibyte