Tăng dần trong C ++ - Khi nào sử dụng x ++ hoặc ++ x?

Tôi hiện đang học C ++ và tôi đã học về sự gia tăng một thời gian trước. Tôi biết rằng bạn có thể sử dụng "++ x" để tăng trước và "x ++" để tăng sau.

Tuy nhiên, tôi thực sự không biết khi nào sử dụng một trong hai ... Tôi chưa bao giờ thực sự sử dụng "++ x" và mọi thứ luôn hoạt động tốt cho đến nay - vậy, khi nào tôi nên sử dụng nó?

Ví dụ: Trong vòng lặp for, khi nào sử dụng "++ x" là thích hợp hơn?

Ngoài ra, ai đó có thể giải thích chính xác cách hoạt động của các mức tăng (hoặc giảm) khác nhau không? Tôi thực sự sẽ đánh giá cao nó.

Vấn đề không phải là sở thích, mà là vấn đề logic.

x++tăng giá trị của biến x sau khi xử lý câu lệnh hiện tại.

++xtăng giá trị của biến x trước khi xử lý câu lệnh hiện tại.

Vì vậy, chỉ cần quyết định logic bạn viết.

x += ++isẽ tăng i và thêm i + 1 vào x. x += i++sẽ thêm i vào x, sau đó tăng i.

Scott Meyers cho bạn biết thích tiền tố hơn ngoại trừ những trường hợp mà logic sẽ ra lệnh cho hậu tố đó là phù hợp.

Mục # 6 "C ++ hiệu quả hơn" - đó là đủ thẩm quyền đối với tôi.

Đối với những người không sở hữu cuốn sách, đây là những trích dẫn thích hợp. Từ trang 32:

Từ những ngày còn là một lập trình viên C, bạn có thể nhớ lại rằng dạng tiền tố của toán tử tăng dần đôi khi được gọi là "tăng và tìm nạp", trong khi dạng hậu tố thường được gọi là "tìm nạp và tăng dần". Hai cụm từ này rất quan trọng cần nhớ, bởi vì chúng đều đóng vai trò là thông số kỹ thuật chính thức ...

Và trên trang 34:

Nếu bạn là người lo lắng về hiệu quả, có lẽ bạn đã đổ mồ hôi khi lần đầu tiên nhìn thấy chức năng tăng hậu tố. Hàm đó phải tạo một đối tượng tạm thời cho giá trị trả về của nó và việc triển khai ở trên cũng tạo ra một đối tượng tạm thời rõ ràng phải được xây dựng và hủy. Hàm tăng tiền tố không có thời gian tạm thời như vậy ...

Từ cppreference khi tăng vòng lặp:

