XOR ตามเงื่อนไข?

89

ทำไม C # ถึงไม่มีตัวXORดำเนินการตามเงื่อนไข?

ตัวอย่าง:

true  xor false = true
true  xor true  = false
false xor false = false

c# operators xor boolean-operations

— กิลาดนามาน
แหล่งที่มา

15

วิธีการ!=ทำงานแทน?

— Pascal Cuoq

45

C # จะมีผู้ประกอบการ xor (x ^ y) ฉันจึงปฏิเสธหลักฐานของคำถาม คุณอธิบายได้ไหมว่าทำไมคุณถึงเชื่อว่า C # ไม่มีตัวดำเนินการ xor ฉันสนใจที่จะเรียนรู้ว่าเหตุใดผู้คนจึงเชื่อเรื่องเท็จเกี่ยวกับ C #

— Eric Lippert

3

@Eric Lippert: ฉันคิดว่าเขาหมายถึงตัวดำเนินการเชิงตรรกะ ( & | ^) เทียบกับตัวดำเนินการตามเงื่อนไข ( && ||) แต่คุณพูดถูก (แน่นอน) มี XOR ตรรกะ ...

— BoltClock

14

@BoltClock: โอ้ถ้าคำถามคือ "ทำไมไม่มีตัวดำเนินการ xor ลัดวงจร" - จะมีได้อย่างไร? ด้วย "และ" หากอาร์กิวเมนต์แรกเป็นเท็จคุณไม่จำเป็นต้องประเมินข้อที่สอง ด้วย "หรือ" หากอาร์กิวเมนต์แรกเป็นจริงคุณไม่จำเป็นต้องประเมินข้อที่สอง คุณจำเป็นต้องประเมินทั้งสองอาร์กิวเมนต์สำหรับ xor เสมอดังนั้นจึงไม่มีการลัดวงจรที่เป็นไปได้

— Eric Lippert

4

คำถามนั้นเหมาะกับ Microsoft มากกว่าและนั่นเป็นเหตุผลที่ดีในการลดคะแนน - แต่ถ้าใครก็ตามที่ลงคะแนนก็ทำเช่นนั้นเนื่องจากตัวดำเนินการ ^ คุณจะต้องอ่านอย่างใส่ใจในรายละเอียดมากขึ้นเนื่องจากคำถามมีเงื่อนไขเทียบกับ ตามหลักเหตุผลไม่ใช่แค่ "ทำไมไม่มี XOR"

— The Evil Greebo

124

ใน C # ตัวดำเนินการตามเงื่อนไขจะเรียกใช้ตัวถูกดำเนินการรองหากจำเป็นเท่านั้น

เนื่องจาก XOR ต้องโดยการกำหนดนิยามทดสอบทั้งสองค่าเวอร์ชันที่มีเงื่อนไขจึงเป็นเรื่องงี่เง่า

ตัวอย่าง :

ตรรกะ AND: &- ทดสอบทั้งสองด้านทุกครั้ง
ตรรกะหรือ: |- ทดสอบทั้งสองด้านทุกครั้ง
เงื่อนไข AND: &&- ทดสอบเฉพาะด้านที่ 2 หากด้านที่ 1 เป็นจริง
เงื่อนไขหรือ: ||- ทดสอบเฉพาะด้านที่ 2 หากด้านที่ 1 เป็นเท็จ

— Greebo ผู้ชั่วร้าย
แหล่งที่มา

37

ตัวดำเนินการ XOR จะไม่ละเมิดอนุสัญญา "ตัวดำเนินการที่มีเงื่อนไขจะดำเนินการตัวถูกดำเนินการรองเท่านั้นหากจำเป็น" มันจะจำเป็นเสมอไป

— Nathan Kovner

2

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

— SalvadorGomez

1

ยังไม่ได้ตอบกลับในบางครั้ง แต่เพื่อตอบกลับความคิดเห็นยอดนิยมโดย @KhyadHalda: ทำไมคุณถึงสร้างสิ่งที่คุณรู้ว่าจะไม่ถูกใช้? คุณจงใจเขียนโค้ดตาย

