สวัสดีและยินดีต้อนรับกลับ อีกหนึ่งการบรรยายที่น่าตื่นเต้น ในการบรรยายนี้ เราจะพูดถึงเพิ่มเติมเกี่ยวกับสตริงและฟังก์ชันสตริง
ซึ่งส่วนใหญ่เป็นความสามารถในการค้นหาโทเค็นและวิเคราะห์สตริง
เรามาพูดถึงฟังก์ชันสตริงเพิ่มเติมกัน ค้นหาสตริง
ค้นหาสตริง
ฟังก์ชันทั้งหมดนี้จะอยู่ในส่วนหัวของสตริง
มีฟังก์ชันการค้นหาสตริงบางฟังก์ชันที่ใช้เฉพาะซึ่งคุณสามารถค้นหาอักขระเฉพาะหรือสตริงย่อยได้
ชื่อของฟังก์ชันเหล่านั้นคือ strchr
และ strstr
การค้นหาอักขระตัวเดียวหรือสตริงย่อยภายในสตริง
เราจะยกตัวอย่างของสิ่งนั้น
นอกจากนี้ยังมีความสามารถบางอย่างสำหรับการสร้างโทเค็นให้กับสตริง
คุณอาจพูดสิ่งที่เป็นโทเค็นการสตริง ขั้นแรก คุณต้องกำหนดว่าโทเค็นคืออะไร
โทเค็นคือลำดับของอักขระภายในสตริงที่ล้อมรอบด้วยตัวคั่น
ตัวคั่นคือสิ่งที่อยู่ในสตริงที่คุณสังเกตเห็นว่ามีความหมายพิเศษ
โทเค็นจะเป็นถ้าคุณมีสตริงที่สมบูรณ์ นี่คือเจสันและมันถูกคั่นด้วยช่องว่าง
โทเค็นหนึ่งอาจเป็นสิ่งนี้ อีกอันหนึ่งอาจเป็น อีกอันอาจเป็นเจสัน
เป็นวิธีการแยกสตริงทั้งหมดและแยกออกเป็นขอบเขตตามตัวคั่น
และคุณต้องการให้แน่ใจว่าตัวคั่นของคุณไม่ใช่สิ่งที่ถูกต้องในสตริงจริง
ดังนั้น
คุณจึงใช้ตัวคั่นเมื่อคุณอ่านจากไฟล์ ซึ่งเป็นแนวคิดประเภทเดียวกัน
ที่คุณแบ่งประโยคออกเป็นคำที่เรียกว่า tokenizing เราจะใช้ฟังก์ชันที่เรียกว่า
strtok
ฉันยังต้องการพูดคุยเกี่ยวกับสตริงการวิเคราะห์ มีสิ่งเหล่านี้มากมาย
หลายตัวที่จะตรวจสอบว่าอักขระเป็นอักขระตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่หรือตัวอักษรและตัวเลขหรือตัวเลข
สิ่งเหล่านี้ทำกับอักขระเป็นหลัก แต่อักขระในสตริงด้านข้าง และคุณยังสามารถนำไปใช้กับทั้งสตริงได้
ตอนนี้เรากำลังเข้าสู่รายละเอียดเพิ่มเติมเกี่ยวกับสตริง
และเพื่อให้เข้าใจฟังก์ชันเหล่านี้ เราต้องพูดถึงพอยน์เตอร์เล็กน้อย
พอยน์เตอร์เป็นแนวคิดที่ยิ่งใหญ่ในค.
เราจะมีหัวข้อทั้งหมดสำหรับพอยน์เตอร์
น่าจะเป็นอย่างใดอย่างหนึ่งต่อไปหรืออย่างใดอย่างหนึ่งหลังจากนั้น
และมีการอภิปรายมากมาย อาจเป็นหัวข้อที่สับสนที่สุดของภาษา
ฉันไม่ต้องการที่จะพูดถึงรายละเอียดในตอนนี้เพราะมันไม่เกี่ยวข้อง
ฉันแค่อยากจะพูดถึงมัน แค่ให้การแอบมองเล็กๆ น้อยๆ เกี่ยวกับพอยน์เตอร์ เพื่อที่คุณจะได้เข้าใจฟังก์ชันบางอย่างที่เราจะใช้
นั่นเป็นจุดประสงค์เดียวของสิ่งนี้ ดังนั้น หากคุณไม่เข้าใจพอยน์เตอร์
ณ จุดนี้หลังจากสไลด์คู่นี้ ไม่ต้องกังวล
แนวคิดของพอยน์เตอร์ อีกครั้ง เราจะพูดถึงรายละเอียดในภายหลัง
แต่เพื่อให้เข้าใจฟังก์ชันสตริงเหล่านี้ ฉันต้องการให้คุณดูคร่าวๆ
C จัดเตรียมตัวแปรที่มีประโยชน์อย่างน่าทึ่ง ซึ่งเรียกว่าพอยน์เตอร์
ฉันกำลังพูดถึงมัน เกี่ยวข้องกับหน่วยความจำและการจัดสรรหน่วยความจำ
บางภาษา หากคุณเคยตั้งโปรแกรมมาก่อน และคุณไม่ใช่มือใหม่ในการเขียนโปรแกรมเลย
บางภาษาจะจัดการหน่วยความจำให้คุณโดยอัตโนมัติ
พวกเขาจะจัดสรรหน่วยความจำให้คุณและลบทิ้ง ภาษาอย่าง java ทำเช่นนี้
เรียกว่าคนเก็บขยะ ภาษาเช่น c ไม่ทำเช่นนี้
ดังนั้นเมื่อใดก็ตามที่คุณสร้างหน่วยความจำสำหรับการใช้พอยน์เตอร์
คุณจะต้องลบหน่วยความจำนั้น
แต่ตัวชี้คืออะไร มันมีประโยชน์มาก และมันคืออะไร
มันคือตัวแปรที่เก็บที่อยู่
ที่อยู่จำไว้เป็นสิ่งที่อยู่ในความทรงจำ
ปกติจะเป็นเลขฐานสิบหก
ค่าในที่อยู่นั้นอยู่ในตำแหน่งอื่นในหน่วยความจำ
ตัวชี้เพียงชี้ไปยังที่อยู่ที่มีค่า
และในอดีตเราเคยใช้ที่อยู่กับฟังก์ชัน scanf
จำไว้ว่าเครื่องหมายและที่เราใช้นั่นคือที่อยู่ของโอเปอเรเตอร์
ฟังก์ชั่น Scanf เป็นพารามิเตอร์ที่สองจะต้องรับตัวแปรที่คุณต้องการเก็บข้อมูล
ตัวแปรนั้นจะต้องเป็นตัวชี้
ดังนั้นฟังก์ชัน scanf จึงคาดหวังตัวชี้
ในการสร้างจำนวนเต็มด้วยตัวเอง มันไม่ใช่ตัวชี้ แต่ถ้าคุณได้รับที่อยู่ของมัน
มันจะกลายเป็นตัวชี้
เรากำลังใช้เครื่องหมายและเพื่อรับที่อยู่ของประเภทข้อมูลดั้งเดิม
คุณจึงคุ้นเคยกับแนวคิดที่อยู่เพียงเล็กน้อย
จำไว้ว่า ต่อจากนี้ด้วยพอยน์เตอร์
คุณต้องสร้างจำนวนเต็ม และนั่นไม่ใช่พอยน์เตอร์
และเท่ากับ 25
แต่ถ้าคุณได้รับเครื่องหมายและซึ่งเป็นที่อยู่ของมัน คุณสามารถกำหนดให้กับตัวชี้ได้
ตัวชี้มีไวยากรณ์พิเศษใน c เครื่องหมายดอกจันแสดงถึงตัวชี้
ดังนั้นเราจึงประกาศตัวเลขตัวแปรที่มีค่า 25 จากนั้นเราประกาศตัวชี้โดยใช้เครื่องหมายดอกจันชื่อ
pNumber ซึ่งมีที่อยู่ของตัวเลข
และอีกครั้ง เครื่องหมายดอกจันใช้เพื่อประกาศตัวชี้ นั่นคือวิธีที่คุณรู้ว่าเป็นประเภทข้อมูลตัวชี้
เพื่อให้ได้ค่าตัวแปร p เพราะเลข
p คืออะไร? เป็นตัวชี้ที่ชี้ไปยังที่อยู่ในหน่วยความจำ
หากคุณเพียงแค่ลองดูค่าของเลข p มันจะให้ที่อยู่แก่คุณ
หากคุณต้องการทราบค่าของสิ่งที่อยู่ชี้ไป คุณต้องยกเลิกการอ้างอิง
ดังนั้นจึงมีรูปแบบพิเศษที่
c ใช้เรียกว่าเครื่องหมายดอกจันและชื่อของตัวแปร นั่นคือวิธีที่คุณสามารถเข้าถึงตำแหน่งหน่วยความจำที่มีค่า
ดังนั้นหากคุณต้องการกำหนดข้อมูลให้กับตำแหน่งหน่วยความจำนั้น คุณต้องบอกว่า star p number
ผลกระทบอีกครั้งคือเข้าถึงข้อมูลที่เก็บไว้ตามที่อยู่ที่ระบุโดยตัวชี้
ดังนั้นมันจึงสับสนมากเมื่อเราพูดถึงพอยน์เตอร์เพราะคุณไม่คุ้นเคยกับแนวคิดนี้
คุณคิดว่าตัวแปรมีค่า แค่นั้นแหละ แต่ตัวแปรสามารถมีที่อยู่และที่อยู่ก็สามารถมีค่าได้
สไลด์นี้พยายามอธิบายสิ่งที่ฉันเพิ่งพูดถึง
ฉันพบสิ่งนี้ในหนังสือที่ฉันอ่าน
เป็นสไลด์ที่แสดงแนวคิดของตัวชี้ในหน่วยความจำและการทำงานของสิ่งต่างๆ
กับที่อยู่
ฉันก็เลยย้ำสิ่งที่ฉันเพิ่งพูดถึง
แต่ค่าของเครื่องหมายและตัวเลขคือที่อยู่ที่หมายเลขนั้นตั้งอยู่
ดังนั้นหากคุณมีตัวแปรสองตัว คือ ตัวเลขและหมายเลข
p หมายเลข p คือตัวชี้ หมายเลขคือ int คุณยังต้องระบุประเภทของตัวชี้ด้วย
แม้ว่าตัวชี้จะเป็นที่อยู่
คุณยังคงระบุประเภทหรือตำแหน่งที่ที่อยู่จะชี้ไป
จำนวน int star p จะเท่ากับแอดเดรสของตัวเลข
ตัวเลขอยู่ในหน่วยความจำ และชี้ไปที่ที่อยู่หลักพัน
เช่น มีค่า 25
หมายเลข P มีที่อยู่ 105 สำหรับหมายเลข
p จริงนั้น แต่ค่าของที่อยู่นั้นคือ
1,000 ที่อยู่
เพื่อให้ได้ค่าของเลข p คุณจะต้องตัดค่า 1000 ซึ่งจะให้
25
เหตุผลที่ฉันพูดถึงสิ่งนี้เกี่ยวกับพอยน์เตอร์
เพราะฟังก์ชันสตริงจำนวนมากจะส่งกลับพอยน์เตอร์
มันจะไม่เป็นอะไรมากขนาดนั้น
สำคัญก็ต่อเมื่อคุณต้องการทำความเข้าใจว่าคุณได้รับอักขระบางตัวในอาร์เรย์อย่างไร
แต่ฉันต้องการพูดถึงพวกเขาสั้น ๆ
ไม่เป็นไรถ้าแนวคิดไม่จมอยู่ในตอนนี้เพราะเราจะพูดถึงรายละเอียดมากมายในหัวข้อต่อไป
แต่เข้าใจว่าฟังก์ชันสตริงในตอนนี้ที่เราจะใช้จะส่งกลับพอยน์เตอร์
จากนั้นคุณอาจใช้การส่งคืนนั้นเพื่อทำสิ่งที่มีประโยชน์
ในอดีตเมื่อเราใช้ str สำเนาและ str เปรียบเทียบ เราส่งพอยน์เตอร์แต่ไม่ส่งคืนพอยน์เตอร์
เราไม่เคยต้องใช้พอยน์เตอร์นั้น
ตอนนี้เราต้องใช้พอยน์เตอร์แล้ว ฉันต้องการแค่ให้คำอธิบายเล็กน้อยว่านั่นหมายถึงอะไร
ตัวชี้เป็นเพียงการชี้ไปยังที่อยู่
จากนั้นคุณสามารถใช้ที่อยู่นั้นเพื่อแยกวิเคราะห์หรือทำอะไรก็ได้ที่คุณต้องทำ
หวังว่านี่จะไม่ครอบงำคุณ อีกครั้ง อย่ากังวลหากคุณไม่เข้าใจอย่างถ่องแท้
เราจะพูดถึงตัวอย่างการวิเคราะห์
การแปลงโทเค็น และการค้นหาสตริงในตอนนี้
ในการค้นหาสตริง เราพูดถึง คุณจะใช้ strchr หรือ strstr
strchr ค้นหาสตริงที่กำหนดสำหรับอักขระตัวเดียว
อาร์กิวเมนต์แรกของฟังก์ชันคือสตริงที่จะค้นหา
ซึ่งจะเป็นที่อยู่ของอาร์เรย์อักขระ
อาร์กิวเมนต์ที่สองคือตัวละครที่คุณกำลังมองหา
เราจะให้ตัวอย่างในวินาที ดังนั้นฟังก์ชันจะค้นหาสตริงโดยเริ่มต้นที่จุดเริ่มต้นและส่งคืนตัวชี้ไปยังตำแหน่งแรกในสตริงที่พบอักขระ
นี่คือเหตุผลที่ตัวชี้มีความสำคัญในขณะนี้ เนื่องจากเราไม่ได้คืนค่าทั้งหมด
เรากำลังคืนค่าตัวชี้ไปยังอักขระภายในสตริง และที่อยู่นั้นแสดงถึงดัชนีของอาร์เรย์
โดยพื้นฐานแล้ว
ที่อยู่ของตำแหน่งนี้ในหน่วยความจำ มันคือตัวอักษรประเภทดาว และมันถูกอธิบายว่าเป็นตัวชี้ไปยังตัวอักษร
ซึ่งจริงๆ แล้วเป็นแค่ตัวอักษรตัวเดียวในหน่วยความจำ
ในการจัดเก็บค่าที่ส่งคืน คุณต้องสร้างตัวแปรที่สามารถเก็บที่อยู่ของอักขระได้
ดังนั้นคุณต้องสร้างตัวชี้
ถ้าตอนนี้พบอักขระ ฟังก์ชันจะส่งกลับค่าพิเศษ ซึ่งเป็นค่าว่าง
Null หมายความว่าตัวชี้ไม่ชี้ไปที่สิ่งใด
เราใช้ null เมื่อเราพูดถึงพอยน์เตอร์ และ
null ก็แค่บอกว่าไม่พบอะไรเลย จึงไม่ชี้นำสิ่งใด
เมื่อมันชี้ไปที่บางสิ่ง มันจะชี้ไปยังที่อยู่ที่คุณพบอักขระนั้น จากนั้นคุณสามารถเริ่มแยกวิเคราะห์จากที่นั่นได้
เพราะจำจากการบรรยายก่อนหน้านี้
เมื่อคุณสร้างอาร์เรย์อักขระในหน่วยความจำ
คุณเพียงแค่มีอักขระแต่ละตัวแสดงเป็นไบต์
และหากคุณกำลังแยกวิเคราะห์สตริงและต้องการดูว่าอักขระตัวใดตัวหนึ่งเริ่มต้นที่ใดในสตริงนั้น
ให้คืนค่าไบต์นั้นแล้วเริ่มดูจากที่นั่น
ดังนั้น str char วิธีที่คุณใช้มันเป็นสิ่งนี้
คุณบอกว่าคุณสร้างสตริงอักขระและเราเริ่มต้นที่นี่ด้วยสุนัขจิ้งจอกสีน้ำตาลอย่างรวดเร็ว
จากนั้นเราสร้างอักขระตัวเดียวและเริ่มต้นด้วย q
จากนั้นเราสร้างพอยน์เตอร์เพราะเราต้องสร้างพอยน์เตอร์เพราะนั่นคือสิ่งที่กลับมาจาก str char
นั่นคือสิ่งที่ช่วยให้เราเห็นว่าเราพบอักขระที่ใดในสตริงนั้น
เราจะเริ่มต้นตัวชี้ของเราให้เป็นโมฆะ เพราะตอนนี้ไม่ได้ไปชี้อะไรแล้ว
จากนั้นเราจะเรียก str char เราจะผ่านสตริงของเราซึ่งเป็นสุนัขจิ้งจอกสีน้ำตาลเร็ว และเราจะผ่านในอักขระตัวเดียวของเราซึ่งก็คือ
q
สิ่งที่เกิดขึ้นคือมันจะมองเข้าไปในจิ้งจอกสีน้ำตาลว่องไว
และครั้งแรกที่มันพบ q มันจะส่งคืนที่อยู่ของ q นั้น
ดังนั้น p got char จะชี้ไปที่ดัชนีที่สี่ของ
str
เนื่องจาก t เป็นศูนย์ย่อย, h เป็นหน่วยย่อยหนึ่ง, e เป็นเศษสอง,
ช่องว่างเป็นเศษสาม, q คือเศษสี่
ดังนั้น p got char จะชี้ไปที่ q ในจิ้งจอกสีน้ำตาลเร็ว
ดังนั้นคุณจึงสามารถเห็นได้ว่าอักขระนั้นเริ่มต้นที่ใดในสตริงนั้น
ดังนั้นอาร์กิวเมนต์แรกของ str char คือที่อยู่ของตำแหน่งแรกที่จะค้นหา นั่นคือสตริงการค้นหา
อาร์กิวเมนต์ที่สองคืออักขระที่ค้นหา อักขระที่คุณต้องการค้นหา อักขระตัวเดียว
คาดว่าอาร์กิวเมนต์ที่สองจะเป็นประเภท int
ในทางเทคนิคแล้ว str char อาร์กิวเมนต์ที่สองเข้ามา
แต่คอมไพเลอร์ c จะแปลงแผนภูมิเป็น int โดยอัตโนมัติ
มันจะได้รับค่า ASCII เป็นหลัก
ดังนั้นคุณสามารถกำหนด q อักขระตัวเดียวแทนตัวอักษรตัวเดียวได้
คุณสามารถกำหนดเป็น int ได้
นั่นเป็นเพียงความรู้ทางเทคนิคที่ฉันต้องการให้คุณรู้
แต่ p got char จะชี้ไปที่ค่า quick brown fox เพราะมันจะเริ่มที่
q แล้วมันจะไปที่ null terminator ถ้าคุณพยายามพิมพ์ออกมา
มันจะเป็นสุนัขจิ้งจอกสีน้ำตาลเร็วจริง ๆ เมื่อคุณเรียกใช้ตัวอย่างนี้
นี่คือวิธีที่คุณสามารถค้นหาอักขระตัวเดียวในสตริงทั้งหมดได้
ใช้ str char จากนั้นใช้ตัวชี้ จากนั้นแสดงตัวชี้
และคุณจะแสดงตัวชี้นั้นอย่างไร เช่นเดียวกับที่คุณแสดงอักขระอื่น ๆ ใช้ printf เปอร์เซ็นต์ s
นี่เป็นกลไกที่ดีในการค้นหาอักขระในสตริงทั้งหมด
หากคุณต้องการค้นหาสตริงภายในสตริง ซึ่งจะเป็นสตริงย่อย
ให้ใช้ strstr
นี่อาจเป็นประโยชน์มากที่สุดสำหรับฟังก์ชันการค้นหาทั้งหมด
มันค้นหาหนึ่งสตริงสำหรับการเกิดขึ้นของสตริงย่อย
และส่งคืนตัวชี้ไปยังตำแหน่งในสตริงแรกที่พบสตริงย่อย
ซึ่งคล้ายกับ str char แต่ค้นหาทั้งสตริง หากไม่พบรายการที่ตรงกัน จะคืนค่า null
อาร์กิวเมนต์แรกคือสตริงที่จะค้นหาเหมือนกับ str char
ประการที่สองคือสตริงย่อยที่คุณต้องการ สตริงอื่น นี่คือตัวอย่าง
มันดูคล้ายกับอีกอันหนึ่งมาก ยกเว้นแทนที่จะมองหาอักขระตัวเดียว
เรากำลังมองหาคำ สตริง
ดังนั้นเราจึงมีคำพูดซึ่งเท่ากับสุนัข
และเรามีข้อความที่สุนัขทุกตัวมีวันของเขา
เราสร้างตัวชี้อีกครั้งเพราะมันต้องเป็น - นี่คือสิ่งที่ฟังก์ชันส่งคืน
เมื่อเราเรียก strstr เราจะส่งข้อความเป็นสตริงที่เราต้องการดู
แล้วอาร์กิวเมนต์ที่สองคือคำที่เราต้องการที่จะดูภายในสตริงนั้น
ดังนั้นมันจะค้นหาข้อความที่เกิดขึ้นครั้งแรกของสตริงที่เก็บไว้ในคำ
สุนัขสตริงปรากฏขึ้นที่อักขระที่เจ็ดในข้อความ
หากดูจากข้อความ
ข้อความย่อย 6 จะเท่ากับ dog นั่นคือจุดเริ่มต้น
ตัวชี้จะชี้ไปที่แอดเดรสของข้อความ บวก 6 dog, และมันจะเริ่มตรงนั้น,
แล้วก็จะไปที่ตัวสิ้นสุด null
ดังนั้น p พบว่าจะเป็นสุนัขมีวันของเขา
และควรระมัดระวังด้วยเนื่องจากการค้นหาจะคำนึงถึงตัวพิมพ์เล็กและตัวพิมพ์ใหญ่
ถ้าคุณให้ D-O-G ตัวพิมพ์ใหญ่จริงๆ คุณจะไม่พบอะไรเลย มันจะค้นหาเฉพาะกรณีที่ถูกต้องเท่านั้น
แต่สิ่งนี้ใช้เพื่อค้นหาสตริงย่อยและสตริง ซึ่งมีประโยชน์มากเพราะหลายครั้งในโปรแกรมที่คุณกำลังจะบอกว่าสตริงนี้อยู่ภายในสตริงนี้
เพราะมันเกือบจะคล้ายกับ grep หากคุณเคยใช้ grep บน Linux
ฉันหวังว่านี่จะสมเหตุสมผล Tokenizing สตริง
โทเค็นคือลำดับของอักขระหนึ่งในนั้นคือสตริงที่ผูกด้วยตัวคั่น เรารู้สิ่งนี้
ตัวคั่นสามารถเป็นอะไรก็ได้ แต่ควรเป็นสิ่งเฉพาะสำหรับสตริงนั้น
อย่ามีตัวคั่นเป็น "A" เพราะตอนนี้จะพบบางสิ่งที่ถูกต้องในสตริงนั้นในคำ
ทำให้เป็นเอกลักษณ์ เช่น การเว้นวรรคหรือเครื่องหมายจุลภาค นี้ อีกครั้ง ใช้เป็นขอบเขตสำหรับคำปกติในสตริงเดียว
จึงแบ่งประโยคออกเป็นคำ เรียกว่า tokenizing
ฟังก์ชัน strtok นี้ใช้สำหรับการสร้างโทเค็นให้กับสตริง
มันต้องมีข้อโต้แย้งสองข้อ
สตริงที่จะ tokenized ซึ่งเป็นสตริงทั้งหมดที่มีช่องว่างและตัวคั่น
แล้วสตริงที่มีอักขระจำกัดที่เป็นบวกทั้งหมด
คุณสามารถระบุสิ่งที่คุณต้องการกำหนดเป็นขอบเขตได้
นี่คือตัวอย่าง
เรากำลังสร้างอาร์เรย์อักขระ 80
มันพูดว่าสวัสดี สบายดีไหม คุณเป็นแดช ฉันชื่อแดช เจสัน
จากนั้นเราสร้างสตริงคงที่ที่แสดงถึงตัวคั่น ซึ่งก็คือเครื่องหมายลบ
เส้นประ มันดูแตกต่างออกไปเล็กน้อย แต่ก็ยังเป็นเครื่องหมายลบ
เส้นประ ทั้งสองเส้น
จากนั้นเราสร้างพอยน์เตอร์ซึ่งเป็นโทเค็น
เพราะ strtok กำลังจะคืนโทเค็นของเราแต่ละอัน
ดังนั้นหากเราเรียก strtok ของเรา และเราส่งผ่านเป็น
string และเราผ่านตัวคั่นของเรา
โทเค็นจะเท่ากับสิ่งแรกที่มันพบ
ครั้งแรกที่คุณเรียก strtok มันจะเท่ากับ สวัสดี คุณเป็นอย่างไรบ้าง
แล้วมันจะพบการจับคู่กับเส้นประ
และถ้าโทรไปครั้งที่สองก็จะพิมพ์ชื่อผมออกมา
ถ้าคุณเรียกมันว่าครั้งที่สาม
มันจะพิมพ์เจสันออกมาเพราะมันจะผ่านขีดกลาง
นั่นเป็นเหตุผลที่เรามีการวนรอบที่นี่ เราบอกว่าในขณะที่โทเค็นไม่เท่ากับ null
ให้พิมพ์โทเค็นออกมา
จากนั้นเราจะได้โทเค็นตัวต่อไปโดยเรียก strtok
และเราบอกว่า null เป็นพารามิเตอร์แรกของเรา
และ s เป็นพารามิเตอร์ที่สอง
จากนั้นเรา แสดง ลองดูสิ่งนี้ในบล็อคโค้ดเพราะมันจะทำให้เข้าใจได้ง่ายขึ้น
มาสร้างสิ่งนี้กันเถอะ เราเพิ่งผ่านตัวอย่างนี้
ฉันต้องการแสดงให้คุณเห็นว่าผลลัพธ์คืออะไร ดังนั้นชัดเจนว่าเกิดอะไรขึ้นที่นี่
ที่นี่คุณจะเห็นว่ามันพิมพ์โทเค็นแรกออกมาซึ่งก็คือสวัสดี
คุณเป็นอย่างไรบ้าง
สิ่งแรกที่มันทำคือ ค้นหาโทเค็นตัวแรก
พิมพ์ออกมา สวัสดี สบายดีไหม ฉันชื่อ แล้วก็เจสัน
ตอนนี้เรามีสวัสดีเป็นอย่างไรบ้าง
หาขีดแรก พิมพ์ออกมา ชื่อของฉันคือ find token ตัวต่อไป
จากนั้นตัวที่สามคือ Jason แต่คุณต้องเรียกโทเค็นสามครั้งเพื่อรับแต่ละโทเค็น
อันแรกกำลังจะ tokenize บน str.
ดูรายการถัดไปที่คุณสามารถส่งผ่านเป็นโมฆะได้เพราะคุณไม่ต้องการดูอีกครั้ง คุณแค่ต้องการรับโทเค็นตัวถัดไป
ดังนั้นคุณจึงส่งค่าว่างเป็นค่าที่สอง และคุณก็แค่ส่ง s
มันจะให้โทเค็นถัดไปของ str แล้ว tok
นั่นคือวิธีที่คุณสามารถใช้ strtok ช่วยในการแยกวิเคราะห์ได้มาก
คุณสามารถแยกวิเคราะห์บางสิ่งและแยกขอบเขตออกได้
ฟังก์ชันสุดท้ายที่ฉันต้องการพูดถึงคือฟังก์ชันวิเคราะห์สตริงเหล่านี้
มีเยอะมาก เลยจัดโต๊ะเล็กๆ ไว้ที่นี่
อยู่ล่าง อยู่บน. มันทำในสิ่งที่คุณคิดว่าจะทำ
มันทดสอบเพื่อดูว่าอักขระเป็นตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่
เรากำลังทดสอบอักขระบางตัว แต่ใช้อยู่ภายในสตริง
ดังนั้น อาร์กิวเมนต์ของฟังก์ชันเหล่านี้แต่ละอย่างจึงเป็นอักขระที่คุณต้องการค้นหา
จากนั้นฟังก์ชันทั้งหมดเหล่านี้จะคืนค่าที่ไม่ใช่ศูนย์ของประเภท
int หากอักขระอยู่ในชุดที่กำลังทดสอบ
ดังนั้นเราจะส่งอักขระ int เข้าไปข้างในเพื่อค้นหาคำที่อยู่ภายใน
หากเรามีอักษรตัวพิมพ์ใหญ่อยู่ภายในคำ คำนั้นจะบอกเราและเราสามารถใช้เพื่อแยกวิเคราะห์องค์ประกอบแต่ละอย่างในลักษณะอักขระได้เช่นกัน
ดังนั้นค่าที่ส่งคืนจะแปลงเป็นจริงหรือเท็จเพื่อให้คุณสามารถใช้เป็นบูลีนได้เช่นกันซึ่งเป็นสิ่งที่ดี
ดังนั้นค่าที่ต่ำกว่าจะคืนค่าเป็นจริงหากคำหรืออักขระมีตัวพิมพ์เล็ก
นี่เป็นตัวอย่างที่ดีที่ฉันต้องการใช้
ซึ่งจะนับจำนวนตัวอักษรในสตริงทั้งหมด
เรามาเริ่มกันเพราะมันจะชัดเจน แต่สิ่งที่คุณควรสังเกตคือ
เรากำลังสร้างบัฟเฟอร์ บัฟเฟอร์อินพุตของเรา จากนั้น
เรากำลังสร้างจำนวนเต็มสามจำนวนเพื่อนับ
เรากำลังบอกให้ผู้ใช้ป้อนสตริงที่มีอักขระน้อยกว่ามาก
จากนั้นเราจะอ่านมันเข้าไป
จากนั้นเราจะดูที่สตริงนั้นเพื่อดูว่ามีอักขระบางตัวหรือไม่
ดังนั้น เราจะวนซ้ำผ่านสตริงนั้นโดยดูที่แต่ละดัชนีในอาร์เรย์
นี่คือตัวอย่างของเรา
อีกครั้งบัฟเฟอร์คืออาร์เรย์อักขระของเราที่จะเก็บอินพุต
เราจะใช้ scanf เพื่อเติมข้อมูลนั้น
เราต้องพิมพ์สตริงของเราโดยไม่เว้นวรรค มันเป็นสตริงเดียว
เราจะผ่านมันไป ผ่านแต่ละองค์ประกอบในบัฟเฟอร์แล้วเรียก is alpha
เป็นตัวเลขหรือเป็นฟังก์ชัน punct เพื่อดูว่าอักขระเหล่านั้นอยู่ในนั้นหรือไม่
จากนั้นจะเพิ่มขึ้นตามนั้น ไม่ว่าสิ่งนั้นหรือไม่
ส่งคืนค่าจริงหรือเท็จ จากนั้นจะแสดงจำนวนตัวอักษร ตัวเลข และเครื่องหมายวรรคตอนภายในสตริงนั้น
เรียกใช้สิ่งนี้กันเถอะ
ผมจะป้อนบางอย่างด้วยตัวพิมพ์ใหญ่
อาจเป็นตัวเลข
แล้วพอตีกลับจะนับทุกอย่าง มันบอกว่าพวงมาลัยของฉันมีตัวอักษร
24 ตัว 4 หลักและเครื่องหมายวรรคตอน 1 ตัว ทวิภาค
โปรแกรมเล็ก ๆ น้อย ๆ ที่เรียบร้อยดีที่ใช้ฟังก์ชั่นอักขระเหล่านั้น
แต่มีประโยชน์ในการวิเคราะห์สตริงเพราะนั่นคือสิ่งที่คุณกำลังทำ
คุณกำลังวิเคราะห์สตริง แต่คุณกำลังอ่านทีละอักขระ
ขอขอบคุณ.