สวัสดี ยินดีต้อนรับกลับ. ในการบรรยายนี้
เราจะพูดถึงตัวดำเนินการพื้นฐานบางตัวที่สนับสนุนโดยภาษาโปรแกรมซี
ดังนั้นตัวดำเนินการจึงเป็นเพียงสัญลักษณ์พิเศษสำหรับฟังก์ชันที่คุณกำลังดำเนินการอยู่
ดังนั้น เราจะมาพูดคุยกันโดยทั่วไปในการบรรยายนี้ ตัวดำเนินการ
4 ประเภทที่แตกต่างกัน
ตัวดำเนินการเลขคณิต ตรรกะ
การมอบหมาย และเชิงสัมพันธ์
แล้วเราจะพูดถึงตัวดำเนินการระดับบิตในอีกการบรรยาย
และตัวดำเนินการพิเศษอีกสองสามตัวที่ดูเหมือนไม่ใช่ตัวดำเนินการ
แต่มันคือ ขนาดของตัวดำเนินการ และตัวดำเนินการแคสต์
ดังนั้นตัวดำเนินการเลขคณิตจึงเป็นตัวที่ใช้สามัญสำนึกมากที่สุด
ตัวดำเนินการที่คุณน่าจะคุ้นเคยมากที่สุด เป็นฟังก์ชันทางคณิตศาสตร์
นำตัวถูกดำเนินการ 2 ตัวมาคำนวณ
มันคือ infix ดังนั้นตัวดำเนินการและระหว่างตัวถูกดำเนินการ
ตัวดำเนินการเชิงตรรกะ ซึ่งบางครั้งเรียกว่าตัวดำเนินการบูลีน คือตัวดำเนินการที่ส่งกลับผลลัพธ์บูลีน
ค่าจริงหรือเท็จ นั่นคือสิ่งที่บูลีนเป็น
มันก็แค่ตัวดำเนินการตามเงื่อนไข
โดยยึดตามผลลัพธ์บูลีนของนิพจน์อื่นอย่างน้อย 2 นิพจน์ นิพจน์อื่นหนึ่งหรือสองนิพจน์
ตัวดำเนินการกำหนดค่าเพียงแค่ตั้งค่าตัวแปรให้เท่ากับค่า
โดยกำหนดค่าของนิพจน์ทางด้านขวาให้กับตัวแปรทางด้านซ้าย
มันจึงเป็นตัวถูกดำเนินการทางขวาและตัวถูกดำเนินการทางซ้าย
อีกครั้งมันเป็นสิ่งที่แนบมา
จากนั้นตัวดำเนินการเชิงสัมพันธ์จะเปรียบเทียบตัวแปรซึ่งกันและกัน
นี่เป็นลำดับประเภทที่เปรียบเทียบกันได้ น้อยกว่าและมากกว่า
แต่มาดูแต่ละอันกันดีกว่า เพราะมีโอเปอเรเตอร์ที่แตกต่างกันมากมาย
หลายตัว C รองรับชุดซุปเปอร์ริช
อันแรกคือตัวดำเนินการเลขคณิตเหล่านี้ใน c
นี่คือฟังก์ชันทางคณิตศาสตร์ มีตารางเล็ก ๆ ที่ฉันพบทางออนไลน์จากเว็บไซต์จุดฝึกสอน
ซึ่งดีมาก
และนี่จะสรุปตัวดำเนินการเลขคณิตทั้งหมดใน c ที่รองรับ
พื้นฐานเช่นเดียวกับในวิชาคณิตศาสตร์ ไม่มีอะไรใหม่ที่นี่จริงๆ
ทางด้านซ้ายมือของตารางคือตัวดำเนินการ และตรงกลางคือคำอธิบายของสิ่งที่มันทำ
และทางด้านขวาคือตัวอย่าง
เครื่องหมายบวกที่จะบวกตัวถูกดำเนินการ
มันเป็นสิ่งที่แนบมา อยู่ระหว่างตัวถูกดำเนินการ 2 ตัว
สิ่งที่คุณจะทำคือคุณสามารถเพิ่มตัวแปรได้
คุณสามารถเพิ่มค่าคงที่ในตัวแปรหรือค่าคงที่ก็ได้
และอันนี้เรากำลังบอกว่า a บวก b เท่ากับ 30
แต่ตัวดำเนินการและตัวถูกดำเนินการจริงเป็นเพียง a บวก b
แล้วนั่นก็จะเป็นตัวอย่าง
ลบ ลบ 2 ตัวถูกดำเนินการ a ลบ b
แล้ว a ลบ b อาจเท่ากับบางอย่างเช่นลบ 10 ถ้า
a เท่ากับ 20 และ b เท่ากับ 10 หรือ b เท่ากับลบ
10
เครื่องหมายดอกจันคือการคูณ
ตรึงอีกครั้งระหว่างตัวถูกดำเนินการ
ดิวิชั่นคือฟันเฟืองไปข้างหน้า
เปอร์เซ็นต์เป็นตัวดำเนินการโมดูลัส นี่คือตัวดำเนินการที่เหลือ
แล้วถ้าคุณบอกว่าเป็นตัวแปร เปอร์เซ็นต์
a มันจะเท่ากับอะไร ถ้า b เท่ากับ 20, a เท่ากับ 12,
ตัวดำเนินการโมดูลัสจะส่งกลับ
8 เพราะนั่นคือส่วนที่เหลือของ 20 หารด้วย 12
บวก บวก ลบ เหล่านี้เป็นตัวดำเนินการเพิ่มและลดค่าเฉพาะ
พวกมันยังคงถูกเรียกว่าตัวดำเนินการเลขคณิต แต่โดยทั่วไปคุณจะเห็นพวกมันเป็นลูปเป็นส่วนใหญ่เมื่อคุณทำซ้ำโค้ด
แต่ไม่เสมอไป ฉันหมายถึงในตัวอย่างนี้
โดยพื้นฐานแล้ว คุณกำลังเพิ่มตัวแปร 1 หรือด้วยค่าเฉพาะ
หากคุณทำอย่างอื่น
แต่ถ้าคุณทำบวก
บวก ไม่ว่า a จะเป็นอะไร ถ้ามันเป็น 5 มันจะไม่เท่ากับ 6
แล้วมีตัวดำเนินการลดค่า
ซึ่งลดค่าจำนวนเต็มลง 1, ได้ลบลบ
และบวก บวก ลบ ที่คุณควรสังเกตว่าอยู่หลังตัวแปร
สิ่งนี้เรียกว่า postfix
และความหมายก็คือ ถ้าตัวแปรนั้นอยู่ในนิพจน์ มันจะไม่ถูกกำหนดให้เป็นตัวแปรพิเศษจนกว่าจะถึงหลังจากคำสั่งนั้น
ถ้าเป็นคำนำหน้าก็จะถูกกำหนดไว้ก่อน
ลองมาดูตัวอย่างของบล็อกโค้ดปฏิบัติการเลขคณิตเหล่านี้กัน
เพื่อให้เข้าใจมากขึ้น
นี่คือการบล็อกโค้ด นี่คือกิจวัตรหลักของเรา
เราคุ้นเคยกับสิ่งนี้แล้ว ฉันจะสร้างตัวแปรสองสามตัวและดำเนินการกับพวกมันแล้วพิมพ์ออกมา
และผมแค่จะสร้างจำนวนเต็ม และไม่สำคัญว่าคุณสามารถสร้างโฟลตเพื่อคำนวณหรือเพิ่มเป็นสองเท่า
แต่เราจะทำให้เป็นพื้นฐาน
เราจะบอกว่า a เท่ากับ 33
สร้างตัวแปรประเภทจำนวนเต็มอีกตัวหนึ่ง แล้วเราจะกำหนดให้
15 ดังนั้นเราจึงทำการประกาศและมอบหมายงานในคำสั่งเดียว
แล้วเราก็จะได้ตัวแปรผลลัพธ์
และนี่จะถูกตั้งค่าเริ่มต้นเป็น 0 ดังนั้นที่นี่
เราสามารถเริ่มการคำนวณได้ เราสามารถพูดได้ว่า c และเราสามารถทำงานที่ได้รับมอบหมายได้
เราไม่ได้เรียนรู้เกี่ยวกับการมอบหมายงานอย่างเป็นทางการ
แต่เรารู้ว่างานมอบหมายคืออะไร Assignments กำลังรับข้อมูลและใส่ข้อมูลนั้นลงในตัวแปรนั้น
ดังนั้น
c เท่ากับคือการเอาอะไรก็ตามที่อยู่ทางขวามือมาใส่ผลลัพธ์ลงในตัวแปรนั้น
ถ้าเราบอกว่า a บวก b, นี่ก็ดูเหมือนเป็นกิจวัตรทางคณิตศาสตร์ปกติ,
และมันก็เป็น มันจะเท่ากับ 33 บวก 15 แล้วค่าของ
c, 48 จะเป็นเท่าไหร่ คุณพิมพ์ค่าออกมาได้เลย
คุณสามารถพูดได้ว่า c คือเปอร์เซ็นต์ d โดยใช้ตัวระบุรูปแบบของเรา
และเพียงแค่พิมพ์ c
แล้วบางทีเราอาจจะทำการป้อนเส้น
และนั่นก็บวก 2 ตัวเลขเท่านั้น มันเป็นพื้นฐานที่ มันง่ายมาก
เราแค่แสดงมัน เมื่อเรารันโปรแกรมนี้
เราจะเห็นการบวก 33 บวก 15
เราคอมไพล์ใหม่ บันทึก พูดบิลด์ แล้วบันทึกการรัน
คุณจะเห็นว่าเมื่อฉันเรียกใช้หลังจากโปรแกรมสแกนไวรัสของฉัน มันบอกว่า c คือ 48
เพื่อให้คุณสามารถเล่นกับสิ่งเหล่านี้ได้ ฉันหมายความว่านี่คือสิ่งเหล่านี้เป็นพื้นฐาน บวก b, คุณลบได้,
เครื่องหมายดอกจันสำหรับการคูณ, จากนั้นคุณสามารถหารด้วยเครื่องหมายทับ
ตามด้วยสัญลักษณ์เปอร์เซ็นต์ซึ่งเป็นโมดูลัส
นี่น่าสนใจเพราะคุณรู้ว่า 33 หารด้วย 15 จะเป็น 2 เหลือเศษ
3 ดังนั้นผลลัพธ์จะเป็น 3 ในกรณีนี้ ลองให้แน่ใจ
บันทึกสิ่งนี้ และตรวจสอบให้แน่ใจว่าเราปิดการดำเนินการของเรา
และเมื่อเรารันมัน เราจะเห็นว่าเรามี
c เท่ากับ 3 เพราะนั่นคือเศษที่เหลือ
อย่างอื่นก็ค่อนข้างพื้นฐาน สิ่งสำคัญที่มีเครื่องหมายบวกคือต้องเข้าใจคำนำหน้าและคำต่อท้าย
ดังนั้น ถ้าจะให้ผมพูด และนี่มีความเกี่ยวข้องมากกว่าเมื่อคุณทำจริงๆ ด้วยคำสั่งเดียว printf
สมมุติว่าผมพิมพ์บวกบวกออกมา
สิ่งที่จะพิมพ์ออกมาคือ 34 เพราะคุณจะเพิ่ม
a ทีละ 1 แล้วพิมพ์ออกมา
แต่คุณจะทำมันในคำสั่งเดียว
คุณจะทำในบรรทัดเดียวกันเพราะมันเป็นหลังจากนั้น
ที่จริงแล้วสิ่งที่จะแสดงที่นี่ก็คือจะแสดงแค่
33 เท่านั้น
มันจะไม่เพิ่ม a จนกว่าจะถึงบรรทัดถัดไปของโค้ด
ถ้าเรารันสิ่งนี้ คุณจะเห็นว่ามันพิมพ์ออกมาแค่
33
นั่นคือความแตกต่างระหว่างการทำ a plus plus a
หากคุณทำการบวกบวก a ซึ่งเป็นสิ่งเดียวกับที่คุณจะเพิ่มทีละหนึ่ง
ความแตกต่างตรงนี้คือคุณจะเพิ่มมันขึ้น 1 และก่อนที่จะดำเนินการคำสั่ง
ตอนนี้เราจะสังเกตเห็นว่าเราเพิ่งมีคำเตือนสองสามข้อ
ไม่มีข้อผิดพลาด และเมื่อเรารันมัน ตอนนี้ คุณจะเห็นคำตอบคือ 34 เพราะมันเพิ่มขึ้นจริง
ๆ ก่อนดำเนินการคำสั่ง และสิ่งสำคัญคือต้องรู้ระหว่างชื่อตัวแปรบวกบวกกับชื่อตัวแปรบวกบวก
นั่นเป็นเพียงการอ้างถึงคำนำหน้าและคำต่อท้าย
เช่นเดียวกันจะเกิดขึ้นสำหรับลบลบ
ดังนั้นจงคำนึงถึงสิ่งเหล่านี้สำหรับเอกภาพของคุณ
เหล่านี้ยังเป็นตัวดำเนินการเอกภาพเนื่องจากมีตัวถูกดำเนินการเพียงตัวเดียว
อีกตัวหนึ่งเป็นตัวดำเนินการไบนารีเนื่องจากมีตัวดำเนินการอยู่ระหว่างตัวถูกดำเนินการ
แต่เข้าใจลบลบกับบวกบวก
แล้วเข้าใจด้วยว่าถ้าคุณวางไว้หน้าตัวแปรหลังตัวแปร
เมื่อมันจะเพิ่มหรือลดจริง ๆ
และอีกครั้ง ทั้งหมดก็คือถ้ามันอยู่หลังตัวแปร
มันจะเพิ่มหรือลดค่าตรงนั้นก่อนที่จะรันบรรทัดของโค้ด
ถ้าเป็น
um ก่อนตัวแปร มันจะรันบรรทัดของโค้ด จากนั้นจึงรันคำสั่ง มันก็จะเพิ่มหรือลด
แต่ลองเล่นดู เปิดหน้าต่าง ทำนิพจน์เลขคณิตหลายชุด
และดูว่ามันทำงานอย่างไร
ทีนี้มาพูดถึงตัวดำเนินการประเภทอื่นๆ กันบ้าง
ตัวดำเนินการกลุ่มถัดไปจะเรียกว่าตัวดำเนินการเชิงตรรกะ
และเรากำหนดว่าสิ่งนี้หมายความว่าอย่างไร โดยพื้นฐานแล้วมันคือตัวดำเนินการประเภทตามเงื่อนไข
ส่งคืนผลลัพธ์บูลีน
ค่าจริงหรือเท็จ
ดังนั้นสัญลักษณ์ที่แสดงถึงตัวดำเนินการเชิงตรรกะคือเครื่องหมายและเครื่องหมาย
แท่งคู่ขนาน 2 แท่ง และเครื่องหมายอัศเจรีย์
เครื่องหมายและเครื่องหมายถูกเรียกว่าตรรกะและตัวดำเนินการ
นอกจากนี้ยังเป็นตัวดำเนินการ infix ที่รับตัวถูกดำเนินการ 2 ตัว ตัวหนึ่งอยู่ทางซ้าย
ตัวหนึ่งอยู่ด้านข้าง โดยพื้นฐานแล้ว ถ้าตัวถูกดำเนินการแต่ละตัวไม่ใช่
-0 เงื่อนไขจะกลายเป็นจริง
ดังนั้น non-0 จึงหมายถึง 1 ซึ่งหมายถึงจริง ดังนั้น ถ้า a เป็นจริง
และ b เป็นจริง คำตอบก็จะเป็นจริง
ถ้า a เป็นเท็จ และ b เป็นจริง
คำตอบจะเป็นเท็จ ถ้า a เป็นเท็จ และ b เป็นเท็จ คำตอบจะเป็นเท็จ
เราจะยกตัวอย่างอีกครั้ง
แล้วแถบคู่ขนานคือตรรกะหรือตัวดำเนินการ อีกครั้ง นี่ควรจะคล้ายกับชั้นเรียนคณิตศาสตร์ของคุณ
ดังนั้นฉันจึงไม่ต้องการใช้เวลากับมันมากเกินไป แต่ถ้าตัวถูกดำเนินการ 2 ตัวใดไม่ใช่
-0 ตัวใดตัวหนึ่งเป็นจริง
มันก็เป็นจริง ดังนั้น ถ้า a เป็นจริง และ b เป็นเท็จ แสดงว่าเป็นจริง
และนี่คือนิพจน์ที่คืนค่า
ดังนั้นผลตอบแทนที่ได้จะเป็นถ้า a เป็นจริง และ b เป็นเท็จ การคืนค่าจะเป็นจริง
แล้วโอเปอเรเตอร์ตรรกะไม่ใช่ซึ่งเป็นเครื่องหมายอัศเจรีย์ นี่ก็แค่กลับสถานะตรรกะของตัวถูกดำเนินการของมัน
ดังนั้น ถ้าเงื่อนไขเป็นจริง มันจะคืนค่าเท็จ
ดังนั้น ถ้าคุณบอกว่าไม่ใช่ a เครื่องหมายอัศเจรีย์และ a เป็นจริง a จะเป็นเท็จ
หากคุณใส่ค่าที่ไม่อยู่นอกวงเล็บ ไม่ว่า a และ b ใดที่ประเมินค่า
มันก็จะมีค่าเป็นตรงกันข้าม
ลองมาดูตัวอย่างและบล็อคโค้ดอีกครั้ง
นี่คือบล็อคเย็น และอีกครั้ง ฉันจะสร้างตัวแปรสองสามตัวเพื่อแสดงตัวดำเนินการเชิงตรรกะ
อีกครั้ง ผมจะสร้างจำนวนเต็มขึ้นมา
โดยบอกว่า a เท่ากับ 12 แล้ว b เท่ากับ 20
และที่ดีกว่าคือเราจะสร้าง a
เพราะฉันไม่ต้องการใช้เงื่อนไข ดังนั้นเราจะสร้าง
underscore bool และเราจะกำหนดสิ่งนั้น ฉันจะบอกว่ามันจะเป็นผลลัพธ์ และเราจะเริ่ม
ไม่มอบหมายสิ่งนั้นให้กับสิ่งใด
แล้วเราจะพิมพ์ข้อมูลออกมา
ดังนั้นเราจึงต้องการดูว่านิพจน์เหล่านี้คืนค่าเป็นค่าใด
หากเราใช้ตัวดำเนินการเชิงตรรกะ
ในนี้ผมจะพิมพ์เปอร์เซ็นต์
d ซึ่งเป็นจำนวนเต็ม เพราะจำไว้ว่านิพจน์บูลีนเป็นเพียงจำนวนเต็ม
ตัวแปรบูลีนเป็นจำนวนเต็ม ดังนั้นหากค่าบูลีนเป็น 1
แสดงว่าเป็นจริง
หากเป็น 0 แสดงว่าเป็นเท็จ อย่างอื่นมักจะ 1 ก็จริง
ผมจะพิมพ์ผลลัพธ์ออกมา
แล้วฉันจะกำหนดข้อมูลบางอย่างให้กับมัน ถ้าฉันบอกว่าผลลัพธ์เท่ากับ
a กับ b มันไม่สมเหตุสมผลเลย
เพราะนี่คือตัวเลข
ลองเริ่มต้นเท่ากับจริงแล้วใช้บูลีนอีกครั้ง
และที่นี่เราจะบอกว่านี่เป็นความจริงและนี่เป็นความจริง
และเมื่อเราใช้เครื่องหมายแอมเพอร์แซนด์
นี่บอกว่า a และ b ทั้งคู่ต้องเป็นจริงจึงจะกลับมาเป็นจริงได้
ดังนั้นผลลัพธ์ควรพิมพ์ 1 เพราะ
1 แทนค่าจริง มาสร้างสิ่งนี้กันเถอะ
และเราต้องใช้พื้นที่ชื่อที่ถูกต้อง
เราก็แค่แทน
1 แทนค่าจริงกับ 1 เพราะเราไม่ได้รวมค่าที่ถูกต้องในตอนนี้,
นั่นจึงไม่ใช่เรื่องใหญ่ ตอนนี้เรารัน มันควรจะรายงานจริง
1 และทำ 1
ตอนนี้ถ้าฉันเปลี่ยนสิ่งเหล่านี้เป็นไม่จริงถ้าฉันบอกว่า
0 ผลลัพธ์จะเป็นเท็จเพราะ a และ b ทั้งคู่ต้องเป็นจริงเพื่อให้ผลลัพธ์เป็นจริง
ถ้าฉันสร้างสิ่งนี้และรันมัน
คุณจะเห็นว่าผลลัพธ์เป็น 0 เพราะมันเป็นเท็จ
ดังนั้นอย่างใดอย่างหนึ่งถ้าฉันเปลี่ยน a หรือ
b เป็น 0 ซึ่งหมายถึงเท็จ ผลลัพธ์จะเป็นเท็จเพราะทั้ง a และ b ต้องเป็นจริง
ทีนี้ ถ้าฉันบอกว่าแท่งขนาน แท่งคู่ขนาน ซึ่งก็คือ
หรือ a หรือ b มีเพียงหนึ่งแท่งเท่านั้นที่จะต้องเป็นจริง เพื่อให้ได้ผลลัพธ์ที่เป็นจริง
ในกรณีนี้ ผลลัพธ์ควรเป็น 1
มาสร้างสิ่งนี้และเรียกใช้กัน
และตอนนี้เรามีค่าเท่ากับ 1
ดังนั้นเพียงหนึ่งในนั้นจะต้องเป็นจริง ดังนั้นตอนนี้ ถ้าฉันทำให้พวกเขาทั้งสองเป็นเท็จ
และนี่จะยิ่งใช้ได้มากขึ้นเมื่อเราพูดถึงคำสั่งและเงื่อนไขและการตัดสินใจ
แต่ฉันกำลังแสดงตรรกะบูลีนที่นี่
ตอนนี้ทั้งคู่เป็นเท็จ นี่ควรคืนค่า
0 ซึ่งเป็นเท็จ และกลับเป็น
0 ค่อนข้างเรียบร้อย แล้วอันสุดท้ายก็แค่ไม่ใช่สัญลักษณ์ ซึ่งเป็นเครื่องหมายอัศเจรีย์ที่ทำหน้าที่ผกผัน
ถ้าฉันบอกว่าไม่ใช่ a, ถ้า
a เท่ากับ 0, a ตอนนี้จะเท่ากับ
1 หรือผลลัพธ์จะเป็น และผลลัพธ์จะเท่ากับ
1, ซึ่งก็คือ
นั่นคือตัวดำเนินการเชิงตรรกะ 3 ตัว อีกครั้ง พวกเขาจะใช้ในคำสั่งการตัดสินใจ
ตอนนี้เรามาพูดถึงโอเปอเรเตอร์ชุดอื่นกัน
ต่อไปนี้คือตัวดำเนินการมอบหมาย เราค่อนข้างคุ้นเคยกับตัวดำเนินการมอบหมายอย่างง่ายซึ่งเป็นสัญลักษณ์ที่เท่ากัน
สัญลักษณ์เท่ากับกำหนดข้อมูลและนั่นก็ค่อนข้างพื้นฐาน
C เท่ากับ a บวก b, c จะเท่ากับผลลัพธ์ของ a บวก b
ทีนี้ มีตัวดำเนินการประเภทผสมเหล่านี้
ซึ่งคุณสามารถบวก เท่ากับ หรือ ลบเท่ากับ หรือ สตาร์เท่ากับได้
บวกเท่ากับเป็นที่ที่คุณเพิ่มและตัวดำเนินการมอบหมาย
ดังนั้นมันจึงเพิ่มตัวถูกดำเนินการทางขวาให้กับตัวถูกดำเนินการทางซ้าย จากนั้นตัวถูกดำเนินการกำหนดผลลัพธ์ให้กับตัวถูกดำเนินการทางซ้าย
คุณจึงบอกว่า c บวก เท่ากับ a, และนั่นก็เหมือนกับว่า c เท่ากับ c บวก a
ลบ เท่ากับสิ่งเดียวกันทุกประการ เว้นแต่คุณกำลังลบ คุณกำลังลบและจากนั้นคุณกำลังกำหนด
ดังนั้น คุณลบตัวถูกดำเนินการทางขวาจากตัวถูกดำเนินการทางซ้าย แล้วกำหนดข้อมูล
ถ้าคุณบอกว่า c ลบ เท่ากับ a, มันก็คือ c เท่ากับ c ลบ a
มันเป็นสัญกรณ์ชวเลข พวกนี้บวกเท่ากับลบเท่ากับ
คุณสามารถเขียนสิ่งต่าง ๆ ได้เร็วขึ้นเล็กน้อย
เนื่องจากคุณดำเนินการ 2 อย่างโดยพื้นฐานแล้วในคำสั่งเดียว
แล้วคูณสิ่งเดียวกัน ดาวเท่ากับ คูณ และกำหนด
ดังนั้น c ดาวเท่ากับ a เท่ากับ c เท่ากับ c คูณ a
ค่อนข้างตรงไปตรงมาฉันคิดว่า
ตัวดำเนินการมอบหมายอื่นๆ
จะคล้ายกัน ยกเว้นว่าคุณกำลังใช้แผนก หารเท่ากับหารแล้วเซ็น
เปอร์เซ็นต์คือการทำโมดูลัสแล้วกำหนดผลลัพธ์
ดังนั้นสิ่งเหล่านี้ค่อนข้างตรงไปตรงมา
แล้วเราก็มีเรื่องอื่นๆ ซึ่งเราจะพูดถึงในการบรรยายอีกเรื่องโดยละเอียดมากขึ้น
ดังนั้นฉันจะไม่แตะต้องพวกเขาที่นี่เพราะพวกเขาแตกต่างไปจากเดิมอย่างสิ้นเชิง
พวกมันถูกเรียกว่าตัวดำเนินการระดับบิต ซึ่งเหลืออยู่
และทั้งหมดที่ฉันพูดในที่นี้คือสำหรับตัวดำเนินการระดับบิตที่เรากำลังจะพูดถึง
คุณยังสามารถกำหนดพวกมันเป็นคำสั่งเดียวได้
ดังนั้น การเปลี่ยน การเลื่อนซ้ายและขวา
และการมอบหมาย คุณสามารถทำน้อยกว่าน้อยกว่าเท่ากับและเขียนมากกว่าใดๆ ที่มากกว่าเท่ากับ
เครื่องหมายและ แครอท และแท่งคู่ขนาน ล้วนเกี่ยวข้องกับการทำสิ่งเล็กๆ
น้อยๆ
เราจะกลับมาที่เรื่องนั้น แต่พวกเขาเป็นส่วนหนึ่งของผู้ปฏิบัติงานที่ได้รับมอบหมาย
ดังนั้น ตัวดำเนินการมอบหมายจึงค่อนข้างง่าย กำหนดข้อมูล แล้วถ้าคุณต้องการทำนิพจน์จริง
ๆ นิพจน์สองนิพจน์ จากนั้นกำหนด คุณก็ทำการรวมกัน
ตัวดำเนินการเชิงสัมพันธ์คือตัวดำเนินการเปรียบเทียบ พวกเขาเปรียบเทียบ 2 ค่า
นี่จึงเป็นสิ่งสำคัญ เท่ากับ เราจะเปรียบเทียบค่าของตัวแปร 2 ตัว
และถ้ามันเหมือนกัน มันจะคืนค่า จริง เพราะมันจะส่งกลับนิพจน์บูลีน
ค่าจริงหรือเท็จ หรือค่าบูลีน
เครื่องหมายอัศเจรีย์เท่ากับกำลังตรวจสอบว่าค่า 2 ตัวถูกดำเนินการเท่ากันหรือไม่
a ไม่เท่ากับ b คือวิธีที่คุณอยากอ่าน
ถ้า a เป็นจริง และ b เป็นจริง
มันจะคืนค่าเท็จเพราะมันเท่ากัน
ดังนั้น a จะต้องเป็นเท็จ
หรือ b จะต้องเป็นจริงหรือกลับกัน และนั่นจะคืนค่าเป็นจริง เครื่องหมายมากกว่า คือ ตรวจสอบว่า
a มากกว่า b หรือไม่
น้อยกว่าสัญลักษณ์ a น้อยกว่า b มากกว่าเท่ากับ a มากกว่าหรือเท่ากับและน้อยกว่าเท่ากับ
อีกครั้ง นี่เป็นเรื่องพื้นฐานทางคณิตศาสตร์ทั้งหมด
ฉันจะไม่พูดถึงตัวอย่างใน IDE เพราะค่อนข้างตรงไปตรงมา
ตัวดำเนินการเปรียบเทียบก็เหมือนในทางคณิตศาสตร์ มากกว่าเท่ากับและอื่นๆ
หวังว่าเราจะมีการจัดการที่ดีเกี่ยวกับตัวดำเนินการพื้นฐาน
เลขคณิต ตรรกะ การมอบหมาย และเชิงสัมพันธ์
ใช้มาไม่น้อยแล้วต้องเข้าใจ หวังว่าจะไม่ยากหรือสับสนจนเกินไป
คุณจะใช้สิ่งนี้เป็นจำนวนมากในคำสั่ง
if และคำชี้แจงการตัดสินใจ ดังนั้นเราจะให้ตัวอย่างเพิ่มเติมมากมายเกี่ยวกับสิ่งเหล่านี้ ขอขอบคุณ.