Bạn nên thích toán tử tăng trước (++ iter) hơn toán tử tăng sau (iter ++) nếu bạn không sử dụng giá trị cũ. Tăng sau thường được thực hiện như sau:

   Iter operator++(int)   {
     Iter tmp(*this); // store the old value in a temporary object
     ++*this;         // call pre-increment
     return tmp;      // return the old value   }

Rõ ràng, nó kém hiệu quả hơn so với tăng trước.

Tăng trước không tạo ra đối tượng tạm thời. Điều này có thể tạo ra sự khác biệt đáng kể nếu đối tượng của bạn đắt tiền để tạo ra.

Tôi chỉ muốn lưu ý rằng mã được tạo không giống nhau nếu bạn sử dụng phần tăng trước / sau trong đó ngữ nghĩa (của trước / sau) không quan trọng.

thí dụ:

pre.cpp:

#include <iostream>

int main()
{
  int i = 13;
  i++;
  for (; i < 42; i++)
    {
      std::cout << i << std::endl;
    }
}

post.cpp:

#include <iostream>

int main()
{

  int i = 13;
  ++i;
  for (; i < 42; ++i)
    {
      std::cout << i << std::endl;
    }
}

_

$> g++ -S pre.cpp
$> g++ -S post.cpp
$> diff pre.s post.s   
1c1
<   .file   "pre.cpp"
---
>   .file   "post.cpp"

Điều quan trọng nhất cần ghi nhớ, imo, là x ++ cần trả về giá trị trước khi quá trình tăng thực sự diễn ra - do đó, nó phải tạo một bản sao tạm thời của đối tượng (bước tăng trước). Điều này kém hiệu quả hơn ++ x, được tăng tại chỗ và trả về.

Tuy nhiên, một điều đáng nói khác là hầu hết các trình biên dịch sẽ có thể tối ưu hóa những thứ không cần thiết như vậy khi có thể, ví dụ: cả hai tùy chọn sẽ dẫn đến cùng một mã ở đây:

for (int i(0);i<10;++i)
for (int i(0);i<10;i++)

Tôi đồng ý với @BeowulfOF, mặc dù để rõ ràng, tôi sẽ luôn ủng hộ việc chia nhỏ các câu lệnh để logic hoàn toàn rõ ràng, tức là:

i++;
x += i;

hoặc là

x += i;
i++;

Vì vậy, câu trả lời của tôi là nếu bạn viết mã rõ ràng thì điều này hiếm khi quan trọng (và nếu nó quan trọng thì mã của bạn có thể không đủ rõ ràng).

Chỉ muốn nhấn mạnh lại rằng ++ x được mong đợi sẽ nhanh hơn x ++, (đặc biệt nếu x là một đối tượng của một số kiểu tùy ý), vì vậy trừ khi được yêu cầu vì lý do logic, ++ x nên được sử dụng.

Bạn đã giải thích sự khác biệt một cách chính xác. Nó chỉ phụ thuộc vào việc bạn muốn x tăng lên trước mỗi lần chạy qua một vòng lặp hay sau đó. Nó phụ thuộc vào logic chương trình của bạn, những gì là phù hợp.

Một sự khác biệt quan trọng khi xử lý STL-Iterator (cũng triển khai các toán tử này) là nó ++ tạo ra một bản sao của đối tượng mà trình vòng lặp trỏ tới, sau đó tăng dần và sau đó trả về bản sao. ++ ngược lại, nó thực hiện việc tăng trước và sau đó trả về một tham chiếu đến đối tượng mà trình lặp hiện trỏ đến. Điều này chủ yếu chỉ phù hợp khi mỗi bit của hiệu suất được tính hoặc khi bạn triển khai STL-iterator của riêng mình.

Chỉnh sửa: sửa lỗi kết hợp ký hiệu tiền tố và hậu tố

Dạng hậu tố của ++, - toán tử tuân theo quy tắc use-then-change ,

Tiền tố dạng (++ x, - x) tuân theo quy tắc thay đổi-rồi-sử dụng .

Ví dụ 1:

Khi nhiều giá trị được xếp tầng với << sử dụng cout thì các phép tính (nếu có) diễn ra từ phải sang trái nhưng việc in diễn ra từ trái sang phải, ví dụ: (nếu val nếu ban đầu là 10)

 cout<< ++val<<" "<< val++<<" "<< val;

sẽ dẫn đến

12    10    10 

Ví dụ 2:

Trong Turbo C ++, nếu nhiều lần xuất hiện của ++ hoặc (ở bất kỳ dạng nào) được tìm thấy trong một biểu thức, thì trước hết tất cả các dạng tiền tố được tính toán sau đó biểu thức được đánh giá và cuối cùng các dạng hậu tố được tính toán, ví dụ:

int a=10,b;
b=a++ + ++a + ++a + a;
cout<<b<<a<<endl;

Đầu ra của nó trong Turbo C ++ sẽ là

48 13

Trong khi đầu ra của nó trong trình biên dịch hiện đại sẽ là (vì chúng tuân theo các quy tắc nghiêm ngặt)

45 13

• Lưu ý: Không nên sử dụng nhiều toán tử tăng / giảm trên cùng một biến trong một biểu thức. Việc xử lý / kết quả của các
  biểu thức như vậy khác nhau giữa các trình biên dịch.

Hiểu cú pháp ngôn ngữ là quan trọng khi xem xét tính rõ ràng của mã. Hãy xem xét việc sao chép một chuỗi ký tự, chẳng hạn với dấu tăng sau:

char a[256] = "Hello world!";
char b[256];
int i = 0;
do {
  b[i] = a[i];
} while (a[i++]);

Chúng tôi muốn vòng lặp thực thi thông qua việc gặp phải ký tự 0 (kiểm tra sai) ở cuối chuỗi. Điều đó yêu cầu kiểm tra giá trị tăng trước và cũng tăng chỉ số. Nhưng không nhất thiết phải theo thứ tự đó - một cách để viết mã này với số tăng trước sẽ là:

int i = -1;
do {
  ++i;
  b[i] = a[i];
} while (a[i]);

Vấn đề là sở thích rõ ràng hơn và nếu máy có vô số thanh ghi thì cả hai phải có thời gian thực thi giống nhau, ngay cả khi [i] là một hàm đắt tiền hoặc có tác dụng phụ. Một sự khác biệt đáng kể có thể là giá trị thoát của chỉ mục.