การเพิ่ม C ++ - เมื่อใดควรใช้ x ++ หรือ ++ x

ฉันกำลังเรียนรู้ C ++ และฉันได้เรียนรู้เกี่ยวกับการเพิ่มขึ้นเมื่อสักครู่ที่ผ่านมา ฉันรู้ว่าคุณสามารถใช้ "++ x" เพื่อเพิ่มส่วนก่อนและ "x ++" เพื่อทำหลังจากนั้น

ถึงกระนั้นฉันก็ไม่รู้จริงๆว่าจะใช้ทั้งสองอย่างเมื่อใด ... ฉันไม่เคยใช้ "++ x" จริงๆและจนถึงตอนนี้สิ่งต่างๆก็ใช้ได้ดี - ดังนั้นฉันควรใช้เมื่อใด

ตัวอย่าง: ในสำหรับลูปควรใช้ "++ x" เมื่อใด

นอกจากนี้ใครบางคนสามารถอธิบายได้อย่างชัดเจนว่าการเพิ่มขึ้น (หรือการลดระดับ) ทำงานอย่างไร ฉันจะขอบคุณมันจริงๆ

ไม่ใช่คำถามเกี่ยวกับความชอบ แต่เป็นเหตุผล

x++เพิ่มค่าของตัวแปร x หลังจากประมวลผลคำสั่งปัจจุบัน

++xเพิ่มค่าของตัวแปร x ก่อนประมวลผลคำสั่งปัจจุบัน

ดังนั้นเพียงแค่ตัดสินใจตามตรรกะที่คุณเขียน

x += ++iจะเพิ่ม i และเพิ่ม i + 1 เป็น x x += i++จะเพิ่ม i เป็น x แล้วเพิ่ม i

สก็อตต์เมเยอร์สบอกให้คุณชอบคำนำหน้ายกเว้นในโอกาสที่ตรรกะกำหนดว่า postfix นั้นเหมาะสม

"C ++ ที่มีประสิทธิภาพมากขึ้น" รายการ # 6 - นั่นเป็นอำนาจที่เพียงพอสำหรับฉัน

สำหรับผู้ที่ไม่ได้เป็นเจ้าของหนังสือนี่คือคำพูดที่เกี่ยวข้อง จากหน้า 32:

ตั้งแต่สมัยคุณเป็นโปรแกรมเมอร์ C คุณอาจจำได้ว่ารูปแบบคำนำหน้าของตัวดำเนินการส่วนเพิ่มบางครั้งเรียกว่า "Increment and fetch" ในขณะที่รูปแบบ postfix มักเรียกว่า "การดึงข้อมูลและการเพิ่ม" วลีทั้งสองเป็นสิ่งสำคัญที่ต้องจำเพราะทั้งหมดนี้ทำหน้าที่เป็นข้อกำหนดที่เป็นทางการ ...

และในหน้า 34:

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

จากcppreferenceเมื่อเพิ่มตัววนซ้ำ:

คุณควรเลือกตัวดำเนินการเพิ่มล่วงหน้า (++ iter) มากกว่าตัวดำเนินการหลังการเพิ่ม (iter ++) หากคุณจะไม่ใช้ค่าเก่า โดยทั่วไปแล้วการเพิ่มขึ้นภายหลังจะดำเนินการดังนี้:

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

เห็นได้ชัดว่ามีประสิทธิภาพน้อยกว่าการเพิ่มขึ้นล่วงหน้า

การเพิ่มล่วงหน้าไม่ได้สร้างวัตถุชั่วคราว สิ่งนี้สามารถสร้างความแตกต่างอย่างมากหากวัตถุของคุณมีราคาแพงในการสร้าง

ฉันแค่ต้องการสังเกตว่าโค้ดที่สร้างขึ้นนั้นไม่เหมือนกันถ้าคุณใช้การเพิ่มก่อน / หลังโดยที่ความหมาย (ของก่อน / โพสต์) ไม่สำคัญ

ตัวอย่าง:

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"

สิ่งที่สำคัญที่สุดที่ต้องจำไว้คือ imo คือ x ++ จำเป็นต้องส่งคืนค่าก่อนที่การเพิ่มจะเกิดขึ้นจริงดังนั้นจึงต้องสร้างสำเนาของวัตถุชั่วคราว (เพิ่มขึ้นก่อน) สิ่งนี้มีประสิทธิภาพน้อยกว่า ++ x ซึ่งเพิ่มขึ้นในตำแหน่งและส่งคืน

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

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