— The Evil Greebo

2

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

— The Evil Greebo

1

มันโง่พอ ๆ กับตัวดำเนินการเพิ่มเงื่อนไข ทำไมไม่สร้างตัวดำเนินการอื่นสำหรับการเพิ่มตามเงื่อนไขโดยที่ (a + b) จะประเมิน b เมื่อจำเป็น b เท่านั้น เช่นเดียวกับ XOR แบบมีเงื่อนไขสิ่งนี้จะไม่ละเมิดแบบแผนของตัวดำเนินการตามเงื่อนไขเพียงแค่อาร์กิวเมนต์ที่สองจะจำเป็นเสมอ ไม่มีกรณีการใช้งานสำหรับสิ่งนี้ และฉันไม่เพียง แต่อวดดีกับตัวอย่างนี้ - การดำเนินการ XOR นั้นเป็นการเพิ่ม 1 บิต

— Kevin Holt

283

คำถามค่อนข้างล้าสมัย แต่ ...

นี่คือวิธีการทำงานของตัวดำเนินการนี้:

true xor false = true
true xor true = false
false xor true = true
false xor false = false

นี่คือวิธีที่! = ตัวดำเนินการทำงานกับประเภทบูล:

(true != false) // true
(true != true) // false
(false != true) // true
(false != false) // false

ดังที่คุณเห็น^^สามารถแทนที่ด้วยสิ่งที่มีอยู่!=

— Piotrpo
แหล่งที่มา

46

นี่เป็นคำตอบเดียวที่ตอบคำถามได้โดยตรงและถูกต้อง

— usr

40

ฉันนั่งอยู่ตรงนี้โดยเผชิญหน้ากับตัวเองโดยที่ฉันไม่รู้เลยว่า!=จะได้ผลสำหรับสิ่งนี้

— AdamMc331

1

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

— The Evil Greebo

3

@TheEvilGreebo - สิ่งที่คุณพูดเป็นความจริง ตัวดำเนินการ! = ไม่ใช่ตัวดำเนินการ XOR แบบมีเงื่อนไขในทางเทคนิค อย่างไรก็ตามคำตอบนี้กล่าวได้อย่างมีประสิทธิภาพว่า "ไม่มีตัวดำเนินการ XOR แบบมีเงื่อนไขเนื่องจากตัวดำเนินการ! = ทำ" นั่นคือวิธีที่ฉันอ่านอย่างไรก็ตาม

— Syndog

6

ฉันคิดว่าทุกคนลงเอยด้วยโพสต์นี้จริง ๆ แล้วต้องการเขียน XOR บนบูลีน เหมือนมีตรรกะANDและแต่ไม่มีอะไรเป็นOR XORหรืออย่างน้อยเราก็ไม่รู้!=:) @TheEvilGreebo

— M.kazem Akhgary

30

มีตัวดำเนินการ XOR ตรรกะ: ^

เอกสารประกอบ: C # Operatorsและ^ Operator

— น้ำแข็ง
แหล่งที่มา

2

ตรรกะไม่ใช่เงื่อนไข ตรรกะและ = & เงื่อนไขและ = && เขาถามเกี่ยวกับเงื่อนไข

— The Evil Greebo

3

มันเป็นไบนารีไม่ใช่ตรรกะ ถือว่าบูลเป็น 0 หรือ 1 ซึ่งไม่เป็นความจริงบน CLR

— usr

1

ขออภัยคำตอบนี้ไม่ได้ตอบคำถามเกี่ยวกับตัวดำเนินการ CONDITIONAL นี่คือตัวดำเนินการเล็กน้อย

— Nathan Tregillus

3

สำหรับเร็กคอร์ดเอกสารที่เชื่อมโยงในคำตอบนี้ระบุอย่างชัดเจนว่า^เมื่อใช้กับบูลีนตัวถูกดำเนินการเป็นตัวดำเนินการบูลีน "สำหรับตัวถูกดำเนินการบูลตัวดำเนินการ ^ จะคำนวณผลลัพธ์เดียวกันกับตัวดำเนินการอสมการ! =" คุณยังสามารถดำเนินการกับจำนวนเต็ม bitwise-xor ด้วย^. C # ไม่ใช่ C

