สวัสดีและยินดีต้อนรับกลับ
ในการบรรยายครั้งนี้ ฉันต้องการ เพื่อพูดคุยเกี่ยวกับวิธีที่เราสามารถอ่านข้อความจากไฟล์ได้
ตอนนี้เรากำลังจะไป เน้นการอ่านไฟล์ข้อความ
ดังนั้นถ้าเราต้องการอ่านตัวอักษร จากไฟล์ข้อความ เราจะใช้ฟังก์ชันสองสามอย่าง
ตัวแรกจะเป็น fgetc
สิ่งนี้จะอ่านตัวอักษรจากข้อความ ไฟล์ที่เปิดอ่านได้
จำไว้เราต้องเปิดเสมอ ขึ้นไฟล์ก่อนที่เราจะสามารถดำเนินการกับไฟล์ใด
ๆ ได้เว้นแต่ เป็นการเปลี่ยนชื่อหรือลบแล้วไฟล์ไม่สามารถเปิดได้
แต่ถ้าอยากอ่านหนังสือ และเขียนหรือต่อท้ายเราต้องเปิดไฟล์นั้น
เรารู้ว่าเราเปิดใจได้ ไฟล์ที่มีโหมดต่างๆ
ในกรณีนี้สำหรับการอ่านเราจะมี เพื่อเปิดด้วย r หรือ r plus
แล้วเราก็เริ่มเรียก fgetc ได้
ฟังก์ชัน fgetc รับ ตัวชี้ไฟล์เป็นอาร์กิวเมนต์เดียวและจะส่งคืน
อักขระที่อ่านเป็นชนิด int
นี่คือตัวอย่าง เราสร้าง mchar พิมพ์ int และเราพูดว่า fgetc pfile
มันจะอ่านตัวอักษร ลงในตัวแปร mchar ด้วย pfile
เป็นตัวชี้ไฟล์
คิดถึง pfile แล้ว เปิดกลับไปที่ตัวชี้ไฟล์
mchar เป็นประเภทเพราะ eof ซึ่งเป็นอักขระพิเศษของเรา
สิ้นสุดไฟล์ ที่ส่งคืน if ถึงจุดสิ้นสุดของไฟล์แล้ว
เพื่อให้เราตรวจสอบได้เสมอว่า จำนวนเต็มเพื่อดูว่าเป็น eof หรือไม่
และถ้าใช่เราก็ไม่ต้องการ เพื่ออ่านอีกต่อไป
เราไม่ต้องการเรียก fgetc อีกต่อไป
ฟังก์ชัน fgetc ซึ่งก็คือ เทียบเท่ากับ fgetc ก็มีให้เช่นกัน
ดังนั้น getc เกือบจะเหมือนกับ fgetc คุณแค่ต้องการใช้ fgetc
คิดว่ามีบ้าง การป้องกันเพิ่มเติมในนั้น
ด้วย getc มันต้องมีอาร์กิวเมนต์ ของประเภทไฟล์ติดดาวและส่งคืนอักขระสีแดงเป็นประเภท
int
มันแทบจะเหมือนกับ fgetc
ความแตกต่างเพียงอย่างเดียวระหว่างพวกเขา คือ getc นั้นอาจถูกนำไปใช้เป็นมาโครและเราไม่ได้
รู้ว่าตอนนี้มาโครคืออะไร
ดังนั้นเราจะยึดติดกับ ใช้ fgetc เป็นฟังก์ชันของเราในการอ่านตัวอักษร
คุณสามารถอ่านเนื้อหาของไฟล์
อีกครั้งเมื่อจำเป็น คุณสามารถใช้ ฟังก์ชั่นกรอกลับนี้ซึ่งวางตำแหน่งไฟล์ที่ระบุโดย
file ตัวชี้ไปที่จุดเริ่มต้นของไฟล์
ดังนั้นคุณสามารถใช้การกรอกลับ if คุณต้องการที่จะอ่านอีกครั้ง
แค่พูดว่ากรอกลับแล้ว ตัวชี้ไฟล์ค่อนข้างพื้นฐาน
นี่คือตัวอย่าง
คุณต้องรวม ส่วนหัว io มาตรฐานทุกครั้งที่เราดำเนินการกับไฟล์ใดๆ
ในหน้าที่หลักของเรา เราคือ จะสร้างตัวชี้ไฟล์ของเรา
ถ้าฉันต้องการเริ่มต้นสิ่งนี้เป็นโมฆะ และเราจะสร้างจำนวนเต็ม
สิ่งแรกที่เราจะทำคือเรา จะไปเปิดไฟล์โดยใช้
f open call และเราจะระบุ ชื่อของไฟล์และเราจะระบุว่าเป็นไฟล์สำหรับอ่าน
ที่จะส่งคืนตัวชี้ไฟล์ของเรา
ตอนนี้ตัวชี้ fp ของเราคือ ชี้ไปที่ไฟล์ที่ถูกต้อง
หากไม่สามารถเปิดไฟล์ได้ txt นั่นไม่อยู่ในเส้นทางที่ถูกต้องหรืออะไรก็ตาม
มันจะคืนค่าเป็นโมฆะ
คุณต้องการตรวจสอบค่า null ตรวจสอบให้แน่ใจว่า fp ไม่เป็นโมฆะ
หากเป็นโมฆะ ให้ออกจากโปรแกรม
มิฉะนั้นเมื่อคุณมักจะ อ่านอักขระ คุณจะมีพวกมันอยู่ในลูป
ในที่นี้เรากำลังพูดว่าในขณะที่ค เท่ากับ fgetc fp นี่คือการอ่านอักขระจากไฟล์ของเรา
ส่งตัวชี้ไฟล์ไปที่ fgetc ซึ่งส่งคืนจำนวนเต็ม
จำไว้ว่าเราสามารถกระโดดออกจากวงได้ ถ้าจำนวนเต็มนั้นกลับมาเป็นจุดสิ้นสุดของไฟล์เพราะเราไม่ต้องการ
เพื่ออ่านส่วนท้ายของไฟล์
ไม่งั้นก็ปริ้นออกมาได้ ตัวละครของเราโดยใช้เปอร์เซ็นต์ c และ c
สิ่งสุดท้ายที่เราต้องการจะทำคือเรา ต้องการปิดไฟล์ จากนั้นเราต้องการตั้งค่าตัวชี้ไฟล์ของเรา
เป็นโมฆะและเราสามารถส่งคืนได้
ลองใช้สิ่งนี้สร้าง นี้ภายในบล็อกรหัส
นี่คือโปรแกรมของเราภายในบล็อคโค้ด
มันบอกว่าโปรแกรมนี้จะไม่ไป ทำงานได้เว้นแต่เราจะมีไฟล์อยู่บนดิสก์ทุกที่ที่โปรแกรมทำงานอยู่
ก่อนอื่นถ้าเราสร้างสิ่งนี้ มันควรจะสร้างได้ มันควรจะสร้างไฟล์ปฏิบัติการ
ที่ไหนสักแห่งบนฮาร์ดไดรฟ์ของคุณ
ฉันได้วางโครงการทั้งหมดของฉันแล้ว ภายในไดเร็กทอรีสินเชื่อดอทของฉัน
ดังนั้นถ้าฉันไปที่ดาวน์โหลดของฉัน ไดเร็กทอรีและฉันไปที่ชื่อโครงการซึ่งนี่เป็นเพียงการทดสอบ
โครงการดังนั้นทุกที่ที่คุณจัดเก็บโครงการของคุณอยู่ในการทดสอบ
ถ้าฉันไปสอบคุณจะเห็น ที่ภายในไดเร็กทอรี bin ภายใน debug เป็นไฟล์ปฏิบัติการของคุณ
นี่คือที่ที่คุณสร้าง ไฟล์ถ้าคุณมีญาติ
เส้นทางดังนั้นที่นี่ฉันสามารถสร้าง a . ได้ ไฟล์ใหม่และเราสามารถมีเป็นไฟล์ข้อความได้
ดังนั้นผมจึงสามารถสร้างเป็นข้อความได้ เอกสารและจะต้องตั้งชื่อไฟล์
แล้วฉันจะใส่ ข้อมูลบางอย่างในนั้น
เดี๋ยวจะลงข้อมูลให้นะคะ อย่างเช่นสวัสดี นี่คือเจสันไลน์ฟีด
โอเค ไม่เป็นไร ต่อไป และฉันจะรักษามันไว้
ไฟล์นี้จะต้องมีอยู่ใน เพื่อให้โปรแกรมนี้ทำงานได้
ดังนั้นฉันจึงสร้างไฟล์.
ตอนนี้เมื่อฉันเรียกใช้หวังว่า มันจะอ่านสิ่งที่ฉันเพิ่งเพิ่มเข้าไปและพิมพ์ออกมา
มันขึ้นว่า error และการเปิดไฟล์ file ไม่มีไดเร็กทอรีไฟล์ดังกล่าว
และนั่นอาจเป็นเพราะฉัน มีไว้ในโฟลเดอร์ debug
และสิ่งนี้ไม่ได้ทำงานอยู่ในการดีบัก
ลองเรียกใช้ในดีบักและ ฉันคิดว่ามันน่าจะใช้ได้ตอนนี้
เราสามารถพูดดีบั๊ก เริ่มเลย
สิ่งนี้จะมองหาไฟล์ปฏิบัติการ ในไดเร็กทอรี debug หวังว่า
เราต้องการให้แน่ใจว่ามันทำงาน
ยังไม่ถึงไหนก็ต้องทำให้ แน่ใจว่าคุณรู้ว่าไฟล์ปฏิบัติการอยู่ที่ไหน
ลองที่อื่นหรือ ดีกว่า แต่ฉันสามารถเรียกใช้ไฟล์ปฏิบัติการได้ภายใน
debug ไดเร็กทอรีและควรค้นหาที่นั่น
ถ้าผมดับเบิลคลิกตรงนี้ จริงๆมันไม่หยุด
มันกระโดดออกมา
สิ่งที่คุณทำได้คือ แทนที่จะกลับมา
คุณสามารถพูดว่าระบบหยุดชั่วคราวและจะไม่ออก โปรแกรมจนกว่าคุณจะเรียกใช้
ตอนนี้เรามาลองกัน
ตอนนี้หยุดชั่วคราวไม่ได้ รันโปรแกรม
และสิ่งที่คุณเห็นก็คือ สวัสดี นี่คือเจสัน
มันสามารถค้นหาไฟล์, พิมพ์ออกมาโอเค พิมพ์ออกมาแล้วหยุดชั่วคราว
มิฉะนั้น เมื่อคุณดำเนินการ โปรแกรมจะพิมพ์ข้อมูลอย่างรวดเร็วและออกจาก
โปรแกรมที่คุณทำเสร็จแล้ว
นั่นคือวิธีที่คุณสามารถทดสอบได้
จะต้องเก็บไว้ในที่ที่ปฏิบัติการได้ ถูกเก็บไว้ที่ที่มันวิ่งจาก
มันคงวิ่งมาจากที่ไหนสักแห่ง อื่น ๆ ในไดเรกทอรีโครงการของคุณ
ฉันไม่แน่ใจว่ามันวิ่งมาจากไหน
เราสามารถลองย้ายไฟล์ ว่าซอร์สโค้ดอยู่ที่ไหน
มันอาจจะวิ่งจากที่นี่
ดังนั้นเราจะใส่ไว้ที่นี่
และตอนนี้เราจะลองเรียกใช้จาก ID และอาจใช้งานได้
เราไม่สร้าง
เราเรียกใช้และมันสามารถค้นหาได้
ดูเหมือนว่าเรามี เพื่อวางไฟล์ไว้ในตำแหน่งที่ซอร์สโค้ดอยู่
ตราบใดที่เราใส่ไฟล์นั้น ไฟล์. ข้อความภายในไฟล์โครงการ
คุณจะสามารถดูได้
ตัวอย่างอย่างรวดเร็วของวิธีการที่คุณสามารถ เปิดไฟล์และอ่านตัวอักษรตัวเดียวไม่มีประสิทธิภาพมากที่สุด
วิธีอ่านจากไฟล์เพราะโดยปกติคุณต้องการอ่านสตริง
แต่สิ่งนี้จะเปิดขึ้น
คุณเห็น f เปิดสายและ คุณสังเกตเห็นวง while
นั่นเป็นสิ่งสำคัญ
กลับมาคุยกันว่าเป็นยังไงบ้าง เราสามารถอ่านสตริงจากไฟล์ที่มีประสิทธิภาพมากขึ้น
นั่นคือการอ่านตัวอักษรตัวเดียว
การอ่านสตริงเป็นอย่างไร?
คุณสามารถใช้ฟังก์ชัน fgets เพื่ออ่านจากไฟล์หรือสตรีมใด ๆ
สิ่งนี้จะอ่านสตริง
ต้องใช้สตริงอักขระ มีพารามิเตอร์แรก
จำนวนตัวอักษรที่คุณต้องการ อ่านแล้วชี้ไฟล์จริง
ฟังก์ชันนี้จะไป อ่านสตริงในพื้นที่หน่วยความจำที่ชี้โดย
str
ดังนั้นคุณต้องจริง ส่งผ่านในบัฟเฟอร์ที่จะจัดเก็บข้อมูล
และนั่นคือตัวชี้ ดังนั้นคุณจะ ต้องจัดสรรหน่วยความจำสำหรับมัน
แล้วจะอ่านจาก ไฟล์ที่ระบุเป็นพารามิเตอร์ที่สามซึ่งเป็นตัวชี้ไฟล์
แล้ว nchar กำลังจะไป เพื่อบอกว่าต้องอ่านข้อมูลมากน้อยเพียงใด
ดังนั้นถ้าคุณใส่ nchars เช่น 10 มันจะอ่านได้ 10 ตัวอักษร เว้นแต่ว่ามันจะกดขึ้นบรรทัดก่อน
มันจะอ่านว่า ทั้งบรรทัดหรือจะอ่านจำนวนตัวอักษรที่คุณ
ระบุในพารามิเตอร์ที่สอง
จุดสิ้นสุดของบรรทัดถูกระบุโดย แบ็กสแลช n แล้วแต่ว่าอย่างใดเกิดขึ้นก่อน
หากอักขระขึ้นบรรทัดใหม่เป็นสีแดง มันถูกเก็บไว้ในสตริงและเทอร์มิเนเตอร์
null จะเป็น ต่อท้ายสตริง
ดังนั้นหากคุณระบุจริงๆ ตัวอักษรมากขึ้นก็จะอ่านถึงบรรทัดฟีดแล้ว
กระโดดออกมาแล้วได้อักขระขึ้นบรรทัดใหม่แล้ววาง
a อักขระ null ที่ส่วนท้ายของมัน
หากไม่มีข้อผิดพลาด fgets is จะส่งกลับตัวชี้ซึ่งเป็นพารามิเตอร์แรก
มันจะส่งคืนตัวชี้ซึ่ง รับกลับจากฟังก์ชัน
แล้วมันก็ยังไป เพื่อเติมตัวชี้ str เป็นพารามิเตอร์แรก
หากมีข้อผิดพลาดจะส่งกลับค่า null
แล้วอ่านท้ายไฟล์ ทำให้คืนค่า null ซึ่งหมายความว่าคุณอ่านสตริงทั้งหมดของคุณ
ลองมาดูตัวอย่างกัน
ที่นี่เรามีหลักของเราและ เรากำลังสร้างตัวชี้ไฟล์ของเราสร้างสตริงอักขระ
นี่คือตัวชี้ที่เราไม่ได้ mallocate ข้อมูลใด ๆ สำหรับมัน เราแค่สร้างอาร์เรย์อักขระ
เราเปิดไฟล์เพื่ออ่าน อ่านอย่างเดียวเพราะมันเป็น r
เราบอกว่าถ้ามันเป็นโมฆะให้กระโดดออกมา
มิฉะนั้นเราเพียงแค่พูดว่า fgets, เราอ่านใน 60 ตัวอักษร
หรือถ้าไลน์ฟีดมาก่อน ว่าการป้อนบรรทัดจะปรากฏขึ้นจากนั้นจะพิมพ์ออกมาและ
มีอะไรอยู่ในบัฟเฟอร์ str
str คืออันนั้นก่อน ตัวละครที่ผ่านเข้ามา
จากนั้นเราก็ปิดตัวชี้ไฟล์ ตั้งค่าเป็น null และคืนค่าศูนย์
เลยมาดูอีกที สิ่งนี้ภายในโค้ดของเราบล็อก IDE
สิ่งเดียวที่เปลี่ยนไปในนี้ โปรแกรมเป็นบรรทัดที่ 14 ถึง 17 จริงๆ
เรากำลังใช้ fgets เพื่ออ่านสตริงของเรา ใน แล้วเราก็มีบัฟเฟอร์ str
เราจึงต้องสร้าง a . ด้วย อาร์เรย์อักขระบนนี้ซึ่งเป็น
str ของเรา และเราต้องการให้มี 60
เรากำลังอ่านใน 60
เราจะเพิ่มการฟีดบรรทัด ดังนั้นมันจึงเป็น กำลังจะอ่านใน 59 แล้วเพิ่มการป้อนบรรทัดต่อท้าย
เราก็บอกว่า 61 ได้.
จากนั้น fgets ก็จะเข้า if คำสั่งและมันจะอ่านในแต่ละสตริงจนกว่าจะถึงเช่นกัน
ถึง 60 อักขระหรือขึ้นบรรทัดใหม่ และมันจะพิมพ์สตริงนั้นออกมา
คุณจะสังเกตเห็นว่าไม่ใช่ a while loop ดังนั้นเราจึงไม่อ่านจนจบไฟล์
เราอ่านตอนจบของ ไฟล์เราได้รับค่า null
ดังนั้นถ้าเราสร้างสิ่งนี้ เราต้องการสร้าง แน่ใจว่าเรามีคำพูดของเราอย่างถูกต้อง
เมื่อใดก็ตามที่คุณคัดลอกจาก powerpoint มันเลอะคำพูด
และเราต้องการให้แน่ใจว่า เราสร้างตัวแปร c ของเรา ไม่ได้ใช้
ไม่เป็นไร
ไปข้างหน้าและดำเนินการนี้
และคุณเห็นว่าสวัสดีนี่คือเจสัน
จริงๆแล้วอ่านทั้งหมด บรรทัดข้อความจากไฟล์
มันอ่านอยู่บรรทัดแรก
แล้วคุณจะเรียกมันอีกครั้ง และอ่านในบรรทัดที่สอง
หากคุณเปลี่ยนจำนวนไบต์ อ่านว่า เราแค่อยากอ่าน
10 มันจะอ่านใน 10 แล้วก็มัน จะส่งคืน 10 ตัวนั้นแทนที่จะอ่านทั้งบรรทัด
แค่นี้เราก็มีแล้ว สวัสดีนี่ฉัน
มันจะอ่านเป็นเลข ของอักขระ พารามิเตอร์ที่สองของคุณหรือจนกว่าจะได้บรรทัด
ฟีดและเก็บมันไว้ใน str.
Str เป็นอาร์เรย์อักขระ
เราพิมพ์ออกมา
Fgets มีมากขึ้น มีประสิทธิภาพในการอ่าน
เพราะเราไม่ได้อ่าน ตัวละคร และในแต่ละครั้ง
เรากำลังอ่านข้อมูลเพิ่มเติม
การอ่านตัวอักษรใน a เวลาไม่มีประสิทธิภาพ
ตอนนี้เรารู้วิธีอ่านคนเดียวแล้ว ตัวอักษรเรารู้วิธีอ่านสตริงจนอ่านใหม่
บรรทัดหรือจำนวนอักขระ
แต่คุณยังสามารถอ่านใน อินพุตที่จัดรูปแบบจากไฟล์
เรามี getc, fgetc, fgets
และตอนนี้เรามีอีก ฟังก์ชันที่เรียกว่า fscanf
นี่คือรูปแบบอินพุต
อินพุตที่จัดรูปแบบเป็นข้อมูลที่ระบุ โดยชอบมีตัวคั่นหรือมีรูปแบบเฉพาะที่เกี่ยวข้อง
ฟังก์ชัน fscanf นี้รับไฟล์ จากกระแสแล้วรูปแบบ
รูปแบบก็เหมือนกับ printf ตัวระบุรูปแบบที่คุณใช้
ดังนั้นหากต้องการอ่านเป็นจำนวนเต็ม หรือแบบคู่ ก็สามารถระบุข้อมูลภายในไฟล์ที่จะแนะนำได้
เป็นสองเท่าและมันจะอ่านว่าจนกว่าจะเห็นเหมือน
scanf จนกระทั่งเห็นอักขระช่องว่าง
ดังนั้นอาร์กิวเมนต์แรกของfscanf ฟังก์ชั่นเป็นตัวชี้ไปยังวัตถุไฟล์ที่ระบุสตรีม
เราต้องรู้ว่าอะไร ไฟล์ที่เรากำลังอ่านจาก.
อาร์กิวเมนต์ที่สองของ ฟังก์ชั่นเป็นรูปแบบ
นี่คือสตริง c ที่มี อย่างน้อยหนึ่งรายการต่อไปนี้
อักขระช่องว่างสีขาว ไม่ใช่ช่องว่าง อักขระ ตัวระบุรูปแบบ
การใช้งานเหมือนกับ scanf และ the ใน printf
แต่มาจากไฟล์แทน
ดังนั้นภายในเครื่องหมายคำพูดคู่ คุณสามารถ ใส่ข้อความ คุณสามารถใส่อักขระช่องว่างหรืออักขระที่ไม่ใช่ช่องว่าง
แต่ ตัวระบุรูปแบบเป็นวิธีที่คุณจะอ่านในข้อมูลจริงๆ
แล้วคุณระบุตัวแปร ที่คุณต้องการอ่านเข้าไป
ดังนั้นฟังก์ชันจะกลับคืนมา จำนวนรายการอินพุตที่จับคู่และกำหนดสำเร็จ
นี่คือสิ่งที่ดูเหมือน
คุณจะสังเกตเห็นว่าหลักคือ สร้างอาร์เรย์อักขระสามตัว str1, str2 และ str3
โดยแต่ละชุดมีขนาดเพียงสิบไบต์
เราสร้างจำนวนเต็มที่เรียกว่า ปี เรากดตัวชี้ไฟล์
สิ่งแรกที่เราทำ เราเปิดไฟล์.
ในกรณีนี้เรากำลังเปิด มันขึ้นสำหรับการอ่านและการเขียน
แต่เราจะไม่เขียนจริงๆ อะไรก็ได้ที่เราจะแสดงสิ่งที่เรากำลังอ่านจากมัน
เราตรวจสอบเพื่อให้แน่ใจว่าไฟล์ ตัวชี้ไม่เท่ากับโมฆะ
แล้วนี่เราจริง ใส่บางอย่างลงในไฟล์ fputs
เรายังไม่ได้พูดถึงเรื่องนั้นเลย แต่นี่กำลังเขียนอะไรบางอย่าง
โฟกัสที่นี่ที่ fscanf
fscanf กำลังไปที่ อ่านในข้อมูลที่จัดรูปแบบ
แล้วจะทำไงดี มันจะอ่านเป็นสามสตริงโดยคั่นด้วยช่องว่าง
แล้วคุณจะเห็นเปอร์เซ็นต์ เป็นเปอร์เซ็นต์ของพื้นที่ เป็นเปอร์เซ็นต์ของพื้นที่
เป็นเปอร์เซ็นต์ของพื้นที่ d
แล้วเราก็บอกว่าเราอยู่ที่ไหน จะอ่านมันในอาร์เรย์อักขระสามตัวของเราแล้วของเรา
ปี และเราต้องระบุตัวดำเนินการที่อยู่สำหรับปีของเรา
แต่ข้อมูลอยู่ในรูปแบบ a วิธีเฉพาะเมื่อเขียน
และเมื่อคุณอ่านในสิ่งที่ จัดรูปแบบ คุณต้องเข้าใจรูปแบบของไฟล์ว่าเขียนอย่างไร
ที่นี่เรารู้ว่าไฟล์ถูกเขียนขึ้น โดยการแยกสตริงด้วยช่องว่าง
เราก็เป็นอย่างนั้น จะเข้าไปอ่านใน
แล้วเราจะได้อ่านกัน ด้วยการโทรเพียงครั้งเดียว fscanf
เราสามารถใช้แบบฟอร์มของเราเป็นตัวระบุได้ เป็นอาร์กิวเมนต์ที่สองของเราแล้วตามด้วยจำนวนตัวแปรของอาร์กิวเมนต์สำหรับแต่ละ
คั่นแต่ละจุลภาคเพื่อระบุข้อมูลที่เราต้องการจะอ่าน
แล้วเราก็พิมพ์ออกมาว่า data สามสตริงในปีนั้นแล้วปิดไฟล์อีกครั้ง
และนี่คือสามวิธี คุณสามารถอ่านข้อมูลจากไฟล์
คุณสามารถอ่านเป็นตัวอักษร คุณสามารถอ่านเป็นสตริงหรืออ่านข้อมูลที่จัดรูปแบบได้
และคุณจะสังเกตเห็นวิธีการจัดรูปแบบ การทำนั้นคล้ายกับ scanf มาก
คุณใช้ตัวระบุรูปแบบ ตัวแปรที่จะอ่านเข้าไป
เราจะมีความท้าทายใน การอ่านข้อมูลซึ่งจะทำให้คุณคุ้นเคยกับสิ่งนี้มากขึ้น
มันค่อนข้างพื้นฐาน
คุณกำลังจะทำการเปิดของคุณ โทร คุณจะใช้พอยน์เตอร์ของไฟล์และกำลังจะไป
เพื่อใช้ฟังก์ชันทั้งสามนี้
ขอขอบคุณ.