ฉันเห็นด้วยกับ @BeowulfOF แม้ว่าเพื่อความชัดเจนฉันจะสนับสนุนการแยกข้อความเพื่อให้ตรรกะนั้นชัดเจนอย่างแน่นอนเช่น:

i++;
x += i;

หรือ

x += i;
i++;

ดังนั้นคำตอบของฉันคือถ้าคุณเขียนโค้ดที่ชัดเจนสิ่งนี้จะไม่ค่อยมีความสำคัญ (และถ้ามันสำคัญรหัสของคุณอาจไม่ชัดเจนพอ)

เพียงแค่ต้องการเน้นย้ำอีกครั้งว่า ++ x คาดว่าจะเร็วกว่า x ++ (โดยเฉพาะอย่างยิ่งถ้า x เป็นอ็อบเจ็กต์บางประเภทโดยพลการ) ดังนั้นเว้นแต่ว่าจำเป็นด้วยเหตุผลเชิงตรรกะควรใช้ ++ x

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

ความแตกต่างที่สำคัญเมื่อจัดการกับ STL-Iterators (ซึ่งใช้ตัวดำเนินการเหล่านี้ด้วย) คือ ++ จะสร้างสำเนาของวัตถุที่ตัววนซ้ำชี้ไปแล้วเพิ่มขึ้นแล้วส่งคืนสำเนา ++ ในทางกลับกันจะทำการเพิ่มขึ้นก่อนจากนั้นส่งกลับการอ้างอิงไปยังวัตถุที่ตัววนซ้ำชี้ไป ส่วนใหญ่จะเกี่ยวข้องเมื่อประสิทธิภาพทุกบิตมีค่าหรือเมื่อคุณใช้ STL-iterator ของคุณเอง

แก้ไข: แก้ไขการผสมของคำนำหน้าและสัญกรณ์ต่อท้าย

รูปแบบของ Postfix ++ - ผู้ประกอบการเป็นไปตามกฎการใช้งานแล้วเปลี่ยน ,

รูปแบบคำนำหน้า (++ x - x) เป็นไปตามกฎการเปลี่ยนแปลงการใช้งานแล้ว

ตัวอย่างที่ 1:

เมื่อค่าหลายค่าเรียงกันด้วย << โดยใช้cout การคำนวณ (ถ้ามี) จะเกิดขึ้นจากขวาไปซ้าย แต่การพิมพ์จะเกิดจากซ้ายไปขวาเช่น (ถ้าvalถ้าเริ่มต้น 10)

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

จะส่งผลให้

12    10    10 

ตัวอย่างที่ 2:

ใน Turbo C ++ หากพบการเกิดขึ้นหลายครั้งของ ++ หรือ (ในรูปแบบใด ๆ ) ในนิพจน์ประการแรกรูปแบบคำนำหน้าทั้งหมดจะถูกคำนวณจากนั้นนิพจน์จะได้รับการประเมินและสุดท้ายจะคำนวณรูปแบบ postfix เช่น

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

เอาต์พุตใน Turbo C ++ จะเป็น

48 13

ในขณะที่เอาต์พุตในคอมไพเลอร์สมัยใหม่จะเป็น (เพราะปฏิบัติตามกฎอย่างเคร่งครัด)

45 13

• หมายเหตุ: ไม่แนะนำให้ใช้ตัวดำเนินการเพิ่ม / ลดหลายตัวกับตัวแปรเดียวกันในนิพจน์เดียว การจัดการ / ผลลัพธ์ของ
  นิพจน์ดังกล่าวแตกต่างกันไปในแต่ละคอมไพเลอร์ถึงคอมไพเลอร์

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

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

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

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

เป็นเรื่องของรสชาติที่ชัดเจนกว่าและหากเครื่องมีรีจิสเตอร์ครบมือทั้งสองเครื่องควรมีเวลาดำเนินการเหมือนกันแม้ว่า [i] จะเป็นฟังก์ชันที่มีราคาแพงหรือมีผลข้างเคียงก็ตาม ความแตกต่างที่สำคัญอาจเป็นค่าทางออกของดัชนี