คำถามติดแท็ก operators

ฉันกำลังเขียน wrapper สำหรับองค์ประกอบ XML ที่ช่วยให้นักพัฒนาสามารถวิเคราะห์แอตทริบิวต์จาก XML ได้อย่างง่ายดาย เสื้อคลุมไม่มีสถานะอื่นนอกจากวัตถุที่ถูกห่อ ฉันกำลังพิจารณาการติดตั้งต่อไปนี้ (ทำให้ง่ายขึ้นสำหรับตัวอย่างนี้) ซึ่งรวมถึงโอเวอร์โหลดสำหรับ==โอเปอเรเตอร์ class XmlWrapper { protected readonly XElement _element; public XmlWrapper(XElement element) { _element = element; } public string NameAttribute { get { //Get the value of the name attribute } set { //Set the value of the name attribute } …

19 c#  .net  operators 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน5 ปีที่ผ่านมา ภาษาการเขียนโปรแกรมมักจะมาพร้อมกับตัวดำเนินการบิตต่าง ๆ (เช่นการเปลี่ยนบิตซ้าย - ขวาและบิต, ค่าบิตและ AND, หรือ, แฮคเกอร์ ... ) สิ่งเหล่านี้ไม่ได้ถูกใช้อย่างมาก แต่อย่างน้อยประสบการณ์ของฉันก็เช่นกัน บางครั้งพวกเขาจะใช้ในการเขียนโปรแกรมความท้าทายหรือคำถามสัมภาษณ์หรือวิธีแก้ปัญหาต้องใช้พวกเขาเช่น: โดยไม่ต้องใช้ตัวดำเนินการเท่าเทียมกันใด ๆ สร้างฟังก์ชันที่ส่งคืนtrueเมื่อสองค่าเท่ากัน โดยไม่ใช้ตัวแปรตัวที่สามให้สลับค่าของตัวแปรสองตัว สิ่งเหล่านี้อีกครั้งอาจมีการใช้งานจริงไม่กี่แห่ง ฉันเดาว่าพวกเขาควรจะเร็วขึ้นเพราะพวกเขาจัดการหน่วยความจำโดยตรงในระดับต่ำ เหตุใดจึงพบเช่นนี้ในภาษาการเขียนโปรแกรมส่วนใหญ่ กรณีใช้งานจริงใด ๆ

19 programming-languages  operators  bitwise-operators 

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

19 operators  bitwise-operators 

ใน c ++ ตัวดำเนินการ * สามารถโอเวอร์โหลดได้เช่นกับตัววนซ้ำ แต่ตัวดำเนินการลูกศร (->) (. *) ไม่ทำงานกับคลาสที่โอเวอร์โหลดตัวดำเนินการ * ฉันจินตนาการว่าตัวประมวลผลล่วงหน้าสามารถแทนที่อินสแตนซ์ทั้งหมดของ -> ด้วย (* ซ้าย). right ได้อย่างง่ายดายและนั่นจะทำให้ iterators ดีกว่าที่จะใช้ มีเหตุผลในทางปฏิบัติสำหรับ -> แตกต่างหรือว่าเป็นเพียงลักษณะเฉพาะของภาษา / นักออกแบบ?

18 c++  operators 

ฉันเคยเห็นคนอื่นใช้ Bitwise-OR เพื่อรวมแฟล็กก่อนหน้านี้: #define RUN 0x01 #define JUMP 0x02 #define SHOOT 0x04 const byte madPerson = RUN | JUMP | SHOOT; นั่นเป็นวิธีที่ฉันทำ แต่ฉันยังเห็นบางอย่าง (ไม่มาก) รวมธงโดยใช้การเพิ่ม: #define RUN 0x01 #define JUMP 0x02 #define SHOOT 0x04 const byte madPerson = RUN + JUMP + SHOOT; อันไหน "อ่าน" มากกว่า? (อันไหนที่คุณคิดว่าคนอื่นจะจำได้?) วิธี "มาตรฐาน" ในการทำคืออะไร? …

16 c++  operators 

ใน C # เราสามารถโอเวอร์โหลดตัวดำเนินการแปลงโดยนัยเช่นนี้ (ตัวอย่างจากMSDN ): struct Digit { /* ... */ public static implicit operator byte(Digit d) // implicit digit to byte conversion operator { /* ... */ } } ดังนั้นเราจึงสามารถมีประเภทเป็นประเภทค่าที่กำหนดเอง , น่าอัศจรรย์แปลงตัวเองไปอีก (ไม่เกี่ยวข้อง) ประเภทออกจากผู้ชมในความสับสน (จนกว่าพวกเขาจะมองเข้าไปหลังเวทีและเห็นผู้ประกอบการแปลงนัยที่มี) ฉันไม่ชอบปล่อยให้ใครก็ตามที่อ่านรหัสของฉันในความสับสน ฉันไม่คิดว่าหลายคนทำ คำถามคือกรณีใช้งานของโอเปอเรเตอร์การแปลงประเภทโดยนัยคืออะไรจะไม่ทำให้โค้ดของฉันเข้าใจยากขึ้น?

14 c#  operators 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังว่าคำตอบจะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้อาจเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน7 ปีที่ผ่านมา มันเป็นอัตวิสัยเล็กน้อย แต่ฉันหวังว่าจะได้รับความเข้าใจที่ชัดเจนขึ้นว่าปัจจัยใดที่ทำให้ผู้ปฏิบัติงานชัดเจนในการใช้กับป้านและยาก ฉันกำลังพิจารณาการออกแบบภาษาเมื่อเร็ว ๆ นี้และสิ่งหนึ่งที่ฉันมักจะวนเวียนอยู่รอบ ๆ คือเมื่อใดที่จะทำให้การดำเนินงานที่สำคัญบางอย่างในภาษาเป็นผู้ดำเนินการและเมื่อใช้คำหลักหรือฟังก์ชั่น Haskell ค่อนข้างมีชื่อเสียงในเรื่องนี้เนื่องจากตัวดำเนินการแบบกำหนดเองนั้นง่ายต่อการสร้างและบ่อยครั้งที่ชนิดข้อมูลใหม่จะมาพร้อมกับตัวดำเนินการหลายตัวเพื่อใช้กับมัน ยกตัวอย่างเช่นห้องสมุด Parsec มาพร้อมกับตัวดำเนินการมากมายสำหรับการรวมตัวแยกวิเคราะห์เข้าด้วยกันด้วยอัญมณี>.และ.> ฉันจำไม่ได้ว่าพวกเขาหมายถึงอะไรในตอนนี้ แต่ฉันจำได้ว่าพวกเขาทำงานได้ง่ายมาก พวกเขาหมายถึงจริง ฟังก์ชั่นการโทรเช่นleftCompose(parser1, parser2)นี้ดีขึ้นหรือไม่ แน่นอนมากขึ้น verbose แต่ชัดเจนในบางวิธี ตัวดำเนินการโอเวอร์โหลดในภาษา C เหมือนเป็นปัญหาที่คล้ายกัน แต่ conflated โดยปัญหาเพิ่มเติมของการบรรทุกเกินพิกัดความหมายของผู้ประกอบการที่คุ้นเคยเช่น+ความหมายใหม่ที่ผิดปกติ ในภาษาใหม่ใด ๆ ดูเหมือนว่าจะเป็นปัญหาที่ค่อนข้างยาก ยกตัวอย่างเช่นใน F # การคัดเลือกนักแสดงใช้ตัวดำเนินการแคสติ้งประเภทที่ได้มาในเชิงคณิตศาสตร์แทนที่จะใช้ไวยากรณ์ของการส่งรูปแบบ C # หรือสไตล์ VB verbose C #: (int32) xVB: …

14 language-design  operators 

โอเปอเรเตอร์ของ infix มีประโยชน์อย่างไรในภาษาการเขียนโปรแกรม? พวกเขาคุ้มค่ากับความซับซ้อนที่เพิ่มขึ้นหรือไม่ คุณสามารถให้ตัวอย่างใด ๆ ที่ตัวดำเนินการมัดเหมาะกับปัญหาที่ไม่สามารถจัดการได้โดยเพียงแค่บรรทุกเกินพิกัดตัวดำเนินการปกติหรือไม่

13 programming-languages  syntax  operators 

พิจารณาสถานการณ์ทั่วไปดังต่อไปนี้: if(myObject == null) { myObject = new myClass(); } ฉันสงสัยว่าความคิดของการแทนที่ต่อไปนี้โดยใช้ตัวดำเนินการ null รวมกัน: myObject = myObject ?? new myClass(); ฉันไม่แน่ใจว่าควรใช้แบบฟอร์มที่สองหรือไม่ ดูเหมือนว่าจะเป็นชวเลขที่ดี แต่การmyObject = myObjectสร้างที่จุดเริ่มต้นดูเหมือนจะเป็นกลิ่นโค้ดเล็กน้อย นี่เป็นสิ่งที่สมเหตุสมผลที่ต้องทำหรือมีชวเลขที่ดีกว่าที่ฉันทำหายไปหรือไม่? หรืออาจจะ "มันเป็นสามบรรทัดเอาเลย!"? แก้ไข: ดังที่ได้กล่าวไว้บางทีการเรียกสิ่งนี้ว่าสถานการณ์โดยทั่วไปนั้นเป็นเรื่องที่เกินความจริง ฉันมักจะพบว่าฉันพบสถานการณ์นี้เมื่อฉันดึงข้อมูลเอนทิตี้จากฐานข้อมูลที่มีคุณสมบัติประเภทการอ้างอิงลูกที่อาจหรืออาจจะไม่ได้บรรจุ: myClass myObject = myClassService.getById(id); myObject.myChildObject = myObject.myChildObject ?? new myChildClass();

12 c#  operators 

ปิด คำถามนี้จะต้องมีมากขึ้นมุ่งเน้น ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้มุ่งเน้นที่ปัญหาเดียวโดยแก้ไขโพสต์นี้ ปิดให้บริการใน4 ปีที่แล้ว ในขณะที่ฉันเรียนรู้ C # ฉันพบว่า C # รองรับการบรรทุกเกินพิกัด ฉันมีปัญหากับตัวอย่างที่ดีซึ่ง: Make sense (เช่นเพิ่มคลาสที่ชื่อแกะและวัว) ไม่ใช่ตัวอย่างของการต่อข้อมูลสองสตริง ตัวอย่างจาก Base Class Library ยินดีต้อนรับ

12 c#  .net  operators 

ชื่อจะทำให้เข้าใจผิดดังนั้นโปรดอ่านคำถามทั้งหมด :-) โดย "ผู้ประกอบการที่ได้รับมอบหมายสารประกอบ" ผมมีในใจสร้างเช่นนี้ยกตัวอย่างเช่นop= +=ตัวดำเนินการกำหนดค่าบริสุทธิ์ ( =) ไม่ได้อยู่ในคำถามของฉัน โดย "ทำไม" ฉันไม่ได้หมายถึงความเห็น แต่เป็นแหล่งข้อมูล (หนังสือบทความ ฯลฯ ) เมื่อนักออกแบบบางคนหรือเพื่อนร่วมงาน ฯลฯ แสดงเหตุผลของพวกเขา(เช่นแหล่งที่มาของตัวเลือกการออกแบบ) ฉันงงงวยด้วยความไม่สมดุลที่พบใน C ++ และ C # ( ใช่ฉันรู้ว่า C # ไม่ใช่ C ++ 2.0 ) - ใน C ++ คุณต้องโอเวอร์โหลดโอเปอเรเตอร์+=แล้วเขียน+ตัวดำเนินการที่เหมาะสมโดยอัตโนมัติอาศัยโอเปอเรเตอร์ที่กำหนดไว้ก่อนหน้านี้ ใน C # เป็นแบบย้อนกลับ - คุณโอเวอร์โหลด+และ+=สังเคราะห์สำหรับคุณ หากฉันไม่เข้าใจผิดวิธีการในภายหลังจะฆ่าโอกาสในการปรับให้เหมาะสมในกรณีของจริง+=เนื่องจากต้องสร้างวัตถุใหม่ ดังนั้นจะต้องมีข้อได้เปรียบที่ยิ่งใหญ่ของวิธีการดังกล่าว แต่ MSDN อายเกินกว่าจะบอกได้ …

11 c#  language-design  operators 

คุณสามารถใช้<<เพื่อคูณและ>>หารตัวเลขในไพ ธ อนเมื่อฉันเวลาพวกเขาพบว่าการใช้วิธีการเปลี่ยนแบบไบนารีในการทำนั้นเร็วกว่าการหารหรือคูณด้วยวิธีปกติเป็น 10 เท่า ทำไมถึงใช้งาน<<และ>>เร็วกว่า*และมาก/? เบื้องหลังกระบวนการอะไรที่เกิดขึ้น*และ/ช้าลง?

9 operators  bitwise-operators 

ฉันกำลังเขียนโค้ดเพื่อแยกสตริงการแสดงออกทางคณิตศาสตร์และสังเกตว่าลำดับที่ตัวดำเนินการพลังงานถูกล่ามโซ่ถูกประเมินใน Python แตกต่างจากลำดับใน Excel จากhttp://docs.python.org/reference/expressions.html : "ดังนั้นในลำดับพลังงานและตัวดำเนินการ unaryhesized ตัวดำเนินการจะถูกประเมินจากขวาไปซ้าย (สิ่งนี้ไม่ได้ จำกัด ลำดับการประเมินสำหรับตัวถูกดำเนินการ): -1 * 2 ผลลัพธ์เป็น -1" * ซึ่งหมายความว่าใน Python: 2**2**3ถูกประเมินเป็น2**(2**3) = 2**8 = 256 ใน Excel มันทำงานในลักษณะอื่น ๆ : 2^2^3ถูกประเมินเป็น(2^2)^3 = 4^3 = 64 ตอนนี้ฉันต้องเลือกการดำเนินการสำหรับตัวแยกวิเคราะห์ของฉันเอง คำสั่งซื้อของ Excel นั้นง่ายต่อการติดตั้งเพราะมันจะสะท้อนลำดับการประเมินผลของการคูณ ฉันถามผู้คนรอบ ๆ สำนักงานว่าพวกเขารู้สึกอย่างไรกับการประเมิน2^2^3และได้รับคำตอบที่หลากหลาย มีใครรู้บ้างเกี่ยวกับเหตุผลที่ดีหรือข้อเสนอแนะที่เป็นประโยชน์ต่อการใช้งาน Python หรือไม่? และถ้าคุณไม่มีคำตอบโปรดแสดงความคิดเห็นกับผลลัพธ์ที่คุณได้รับจากความรู้สึกลำไส้ - 64หรือ256?

9 python  operators  excel  order 

ฉันเพิ่งตรวจสอบบางส่วนของรหัสของฉันและสังเกตเห็นว่าในแบบที่ขาดสติฉันจะออกจากโครงสร้างดังต่อไปนี้: $guid = empty($subscription->guid) ? : $subscription->guid; ตอนนี้สิ่งนี้ไม่ได้ทำในสิ่งที่ควรจะเป็นและผิดแต่เนื่องจากคุณสมบัตินั้นถูกตั้งค่าเสมอตอนนี้มันทำงานได้ดีและไม่มีข้อผิดพลาดทางไวยากรณ์ตั้งแต่ 5.3 เนื่องจากการเปลี่ยนแปลงต่อไปนี้ : ตั้งแต่ PHP 5.3 เป็นไปได้ที่จะปล่อยให้ผู้ให้บริการรายกลางอยู่ Expression expr1?: expr3 ส่งคืน expr1 ถ้า expr1 หาค่าเป็น TRUE และ expr3 เป็นอย่างอื่น ฉันไม่ได้ตระหนักถึงการเปลี่ยนแปลงนี้และตอนนี้ฉันอยากรู้ว่าฉันควรจะใช้มันหรือไม่ นี่คือสิ่งที่ฉันขาดไปอย่างมากจากภาษาเช่นทับทิมที่คุณสามารถทำได้เช่นa = b || cเพื่อให้ได้บูลีน 'ของจริง' bหรือcมากกว่า อย่างไรก็ตามไวยากรณ์ที่พวกเขาเลือกสำหรับผู้ประกอบการที่ดูเหมือนจะเป็นเรื่องง่ายสำหรับฉัน ฉันควรจะใช้สิ่งนี้ในรหัสการผลิตหรือไม่? แน่นอนว่ามันทำให้ฉันประหลาดใจเมื่อฉันเห็นมันโดยบังเอิญ

9 php  comparison  operators