สวัสดีและยินดีต้อนรับกลับ ในการบรรยายนี้
ฉันต้องการพูดคุยเกี่ยวกับการสร้างสตริง โดยเฉพาะวิธีที่คุณสามารถทำใน
c โดยใช้อาร์เรย์อักขระ
ฉันมักจะใช้คำว่า string และ string สลับกันได้
แต่จริงๆ แล้ว สตริงอักขระคืออาร์เรย์ถ่านที่เราจะพูดถึง
เป็นแนวคิดที่สำคัญมาก
ตอนนี้เราจะสามารถใช้คำและข้อความในโปรแกรมของเราเพื่อทำสิ่งต่างๆ ได้ทุกประเภท
ตอนนี้ c เองไม่มีประเภทข้อมูลใด ๆ ที่แสดงถึงสตริง
ไม่มีอะไรอยู่ที่นั่น หลายภาษารองรับทั้งอ็อบเจ็กต์หรือประเภทข้อมูลของสตริงประเภท
เนื่องจากไม่มีข้อมูลประเภท c ในสตริง คุณจึงไม่สามารถใช้ตัวดำเนินการใดๆ
ในสตริงได้
สิ่งที่เราจะทำคือจบลงด้วยการใช้ไลบรารีมาตรฐาน และมีฟังก์ชันสตริงทุกประเภทที่เราจะพูดถึง
เรามีการบรรยาย 3 ครั้งเกี่ยวกับฟังก์ชันสตริงต่างๆ ที่คุณสามารถใช้ได้
และสิ่งนี้จะช่วยเราจัดการสตริง รับข้อมูลเกี่ยวกับสตริง
แต่คุณไม่สามารถใช้ตัวดำเนินการกับสตริงได้ ไม่มีการบวกหรือลบสตริง
ไม่มีอะไรแบบนั้น
สตริงใน c ถูกเก็บไว้ในอาร์เรย์ของประเภทถ่าน
เรารู้ว่าอาร์เรย์คืออะไร เรารู้ว่าถ่านประเภทคืออะไร
ถ่านประเภทเป็นอักขระตัวเดียว อาร์เรย์ที่คุณสามารถจัดเก็บองค์ประกอบหลายรายการในชื่อเดียวกันได้
ดังนั้นจึงสมเหตุสมผลที่สตริงจะอยู่ภายในอาร์เรย์อักขระเนื่องจากสตริงมีอักขระหลายตัว
ดังนั้นอักขระของสตริงจึงถูกเก็บไว้ในเซลล์หน่วยความจำที่อยู่ติดกัน หนึ่งอักขระต่อเซลล์
คุณสามารถเข้าถึงได้เช่นเดียวกับที่คุณเข้าถึงอาร์เรย์เช่นกัน
แต่วิธีที่คุณจะประกาศสตริงและดูว่าจริง ๆ แล้วคุณก็แค่ใช้ประเภท char
แล้วตามด้วยวงเล็บเพื่อระบุขนาด เช่นเดียวกับอาร์เรย์ปกติ
หากคุณต้องสร้างประเภทอื่น
Char แล้วชื่อของคุณคืออะไร แล้วก็ขนาดของอาร์เรย์อักขระภายในวงเล็บเหลี่ยม
นั่นคือวิธีที่คุณสามารถประกาศสตริงในค.
เมื่อคุณประกาศสตริงใน c แบบนี้ จะไม่มีข้อมูลจริงที่เกี่ยวข้อง
คุณเพียงแค่ระบุขนาด
นั่นเป็นวิธีที่ง่ายที่สุด
ดังนั้นตัวแปรจึงสามารถรองรับสตริงที่มีอักขระได้สูงสุด 19 ตัว
จำอักขระว่างนี้
ถ้าคุณบอกว่าขนาดสตริงของคุณจะเท่ากับ 20 นั่นหมายความว่าสามารถจัดเก็บอักขระได้เพียง
19 ตัวจริง ๆ เพราะคุณต้องมีอักขระพิเศษอีกหนึ่งตัวสำหรับค่าว่าง
โปรดทราบว่าการประกาศอาร์เรย์อักขระคือ 20 หมายความว่าสามารถจัดเก็บอักขระได้
19 ตัวที่นั่น
เมื่อคุณระบุขนาดของอาร์เรย์ที่คุณต้องการใช้ก่อนสตริง - เพื่อจัดเก็บสตริง
ต้องมีอย่างน้อยหนึ่งมากกว่าจำนวนอักขระในสตริงที่คุณต้องการจัดเก็บ
คอมไพเลอร์จะเพิ่มตัวสิ้นสุด null โดยอัตโนมัติเมื่อสิ้นสุดค่าคงที่ของสตริงทุกค่า
ดังนั้น สิ่งที่คุณควรทำจริงๆ คือ เมื่อคุณสร้างสตริงอักขระเหล่านี้
คุณควรเริ่มต้นสตริงเหล่านี้
ดังนั้นคุณจึงสามารถเริ่มต้นตัวแปรสตริงได้เหมือนกับที่คุณเริ่มต้นอาร์เรย์ได้
คุณใส่อักขระแต่ละตัวในวงเล็บเหล่านี้
ดังนั้น นี่จึงดูคล้ายกันมากกับกรณีที่คุณเริ่มต้นองค์ประกอบในอาร์เรย์จำนวนเต็ม
แต่ถ้าคุณพูดคำว่า char และจากนั้นในวงเล็บปีกกา
คุณใส่อักขระแต่ละตัวเพื่อสร้างอาร์เรย์อักขระ
ดังนั้นจึงเหมือนกับการเริ่มต้นอาร์เรย์อื่นๆ
ในกรณีที่ไม่มีการใส่ขนาด คอมไพเลอร์ c จะคำนวณจำนวนองค์ประกอบในอาร์เรย์โดยอัตโนมัติ
แล้วเพิ่มหนึ่งรายการสำหรับตัวสิ้นสุดค่า null
ดังนั้นมันจึงขึ้นอยู่กับจำนวนตัวเริ่มต้นที่คุณมีระหว่างวงเล็บปีกกา
วงเล็บปีกกา
คำสั่งนี้จะสงวนพื้นที่และหน่วยความจำสำหรับอักขระเจ็ดตัวพอดี
เครื่องหมายอัศเจรีย์ h-e-l-l-o และจากนั้นตัวสิ้นสุด
null และแผนภาพเล็กๆ นี้ทางด้านขวาจะแสดงให้คุณเห็นว่า
โดยอัตโนมัติและเพิ่มเทอร์มินัล null นั้น ตอนนี้คงเป็นเรื่องที่เจ็บปวดมากหากคุณต้องเริ่มต้นอาร์เรย์อักขระของคุณด้วยเครื่องหมายคำพูดเดี่ยวตามด้วยเครื่องหมายจุลภาค
สิ่งที่คุณทำได้คือแม้แต่การจดชวเลขก็คือ คุณสามารถใส่เครื่องหมายอัญประกาศคู่รอบๆ นั้นได้
ดังนั้น คุณสามารถระบุสตริงได้อย่างชัดเจน เช่นในตัวอย่างแรก
จากนั้นคุณจะต้องใช้ฟังก์ชันสตริงจริง ๆ เพื่อนำข้อมูลไปใช้กับสตริงนั้นหรือคุณสามารถปล่อยให้คอมไพเลอร์ทำเพื่อคุณ
ปัญหาในการทำอย่างชัดเจนคือคุณต้องจำไว้เสมอว่าต้องเพิ่มอักขระพิเศษนั้นสำหรับค่าว่าง
ดังนั้นสิ่งที่คุณควรทำจริงๆ ก็คือคุณควรปล่อยให้คอมไพเลอร์คิดหาให้คุณ
ดังนั้นอย่าใส่ตัวเลขใดๆ ในวงเล็บสำหรับขนาด
เพราะหากขนาดที่ระบุมีขนาดเล็กเกินไป คอมไพเลอร์จะไม่สามารถใส่อักขระ
null ที่สิ้นสุดที่ส่วนท้ายของอาร์เรย์ได้ และไม่ได้ใส่ไว้ที่นั่น และจะไม่บอกคุณว่าไม่ได้ใส่ไว้ที่นั่น
ดังนั้น คุณจะมีจุดบกพร่องในโปรแกรมของคุณ โดยที่คุณไม่รู้ตัวด้วยซ้ำ
แนวทางปฏิบัติที่ดีที่สุดคือเมื่อคุณใช้ตัวอักษรสตริงและคุณกำลังเริ่มต้นสตริงเพื่อให้คอมไพเลอร์หาขนาดสำหรับคุณ
ทำให้เป็นขนาดที่ใหญ่ขึ้นหรืออย่างอื่นแล้วใส่เข้าไปแล้วมันจะหาขนาดให้คุณเอง
จึงไม่ระบุขนาด ให้คอมไพเลอร์คิดออก
วิธีนี้คุณสามารถมั่นใจได้ว่ามันจะถูกต้อง
เพียงปล่อยให้วงเล็บเหล่านั้นเป็นวงเล็บว่างและกำหนดด้วยตัวดำเนินการมอบหมาย
จากนั้นใส่เครื่องหมายอัญประกาศคู่ในเครื่องหมายคำพูด
คุณไม่จำเป็นต้องมีวงเล็บเหลี่ยมด้วยซ้ำ
นี่คือแนวทางปฏิบัติที่ดีที่สุด เราจะพูดถึงตัวอย่าง
คุณยังสามารถเริ่มต้นเพียงส่วนหนึ่งของอาร์เรย์ขององค์ประกอบประเภทถ่านด้วยสตริงได้
ดังนั้น หากคุณสร้างขนาดที่ใหญ่จริงๆ และคุณกำหนดอักขระเพียงสองสามตัว
ก็ถือว่าดีเช่นกัน คุณกำลังเริ่มต้นอักขระบางตัวเท่านั้น
อักขระอื่น
ๆ ทั้งหมดจะว่างเปล่า
ดังนั้นสิ่งที่จะเกิดขึ้นที่นี่คือคอมไพเลอร์จะเริ่มต้นห้าองค์ประกอบแรก
Str ศูนย์ถึง str สี่ อักขระทั้งหมดของค่าคงที่สตริงและสตริงย่อย
5 จะมีอักขระ null
พื้นที่จะยังคงถูกจัดสรรสำหรับองค์ประกอบทั้งหมด 40
รายการในอาร์เรย์ แต่จะมีการใช้เพียงห้ารายการเท่านั้น สี่รายการบวกอักขระว่าง
แนวทางปฏิบัติที่ดีที่สุดของคุณไม่ได้ระบุตัวเลขในขนาดอีกต่อไป เพียงกำหนดตัวอักษรสตริงโดยใช้เครื่องหมายอัญประกาศคู่
นั่นคือสิ่งที่คุณจะเห็นในที่สุด
ตอนนี้ หากคุณไม่ได้เริ่มต้นและเพิ่งสร้างอาร์เรย์อักขระด้วยขนาด
คุณจะใส่วันที่ลงในอาร์เรย์ได้อย่างไร
เพราะเป็นอาร์เรย์ คุณจึงกำหนดข้อมูลไม่ได้
เรารู้ว่าถ้าเรามีอาร์เรย์จำนวนเต็ม เราไม่สามารถกำหนดอาร์เรย์จำนวนเต็มเป็นตัวเลขห้าได้
มันไม่สมเหตุสมผล คุณต้องระบุองค์ประกอบจริง
คุณต้องระบุดัชนี
ดังนั้นคุณจึงไม่สามารถทำอะไรเช่นประกาศอาร์เรย์อักขระที่มีอักขระ 100 ตัวแล้วพูดว่า
s เท่ากับ สวัสดี นั่นจะไม่ทำงาน
เพราะอีกครั้ง s เป็นอาร์เรย์ แม้ว่าจะเป็นสตริงภายในเครื่องหมายคำพูดคู่ แต่ก็ยังเป็นอาร์เรย์ในหน่วยความจำ
ดังนั้น หากคุณกำลังดำเนินการมอบหมาย คุณจะไม่สามารถกำหนดอาร์เรย์ของอักขระหนึ่งให้กับอาร์เรย์ของอักขระอื่นเช่นด้านบน
หากคุณต้องการกำหนดข้อมูลให้กับอาร์เรย์อักขระหลังจากที่คุณได้ประกาศและหลังจากที่คุณได้เริ่มต้นแล้ว คุณต้องใช้ฟังก์ชันพิเศษที่เรียกว่า
str copy
และเราจะพูดถึงเรื่องนั้นในการบรรยายอื่น
จนถึงตอนนี้ เมื่อคุณสร้างสตริง พวกมันจะเป็นตัวอักษรสตริง พวกมันจะอยู่ภายในอัญประกาศคู่
และคุณจะไม่มีวันแก้ไขมัน
ดังนั้นสิ่งนี้จึงถูกต้องสมบูรณ์เช่นกัน คุณสามารถเข้าถึงอักขระเหล่านี้หรือแต่ละองค์ประกอบในอาร์เรย์โดยดัชนีและระบุแต่ละอักขระได้
ดังนั้น s ย่อย 0, s ย่อย 1 แล้วใส่อักขระตัวเดียวในเครื่องหมายคำพูดเดี่ยว
คุณสามารถกำหนดแบบนั้นได้ แต่ลองนึกดูว่าถ้าคุณมีสตริงที่มีขนาด 100 ไบต์
นี่จะใช้โค้ดหลายบรรทัด ดังนั้นคุณไม่ต้องการทำอย่างนั้น
สิ่งที่คุณต้องการทำคือเริ่มต้นเมื่อคุณประกาศว่าไม่มีขนาดแล้วระบุว่าคุณต้องการแก้ไขหรือไม่
str copy
เท่าที่แสดงสตริงเป็นเอาต์พุต เรายังคงใช้ฟังก์ชัน printf นั้นอยู่
เมื่อคุณต้องการอ้างถึงสตริงที่ใดก็ได้ในโปรแกรมของคุณ คุณเพียงแค่ใช้ชื่ออาร์เรย์เพียงอย่างเดียว
คุณไม่จำเป็นต้องระบุดัชนี
เนื่องจากดัชนีภายในอาร์เรย์จะระบุอักขระตัวเดียว
ถ้าคุณต้องการสตริงทั้งหมด คุณเพียงแค่ใช้ชื่ออาร์เรย์
ดังนั้น หากคุณใช้ฟังก์ชัน printf เพื่อแสดงผลลัพธ์
ให้ทำดังนี้ ภายในเครื่องหมายคำพูดคู่
คุณจะใช้เปอร์เซ็นต์ s เป็นตัวระบุรูปแบบของคุณ แล้วตามด้วยชื่อของอาร์เรย์อักขระ
ดังนั้นคุณจึงไม่ปฏิบัติต่อมันเหมือนอาร์เรย์อื่นๆ เมื่อคุณต้องการเข้าถึง เมื่อคุณต้องการเข้าถึงก็เพียงแค่ชื่อที่ไม่มีดัชนีหรือวงเล็บที่แท้จริง
และเปอร์เซ็นต์ที่เป็นตัวระบุรูปแบบใช้สำหรับแสดงสตริงที่สิ้นสุดด้วยค่า
null จำไว้ว่าก่อนที่เราจะใช้เปอร์เซ็นต์ d สำหรับจำนวนเต็ม
คุณสามารถใช้เปอร์เซ็นต์ c สำหรับอักขระได้
สำหรับสตริง คุณใช้เปอร์เซ็น s ซึ่งเป็นอาร์เรย์อักขระ
คาดว่าจะมีสตริงที่สิ้นสุดด้วยค่า null
อย่างไรก็ตาม คุณเริ่มต้นสตริงได้หากคุณไม่มีขนาดและตัวสิ้นสุด null จะถูกเพิ่มโดยอัตโนมัติ
หรือหากคุณสร้างสตริงด้วยขนาดเฉพาะและคุณเพิ่มเข้าไป
หรือหากคุณเพิ่มเข้าไปอย่างชัดแจ้ง ก็ไม่สำคัญ
มันจะต้องถูกยกเลิกเป็นโมฆะ
ฟังก์ชัน printf ถือว่าพบตัวระบุรูปแบบเปอร์เซ็นต์ที่อาร์กิวเมนต์ที่เกี่ยวข้องเป็นสตริงอักขระที่สิ้นสุดโดยอักขระ
null
นั่นคือสิ่งที่มันคาดหวัง มันต้องเป็นเช่นนั้น
ในการป้อนสตริง เรารู้วิธีป้อนข้อมูลชุดอื่นๆ
ผ่านแป้นพิมพ์โดยใช้ scanf
เรากำลังจะทำสิ่งเดียวกันสำหรับการป้อนสตริง
เราจะใช้ฟังก์ชัน scanf ด้วยฟังก์ชัน scanf มันจะเป็นแบบเดียวกัน
เว้นแต่คุณจะใช้ตัวระบุรูปแบบอื่น
สำหรับสตริง คุณจะต้องใช้เปอร์เซ็น s เป็นอินพุต
และใช้สำหรับป้อนสตริง
สิ่งอื่นที่ควรสังเกตที่นี่คือไม่มีเครื่องหมายสำหรับชื่อตัวแปรเพราะเป็นอักขระ
โปรดจำไว้ว่า
เรากล่าวว่าคุณต้องระบุเครื่องหมายและที่อยู่ของโอเปอเรเตอร์ในสตริงเท่านั้น
เหตุผลก็คือเมื่อเราพูดถึงพอยน์เตอร์จะมีความชัดเจนมากขึ้น
แต่การป้อนถ่านแม้ว่าจะเป็นอาร์เรย์ของอักขระ
แต่ก็เป็นตัวชี้และ scanf เนื่องจากอาร์กิวเมนต์ที่สองใช้ตัวชี้
และนั่นคือเหตุผลที่คุณไม่ต้องทำ เมื่อคุณประกาศจำนวนเต็มและคู่ สิ่งเหล่านี้ไม่ใช่ตัวชี้และ
ดังนั้นหากคุณต้องการอ่านอินพุตจากแป้นพิมพ์โดยใช้
scanf อาร์กิวเมนต์ที่สองคาดหวังให้พอยน์เตอร์ที่คุณต้องส่งผ่านไปยังที่อยู่
ตอนนี้เมื่อใช้ scanf เมื่อคุณสร้างสตริง
scanf จะอ่านจนถึงช่องว่างเท่านั้น
ดังนั้นถ้าคุณทำ scanf แล้วพิมพ์ Jason
เป็นผู้สอน
สิ่งเดียวที่จะเก็บไว้ในอินพุตคือเจสัน เพราะเมื่อมันกระทบพื้นที่นั้น
มันจะไม่อ่านส่วนที่เหลือของสตริง
จึงมีฟังก์ชันอื่นๆ ที่คุณสามารถใช้อ่านสตริงทั้งหมดได้
ตัวอย่างบางส่วนที่เราจะใช้อาจจะทำเช่นนั้น คุณสามารถทำสิ่งต่างๆ เช่น f get s ซึ่งเป็นอีกวิธีหนึ่งในการอ่านอินพุตจากแป้นพิมพ์และจะอ่านสตริงทั้งหมดโดยไม่คำนึงถึงช่องว่าง
แต่มีอีกอันหนึ่งที่ฉันคิดว่าเรียกว่า get underscore
s สำหรับ C11 แต่เราจะพูดถึงมากกว่านี้ แต่นั่นเป็นเพียงสิ่งเดียวที่ต้องจำเมื่อคุณอ่านอินพุตสำหรับสตริง
มันจะอ่านจนจบเท่านั้นจนถึงพื้นที่
ลองทดสอบดูว่าสองสตริงเท่ากันหรือไม่
จนถึงจุดนี้ เราได้ทดสอบตัวแปรทั้งหมดเพื่อดูว่ามันเท่ากันหรือไม่
เราแค่ใช้เท่ากับเท่ากับ
แต่ด้วยสตริง วิธีนี้ใช้ไม่ได้ผล
ตัวดำเนินการความเท่าเทียมกัน จำไว้ว่า เราบอกว่าสตริงเป็นอาร์เรย์อักขระ ดังนั้นคุณจึงไม่สามารถใช้ตัวดำเนินการกับตัวดำเนินการเหล่านี้ได้
และตัวดำเนินการความเท่าเทียมกันสามารถใช้ได้กับ int และ doubles หรือ
float หรือ character เท่านั้น
ใช้งานไม่ได้กับโครงสร้างหรืออาร์เรย์ คุณไม่สามารถเปรียบเทียบสองอาร์เรย์ได้
ดังนั้นมันจะไม่ทำงานกับสตริง หากคุณต้องการตรวจสอบว่าสตริงทั้งสองมีค่าเท่ากันหรือไม่
คุณต้องเปรียบเทียบสตริงอักขระสองตัวให้ชัดเจนทีละอักขระ
ดังนั้นคุณต้องดูแต่ละองค์ประกอบในดัชนีอาร์เรย์โดยดัชนี
อย่างไรก็ตาม นั่นเป็นปัญหาใหญ่จริงๆ เพราะมันน่าเบื่อจริงๆ
เราจะพูดถึงวิธีการทำอย่างง่ายดายโดยใช้ฟังก์ชัน
str Compare จากไลบรารีมาตรฐาน แต่คุณไม่สามารถใช้เท่ากับเท่ากับจำไว้
และอีกครั้ง เพื่อเป็นการเตือนความจำ ฉันได้พูดไปแล้วสองสามครั้ง ฉันต้องการพูดอีกครั้ง
ค่าคงที่สตริง x ภายในเครื่องหมายคำพูดคู่ ไม่เหมือนกับค่าคงที่อักขระ
x ภายในเครื่องหมายคำพูดเดี่ยว
X ภายในอัญประกาศเดี่ยวเป็นประเภทพื้นฐาน เป็นแค่ถ่านหรือแคร์
X ภายในเครื่องหมายคำพูดคู่เป็นประเภทไดรฟ์ เป็นอาร์เรย์ประเภทถ่าน
X ภายในเครื่องหมายคำพูดคู่ประกอบด้วยอักขระสองตัวจริงๆ คือ
x และตัวสิ้นสุด null อักขระ null ดังนั้นโปรดระลึกไว้เสมอว่า
นี่คือตัวอย่างวิธีที่เราสามารถสร้างสตริงโดยการประกาศขนาดหรือเริ่มต้นในบรรทัดเดียวกัน
นี่คือแนวทางปฏิบัติที่ดีที่สุด หากคุณกำลังจะใช้ตัวอักษรสตริง สิ่งที่ฉันจะทำคือ
ฉันจะทำในสิ่งที่มันบอกไว้ตรงนี้
สร้างอาร์เรย์อักขระ ไม่ต้องระบุขนาด จากนั้นที่ด้านขวาของตัวดำเนินการกำหนดจะมีเครื่องหมายคำพูดคู่
คอมไพเลอร์จะสร้างสตริงที่ถูกต้องโดยอัตโนมัติและเพิ่มตัวสิ้นสุด null เข้าไป
หากคุณระบุขนาดแล้วคุณมีอักขระไม่เพียงพอ จะไม่มีการจัดเก็บไว้
ดังนั้น เพียงแค่สร้างตัวอักษรสตริงอักขระโดยใช้ชนิดข้อมูล
char ชื่อของตัวแปร และวงเล็บที่ว่างเปล่า
ฉันคิดว่าโปรแกรมนี้จะนับอักขระในอาร์เรย์
ดังนั้นโดยพื้นฐานแล้วจะได้ความยาวของสตริง
สิ่งที่เรากำลังทำอยู่นี้คือ เรากำลังสร้างตัวแปรที่มีชื่อ count ในอาร์เรย์อักขระสองตัวที่มีสตริงที่แตกต่างกันสองสตริง
เป็นหรือไม่เป็น และตามด้วยเครื่องหมายจุลภาคที่เป็นคำถาม
Char str one จะมีเครื่องกำเนิดไฟฟ้ากระแสสลับหลังจาก
b และ str จะมีทางเลือกอื่นหลังจากคำถาม
ดังนั้นเราจึงมีลูปตรงนี้ที่จะผ่านอาร์เรย์แรก
จากการนับเท่ากับศูนย์ตลอดจนเราเห็นตัวสิ้นสุดค่าว่าง
และเราสามารถใช้ not equals ได้ในกรณีนี้ เนื่องจากเรากำลังเปรียบเทียบอักขระ
ตัวสิ้นสุดค่า Null เป็นอักขระ เป็นการดีที่จะเปรียบเทียบตัวละคร
ดังนั้น while loop ของเราจะไปจนสุดจนกว่าเราจะเห็น null terminator
เมื่อเราเห็นเทอร์มิเนเตอร์เป็นโมฆะ เราจะกระโดดออกไป
Count จะเท่ากับจำนวนอักขระในสตริงนั้น
มันคือความยาวของสตริงนั้น
เราทำทั้งสองสาย และคุณจะสังเกตได้ว่าโดยพื้นฐานแล้ว
ทั้งสองสตริงจะมีความยาวที่ถูกต้อง เพราะเราเพิ่งจะผ่านแต่ละอัน
ถึง b กับ b จะเท่ากับ 18
อักขระ
ตอนนี้คุณไม่ต้องทำอะไรแบบนี้อีกแล้วเพราะเรามีฟังก์ชันตัวช่วยที่ดีที่มีความยาว
str เพื่อค้นหาความยาวของสตริง
แต่อีกครั้ง สิ่งที่แสดงให้เห็นคือความจริงที่ว่ามันเป็นอาร์เรย์
และถ้าคุณต้องการเปรียบเทียบหรือค้นหาความยาวของสตริง คุณสามารถใช้
not equals และดูอักขระ null terminator ได้
ฉันหวังว่านี่จะเป็นประโยชน์ นี่คือวิธีที่เราจะกำหนดและเริ่มต้นตัวอักษรสตริง
ขอขอบคุณ.