— 15ee8f99-57ff-4f92-890c-b56153

25

เช่นเดียวกับการชี้แจงตัวดำเนินการ ^ ทำงานได้กับทั้งประเภทอินทิกรัลและบูล

ดู^ Operator ของ MSDN (อ้างอิง C #) :

ตัวดำเนินการไบนารี ^ ถูกกำหนดไว้ล่วงหน้าสำหรับประเภทอินทิกรัลและบูล สำหรับชนิดอินทิกรัล ^ จะคำนวณ bitwise เอกสิทธิ์ - หรือของตัวถูกดำเนินการ สำหรับตัวถูกดำเนินการบูล ^ คำนวณตรรกะเอกสิทธิ์หรือของตัวถูกดำเนินการ นั่นคือผลลัพธ์จะเป็นจริงก็ต่อเมื่อตัวถูกดำเนินการตัวใดตัวหนึ่งเป็นจริงเท่านั้น

เอกสารอาจมีการเปลี่ยนแปลงตั้งแต่ปี 2011 เมื่อมีการถามคำถามนี้

— RichardCL
แหล่งที่มา

2

เขียนโปรแกรมใน c # มานานไม่เคยรู้เรื่องนี้มาก่อน! ขอบคุณ @RichardCL!

— Nathan Tregillus

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

— คริส

13

ตามที่Mark Lถามนี่คือเวอร์ชันที่ถูกต้อง:

 Func<bool, bool, bool> XOR = (X,Y) => ((!X) && Y) || (X && (!Y));

นี่คือตารางความจริง:

 X | Y | Result
 ==============
 0 | 0 | 0
 1 | 0 | 1
 0 | 1 | 1
 1 | 1 | 0

อ้างอิง: Exclusive OR

— เพื่อนง่าย
แหล่งที่มา

2

คำถามที่ถามคือทำไม C # ไม่มีตัวดำเนินการ XOR แบบมีเงื่อนไข สิ่งนี้ไม่ตอบคำถาม สำหรับฟังก์ชันเอง: ฟังก์ชันนี้ทำงานเป็น XOR แบบมีเงื่อนไข - อย่างไรก็ตามคำถามคือมีประสิทธิภาพมากกว่า XOR ที่ไม่มีเงื่อนไขหรือไม่? ในการทดสอบความจริงเฉพาะตัว XOR ต้องยืนยันว่าหนึ่งผลลัพธ์เป็นจริง ซึ่งหมายความว่าทั้งสองฝ่ายจะต้องได้รับการประเมินและเปรียบเทียบ ฟังก์ชันด้านบนทดสอบทั้งสองด้านของเงื่อนไขและในขณะที่กลับค่าหนึ่งค่าเป็นอย่างน้อย เราทราบเป็นการภายในหรือไม่ว่าสิ่งนี้แตกต่างจาก XOR หรือไม่?

— The Evil Greebo

6

อ๋อใช่แล้ว

bool b1 = true;
bool b2 = false;
bool XOR = b1 ^ b2;

— Armen Tsirunyan
แหล่งที่มา

1

มันเป็นตัวดำเนินการไบนารีไม่ใช่ตัวดำเนินการทางตรรกะ ถือว่าบูลเป็น 0 หรือ 1 ซึ่งไม่เป็นความจริงบน CLR ดังนั้นรหัสนี้จึงไม่สามารถใช้งานได้จริง

— usr

6

@usr ใน C # ตัวดำเนินการ ^ เป็นตรรกะเมื่อนำไปใช้กับตัวถูกดำเนินการบูลีนสองตัว คุณแสดงความคิดเห็นมากมายผ่านคำตอบเหล่านี้คุณเคยใช้โค้ดเพื่อทดสอบสมมติฐานของคุณหรือไม่?

— Marc L.

2

@MarcL. ฉันทำ: pastebin.com/U7vqpn6Gพิมพ์จริงแม้ว่า true ^ true ควรจะเป็นเท็จ บูลไม่ได้เท่ากับ 0 หรือ 1 เสมอไปไม่ใช่ประเภทตรรกะบน CLR เป็นปริมาณ 8 บิตที่มีเนื้อหาตามอำเภอใจ ฉันสามารถสร้าง IL ที่ตรวจสอบได้เพื่อแสดงปัญหาเช่นกัน

— usr

2

เมื่อใช้ภาษา CLR อื่นที่ไม่ใช่ C # เช่น ฉันพูดซ้ำ: ฉันสามารถใช้ ILASM เพื่อสร้างชุดประกอบที่ปลอดภัยและตรวจสอบได้อย่างสมบูรณ์ซึ่งทำสิ่งนี้ได้ (ที่ระดับ IL ค่าบูลีนเป็นเพียงค่าหนึ่งi1เช่นเดียวกับไบต์) นี่คือพฤติกรรมที่กำหนดและมีการจัดการที่ปลอดภัย 100% CLR ไม่หยาบขึ้น; ครั้งแรกที่ฉันเห็นพฤติกรรมนี้คือเมื่อใช้ Microsoft Pex

— usr

1

@EdPlunkett ฉันไม่คิดว่ารถบรรทุกของคุณอยู่กับฉัน usr แสดงให้เห็นว่าภายในเป็นตัวดำเนินการไบนารี "การละเมิด" ที่ฉันบ่นเป็นวิธีการที่เขาพิสูจน์ได้ซึ่งฉันยังคงคิดว่ามันน่าหงุดหงิดเกินไป มันอาจเกิดขึ้นได้ แต่ทำให้การใช้บูลีนอย่างละเอียดถี่ถ้วนในดินแดนที่ไม่มีมนุษย์ซึ่งจะนำไปใช้งานได้เนื่องจากความปลอดภัย CLR จะเป็นอันตรายอย่างดีที่สุดไม่เหมาะสม (หากไม่เป็นอันตราย) ที่เลวร้ายที่สุดและควรถือว่าเป็นข้อบกพร่อง สิ่งที่ usr พิสูจน์ได้ก็คือ C # ภายในเหมือน C มากกว่าที่เราคิด ควรพิจารณาว่ารหัสที่ทำเช่นนี้ถูกต้องหรือไม่เป็นคำถามอื่น

— Marc L.

4

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

ดังนั้นคุณสามารถพูดว่า:

if ( (a == b) ^ (c == d))
{

}

— คลาร์ก
แหล่งที่มา

มันเป็นตัวดำเนินการไบนารีไม่ใช่ตัวดำเนินการทางตรรกะ ถือว่าบูลเป็น 0 หรือ 1 ซึ่งไม่เป็นความจริงบน CLR ดังนั้นรหัสนี้จึงไม่สามารถใช้งานได้จริง

— usr

@usr CLR หมายถึงอะไร สิ่งนี้ใช้ได้ผลสำหรับฉันไม่แน่ใจว่าฉันพลาดกรณีขอบที่นี่ ...

— LunaCodeGirl

3

@Spencevail 1คุณอาจไม่ได้คิดเกี่ยวกับกรณีที่บูลที่ไม่เป็นเท็จไม่อาจมีจำนวนเต็มตัวแทน นี่เป็นข้อเท็จจริงที่ทราบกันเล็กน้อย คุณสามารถจบลงในสถานการณ์ที่ xor ของสองบูลีนที่ไม่ใช่เท็จยังคงไม่เป็นเท็จ! ที่กล่าวว่าในรหัสเฉพาะนี้ตัวดำเนินการ xor จะถูกนำไปใช้กับค่าใน [0,1] เท่านั้นดังนั้นความคิดเห็นของฉันจึงใช้ไม่ได้ (ทั้งหมด)

— usr

1

@Spencevail นั่นเป็นกรณีที่สามารถล้มเหลวได้ เป็นไปได้ที่จะสร้างฟังก์ชันโค้ดที่มีการจัดการที่ปลอดภัย CreateBool (ไบต์) ที่แปลงไบต์เป็นบูลของบิตเดียวกัน จากนั้น CreateBool (1) ^ CreateBool (2) เป็นจริง แต่ CreateBool (1) เป็นจริงและ CreateBool (2) ก็เป็นจริงเช่นกัน! &ยังมีความเสี่ยง

— usr

1

อันที่จริงฉันเพิ่งรายงานข้อผิดพลาดของ RyuJIT เพราะพวกเขาไม่ได้พิจารณาถึงความเป็นไปได้นี้และรวบรวม&&ราวกับว่ามันเป็นการคอมไพล์&ผิด

— usr

3

แม้ว่าจะมีตัวดำเนินการ xor แบบลอจิคัล^แต่ก็ไม่มีตัวดำเนินการ xor แบบมีเงื่อนไข คุณสามารถบรรลุ xor ตามเงื่อนไขของสองค่า A และ B โดยใช้สิ่งต่อไปนี้:

A ? (!B) : B

parens ไม่จำเป็น แต่ฉันเพิ่มเพื่อความชัดเจน

ในฐานะที่เป็นออกแหลมโดยความชั่วร้าย Greebo ประเมินนี้ทั้งการแสดงออก แต่ xor ไม่สามารถลัดสั้น ๆ เช่นและและหรือ

— จิมเรด
แหล่งที่มา

อะไรคือความแตกต่างระหว่าง logican ^ และ conditional ^? oO

— Armen Tsirunyan

@Armen Tsirunyan ตัวดำเนินการเชิงตรรกะดำเนินการในระดับบิตในประเภทที่เหมาะสมในขณะที่ตัวดำเนินการตามเงื่อนไขทำงานกับค่าบูลีนและส่งคืนผลลัพธ์แบบบูลีน พิจารณาค่าบูลีน: มีค่า0101 ^ 0011 0110

— jimreed

3

ไม่คุณคิดผิดอย่างสิ้นเชิง มี XOR ทั้งสองประเภท (เรียกว่าบิตและตรรกะตามลำดับ) ใน C # ทั้งสองใช้สัญลักษณ์ ^

— Armen Tsirunyan

1

คุณสามารถใช้ได้:

a = b ^ c;

เช่นเดียวกับใน c / c ++

— Gulyan
แหล่งที่มา

0

ไม่มีสิ่งที่เรียกว่า XOR แบบมีเงื่อนไข (การลัดวงจร) ตัวดำเนินการตามเงื่อนไขมีความหมายก็ต่อเมื่อมีวิธีที่จะบอกผลลัพธ์สุดท้ายได้อย่างชัดเจนจากการดูเฉพาะอาร์กิวเมนต์แรกเท่านั้น XOR (และการบวก) ต้องการอาร์กิวเมนต์สองตัวเสมอดังนั้นจึงไม่มีทางที่จะลัดวงจรหลังจากอาร์กิวเมนต์แรก

ถ้าคุณรู้ว่า A = true ดังนั้น (A XOR B) =! B

ถ้าคุณรู้ว่า A = false ดังนั้น (A XOR B) = B

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

โปรดทราบว่า XOR ตามคำจำกัดความมีสี่กรณี:

false xor true  = true
true  xor false = true
true  xor true  = false
false xor false = false

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

false op true  = false (or DontCare)
true  op false = true
true  op true  = false
false op false = false

จากนั้นคุณจะได้รับสิ่งนั้นอย่างแน่นอนโดยการดำเนินการตามเงื่อนไขการลัดวงจร:

A && !B

แต่นั่นไม่ใช่ XOR

— เควินโฮลท์
แหล่งที่มา

ฉันไม่เห็นอะไรเลยในคำตอบนี้ที่ไม่ได้อยู่ในคำตอบข้างต้นอย่างน้อยหนึ่งคำตอบ ฉันไม่เห็นสิ่งที่บ่งชี้ว่า un-xor ที่ลัดวงจรของคุณคือสิ่งที่ OP กำลังมองหาเนื่องจากเขายอมรับคำตอบซึ่งถือว่าเขาต้องการ xor ที่เหมาะสม

— 15ee8f99-57ff-4f92-890c-b56153

Mine เป็นคำตอบเดียวที่แนะนำจนถึงตอนนี้ซึ่งสามารถสร้างตารางความจริงที่ร้องขอของ OP โดยไม่ต้องประเมินอาร์กิวเมนต์ที่สอง

— Kevin Holt

นอกจากนี้ OP ยังถามว่าเหตุใดจึงไม่มี XOR ตามเงื่อนไขและในขณะที่คำตอบข้างต้นพูดได้อย่างถูกต้องว่าเป็นเพราะ XOR ต้องการอาร์กิวเมนต์สองข้อ แต่ IMO คำตอบข้างต้นดูเหมือนจะไม่ได้อธิบายได้เพียงพอว่าทำไม XOR จึงต้องการอาร์กิวเมนต์สองข้อ เห็นได้ชัดว่าคุณรู้สึกเป็นอย่างอื่น แต่สำหรับฉันแล้วเห็นได้ชัดจากความคิดเห็นต่างๆในหน้านี้ว่า XOR สองอาร์กิวเมนต์พื้นฐานยังไม่ได้รับการอธิบายอย่างสมบูรณ์ให้กับผู้เริ่มต้นใช้งานอย่างสมบูรณ์

— Kevin Holt

1

คุณพูดฉันเป็นมัน

— 15ee8f99-57ff-4f92-890c-b56153

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

— Thorham

-3

คำถามนี้ได้รับคำตอบอย่างมีเหตุผล แต่ฉันเจอสถานการณ์ที่แตกต่างออกไป เป็นความจริงที่ว่าไม่จำเป็นต้องมี XOR แบบมีเงื่อนไข นอกจากนี้ยังสามารถใช้ตัวดำเนินการ ^ ได้ อย่างไรก็ตามหากคุณต้องการทดสอบสถานะ "true || false" ของตัวถูกดำเนินการ ^ อาจทำให้เกิดปัญหาได้ ตัวอย่างเช่น:

void Turn(int left, int right)
{
    if (left ^ right)
    {
        //success... turn the car left or right...
    }
    else
    {
        //error... no turn or both left AND right are set...
    }
}

ในตัวอย่างนี้หากตั้งค่าทางซ้ายเป็น 10 (0xa) และตั้งค่าทางขวาเป็น 5 (0x5) สาขา "ความสำเร็จ" จะถูกป้อน สำหรับตัวอย่างนี้ (ง่ายถ้าโง่) สิ่งนี้จะทำให้เกิดข้อผิดพลาดเนื่องจากคุณไม่ควรเลี้ยวซ้ายและขวาพร้อมกัน สิ่งที่ฉันรวบรวมจากผู้ถามไม่ใช่ว่าเขาต้องการเงื่อนไข แต่เป็นวิธีง่ายๆในการดำเนินการจริง / เท็จกับค่าที่ส่งไปยัง xor

มาโครสามารถทำเคล็ดลับ:

#define my_xor(a, b) ( ((a)?1:0) ^ ((b)?1:0) )

อย่าลังเลที่จะตบฉันถ้าฉันไม่ได้ทำเครื่องหมาย: o)

ฉันอ่านคำตอบของ jimreed ด้านล่างหลังจากที่ฉันโพสต์สิ่งนี้ (Yapdog ไม่ดี!) และมันก็ง่ายกว่าจริงๆ มันจะได้ผลและฉันไม่รู้เลยว่าทำไมคำตอบของเขาถึงถูกโหวตลง ...

— เห่าหมา
แหล่งที่มา

3

นี่คือคำถาม C # ไม่ใช่ C / C ++ ifต้องการนิพจน์บูลีนมันจะไม่รวบรวมด้วย int

— Marc L.