สวัสดีและยินดีต้อนรับกลับ ฉันต้องการแสดงวิธีแก้ปัญหาสำหรับความท้าทายครั้งก่อนของเราซึ่งเกี่ยวข้องกับการทำความเข้าใจอาร์เรย์อักขระ
โดยพื้นฐานแล้ว เราจะเขียนฟังก์ชันเพื่อรับความยาวของสตริง
ฟังก์ชันเพื่อเชื่อมสตริง และฟังก์ชันเพื่อตรวจสอบว่าสตริงทั้งสองมีค่าเท่ากันหรือไม่
ดังนั้นฉันจะสร้างโครงการ ฉันจะตั้งชื่อมันเพื่อทำความเข้าใจสตริงอักขระ
และอย่างแรกที่เราจะทำคือ เราจะใช้ฟังก์ชันความยาวนี้
เราจะสร้างการประกาศฟังก์ชันสามฟังก์ชันที่ด้านบน
เราจะตั้งชื่อความยาวสตริงแรก
เราจะใช้เคสอูฐในการตั้งชื่อ
นี่เป็นเพียงการใช้สตริงอักขระคงที่
แล้วเราจะรู้ได้อย่างไรว่าเป็นสตริงเพราะเป็นอาร์เรย์อักขระ
แล้วเราจะใส่เครื่องหมายอัฒภาค นั่นจะเป็นคนแรกที่สร้าง ดังนั้นเราจะหยุดเพียงแค่นั้นในตอนนี้
และเราจะสร้างฟังก์ชันนี้
กำหนดไว้ด้านล่าง ดังนั้นคุณควรเข้าใจ
const ของคีย์เวิร์ดที่ดี
Const หมายความว่าเป็นสตริงอักขระที่ไม่สามารถเปลี่ยนแปลงได้ ไม่สามารถแก้ไขได้
เหตุผลที่เราใช้ const ในที่นี้เป็นเพราะเราไม่ต้องการแก้ไขสตริงภายในฟังก์ชัน
เราแค่ต้องการแยกวิเคราะห์โดยพื้นฐานแล้วจึงคืนค่าความยาว
คืนค่าจำนวนเต็ม
ฟังก์ชันนี้ใช้งานได้ง่ายจริง ๆ เพราะเรากำลังดำเนินการผ่านอาร์เรย์
เราสามารถพูดได้ว่าการนับเท่ากับศูนย์
นี่คือตัวแปรท้องถิ่น
ใช้ได้เฉพาะในฟังก์ชันนี้เท่านั้น
ตอนนี้ คุณอาจถามตัวเองว่าทำไมเราถึงใช้ขนาดของโอเปอเรเตอร์ไม่ได้
เพราะขนาดของโอเปอเรเตอร์กำลังจะบอกเราถึงขนาดของสตริง มันจะไม่บอกเราว่ามีอักขระกี่ตัวในสตริงนั้น
แต่สิ่งที่เราต้องทำคือสร้างลูปและผ่านอาร์เรย์จนกว่าเราจะกดจุดสิ้นสุด
null
ดังนั้นเราจึงสามารถดูสตริงของเราได้ เราสามารถพูดได้ว่าจำนวนสตริงไม่เท่ากับตัวสิ้นสุด
null ตัวสิ้นสุด null จะแสดงภายในอักขระตัวเดียวเป็นศูนย์แบ็กสแลช
และเราสามารถใช้โอเปอเรเตอร์ not equals ได้เพราะเรากำลังเปรียบเทียบกับอักขระ
และเรามีเพียงสิ่งเดียวในเนื้อความนี้ ในขณะที่คำสั่งบวกบวกนับ
แค่เพิ่มจำนวน
แล้วเราต้องการคืนมัน เราแค่พูดว่า return Count แค่นั้นเอง
นั่นคือฟังก์ชันความยาวสตริงทั้งหมด มันค่อนข้างง่ายเพราะสตริงอักขระอยู่ภายในอาร์เรย์
และสตริงลงท้ายด้วยตัวสิ้นสุด null
เพื่อทดสอบสิ่งนี้ เราไปและเริ่มวิธีการหลักของเรา และเราสามารถสร้างอักขระคงที่ได้
แค่พูดคำว่า Jason หนึ่งคำ
นี่คือวิธีที่คุณสร้างอาร์เรย์อักขระใน c
คุณไม่จำเป็นต้องมีค่าคงที่ตรงนั้น แต่ค่านี้ไม่ได้ถูกแก้ไข
ใช้คีย์เวิร์ด char ชนิดข้อมูล char ตัวระบุ ตามด้วยวงเล็บ
จะดีกว่าที่จะไม่ระบุขนาดภายในวงเล็บเพราะคอมไพเลอร์
c จะเพิ่มตัวสิ้นสุด null โดยอัตโนมัติ
จากนั้นคุณเพียงแค่ใส่สตริงตามตัวอักษรลงในเครื่องหมายอัญประกาศคู่
เราจะสร้างคู่ที่นี่เพื่อให้แน่ใจว่าใช้งานได้
เราสามารถแสดงสตริงอักขระได้ง่ายมากเพราะเราสามารถใช้สัญลักษณ์เปอร์เซ็นต์ได้
ยกเว้นสิ่งที่เราต้องการแสดงที่นี่คือความยาว
เราจะใช้เปอร์เซ็นต์
d
ดังนั้นเราจะพิมพ์ลิงก์ของสามสตริงนี้
เปอร์เซ็นต์ d แล้วเราจะมีช่องว่างระหว่างนั้น แล้วเพิ่มการป้อนบรรทัด
และนี่จะเรียกฟังก์ชันความยาวสตริงสำหรับแต่ละคำ ง่ายๆ
แค่นี้เอง ตอนนี้เราสามารถสร้างและทดสอบและดูว่ามันใช้งานได้จริงหรือไม่
สิ่งที่เราควรมองว่าเป็นผลลัพธ์คือ เราควรเห็นความยาวของเจสันซึ่งเท่ากับ
5 ความยาวของโอเคคือ 2 และความยาวของสิ่งที่ดูเหมือนประมาณ
8
ตรงนี้เรามี 5, 2 และ 8, ซึ่งดูถูก.
นั่นคือวิธีที่คุณสามารถเขียนความยาวสตริงได้ มาต่อกันที่ฟังก์ชันการต่อกัน
ฟังก์ชันการเรียงต่อกันก็แค่เอาค่าคงที่สามสตริงสองค่ามา
และนี่จะไม่คืนอะไรเลย มันจะใส่สตริงผลลัพธ์ในพารามิเตอร์แรก
เราจะเรียกมันว่าคอนแคท เราจะได้ผลลัพธ์ และเราจะมีสองสตริง
อันหนึ่งที่เราต้องการเชื่อมสองอันเข้าด้วยกัน
และอีกอันที่เราอยากได้แค่สตริงเดียว
ดังนั้นเราจะตั้งชื่อสตริงหนึ่ง สตริงที่สอง
และเราไปที่นั่น และนั่นคือการประกาศฟังก์ชันของเรา
ดังนั้นเราจึงสามารถใช้ที่ใดก็ได้ก่อนที่จะกำหนด
อันนี้จะต้องผ่านอาร์เรย์เช่นกัน มันจะต้องผ่านสองอาร์เรย์และเมื่อเราดำเนินการเพิ่มแต่ละรายการในสตริงผลลัพธ์
เรากำลังจะสร้างตัวแปรโลคัลสองตัว ซึ่งเราสามารถใช้ได้ภายในฟังก์ชันนี้เท่านั้น
int I และ j
จากนั้นเราจะใช้ for
วนรอบอาร์เรย์ เราจะบอกว่า I เท่ากับ 0
Str sub 1 หรือ sub ฉันควรพูดว่าไม่เท่ากับตัวสิ้นสุด
null แล้วเพิ่ม I
เราคุ้นเคยกับไวยากรณ์ for
loop โดยที่เรามีตัวระบุลูปเป็นอย่างแรก
ก่อนเซมิโคลอนแรก เงื่อนไขที่เราข้ามไปก่อนเซมิโคลอนที่สองแล้วแก้ไขตัวแปรควบคุมลูปเพื่อให้แน่ใจว่าเราไม่มีลูปอนันต์
ทั้งหมดที่เราทำคือบันทึกผลลัพธ์
ซับ I เท่ากับ str หนึ่ง ซับ I
จำไว้ว่าสิ่งเหล่านี้คือตัวละคร ดังนั้นมันจึงเป็นเรื่องปกติที่จะใช้การมอบหมายงานที่นี่
เราไม่สามารถทำสิ่งนี้ในอาร์เรย์อักขระได้
เนื่องจากอาร์เรย์อักขระที่คุณไม่สามารถกำหนดอาร์เรย์ให้กับอาร์เรย์ได้
เราจะต้องใช้สำเนา str
นั่นคือการคัดลอกสตริงแรก
และตอนนี้ เราต้องการเชื่อมสตริงที่สองเข้ากับผลลัพธ์
ดังนั้นเราจะทำสิ่งที่คล้ายกันมาก ยกเว้นเราจะดูในอาร์เรย์ที่สอง
และเราจะตรวจสอบให้แน่ใจว่าเราวางมันไว้ในตำแหน่งที่ถูกต้องในผลลัพธ์
ดังนั้นเราจะทำสิ่งนี้ เราจะเปลี่ยนจาก j
เป็นศูนย์ str ถึง j ไม่เท่ากับ null terminator ++j
แล้วคุณจะเห็นผลลัพธ์ก็แค่บอกว่า I บวก j, อะไรก็ตามที่ฉันลงท้ายด้วย
ถ้าฉันเพิ่มอักขระสิบตัว ตอนนี้จะเริ่มที่อักขระตัวที่สิบนั้น
เพราะมันอิงจากศูนย์ และจะเพิ่ม j เข้าไป ดังนั้น
10 บวก 0, 10 บวก 1 และอื่นๆ
และนั่นแหล่ะ
สิ่งสุดท้ายที่คุณต้องทำ ที่สำคัญจริงๆ คือ คุณต้องเพิ่มตัวสิ้นสุดค่าว่างนั้น
ดังนั้นเราจึงต้องการบอกว่าผลลัพธ์ ฉันบวก j แล้วเพิ่มอักขระตัวเดียว
null terminator ซึ่งเป็นศูนย์แบ็กสแลชภายในเครื่องหมายคำพูดเดียว
และนั่นคือหน้าที่ของเรา
เราไม่ต้องส่งคืนอะไรจากฟังก์ชันนี้เพราะเราแค่คัดลอกใน
str 1 ถึง str 2
ลองทดสอบสิ่งนี้กัน
สิ่งที่ฉันคาดหวังจะทำได้ในอันนี้คือทดสอบกับตัวละครสองสามตัว
เราจะใช้ตัวละครที่มีอยู่แล้ว และเราจะเชื่อมกันสองสามตัว
ดังนั้นเราจึงต้องสร้างผลลัพธ์อีกอย่างหนึ่ง
ดังนั้นเราจะบอกว่าผลลัพธ์เพียงเพื่อล้างมัน
ในที่นี้ เราจะบอกว่าเราจะต้องระบุขนาดสำหรับอันแรกนั้น
ดังนั้นเราจะระบุขนาดเป็น 50 เราจะจำกัดมัน
ดังนั้นอักขระคงที่เหล่านี้จึงควรใช้งานได้
ตอนนี้เราจะพูดว่า printf
เราจะพิมพ์สตริง
เราจะบอกว่าเป็นเปอร์เซ็นต์ แล้วเราจะพูดว่า concat
ซึ่งเราตั้งชื่อมันว่า เราจะส่งต่อผลลัพธ์แล้วคำหนึ่งและคำสอง
สิ่งนี้ควรแสดงเป็นเอาต์พุต และเราจะตรวจสอบให้แน่ใจว่าเราใส่มันในบรรทัดใหม่สองสามบรรทัด
สิ่งนี้ควรแสดงเป็นเอาต์พุต Jason โอเค ดังนั้น concat จึงไม่ส่งคืนข้อมูลใด ๆ ดังนั้นฉันจึงไม่สามารถใส่ลงใน
printf โดยตรงได้
สิ่งที่ฉันต้องทำคือเรียกมันแล้วแสดงผล
ที่นั่นเราเรียกว่าคอนแคท
ทุกอย่างถูกใส่ลงในผลลัพธ์และเราจะแสดงผลลัพธ์
อีกครั้งเมื่อเราดำเนินการนี้ เราควรเห็นว่าเจสันโอเคและเราทำได้
ฟังก์ชันที่สามที่เราต้องการนำไปใช้คือฟังก์ชันเปรียบเทียบเพื่อตรวจสอบว่าสองสตริงเท่ากันหรือไม่
ฟังก์ชันนี้ควรส่งคืนบูลีน
ดังนั้นเราจึงต้องการรวมบูลมาตรฐานของเรา
ดังนั้นเราจึงสามารถใช้ค่าบูลีนและค่าจริงและเท็จได้
และนี่จะถูกกำหนดเป็นสตริงที่เท่ากัน
นี่จะใช้อาร์เรย์อักขระคงที่ s1 และอีกอันเพื่อตรวจสอบว่าสองสตริงเท่ากันหรือไม่
เพื่อให้แน่ใจว่าฉันได้ใส่ส่วนหัวที่ถูกต้อง ฉันจะพยายามสร้างมันขึ้นมาและฉันคิดว่าฉันทำได้
เพราะตอนนี้ฉันสามารถใช้คีย์เวิร์ด bool ได้เพราะฉันรวมสิ่งนี้ไว้และฉันก็สามารถใช้
true false ได้
ลองใช้สตริงที่เท่ากันนี้
นี้จะเหมือนกันมากเพียงแค่ผ่านอาร์เรย์และตรวจสอบอักขระแต่ละตัว
เราจะสร้างตัวแปรโลคัลสองตัว
I เท่ากับ 0 สำหรับลูปที่กำหนดค่าเริ่มต้น 0
ในบูลีน ที่บอกเราว่าเท่ากันหรือไม่
เพราะนี่คือสิ่งที่เราจะคืน บางอย่างเช่น เท่ากับ และเราสามารถตั้งค่าเริ่มต้นให้เป็นเท็จได้
สิ่งที่เราอยากทำก่อนคือเราต้องการนับ
เราต้องการที่จะดูว่าทั้งสองมีขนาดใหญ่แค่ไหน
ดังนั้นเราจึงสามารถวนรอบในขณะที่เราต้องการการนับเพื่อดูขนาดโดยพื้นฐานเพื่อตรวจสอบการสิ้นสุดที่เป็นโมฆะ
เราจะถือว่าสตริงที่เราส่งเข้าไปมีขนาดเท่ากัน
เราสามารถเขียน while loop แบบง่ายได้ คุณสามารถเขียนคำสั่ง if ได้เช่นกัน
ฉันรวมทุกอย่างไว้ในลูปในขณะที่เป็นการเปรียบเทียบของฉันโดยใช้ตัวดำเนินการเชิงตรรกะ
คุณไม่จำเป็นต้องใช้ตัวดำเนินการเชิงตรรกะ คุณสามารถใช้คำสั่ง if และอ่านทั้งสตริงที่สองได้
แต่สิ่งที่ผมทำคือผมบอกว่าในขณะที่
s1 ซับ I เท่ากับ s2 ซับ I และพวกมันไม่เท่ากับเทอร์มิเนเตอร์ที่เป็นโมฆะ
เพราะถ้าพวกมันเท่ากับ null terminator
เราอยากจะกระโดดออกมาถ้าตัวใดตัวหนึ่งเป็นโมฆะเทอร์มิเนเตอร์
ทีนี้เราบอกว่า บวก บวก I และสิ่งสุดท้ายที่เราต้องทำคือ ตรวจสอบว่ามันเป็นโมฆะเทอร์มิเนเตอร์หรือไม่
และหากเป็นเช่นนั้น
คุณสามารถตั้งค่าตัวแปรบูลีนให้ส่งคืนข้อมูลที่ถูกต้องได้
ที่นี่เราสามารถพูดได้ว่าถ้า s1 sub I เท่ากับ
null terminator และ s2 sub เท่ากับ null
terminator ตั้งค่าตัวแปรบูลีนของเราเท่ากับ และจากนั้น
เราต้องการคืนค่านั้น
แล้วบอกว่าผลตอบแทนเท่ากับ
และเพื่อทดสอบสิ่งนี้ เราจะต้องทดสอบสตริงที่ดีและสตริงที่ไม่ดี
ต่อไปก็พูดว่าสตริงเท่ากัน
ผมจะพิมพ์เฉพาะค่าจำนวนเต็มของบูลีน เปอร์เซ็นต์
d และเราจะบอกว่าสตริงเท่ากับตรงนี้ นี่ส่งคืนค่าบางอย่าง เพื่อให้เราสามารถใส่ค่านี้ในนิพจน์การพิมพ์
เท่ากับสตริง ฉันแค่ต้องการให้แน่ใจว่าสตริงเท่ากัน
จากนั้นเราจะส่ง เจสันลูกน้ำ เจสัน
และเราจะเรียกมันว่าและครั้งนี้เราจะบอกว่าของเจสัน
และอันแรกควรคืนค่าหนึ่ง ที่สองเพื่อส่งคืนศูนย์
หนึ่งแทนค่าจริง ศูนย์แทนค่าเท็จ
เมื่อเรารันสิ่งนี้ เราจะเห็นหนึ่งและศูนย์
หนึ่งสำหรับจริงและศูนย์สำหรับเท็จยกเว้นว่ามันยากที่จะอ่านเพราะเราไม่มีการป้อนบรรทัด
มาเพิ่มการฟีดบรรทัดและจะแสดงให้คุณเห็นอีกครั้ง
ตอนนี้เราเห็นหนึ่งศูนย์
จริง เท็จ Jason Jason มีความเท่าเทียมกัน
เจสันของเจสันไม่เท่ากัน
ฟังก์ชันเหล่านี้เป็นฟังก์ชันด่วนที่คุณสามารถเรียนรู้ได้ในขณะนี้
เรียนรู้โดยทั่วไปเกี่ยวกับอาร์เรย์อักขระและวิธีแสดงสตริงด้วยแนวคิดนี้
ขอขอบคุณ. ฉันจะให้ไฟล์ต้นฉบับด้วย เพื่อให้คุณสามารถดูรายละเอียดเพิ่มเติมได้
หวังว่านี่จะช่วยคุณได้