สวัสดีและยินดีต้อนรับกลับ ในการบรรยายนี้ ฉันต้องการเริ่มพูดถึงฟังก์ชันสตริง
ฉันได้กล่าวไว้ก่อนหน้านี้ว่า
strings, character arrays ไม่ใช่ชนิดข้อมูลตัวแปรใน
c.
ดังนั้น คุณสามารถใช้โอเปอเรเตอร์ใดก็ได้
แต่คุณยังต้องสามารถทำอะไรหลายๆ อย่างกับสตริงได้
คุณจะสามารถจัดการพวกมันได้
คุณจะต้องการได้รับความยาว คุณต้องการเปรียบเทียบสิ่งเหล่านี้
ทุกสิ่งอาจแปลงพวกเขา
โชคดีที่ไลบรารีมาตรฐานมาพร้อมกับฟังก์ชันมากมายที่คุณสามารถใช้ดำเนินการประเภทนี้ได้
ฉันจะเริ่มพูดถึงเรื่องที่พบบ่อยที่สุดก่อน จากนั้นเราจะพูดถึงเรื่องที่เฉพาะเจาะจงมากขึ้นในการบรรยายอื่นๆ
ดังนั้นเราจึงทราบแล้วว่าสตริงอักขระเป็นอาร์เรย์ถ่านที่สิ้นสุดด้วยอักขระว่าง
สตริงอักขระมักใช้ในโปรแกรมภาษาซี
C โชคดีที่มีฟังก์ชันมากมายที่ออกแบบมาเพื่อทำงานกับสตริงโดยเฉพาะ
สิ่งที่เรากำลังจะพูดถึงคือสิ่งที่คุณใช้บ่อยที่สุด
ขั้นแรก รับความยาวของสตริงโดยใช้ฟังก์ชัน str length
คัดลอกสตริงอักขระหนึ่งไปยังอีกสตริงหนึ่ง
จำไว้ว่า ฉันบอกคุณก่อนหน้านี้ว่าคุณไม่สามารถใช้ตัวดำเนินการมอบหมายเพื่อกำหนดสตริงได้
ดังนั้นสิ่งที่คุณทำคือคุณใช้ str copy หรือ strn copy
นอกจากนี้ การรวมสตริงอักขระสองตัวเข้าด้วยกัน การต่อกัน
มีแมว str และแมว strn
และกำหนดว่าสตริงอักขระสองตัวเท่ากันหรือไม่
อีกครั้ง ตัวดำเนินการเท่ากับเท่ากับจะไม่ทำงานเพื่อเปรียบเทียบสตริงเนื่องจากเป็นอาร์เรย์
ดังนั้นหากคุณต้องการเปรียบเทียบสตริง คุณต้องใช้ฟังก์ชันพิเศษที่ไลบรารี
c จัดเตรียมไว้ให้ Str เปรียบเทียบและเปรียบเทียบ strn
ก่อนอื่นมาพูดถึงความยาวกันก่อน
ฟังก์ชันทั้งหมดเหล่านี้ถูกกำหนดไว้ในสตริง ไฟล์ส่วนหัว ดังนั้นคุณต้องรวมไว้ด้วยเมื่อคุณโทรหรือเรียกใช้ฟังก์ชันใดฟังก์ชันหนึ่งเหล่านี้
รับความยาวของสตริง
Str length เป็นฟังก์ชันที่หาความยาวของสตริง ซึ่งค่อนข้างตรงไปตรงมา
ส่งคืนเป็นตัวแปร size t
คุณสามารถใช้ตัวแปร size t แทนกันได้กับ int
แต่ก่อนอื่น คุณจะต้องรวมไฟล์ส่วนหัวของสตริงนั้นด้วย หากคุณต้องการใช้ความยาว
str และนี่คือวิธีที่คุณใช้
โดยทั่วไปคุณสร้างสตริงตัวอักษรภายในเครื่องหมายคำพูดคู่และคุณกำหนดให้กับอาร์เรย์อักขระ
คุณไม่ได้ระบุขนาดของอาร์เรย์อักขระ
คอมไพเลอร์จะทำเพื่อคุณและจะเพิ่ม null terminator
เมื่อคุณกำหนดสตริงของฉันด้วยค่าคงที่สตริงแล้ว
คุณสามารถเรียกความยาว str และส่งผ่านอักขระนั้นได้ ดีมาก
เป็นหนึ่งในสิ่งที่ใช้บ่อยที่สุดเพราะคุณมักจะต้องการรับความยาวของสตริงนี้เมื่อคุณทำการตรวจสอบความถูกต้องหรืออะไรก็ได้
หากคุณต้องการแน่ใจว่าไม่มีบัฟเฟอร์โอเวอร์โฟลว์ คุณสามารถทำได้เช่นกัน
ฟังก์ชันนี้เปลี่ยนสตริง
ดังนั้นส่วนหัวของฟังก์ชันจึงไม่ใช้ค่าคงที่ในการประกาศสตริงพารามิเตอร์ที่เป็นทางการ
ถ้าจะไปดูสตริง h ภายในผู้ใช้รวมในไดเรกทอรีของคุณ
คุณจะเห็นว่ามันไม่ได้ถูกกำหนดให้เป็นค่าคงที่
การคัดลอกสตริง การคัดลอกสตริงอาจเป็นการแก้ไขสตริงที่มีอยู่
การปรับเปลี่ยนอาร์เรย์อักขระที่มีอยู่ซึ่งมีข้อมูลบางส่วนอยู่ในนั้น
หรือถ้าไม่มีอะไรในนั้น คุณต้องการใส่บางอย่างในนั้น.
เนื่องจากคุณไม่สามารถกำหนดการเพิ่มใน c คุณจึงไม่สามารถกำหนดสตริงได้เช่นกัน ฉันพูดถึงสิ่งนี้ก่อนหน้านี้ การประกาศอักขระแล้วใช้ตัวดำเนินการมอบหมายเท่ากับไม่ทำงาน
ดังนั้นสิ่งที่คุณต้องทำคือคุณต้องใช้ฟังก์ชัน str copy
เพื่อคัดลอกสตริงไปยังสตริงที่มีอยู่
มันเทียบเท่ากับตัวดำเนินการสำหรับสตริง ตัวดำเนินการมอบหมาย
ถ้าเราประกาศอาร์เรย์อักขระสองตัวต้นทางและปลายทาง
สิ่งที่เราต้องทำคือพูดว่า str copy source จากนั้นไม่ว่าจะมีต้นทางใดก็ตาม
เราก็สามารถใส่สตริงลงในสตริงและปลายทางเหมือนกันได้
คุณยังสามารถใส่ตัวแปรลงไปได้เช่นกันหากต้องการคัดลอก
แต่สิ่งที่เรากำลังทำอยู่นี้คือพารามิเตอร์แรกที่คุณคัดลอกไป
พารามิเตอร์ที่สองคือสตริงที่คุณกำลังคัดลอก
ดังนั้นแหล่งที่มาจะมีสิ่งนี้เป็นแหล่งที่มาภายในหลังจากคัดลอก str
ปลายทางหรือปลายทางจะมีสิ่งนี้เป็นปลายทางภายในนั้นหลังจากการเรียกคัดลอก
str
ฟังก์ชันคัดลอก str ไม่ได้ตรวจสอบเพื่อดูว่าสตริงต้นทางพอดีกับสตริงเป้าหมายหรือไม่
แล้วจะเกิดอะไรขึ้นถ้าคุณมีเชือกเส้นใหญ่
ในตัวอย่างก่อนหน้านี้ จะเกิดอะไรขึ้นหากปลายทางมีอักขระ 100 ตัว
และแทนที่จะมีสิ่งนี้เป็นปลายทาง มันมีอักขระ 100 ตัว
คุณพยายามคัดลอกไปยังแหล่งที่มาที่มีอักขระเพียง
50 ตัว จะมีปัญหา
สตริงปลายทางจะมีขนาดใหญ่กว่าสตริงต้นทางที่คุณกำลังคัดลอก
ดังนั้นหากเราพยายามคัดลอก str copy ไปยังซอร์สแทนที่จะคัดลอกสิ่งนี้เป็นซอร์สที่เราใส่เข้าไปนั้นจะมีแหล่งที่มาห้าครั้งหรือสิบเท่าไม่ว่ามันจะเป็นอะไรและมากกว่าหนึ่งมากกว่า
50 ก็จะมีข้อผิดพลาด
และฉันจะแสดงให้เห็นว่า
ดังนั้น วิธีที่ปลอดภัยกว่าในการคัดลอกสตริงคือการใช้ strn copy คุณจะสังเกตเห็นว่า n สามารถเปลี่ยนเป็น
strn copy ได้
Strn copy ใช้อาร์กิวเมนต์ที่สาม
จำนวนอักขระสูงสุดที่จะคัดลอก
ดังนั้นที่นี่คุณระบุจำนวนที่ต้องการคัดลอกได้จริง
ดังนั้นถ้าคุณมีแหล่งที่มา 40 และปลายทาง 12 ขนาด ขั้นแรกคุณสามารถสร้างชุด m ซึ่งเพียงแค่ตั้งค่าขนาดของข้อมูลภายในปลายทางเป็น
null terminators ด้วยวิธีนี้เมื่อคุณเพิ่มบางสิ่ง มันก็จะอยู่ที่นั่นโดยอัตโนมัติ
อย่า ไม่ต้องกังวลเรื่องนั้น
สำเนา str กำลังจะคัดลอก สวัสดี คุณเป็นอย่างไรบ้างกับซอร์ส และจะไม่ตรวจสอบว่าคุณเป็นอย่างไรมากกว่าแหล่งที่มา
แต่ถ้าคุณทำสำเนา strn และคัดลอกในปลายทาง มันจะคัดลอกต้นทาง
และจะคัดลอกเฉพาะ 10 อักขระแรกเท่านั้น
ดังนั้นอาร์กิวเมนต์ที่สามควรสอดคล้องกับขนาดของปลายทาง
ลองไปที่บล็อคโค้ดและดูความยาวของ str และดูที่การคัดลอกสตริงเพื่อดูว่ามันทำงานอย่างไร
ดังนั้นที่นี่เรามีหลักของเรา
และการได้ความยาวของสายอักขระนั้นง่ายมาก
เราจะสร้างอาร์เรย์อักขระของเรา เรารู้วิธีสร้างพื้นที่ตัวละคร เราไม่ต้องการระบุขนาด
แต่เราต้องใส่ชื่อก่อนแล้วจึงใส่วงเล็บ
จากนั้นเราสามารถเริ่มต้นด้วยสิ่งที่เราต้องการ
พูดในเครื่องหมายคำพูดคู่ เครื่องหมายคำพูดคู่แสดงถึงตัวอักษรสตริง
ดังนั้นฉันสามารถพูดได้ว่าฉันชื่อเจสัน
ผลลัพธ์ที่ได้คือ s จะเป็นอาร์เรย์ขนาด
17 อักขระ
อักขระเหล่านี้ทั้งหมดบวกกับเทอร์มิเนเตอร์ที่เป็นโมฆะ
เทอร์มิเนเตอร์ที่เป็นโมฆะคือแบ็กสแลชศูนย์
คุณไม่จำเป็นต้องใส่มันลงไปเพราะมันจะถูกเพิ่มโดยคอมไพเลอร์โดยอัตโนมัติ
นั่นคือวิธีที่เราสามารถเริ่มต้นและสร้างสตริงในอาร์เรย์อักขระได้
จากนั้นในการพิมพ์ สิ่งที่เราต้องทำคือ printf แล้วบอกว่าความยาวเท่ากับ
จากนั้นเราใส่เปอร์เซ็นต์ s เป็นตัวระบุรูปแบบเพื่อแสดงสตริง
แล้วสิ่งที่เราทำคือเราพูดชื่อสตริง
และเพื่อไม่ให้สับสน สมมติว่าสตริงของฉัน
และเราไม่จำเป็นต้องใช้เครื่องหมายแอมเพอร์แซนด์เหมือนที่เคยทำ ตัวอย่างก่อนหน้านี้
เราสามารถพูดสตริงของฉันได้ หากเราคอมไพล์และรันสิ่งนี้
เราอาจต้องแน่ใจว่าเรารวมส่วนหัวของสตริงด้วย
เมื่อเราคอมไพล์และรันสิ่งนี้ คุณจะเห็นความยาวของสตริง
ความยาวก็คือ และฉันไม่ได้เรียกฟังก์ชันความยาวสตริง
ดังนั้นคุณต้องเรียกใช้ฟังก์ชันจริง ๆ ถ้าคุณต้องการแสดงความยาว
คุณก็แค่ทำแบบนั้น คุณใส่สตริงในความยาว str
เมื่อคุณเรียกใช้ คุณจะเห็นความยาวของสตริงจริงๆ
สิ่งนี้จะต้องไม่ใช่สตริง แต่เป็นของจริง
นั่นคือวิธีที่ฉันจะแสดงสตริง ถ้าฉันต้องการแสดงความยาวของสตริง ฉันจะใช้เปอร์เซ็นต์
d ในการเรียกใช้ฟังก์ชัน
เมื่อฉันเรียกใช้ คุณจะสังเกตเห็นว่ามันพิมพ์ออกมาเป็น
16 ซึ่งก็คือความยาว
ดังนั้นมันจึงค่อนข้างง่ายในการใช้ความยาว str หากคุณต้องการคัดลอกสตริง
ให้ใช้ str Compare
และคุณต้องการใช้ strn เปรียบเทียบ เพื่อระบุไบต์จริง ๆ
ถ้าเรามีชื่อของฉันคือเจสัน แล้วเราก็สร้างอีกสตริง
ที่จริงเราจะเก็บมันไว้
เราไม่ต้องระบุด้วยซ้ำ
และสิ่งที่เราจะทำคือเราจะบอกว่าสร้างสตริงอื่นที่เรียกว่า temp และนั่นจะเท่ากับ
str และเปรียบเทียบ เราจะผ่านสิ่งที่เราต้องการ
คัดลอกไปที่
แค่สร้างอาร์เรย์อักขระว่าง และเราจะทำให้เป็นขนาด
50
และสิ่งที่เราจะทำในที่นี้คือ เราจะบอกว่า strn copy
พารามิเตอร์แรกคือตำแหน่งที่เราต้องการคัดลอกทำ เราจะบอกว่า ชั่วคราว
พารามิเตอร์ที่สองคือสิ่งที่เราต้องการคัดลอกซึ่งเป็นสตริงของฉัน
จากนั้นเราไม่ต้องการส่งเกิน 50 ไบต์
ดังนั้นเราสามารถบอกขนาดของ temp เพื่อบอกว่าเราไม่ต้องการส่งเกิน
50 ไบต์ และคุณอาจต้องการทำ -1 สำหรับ
null terminator
ด้วยวิธีนี้ พารามิเตอร์ที่สามนั้นสำคัญมากเพราะเราจะไม่มีบัฟเฟอร์โอเวอร์โฟลว์
คุณควรใช้ strn copy เสมอ ไม่ใช่ str copy
จากนั้นเราสามารถแสดงสตริงของเราเพื่อดูว่ามีการคัดลอกหรือไม่
เราสามารถพูดได้ว่า ชั่วคราว เปลี่ยนเป็นเปอร์เซ็นต์ s
และเมื่อเราสร้างสิ่งนี้ เราควรเห็นว่า
ไม่ใช่ความยาว เราควรเห็นสตริงเป็นแบบนั้น แล้วจบด้วยเครื่องหมายอัฒภาค
ตอนนี้เราควรรวบรวมสิ่งที่เราทำ
ตอนนี้เราเรียกใช้มัน เราควรจะเห็นสตริงของเราที่คัดลอกมา
เราจึงเห็นชื่อของฉันคือเจสัน และนั่นถูกเก็บไว้ใน
temp เพราะเราพิมพ์ temp
แต่ใช้ strn copy เสมอ อย่าใช้การคัดลอก str ซึ่งจะทำให้แน่ใจว่าคุณไม่มีบัฟเฟอร์ล้น
และพารามิเตอร์ที่สามควรเป็นปลายทางเสมอ
ไม่ใช่ต้นทาง ปลายทาง
มันไม่มีประโยชน์ที่จะบอกว่าคัดลอกทั้งสตริงนี้
เพราะถ้าเล็กกว่านี้จะมีปัญหา ดังนั้นจงพูดขนาดนี้เสมอ
และคุณเห็นว่าคุณสามารถใช้ตัวดำเนินการ
sizeof เพื่อดูจำนวนไบต์ที่อยู่ภายในอักขระได้
มาพูดถึงฟังก์ชั่นเพิ่มเติมกันบ้าง
เราจึงรู้วิธีหาความยาว เรารู้วิธีคัดลอกสตริง วิธีการต่อสายอักขระ
ฟังก์ชัน str cap รับสองอาร์กิวเมนต์ สองสตริงเป็นอาร์กิวเมนต์
และคัดลอกสตริงที่สองที่ส่วนท้ายของสตริงแรก
สตริงที่สองไม่มีการเปลี่ยนแปลง
เฉพาะสตริงแรกเท่านั้น มันจะคืนค่าของอาร์กิวเมนต์แรก
ที่อยู่ของอักขระตัวแรกของสตริงที่ต่อท้ายสตริงที่สอง
ดังนั้นส่งคืนบางสิ่งโดยบอกคุณว่าคุณต่อท้ายมันไว้ที่ไหนถ้าคุณจำเป็นต้องใช้สิ่งนั้น
นี่คือตัวอย่าง เราสร้างสตริงอักขระของสตริงของฉัน
และมีเพียงสตริงของฉันที่มีตัวสิ้นสุด null
เราสร้างสตริงอักขระป้อนเข้า ซึ่งเท่ากับ 80 เป็นค่าว่าง
เราบอกว่าใส่สตริงที่จะต่อกัน เราอ่านมันใน
แล้วเราก็เชื่อมมันเข้าด้วยกัน
เราพิมพ์สตริงดั้งเดิมตามด้วยสตริงที่ต่อกันแล้วตามด้วยอินพุต
ดังนั้นหลังจากนี้ สิ่งที่คุณป้อนจะใส่ที่ส่วนท้ายของสตริงของฉัน
ดังนั้น ถ้าคุณเข้าไปในเจสัน มันจะเป็นสายสเปซของฉัน เจสัน
นั่นคือสิ่งที่สตริงของฉันจะเท่ากับ
เพราะคุณทำแมว str กับมัน
ขั้นแรกเราพิมพ์สตริงแล้วเรียก str cat ลงไป
อินพุตจะเท่ากับค่าใดก็ตามที่ป้อน สตริงของฉันตามด้วยค่าใดก็ตามที่ป้อน
เราจะพูดถึงตัวอย่างนี้ในอีกสักครู่ ตอนนี้เหมือนกับ str
copy, str cat มี strn end cat ด้วย
ดังนั้นเวอร์ชันที่รวมกันจึงกลายเป็นสตริงแรกใหม่
เช่นเดียวกับการต่อสายอักขระกับแมว
str มีแมว strn
Str cat มีปัญหาเดียวกันกับ str copy อาจมีบัฟเฟอร์ล้น ไม่ได้ทำให้แน่ใจว่าสตริงที่สองจะพอดีกับอาร์เรย์แรก
ดังนั้น หากคุณมีพื้นที่ไม่เพียงพอในอาร์เรย์แรกนั้น คุณสามารถพบปัญหาบัฟเฟอร์ล้นได้
ดังนั้นสิ่งที่คุณต้องการใช้แมว strn
อาร์กิวเมนต์ที่สองระบุจำนวนอักขระสูงสุดที่จะเพิ่ม
ตัวอย่างเช่น หากคุณใช้ strn cat และสตริงสองสายดักฟัง
Add-on จะเพิ่มเฉพาะอักขระเสริม 13 ตัวแรกให้กับจุดบกพร่องเท่านั้น ขึ้นอยู่กับว่าสิ่งใดเกิดก่อน
หากแอดออนน้อยกว่า
13 แอดออนจะเพิ่มจนกว่าคุณจะเห็น null Terminator
ในตัวอย่างนี้ เรากำลังสร้างสองสตริง
นี่คือต้นทางปลายทางนี้ เรากำลังทำแมว strn
เรากำลังคัดลอกอักขระเพียง 15 ตัวไปยังปลายทางในตอนท้าย
ดังนั้นไม่ว่าขนาดของปลายทางจะเป็นขนาดปลายทางบวก
15 แล้วเราก็พิมพ์ออกมา
ลองดูสิ่งนี้ในบล็อคโค้ดอีกครั้ง
นี่คือตัวอย่างของเรา และเราจะสร้างอาร์เรย์สตริงอักขระสองตัว
หนึ่งขนาด 50 อีกขนาด 50
เราจะทำสำเนา str สองชุดเพื่อตั้งค่าให้เป็นข้อมูล
นี่คือปลายทางของต้นทาง แล้วในบรรทัดที่ 12 เราทำ strn cat
และปลายทางจะเป็นสิ่งที่เราเชื่อมโยงกัน
ที่มาจะเป็นสิ่งที่เรากำลังจะต่อกัน
และเราจะกำหนดอักขระ 15 ตัวเท่านั้น
ดังนั้นหากแหล่งที่มามีขนาดใหญ่กว่า 15
เราจะไม่คัดลอกทั้งหมด
เมื่อเราสร้างและรันมัน
คุณจะเห็นว่าตอนนี้มันบอกว่านี่คือไฟล์ต้นทาง
หรือมันบอกว่านี่คือปลายทาง ตามด้วยนี่คือต้นทาง
มันบอกว่านี่คือปลายทาง นี่คือต้นทาง
มันเชื่อมไปยังจุดสิ้นสุดของปลายทาง
ดังนั้นคุณจึงต้องการใช้ strn cat ในการต่อข้อมูล ดังนั้นคุณจึงไม่มีบัฟเฟอร์ล้น
มาพูดถึง str เปรียบเทียบกัน ซึ่งฉันมักจะพูดแทน str
ก๊อปปี้ str เปรียบเทียบกัน
ดังนั้นสำหรับการเปรียบเทียบสตริง เราต้องใช้ฟังก์ชันด้วย
หากคุณต้องการเปรียบเทียบสตริงหนึ่งกับอีกสตริงหนึ่ง คุณไม่สามารถใช้
double equals ซึ่งจะตรวจสอบเฉพาะข้อมูลอ้างอิงว่าคุณมีที่อยู่เดียวกันหรือไม่
ดังนั้นสิ่งที่คุณต้องใช้คือ str เปรียบเทียบ
นี่เป็นการเปรียบเทียบเนื้อหาสตริง
มันไม่ได้เปรียบเทียบอาร์เรย์ ดังนั้นจึงสามารถใช้เปรียบเทียบสตริงที่จัดเก็บไว้ในอาร์เรย์ที่มีขนาดต่างกันได้
มันไม่เปรียบเทียบตัวละคร
คุณสามารถใช้อาร์กิวเมนต์ เช่น apples และ a ในเครื่องหมายคำพูดคู่ แต่คุณไม่สามารถใช้อาร์กิวเมนต์อักขระ
เช่น อักขระตัวเดียว a
ฟังก์ชันนี้ใช้สำหรับสตริงที่ตัวดำเนินการเชิงสัมพันธ์ทำกับตัวเลข
ดังนั้นฟังก์ชันเปรียบเทียบจะส่งคืนค่าที่บอกคุณว่าสตริงนั้นเท่ากันหรือไม่
ไม่ว่าจะมากกว่าหรือน้อยกว่า
ถ้ามันเท่ากัน มันจะคืนค่าศูนย์
ถ้ามันน้อยกว่า มันจะคืนค่าน้อยกว่าศูนย์ ถ้า
str 1 น้อยกว่า str 2
และถ้า str 2 น้อยกว่า str 1 มันจะคืนค่ามากกว่าศูนย์
แล้วนี่หมายความว่ายังไงกันแน่? ให้ฉันยกตัวอย่างวิธีการทำงานให้คุณ
ลองใส่สิ่งนี้ในบล็อคโค้ดแล้วเรียกใช้
แต่ในที่นี้ เรากำลังเปรียบเทียบ str จำนวนมาก และเราจะบอกคุณว่าค่าคืออะไร ไม่ว่าจะน้อยกว่าหรือมากกว่าเพราะมันไม่ชัดเจนนัก
ลองพิจารณาดูในบล็อคโค้ด
นี่คือตัวอย่างของเรา และเรากำลังเปรียบเทียบสตริงหลายๆ สตริง แล้วแสดงผลลัพธ์ของการเปรียบเทียบ
str ไม่ว่าจะเป็นค่าศูนย์หรืออะไรก็ตาม
ดังนั้น หากคุณเปรียบเทียบสองสตริง a และ a พวกเขาจะต้องอยู่ในเครื่องหมายคำพูดคู่
และสิ่งที่คุณเห็นที่นี่ สิ่งที่เรากำลังทำคือการพิมพ์สิ่งที่เรากำลังเรียก
ดังนั้นเราจึงกำหนดขอบเขตของเครื่องหมายคำพูด
เรากำลังใส่เครื่องหมายแบ็กสแลชเพื่อที่เราจะพิมพ์อักขระอัญประกาศออกมาจริง
ๆ และไม่สิ้นสุดสตริง แต่ถ้าเราเปรียบเทียบ a
กับ a นี่ควรคืนค่าศูนย์ เนื่องจากศูนย์หมายความว่าสตริงมีค่าเท่ากัน
หากเราเปรียบเทียบ a และ b str เปรียบเทียบควรคืนค่าน้อยกว่า
เพราะ a น้อยกว่า b
B a ควรคืนค่าที่มากกว่าศูนย์
แต่ขอให้ผ่านเรื่องนี้ไป ให้แน่ใจว่าฉันไม่ได้ทำผิดพลาดและเราจะเห็นมันในผลลัพธ์
ดังนั้นเมื่อเราเรียกใช้สิ่งนี้และสิ่งนี้ช่วยให้คุณจำได้ว่าจะส่งคืนตัวเลขใด
เมื่อคุณเปรียบเทียบ a กับ a คุณจะได้ 0 จริงๆ
ถ้าคุณเปรียบเทียบ a กับ b, b น้อยกว่า a,
มันเลยเป็นลบ มีค่าน้อยกว่าศูนย์, ฉันอาจจะพูดตรงกันข้าม,
ดูว่าฉันยังคงสับสนอยู่
เนื่องจาก
a มากกว่า b, a มากกว่า b, ลบหนึ่ง
B น้อยกว่า a ดังนั้นคุณจะได้บางสิ่งที่มากกว่าศูนย์ซึ่งเป็นหนึ่ง
C มากกว่า a, คุณจะได้ 1 เมื่อ
b มากกว่า a
แล้วคุณเปรียบเทียบตัวพิมพ์ใหญ่กับตัวพิมพ์เล็ก
เมื่อคุณเปรียบเทียบตัวพิมพ์ใหญ่และตัวพิมพ์เล็ก มันจะทำการผกผัน Z จริงๆ แล้วน้อยกว่า
a ตัวพิมพ์เล็ก
ดังนั้น ทุนจะน้อยกว่าตัวพิมพ์เล็กเสมอ
หากคุณลองเปรียบเทียบแอปเปิลกับแอปเปิล มันจะเป็น 1 เพราะแอปเปิลน้อยกว่าแอปเปิล
และนั่นคือวิธีการทำงานของการเปรียบเทียบ สิ่งสำคัญคือต้องเข้าใจ 0 ที่มากกว่า
1 หรือน้อยกว่า 1 อีกครั้งที่น้อยกว่าศูนย์จะบอกว่าสตริงแรกน้อยกว่าสตริงที่สอง
และมากกว่าศูนย์จะบอกว่าสตริงแรกมากกว่าสตริงที่สอง
ฟังก์ชั่นนี้ใช้งานง่ายมาก คุณไม่ต้องกังวลกับการเปรียบเทียบ
strn ใดๆ เพราะไม่สำคัญว่าขนาดของอาร์เรย์ที่คุณกำลังเปรียบเทียบจะเป็นอย่างไร
ฟังก์ชัน str Compare เปรียบเทียบสตริงจนกว่าจะพบอักขระที่สอดคล้องกันที่แตกต่างกัน
มันอาจจะไปจนสุดสายหนึ่งก็ได้
ฟังก์ชัน Strn เปรียบเทียบจะเปรียบเทียบสตริงจนกว่าจะแตกต่างกันหรือจนกว่าจะเปรียบเทียบอักขระจำนวนหนึ่งที่ระบุโดยอาร์กิวเมนต์ที่สาม
ดังนั้น ในกรณีนี้ คุณไม่จำเป็นต้องใช้ strn comparison
สำหรับบัฟเฟอร์โอเวอร์โฟลว์ มันมีอยู่ แต่คุณจะใช้มันก็ต่อเมื่อคุณต้องการเปรียบเทียบจำนวนอักขระที่กำหนดเท่านั้น
ใช้แตกต่างจาก str
copy หรือ strn copy หรือ strn cat
strn Compare บอกว่าฉันต้องการแสดงอักขระจำนวนมากเท่านั้น
ดังนั้นจะเป็นประโยชน์หากคุณกำลังมองหาคำนำหน้าเท่านั้น
ดังนั้น หากคุณต้องการค้นหาสตริงที่ขึ้นต้นด้วย astro
คุณสามารถจำกัดการค้นหาให้เหลืออักขระห้าตัวแรก และคุณจะใช้
strn เปรียบเทียบด้วยวิธีนี้
ตัวอย่างนี้คุณจะเห็นว่าเราบอกว่าเท่ากับศูนย์
คุณมักจะเห็นคำสั่ง if แบบนี้เมื่อคุณใช้ str Compare
คุณเห็น str เปรียบเทียบภายในคำสั่งนี้และเท่ากับศูนย์เพื่อบอกว่ามันเท่ากัน
ดังนั้น strn comparison ใช้อักขระห้าตัวแรก เปรียบเทียบ
astro กับอักขระดาราศาสตร์ห้าตัวแรก
จะบอกว่าเจอแล้ว. มันจะเท่ากับศูนย์ และมันบอกว่า ดาราศาสตร์พบ
หากคุณทำสิ่งเดียวกัน แต่เปรียบเทียบกับสายอักขระอื่นที่เรียกว่า
อัศจรรย์ มันจะไม่พบมัน จริง ๆ แล้วมันจะแสดงให้เห็นจริง ๆ - มันจะบอกว่าน่าประหลาดใจมากกว่า
astro มันจะแสดงค่าที่มากกว่า
0 ซึ่งเป็น 1 และจะไม่แสดงข้อมูลใดๆ
ดังนั้น ใช้ str เปรียบเทียบ เมื่อคุณเปรียบเทียบสตริงสำหรับเนื้อหาทั้งหมด
ใช้ strn Compare เมื่อคุณต้องการเปรียบเทียบคำนำหน้ากับสตริงเท่านั้น
ไวยากรณ์ประเภทเดียวกันหรือ strn เปรียบเทียบเฉพาะอาร์กิวเมนต์ที่สามนั้น
ดังนั้นเราจึงพูดคุยกันมากมายเกี่ยวกับฟังก์ชันที่สำคัญจริงๆ
ที่เราจะใช้งาน ส่วนใหญ่เป็นความยาว str คัดลอก
strn แมว strn และ strn เปรียบเทียบ
เรากำลังจะมีความท้าทายที่คุณต้องใช้ฟังก์ชันเหล่านี้เพื่อให้คุณคุ้นเคยกับมัน
แต่คุณจะคุ้นเคยกับสิ่งนี้จริงๆ เพราะคุณจะต้องใช้มันซ้ำแล้วซ้ำเล่า
ขอขอบคุณ.