สวัสดีและยินดีต้อนรับ.
ในการบรรยายนี้ ฉันต้องการพูดเกี่ยวกับโอเปอเรเตอร์สองสามตัวที่แปลกเล็กน้อยในแง่ที่คุณไม่จำเป็นต้องคิดว่าพวกมันเป็นตัวดำเนินการ
เนื่องจากตัวดำเนินการทั้งหมดที่เราเรียนรู้มาจนถึงจุดนี้ ชี้ให้คุณทราบถึงการใช้สัญลักษณ์ในการคำนวณตัวเลข
และโอเปอเรเตอร์เหล่านี้ดูเหมือนฟังก์ชันจริงๆ
เรามาพูดถึงนักแสดงในเรื่องขนาดของโอเปอเรเตอร์กัน
ในการที่จะพูดเกี่ยวกับตัวดำเนินการ cast ก่อน ฉันต้องบอกคุณเล็กน้อยเกี่ยวกับการแปลงประเภทว่าข้อมูลถูกแปลงอย่างไร
เราเรียนรู้ทั้งหมดเกี่ยวกับประเภทข้อมูลและประเภทข้อมูลต่างๆ
แต่ถ้าคุณกำลังพยายามกำหนดข้อมูลให้กับประเภทต่างๆ จริงๆ มีการแปลงโดยนัยบางอย่างที่เกิดขึ้นในภาษาการเขียนโปรแกรมภาษาซี
ดังนั้นการแปลงข้อมูลระหว่างประเภทต่าง ๆ สามารถเกิดขึ้นได้โดยอัตโนมัติ
และสิ่งนี้เรียกว่าการแปลงโดยนัยตามภาษาหรือโดยโปรแกรมโดยโปรแกรมหรือ
โปรแกรมเมอร์เอง ผู้พัฒนาสามารถทำบางสิ่งได้
พวกเขาสามารถใช้ตัวดำเนินการแคสต์เพื่อทำการแปลงได้
ข้อมูลที่ถูกแปลงโดยนัยนั้นสำคัญมาก เพราะคุณต้องเข้าใจสิ่งนี้
เพราะโปรแกรมภาษาซีส่วนใหญ่ที่คุณจะพัฒนา เพื่อที่จะพัฒนามันอย่างมีประสิทธิผล
คุณต้องเข้าใจกฎเหล่านี้สำหรับการแปลงเหล่านี้
เพราะคุณมักจะมีเลขจำนวนเต็มและเลขทศนิยม
เลขทศนิยม และจำนวนเต็ม
และคุณจะใช้มันผสมกันในบางครั้ง
และเมื่อคุณทำเช่นนั้น คุณต้องรู้ว่าสิ่งต่างๆ ได้รับการกลับใจใหม่อย่างไร
ตอนนี้คุณควรพยายามหลีกเลี่ยงสิ่งนั้นให้มากที่สุดโดยใช้ตัวดำเนินการแคสต์
แต่เมื่อคุณไม่ใช้ตัวดำเนินการแคสต์ ให้เข้าใจว่าเกิดอะไรขึ้น
และสิ่งที่เกิดขึ้นที่นี่ เมื่อคุณกำหนดข้อมูลให้กับประเภท
float และ doubles ที่แตกต่างกัน
ข้อมูลจะถูกตัดทอนหรือจะถูกเลื่อนระดับ
นี่คือคำศัพท์สองคำที่คุณจะได้ยิน
การตัดทอนจะแม่นยำน้อยลงและได้รับการเลื่อนตำแหน่งหมายความว่าแม่นยำยิ่งขึ้น
ดังนั้นพยายามอย่าผสมสิ่งเหล่านี้เข้าด้วยกัน แต่อาจมีประโยชน์
สิ่งสำคัญที่ต้องเข้าใจคือเรารู้จากการบรรยายก่อนหน้านี้ว่าคมีความยืดหยุ่นมาก
และนั่นเป็นการตัดสินใจอย่างมีสติโดยผู้ออกแบบภาษา
เมื่อพวกเขาต้องการให้มันมีความยืดหยุ่น แต่อีกครั้งเป็นการแลกเปลี่ยน เนื่องจากอิสระเพิ่มเติมนี้มอบให้คุณ
คุณสามารถใช้มันในทางที่ผิด
ดังนั้นอย่าใช้แนวคิดเรื่องการผสมประเภทในทางที่ผิด
ลองใช้ประเภทเดียวกันเมื่อคุณทำได้ จำนวนเต็มเป็นจำนวนเต็ม ลอยตัวด้วยการลอยตัว
แต่เมื่อทำไม่ได้
ให้เข้าใจการแปลงโดยนัยหรือทำการแปลงอย่างชัดเจนโดยใช้ตัวดำเนินการ
cast
อีกครั้ง ปัญหาอื่นหรือแนวคิดอื่นที่
c มีความยืดหยุ่น แต่คุณไม่ควรใช้ในทางที่ผิด
ดังนั้นเมื่อใดก็ตามที่ค่าทศนิยมถูกกำหนดให้กับตัวแปรจำนวนเต็มใน
c ดังนั้นคุณจึงมี int x, float y, x เท่ากับ
y
ส่วนทศนิยมของตัวเลขจะถูกตัดทอน
ดังนั้นถ้าคุณมีตัวเลข int x เท่ากับ 0, float
f เท่ากับ 12 125 แล้วคุณกำหนด
f ให้กับ x ค่าของ x จะเท่ากับ 12
คุณจะสูญเสียความแม่นยำนั้น ค่าจะถูกตัดทอนเนื่องจากคุณกำลังกำหนด
float ให้กับ int int รู้วิธีเก็บจำนวนเต็มเท่านั้น
ดังนั้นมันจึงถูกแปลงโดยอัตโนมัติโดยภาษาโปรแกรม โดยคอมไพเลอร์เป็น 12
โดยจะเก็บเฉพาะการนำเข้าเท่านั้น
ตอนนี้ หากคุณกำหนดตัวแปรจำนวนเต็มให้กับตัวแปรทศนิยม ซึ่งตรงกันข้าม จะไม่ทำให้เกิดการเปลี่ยนแปลงใดๆ
ในค่าของตัวเลข
ค่าจะถูกแปลงโดยระบบและเก็บไว้ในตัวแปรแบบลอยตัว
เพื่อที่คุณจะได้ไม่ต้องกังวลกับการกำหนดโฟลว์
หากคุณกำหนด 12 ให้กับโฟลว์ มันจะยังคงเป็น 12 เพียง 12 0.
เมื่อคุณใช้เลขคณิตกับจำนวนเต็ม ดังนั้นนี่จึงแตกต่างจากการกำหนดค่าที่กำหนดให้กับ
float หรือ float ให้กับ int นี่คือเมื่อคุณมีนิพจน์ คุณกำลังทำการบวกลบ ไม่ว่ากรณีใด
เมื่อคุณทำการลบหรือบวก คุณมีตัวถูกดำเนินการสองตัว
ดังนั้นโอเปอเรเตอร์หนึ่งตัวสามารถเป็น int ตัวถูกดำเนินการหนึ่งตัวสามารถเป็นทุ่นได้
คุณต้องรู้ว่าสิ่งที่แปลงเกิดขึ้นได้อย่างไร
ดังนั้นถ้าคุณมีตัวถูกดำเนินการสองตัวในนิพจน์และเป็นจำนวนเต็มทั้งคู่
ส่วนทศนิยมใดๆ ที่เกิดจากการดำเนินการหารจะถูกยกเลิก
ถ้าคุณทำถ้าคุณมีจำนวนเต็ม x นั่นก็คือ 20
คุณมีจำนวนเต็ม y มันคือ 12 แล้วคุณหาร 20 หารด้วย 12
คุณจะไม่ได้รับ 1 คะแนนบางสิ่งบางอย่าง คุณก็จะได้ 1
มันจะทิ้งผลลัพธ์ทั้งหมดและใส่มันใหม่เพราะอีกครั้ง int เก็บเฉพาะจำนวนเต็มเท่านั้น
เลขสองตัวเป็น int และพวกมันกำลังหารอยู่
คุณจะไม่ได้เลขทศนิยม คุณจะไม่ได้เลขทศนิยม
ตอนนี้ถ้าตัวดำเนินการหนึ่งเป็น int และอีกตัวหนึ่งเป็นทศนิยม การดำเนินการจะถูกสร้างขึ้นเป็นการดำเนินการจุดทศนิยม
ดังนั้นถ้าคุณมี float f เท่ากับ 20 0,
float a คือ 10, an int, แล้วถ้าคุณทำการหารที่นั่นหรือ
12 ฉันขอโทษที่มันใช้ได้มากกว่า ผลลัพธ์จะเป็นเลขทศนิยมและผลลัพธ์จะเป็น 1 คะแนน
8888 หรืออะไรก็ได้ 1 คะแนนแล้วแต่กรณี
คุณไม่ได้กำหนดข้อมูลนี้ให้กับสิ่งใด นี่คือนิพจน์สิ่งที่จะส่งคืน
สองจำนวนในการหาร, มันจะเป็นจำนวนเต็ม
int และ double หรือ float มันจะเป็นทศนิยมเสมอ มันจะเป็นการดำเนินการจุดทศนิยมทศนิยมเสมอ
และนี่คือการแปลงโดยนัย นั่นคือสิ่งที่คุณจำเป็นต้องเข้าใจว่าเกิดอะไรขึ้นและทำอะไรให้คุณโดยโปรแกรมถ้าคุณไม่ทำอะไรเลย
อย่างไรก็ตาม คุณควรพยายามทำการแปลงที่ชัดเจน
ซึ่งคุณสามารถทำได้ด้วยตัวดำเนินการแคสต์
และนี่เรียกว่าแคสต์ไม่มากก็น้อย
และคุณจะเห็นการแคสต์ในหลายภาษาเมื่อคุณต้องการแปลง
และทั้งหมดคือคุณกำลังทำการแปลงอย่างชัดเจน คุณกำลังพูดถึงสิ่งที่คุณต้องการให้ข้อมูลเป็น
ดังนั้น คุณต้องการทำเช่นนี้ถ้าทำได้ เพราะไม่เช่นนั้นข้อมูลอาจถูกลดระดับ
ข้อมูลอาจสูญหาย
หากคุณทำสอง int และคุณกำลังทำการหารและไม่ได้แบ่งเท่าๆ
กัน คุณจะสูญเสียข้อมูลทั้งหมดนั้น
ดังนั้นจึงเป็นไปได้สำหรับคุณที่จะต้องการการแปลงประเภทที่แม่นยำที่คุณต้องการโดยการระบุให้ชัดเจน
สิ่งนี้เรียกว่าการหล่อและประกอบด้วยจำนวนที่มีชื่อประเภทที่ต้องการในวงเล็บ
ดังนั้นวงเล็บและชื่อประเภทจึงเป็นตัวดำเนินการ
cap
คุณใส่วงเล็บซ้ายแล้วระบุชนิดข้อมูลแล้วเขียนวงเล็บ
และนั่นจะแปลงอะไรก็ตามที่อยู่ทางขวาของมัน ไม่ว่านิพจน์จะอยู่ทางขวาของมัน
หรือแม้ว่ามันจะเป็นแค่ตัวแปรเดียว มันจะแปลงสิ่งนั้นเป็นสิ่งที่อยู่ในวงเล็บ
ดังนั้นประเภทที่แท้จริงจึงเป็นที่ต้องการ เช่น แบบยาว มันถูกแทนที่ด้วยประเภทคำนั้น
ดังนั้นตัวดำเนินการประเภทที่ส่งผ่านจึงมีลำดับความสำคัญสูงกว่าตัวดำเนินการเลขคณิตทั้งหมด ยกเว้นตัวดำเนินการรวมลบและหน่วยบวก
เรายังไม่ได้เรียนรู้เกี่ยวกับลำดับความสำคัญเลย
เราจะไปบรรยายในครั้งต่อไป ลำดับความสำคัญคือสิ่งที่เกิดขึ้น
ลำดับของการดำเนินการที่ดำเนินการ
ดังนั้นเราจะยกตัวอย่างบางส่วน ทั้งหมดที่คุณต้องเข้าใจ ณ จุดนี้ก็คือตัวดำเนินการ
typecast มีความสำคัญเหนือตัวดำเนินการอื่น ๆ ทั้งหมด ยกเว้นสองตัว unary ลบ และ unary plus
ตรงนี้ตัวอย่าง เรามีเลข 21 51 และเรามีคาสต์โอเปอเรเตอร์เพราะเรารู้ว่ามันคือโอเปอเรเตอร์คาสต์เพราะมันอยู่ในวงเล็บและมีประเภท
และสิ่งที่เราพูดกันโดยทั่วไปคือ
เทค 21 51 แปลงเป็น int
หากคุณแปลงเลขทศนิยมไปเป็นเลขทศนิยม
มันจะกลายเป็น int เลขจำนวนเต็ม 21
มันทำทางขวามือ มันแปลง 26 99 เป็น int
แล้วอะไรจะเกิดขึ้นตรงนี้ ถ้าคุณทำพจน์นี้ในคำสั่ง มันจะหาค่าเป็น
21 บวก 26 มันจะตัดทอนข้อมูลจาก
0 51 เป็นจำนวนเต็มและเหมือนกับ 0 99.
นั่นคือตัวดำเนินการ cast อะไรก็ได้ในวงเล็บที่มีประเภทข้อมูล
คุณจะเห็นสิ่งนี้มาก
ถ้าคุณบอกว่า 21 บวก 26 และคุณโยนมันเป็นทศนิยม
มันจะบวกจุด 0
โดยปกติ คุณจะไม่เลือกแบบที่แม่นยำกว่านี้เพราะคุณจะไม่แม่นยำมากขึ้น
คุณร่ายจากประเภทที่แม่นยำมากขึ้นเป็นความแม่นยำน้อยลง
เหมือนลอยเป็น int มากกว่า
ดังนั้นคุณจะเห็นสิ่งนี้ในบางโปรแกรมเป็นครั้งคราวเมื่อคุณใช้ประเภทต่างๆ
คุณควรพยายามหลีกเลี่ยงการใช้ประเภทต่างๆ
หากคุณกำลังทำเลขคณิต แต่ถ้าคุณทำคุณจะเห็นสิ่งนี้
ขนาดของโอเปอเรเตอร์ โอเปอเรเตอร์อีกตัวที่แปลกๆ
ไม่เหมือนตัวอื่นๆ มากนัก และนี่ดูเหมือนเป็นฟังก์ชันจริงๆ
แต่ sizeof เป็นตัวดำเนินการ มันดำเนินการ
มันไม่ได้ทำอะไรที่เน้นฟังก์ชั่น
สิ่งที่ทำคือกำลังบอกคุณจำนวนไบต์ที่ถูกครอบครองในหน่วยความจำตามประเภทที่กำหนด
ดังนั้นมันจึงดูเหมือนเป็นฟังก์ชันเพราะมันใช้อาร์กิวเมนต์
และเราจะยกตัวอย่างสิ่งนั้น แต่จะคืนค่าจำนวนไบต์ในหน่วยความจำเท่านั้น จำไว้ว่าขึ้นอยู่กับระบบที่คุณใช้งาน
แพลตฟอร์มที่คุณใช้งาน ระบบปฏิบัติการ
สถาปัตยกรรมของคอมพิวเตอร์ ฮาร์ดแวร์ ประเภทข้อมูลต่างๆ
จะถูกแสดงหน่วยความจำที่มีขนาดต่างกัน
ตัวอย่างเช่น int อาจเป็น 4 ไบต์ใน 1 ระบบ 8 ในอีกระบบหนึ่ง
สิ่งที่คุณสามารถทำได้คือคุณสามารถใช้ตัวดำเนินการ sizeof เป็นคีย์เวิร์ดพิเศษตัวดำเนินการใน c และคุณสามารถส่งผ่านในประเภทข้อมูลและจะบอกคุณว่ามีการใช้ไบต์จำนวนเท่าใดในหน่วยความจำ
sizeof เป็นโอเปอเรเตอร์จริง ๆ มันไม่ใช่ฟังก์ชัน
มีการประเมิน ณ เวลาคอมไพล์และไม่ใช่ที่รันไทม์ เว้นแต่ว่าจะใช้อาร์เรย์ความยาวผันแปรในอาร์กิวเมนต์
ดังนั้นเราจะพูดถึงเรื่องนั้น โดยพื้นฐานแล้วจะบอกว่าถ้าคุณมีตัวแปรที่อยู่ภายในขนาดของอาร์เรย์
มันจะไม่ได้รับการแก้ไข ณ เวลาคอมไพล์ที่รันไทม์ ดังนั้นจึงไม่จำเป็นต้องรู้
อาร์กิวเมนต์ของตัวดำเนินการ sizeof สามารถเป็นตัวแปร ชื่ออาร์เรย์
ชื่อของชนิดข้อมูลพื้นฐาน เช่น int float ชื่อของชนิดข้อมูลที่ได้รับ
อะไรก็ได้ หรือนิพจน์
คุณจึงบอกขนาดของ x บวก y ได้
และนั่นก็หมายถึงขนาดของ x บวก
ขนาดของ y หรือจำนวนผลลัพธ์ ถ้า x เป็น int, y เป็น int ที่มีขนาด 16, มันบอกว่านี่คือ
4 ไบต์นิ้ว
ถ้ามันเป็น int one เป็น float และผลลัพธ์ที่ได้คือเลขคณิตจุดทศนิยม มันจะเป็น
float เป็น 8 ไบต์หรืออะไรทำนองนั้น
แต่คุณสามารถใช้มันได้หลายอย่าง และคุณควรใช้มันเพื่ออะไรหลายๆ อย่าง ตัวอย่างเช่น ขนาดของ int จะส่งผลให้จำนวนไบต์ที่ถูกครอบครองโดยตัวแปรประเภท
int
ดังนั้นสิ่งนี้จะส่งกลับ 4 หรือ 8 ขึ้นอยู่กับระบบของคุณ
คุณยังสามารถใช้ตัวดำเนินการ sizeof กับนิพจน์ อย่างที่ฉันได้กล่าวไปแล้ว
ผลลัพธ์คือขนาดของค่า
ซึ่งเป็นผลมาจากการแสดงออกของพื้นที่ ถ้าสอง int รวมกัน พวกมันก็ยังเป็น int
ดังนั้นมันจึงยังคงเป็นขนาด แต่คุณจะเห็นการใช้ตัวดำเนินการ sizeof เมื่อเราพูดถึงพอยน์เตอร์
ฉันอยากจะพูดถึงเรื่องนี้ในตอนนี้เพราะมันเป็นโอเปอเรเตอร์
แต่เราจะยกตัวอย่างเพิ่มเติมเกี่ยวกับเรื่องนี้และแคสต์ให้ทั่วทั้งชั้นเรียนเมื่อเราพูดถึงแนวคิดเพิ่มเติม
โดยเฉพาะอย่างยิ่ง sizeof โอเปอเรเตอร์มีบทบาทมากขึ้นเมื่อเราพูดถึงพอยน์เตอร์
เพราะเมื่อคุณคำนวณจำนวนหน่วยความจำที่จะจัดสรร
ซึ่งพอยน์เตอร์คืออะไร คุณใช้ sizeof เพราะคุณต้องการความแม่นยำ
แต่คุณสามารถใช้ทำอย่างอื่นได้เช่นกัน
ดังนั้นให้ใช้ตัวดำเนินการ sizeof ทุกครั้งที่ทำได้เพื่อหลีกเลี่ยงไม่ให้มีการคำนวณขนาดฮาร์ดโค้ดในโปรแกรมของคุณ
ตัวเลขเวทย์มนตร์ขนาดฮาร์ดโค้ดไม่ใช่เรื่องดีเพราะอีกครั้งหากคุณอยู่ในระบบอื่น
หากคุณต้องฮาร์ดโค้ด 4 ต่อ 1 ระบบสำหรับ int อีกระบบหนึ่งอาจเป็น
8 ดังนั้นใช้ sizeof ให้มากที่สุดเท่าที่ คุณทำได้ และเราจะเห็นว่าสิ่งนี้มีความเกี่ยวข้องกันมากขึ้นเมื่อเราพูดถึงตัวชี้
โอเปอเรเตอร์อื่นๆ ที่แปลกเล็กน้อยคือโอเปอเรเตอร์ดอกจัน
คุณอาจเคยพูดกับตัวเองว่าดอกจัน เราได้พูดถึงสิ่งนี้ในการคูณไปแล้ว
แต่ดอกจันนั้นใช้ตัวถูกดำเนินการสองตัว ตัวหนึ่งอยู่ทางซ้าย ตัวหนึ่งอยู่ทางขวา
หากคุณใช้ตัวดำเนินการเครื่องหมายดอกจันกับตัวแปร
และคุณเพียงแค่พูดชื่อตัวแปร star ที่มีอาร์กิวเมนต์ทางขวาเพียงตัวเดียว ตัวแปรนั้นจะแสดงถึงอย่างอื่น
อันที่จริงมันเป็นตัวชี้
มันคือ dereference ตัวชี้
และอีกครั้ง นี่คือฉันจะไม่พูดถึงเรื่องนี้เพราะเราจะพูดถึงเรื่องนี้เมื่อเราพูดถึงพอยน์เตอร์
แต่ถ้าคุณเห็นบางอย่างเช่น star a อย่าตกใจว่ามันใช้ได้จริง
ที่ทำเครื่องหมายดอกจันตัวดำเนินการตัวชี้
คุณอาจเห็นเครื่องหมายทวิภาค
นี่คือโอเปอเรเตอร์ที่ใช้สำหรับการตัดสินใจ
หากเงื่อนไขเป็นจริง หากสิ่งที่อยู่ทางซ้ายเป็นจริง ค่าทางด้านขวาหลังเครื่องหมายทวิภาคจะถูกประเมินและอื่นๆ
เป็นอย่างอื่น
เป็นสัญกรณ์ชวเลขสำหรับคำสั่ง if-else
มันเป็นตัวดำเนินการแบบไตรภาค เรียกว่า แต่อีกครั้ง ฉันไม่ต้องการที่จะพูดถึงเรื่องนี้ในรายละเอียดมากนัก
เพราะเราจะพูดถึงสิ่งเหล่านี้เมื่อเราพูดถึงเรื่องเฉพาะของเรา
เราจะพูดถึงผู้ดำเนินการเลี้ยวเมื่อเราพูดถึงคำชี้แจงการตัดสินใจ เราจะพูดถึงตัวดำเนินการเครื่องหมายดอกจัน
unary เมื่อเราพูดถึงพอยน์เตอร์
แต่ถ้าคุณเห็นสิ่งนี้ในตอนนี้ และฉันต้องการพูดถึงตอนนี้ เพราะพวกมันคือโอเปอเรเตอร์ทางเทคนิค แต่เราจะเข้าใจกรณีการใช้งานเหล่านี้เมื่อเราพูดถึงแนวคิดเหล่านั้น
ขอขอบคุณ.