X + = a có nhanh hơn x = x + a không?

Tôi đang đọc "Ngôn ngữ lập trình C ++" của Stroustrup, anh ấy nói rằng trong số hai cách để thêm thứ gì đó vào một biến

x = x + a;

và

x += a;

Anh ấy thích +=vì nó rất có thể được triển khai tốt hơn. Tôi nghĩ ý anh ấy là nó cũng hoạt động nhanh hơn.
Nhưng nó có thực sự không? Nếu nó phụ thuộc vào trình biên dịch và những thứ khác, làm cách nào để kiểm tra?

Bất kỳ trình biên dịch trị giá muối của nó sẽ tạo ra một cách chính xác các chuỗi ngôn ngữ máy tương tự cho cả hai cấu trúc đối với bất kỳ built-in loại ( int, float, vv) miễn là báo cáo kết quả thực sự là đơn giản như x = x + a; và tối ưu hóa được kích hoạt . (Đáng chú ý, GCC's -O0, là chế độ mặc định, thực hiện chống tối ưu hóa , chẳng hạn như chèn các kho lưu trữ hoàn toàn không cần thiết vào bộ nhớ, để đảm bảo rằng trình gỡ lỗi luôn có thể tìm thấy các giá trị thay đổi.)

Tuy nhiên, nếu câu lệnh phức tạp hơn, chúng có thể khác nhau. Giả sử flà một hàm trả về một con trỏ, thì

*f() += a;

fchỉ gọi một lần, trong khi

*f() = *f() + a;

gọi nó hai lần. Nếu fcó tác dụng phụ, một trong hai sẽ sai (có thể là sau này). Ngay cả khi fkhông có tác dụng phụ, trình biên dịch có thể không loại bỏ được cuộc gọi thứ hai, vì vậy cuộc gọi thứ hai thực sự có thể chậm hơn.

Và vì chúng ta đang nói về C ++ ở đây, tình hình hoàn toàn khác đối với các loại lớp quá tải operator+và operator+=. Nếu xlà một loại như vậy, thì - trước khi tối ưu hóa - x += adịch thành

x.operator+=(a);

trong khi x = x + adịch sang

auto TEMP(x.operator+(a));
x.operator=(TEMP);

Bây giờ, nếu lớp được viết đúng cách và trình tối ưu hóa của trình biên dịch đủ tốt, cả hai sẽ kết thúc việc tạo ra cùng một ngôn ngữ máy, nhưng điều đó không chắc chắn như đối với các loại tích hợp sẵn. Đây có lẽ là những gì Stroustrup nghĩ đến khi ông khuyến khích sử dụng +=.

Bạn có thể kiểm tra bằng cách nhìn vào phần tháo lắp, sẽ giống nhau.

Đối với các loại cơ bản , cả hai đều nhanh như nhau.

Đây là đầu ra được tạo bởi một bản dựng gỡ lỗi (tức là không có tối ưu hóa):

    a += x;
010813BC  mov         eax,dword ptr [a]  
010813BF  add         eax,dword ptr [x]  
010813C2  mov         dword ptr [a],eax  
    a = a + x;
010813C5  mov         eax,dword ptr [a]  
010813C8  add         eax,dword ptr [x]  
010813CB  mov         dword ptr [a],eax  

Đối với các kiểu do người dùng xác định , nơi bạn có thể quá tải operator +và operator +=tùy thuộc vào việc triển khai tương ứng của chúng.

Đúng! Nó nhanh hơn để viết, nhanh hơn để đọc và nhanh hơn để tìm ra, cho phần sau trong trường hợp xcó thể có tác dụng phụ. Vì vậy, nó nói chung nhanh hơn cho con người. Thời gian của con người nói chung đắt hơn nhiều so với thời gian của máy tính, vì vậy đó hẳn là những gì bạn đang thắc mắc. Đúng?

Nó thực sự phụ thuộc vào kiểu của x và a và việc thực hiện +. Đối với

   T x, a;
   ....
   x = x + a;

trình biên dịch phải tạo một chữ T tạm thời để chứa giá trị của x + a trong khi nó đánh giá giá trị đó, sau đó nó có thể gán cho x. (Nó không thể sử dụng x hoặc a làm không gian làm việc trong quá trình hoạt động này).

Đối với x + = a, nó không cần tạm thời.

Đối với các loại tầm thường, không có sự khác biệt.

Sự khác biệt giữa x = x + avà x += asố lượng công việc mà máy phải trải qua - một số trình biên dịch có thể (và thường làm) tối ưu hóa nó đi, nhưng thông thường, nếu chúng ta bỏ qua tối ưu hóa trong một thời gian, điều xảy ra là trong đoạn mã cũ, máy phải tra cứu giá trị chox hai lần, trong khi ở máy sau, việc tra cứu này chỉ cần thực hiện một lần.

Tuy nhiên, như tôi đã đề cập, ngày nay hầu hết các trình biên dịch đủ thông minh để phân tích lệnh và giảm bớt các lệnh máy cần thiết.

Tái bút: Câu trả lời đầu tiên về Stack Overflow!

Vì bạn đã gắn nhãn C ++ này, không có cách nào để biết từ hai câu lệnh bạn đã đăng. Bạn cần biết 'x' là gì (nó hơi giống câu trả lời '42'). Nếu xlà POD, thì nó sẽ không thực sự tạo ra nhiều khác biệt. Tuy nhiên, nếu xlà một lớp, có thể có quá tải chooperator + và operator +=phương thức có thể có các hành vi khác nhau dẫn đến thời gian thực thi rất khác nhau.

Nếu bạn nói rằng +=bạn đang làm cho cuộc sống của trình biên dịch dễ dàng hơn rất nhiều. Để trình biên dịch nhận ra điều đó x = x+agiống với x += a, trình biên dịch phải

• phân tích vế trái ( x) để đảm bảo nó không có tác dụng phụ và luôn tham chiếu đến cùng một giá trị l. Ví dụ, nó có thể là z[i], và nó phải đảm bảo rằng cả hai zvà ikhông thay đổi.

• phân tích vế phải ( x+a) và đảm bảo rằng nó là một phép tính tổng, và vế trái xảy ra một lần và chỉ một lần ở vế phải, mặc dù nó có thể được biến đổi, như trong z[i] = a + *(z+2*0+i).

Nếu ý bạn muốn thêm avào x, người viết trình biên dịch đánh giá cao điều đó khi bạn chỉ nói ý của bạn. Bằng cách đó, bạn không thực hiện phần trình biên dịch mà người viết của nó hy vọng rằng anh ấy / cô ấy đã loại bỏ được tất cả các lỗi và điều đó thực sự không làm cho cuộc sống của bạn dễ dàng hơn chút nào, trừ khi bạn thực sự không thể thoát ra của chế độ Fortran.

Đối với một ví dụ cụ thể, hãy tưởng tượng một kiểu số phức đơn giản:

struct complex {
    double x, y;
    complex(double _x, double _y) : x(_x), y(_y) { }
    complex& operator +=(const complex& b) {
        x += b.x;
        y += b.y;
        return *this;
    }
    complex operator +(const complex& b) {
        complex result(x+b.x, y+b.y);
        return result;
    }
    /* trivial assignment operator */
}

Đối với trường hợp a = a + b, nó phải tạo thêm một biến tạm thời và sau đó sao chép nó.

Bạn đang hỏi sai câu hỏi.

Điều này không có khả năng thúc đẩy hiệu suất của một ứng dụng hoặc tính năng. Ngay cả khi nó là như vậy, cách để tìm hiểu là lập hồ sơ mã và biết nó ảnh hưởng đến bạn như thế nào. Thay vì lo lắng ở cấp độ này là nhanh hơn, điều quan trọng hơn là phải suy nghĩ về sự rõ ràng, đúng đắn và dễ đọc.

Điều này đặc biệt đúng khi bạn xem xét rằng, ngay cả khi đây là một yếu tố hiệu suất quan trọng, các trình biên dịch sẽ phát triển theo thời gian. Ai đó có thể tìm ra một cách tối ưu hóa mới và câu trả lời đúng hôm nay có thể trở thành sai vào ngày mai. Đó là một trường hợp kinh điển của việc tối ưu hóa quá sớm.

Điều này không có nghĩa là hiệu suất không quan trọng chút nào ... Chỉ là đó là cách tiếp cận sai lầm để đạt được mục tiêu hiệu quả của bạn. Cách tiếp cận đúng là sử dụng các công cụ lập hồ sơ để tìm hiểu xem mã của bạn đang thực sự sử dụng thời gian của nó ở đâu và do đó, bạn nên tập trung nỗ lực vào đâu.

Tôi nghĩ rằng điều đó sẽ phụ thuộc vào máy và kiến ​​trúc của nó. Nếu kiến ​​trúc của nó cho phép định địa chỉ bộ nhớ gián tiếp, trình biên dịch MIGHT chỉ cần sử dụng mã này thay thế (để tối ưu hóa):

mov $[y],$ACC

iadd $ACC, $[i] ; i += y. WHICH MIGHT ALSO STORE IT INTO "i"

Trong khi, i = i + ycó thể được dịch sang (không cần tối ưu hóa):

mov $[i],$ACC

mov $[y],$B 

iadd $ACC,$B

mov $B,[i]

Không, cả hai cách đều giống nhau.