Tại sao viết 1.000.000.000 dưới dạng 1000 * 1000 * 1000 bằng C?

Trong mã được tạo bởi Apple, có dòng này:

CMTimeMakeWithSeconds( newDurationSeconds, 1000*1000*1000 )

Có bất kỳ lý do để thể hiện 1,000,000,000như 1000*1000*1000?

Tại sao không 1000^3cho vấn đề đó?

Một lý do để khai báo các hằng số theo cách nhân là để cải thiện khả năng đọc, trong khi hiệu suất thời gian chạy không bị ảnh hưởng. Ngoài ra, để chỉ ra rằng người viết đã suy nghĩ theo cách nhân lên về con số.

Xem xét điều này:

double memoryBytes = 1024 * 1024 * 1024;

Rõ ràng là tốt hơn:

double memoryBytes = 1073741824;

như cái nhìn thứ hai không nhìn, thoạt nhìn, sức mạnh thứ ba của 1024.

Như Amin Negm-Awad đã đề cập, ^toán tử là nhị phân XOR. Nhiều ngôn ngữ thiếu toán tử lũy thừa thời gian biên dịch tích hợp, do đó nhân lên.

Tại sao không 1000^3?

Kết quả 1000^3là 1003. ^là toán tử bit-XOR.

Ngay cả nó không đối phó với chính Q, tôi thêm một sự làm rõ. x^ykhông phải lúc nào cũng đánh giá x+ynhư trong ví dụ của người hỏi. Bạn phải xor mỗi bit. Trong trường hợp ví dụ:

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

Nhưng

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

Có những lý do không sử dụng 1000 * 1000 * 1000.

Với 16-bit int, 1000 * 1000tràn. Vì vậy, sử dụng 1000 * 1000 * 1000làm giảm tính di động.

Với 32-bit int, dòng mã đầu tiên sau đây tràn ra.

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

Đề xuất rằng giá trị khách hàng tiềm năng phù hợp với loại điểm đến về tính dễ đọc, tính di động và tính chính xác.

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

Cũng có thể sử dụng eký hiệu đơn giản cho các giá trị có thể biểu diễn chính xác như một double. Tất nhiên, điều này dẫn đến việc biết doublechính xác có thể đại diện cho toàn bộ giá trị số hay không - điều đáng quan tâm với các giá trị lớn hơn 1e9. (Xem DBL_EPSILONvà DBL_DIG).

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

Để dễ đọc.

Đặt dấu phẩy và khoảng trắng giữa các số 0 ( 1 000 000 000hoặc 1,000,000,000) sẽ tạo ra lỗi cú pháp và việc có 1000000000mã khiến bạn khó có thể biết chính xác có bao nhiêu số không.

1000*1000*1000làm cho nó rõ ràng là 10 ^ 9, bởi vì mắt chúng ta có thể xử lý các khối dễ dàng hơn. Ngoài ra, không có chi phí thời gian chạy, bởi vì trình biên dịch sẽ thay thế nó bằng hằng số 1000000000.

Để dễ đọc. Để so sánh, Java hỗ trợ _về số lượng để cải thiện khả năng đọc (lần đầu tiên được đề xuất bởi Stephen Colebourne như là một câu trả lời cho Derek Fosterer PROPOSAL: Binary Literals for Project Coin / JSR 334). Một người sẽ viết 1_000_000_000ở đây.

Theo thứ tự thời gian đại khái, từ hỗ trợ cũ nhất đến mới nhất:

• XPL: "(1)1111 1111"( dường như không dành cho các giá trị thập phân, chỉ dành cho bitstrings đại diện cho các giá trị nhị phân, tứ phân vị, bát phân hoặc thập lục phân )
• PL / M: 1$000$000
• Ada: 1_000_000_000
• Perl: tương tự như vậy
• Ruby: tương tự như vậy
• Fantom (Fan trước đây): tương tự
• Java 7: tương tự như vậy
• Swift: (giống nhau?)
• Python 3.6
• C ++ 14: 1'000'000'000

Đây là một tính năng tương đối mới để các ngôn ngữ nhận ra rằng chúng phải hỗ trợ (và sau đó là Perl). Như trong câu trả lời xuất sắc của chux @, 1000*1000...là một giải pháp một phần nhưng mở ra cho các lập trình viên các lỗi từ việc tràn bội số ngay cả khi kết quả cuối cùng là một loại lớn.

Có thể đơn giản hơn để đọc và nhận được một số liên kết với các 1,000,000,000hình thức.

Từ khía cạnh kỹ thuật tôi đoán không có sự khác biệt giữa số trực tiếp hoặc phép nhân. Trình biên dịch sẽ tạo ra nó dưới dạng số tỷ không đổi.

Nếu bạn nói về object-c, thì 1000^3sẽ không hoạt động vì không có cú pháp như vậy cho pow (đó là xor). Thay vào đó, pow()chức năng có thể được sử dụng. Nhưng trong trường hợp đó, nó sẽ không tối ưu, nó sẽ là một hàm gọi thời gian chạy không phải là trình biên dịch được tạo.

Để minh họa các lý do hãy xem xét chương trình thử nghiệm sau:

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

Một cách khác để đạt được hiệu ứng tương tự trong C đối với các số thập phân là sử dụng ký hiệu dấu phẩy động theo nghĩa đen - miễn là gấp đôi có thể đại diện cho số bạn muốn mà không mất độ chính xác.

IEEE 754 64 bit có thể biểu thị bất kỳ số nguyên không âm nào <= 2 ^ 53 mà không gặp vấn đề gì. Thông thường, gấp đôi dài (80 hoặc 128 bit) có thể đi xa hơn thế. Việc chuyển đổi sẽ được thực hiện vào thời gian biên dịch, do đó không có chi phí thời gian chạy và bạn có thể sẽ nhận được cảnh báo nếu có sự mất chính xác không mong muốn và bạn có một trình biên dịch tốt.

long lots_of_secs = 1e9;