1. การทำงานกับไฟล์ในภาษา C (ใช้ได้กับ C++ ด้วย)
#รวม
#รวม
โมฆะหลัก (เป็นโมฆะ)
{
ไฟล์ *ไฟล์;
ถ่าน* file_name = "file.txt";
ถ่าน load_string = "ไม่มี";
ไฟล์ = fopen(file_name, "w");
Fputs("string", ไฟล์);
ไฟล์ = fopen(file_name, "r");
ถ้า (ไฟล์ != 0)
{
fgets(load_string, 50 , ไฟล์);
ศาล)
อื่น
{
ศาล)
fclose (ไฟล์);
) คำอธิบายฟังก์ชั่นสำหรับการทำงานกับไฟล์อยู่ในไลบรารี stdio.h
ก่อนอื่นคุณต้องสร้างตัวชี้ไปยังตัวแปรประเภท FILE ( ไฟล์ไฟล์*;).
การเปิดไฟล์ทำได้โดยการเรียกใช้ฟังก์ชัน fopen ( file = fopen(file_name, "w");)
พารามิเตอร์แรกของฟังก์ชันนี้คือชื่อไฟล์ โดยพารามิเตอร์ตัวที่สองระบุว่าควรเปิดไฟล์ในโหมดใด "ว"- เปิดสำหรับการบันทึก "ร"- เปิดให้อ่าน "ก"- การเพิ่มไฟล์ (เป็นโหมดที่ใช้มากที่สุดแม้ว่าจะมีโหมดอื่น ๆ ก็ตาม) การเขียนและการอ่านข้อมูลจากไฟล์จะดำเนินการโดยฟังก์ชันต่อไปนี้: fputc, fputs, fgetc, fgets, fprintf, fscanf(สำหรับคำอธิบายของฟังก์ชันเหล่านี้ โปรดดู stdio.h).
การปิดไฟล์ทำได้โดยการเรียกใช้ฟังก์ชัน fclose ( fclose (ไฟล์);).
ไลบรารี MFC มีหลายคลาสสำหรับการทำงานกับไฟล์ คลาสที่กล่าวถึงด้านล่างนี้สืบทอดมาจากคลาสพื้นฐานการทำงานกับไฟล์โดยใช้ MFC (คลาส CFile, CStdioFile, ... ) และคลาส MFC มาตรฐาน CFileDialog
คลาส CF ile
ซีไฟล์ออกแบบมาเพื่อทำงานกับไฟล์ ทำให้ไฟล์ใช้งานได้ง่ายขึ้นโดยการแสดงไฟล์เป็นออบเจ็กต์ที่สามารถสร้าง อ่าน เขียน ฯลฯในการเข้าถึงไฟล์ คุณต้องสร้างอ็อบเจ็กต์ของคลาส CFile ก่อน ตัวสร้างคลาสช่วยให้คุณสามารถเปิดไฟล์ได้ทันทีหลังจากสร้างวัตถุดังกล่าว แต่คุณสามารถเปิดไฟล์ได้ในภายหลังโดยใช้วิธีการ
เปิด.การเปิดและสร้างไฟล์
หลังจากสร้างวัตถุคลาสแล้ว ซีไฟล์คุณสามารถเปิดไฟล์ได้โดยการเรียกเมธอดเปิด- วิธีการจะต้องระบุเส้นทางไปยังไฟล์ที่จะเปิดและโหมดการใช้งาน ต้นแบบวิธีการเปิดมีแบบฟอร์มดังนี้
เปิดบูลเสมือน (LPCTSTR lpszFileName, UINT nOpenFlags, CFileException * pError = NULL); เนื่องจากเป็นพารามิเตอร์ lpszFileName คุณต้องระบุชื่อของไฟล์ที่จะเปิด คุณสามารถระบุเพียงชื่อไฟล์หรือชื่อไฟล์เต็มที่มีเส้นทางแบบเต็มได้ พารามิเตอร์ตัวที่สอง nOpenFlags ระบุการดำเนินการที่เมธอด Open ดำเนินการกับไฟล์ รวมถึงแอตทริบิวต์ของไฟล์ ด้านล่างนี้เป็นค่าที่เป็นไปได้สำหรับพารามิเตอร์ nOpenFlags:
พารามิเตอร์เผื่อเลือก pError ซึ่งเป็นตัวชี้ไปยังอ็อบเจ็กต์คลาส CFileExceptionจะใช้เฉพาะในกรณีที่การดำเนินการกับไฟล์จะทำให้เกิดข้อผิดพลาด ในกรณีนี้ ข้อมูลเพิ่มเติมจะถูกเขียนไปยังวัตถุที่ชี้ไปโดย pError
วิธี เปิดส่งคืนค่าที่ไม่ใช่ศูนย์หากไฟล์เปิดอยู่และมีข้อผิดพลาดเป็นศูนย์ ข้อผิดพลาดในการเปิดไฟล์อาจเกิดขึ้นได้ เช่น ถ้ามีการระบุวิธีการเปิดเพื่ออ่านไฟล์ที่ไม่มีอยู่จริง
เปิดไฟล์ ID
คลาส CFile มีองค์ประกอบข้อมูล m_hFile ประเภท UINT มันเก็บตัวระบุของไฟล์ที่เปิด ถ้าวัตถุของคลาส CFile ถูกสร้างขึ้นแล้ว แต่ยังไม่ได้เปิดไฟล์ ดังนั้นค่าคงที่ hFileNull จะถูกเขียนในตัวแปร m_hFile
โดยทั่วไปแล้วตัวระบุไฟล์ที่เปิดจะไม่ถูกใช้โดยตรง วิธีการเรียน ซีไฟล์อนุญาตให้คุณดำเนินการเกือบทุกอย่างกับไฟล์และไม่จำเป็นต้องระบุตัวระบุไฟล์ เนื่องจาก m_hFile เป็นองค์ประกอบของคลาส การใช้เมธอดจึงสามารถเข้าถึงได้ฟรีเสมอ
กำลังปิดไฟล์
หลังจากทำงานกับไฟล์เสร็จแล้วจะต้องปิดมัน ระดับ ซีไฟล์มีวิธีการปิดแบบพิเศษสำหรับสิ่งนี้ ควรสังเกตว่าถ้าวัตถุของคลาส CFile ถูกสร้างขึ้นและเปิดไฟล์แล้ววัตถุนั้นถูกลบ ไฟล์ที่เกี่ยวข้องจะถูกปิดโดยอัตโนมัติโดยใช้ destructor
การอ่านและการเขียนไฟล์
มีหลายวิธีในการเข้าถึงไฟล์ในชั้นเรียน ซีไฟล์: อ่าน, อ่านมหาศาล, เขียน, เขียนมหาศาล, ฟลัช- วิธีการ อ่านและอ่านมากได้รับการออกแบบมาเพื่ออ่านข้อมูลจากไฟล์ที่เปิดก่อนหน้านี้ บนระบบปฏิบัติการ 32 บิต ทั้งสองวิธีสามารถอ่านจากไฟล์ได้มากกว่า 65535 ไบต์พร้อมกัน ข้อกำหนด ReadHuge ถือว่าล้าสมัยและคงไว้เพื่อความเข้ากันได้กับระบบปฏิบัติการ 16 บิตเท่านั้น
ข้อมูลที่อ่านจากไฟล์จะถูกเขียนไปยังบัฟเฟอร์ lpBuf พารามิเตอร์ nCount ระบุจำนวนไบต์ที่จะอ่านจากไฟล์ ในความเป็นจริง อาจอ่านไบต์จากไฟล์ได้น้อยกว่าที่พารามิเตอร์ nCount ร้องขอ สิ่งนี้จะเกิดขึ้นหากถึงจุดสิ้นสุดของไฟล์ระหว่างการอ่าน วิธีการส่งคืนจำนวนไบต์ที่อ่านจากไฟล์
เมธอด Write และ WriteHuge มีไว้สำหรับการเขียนลงไฟล์ บนระบบปฏิบัติการ 32 บิต ทั้งสองวิธีสามารถเขียนข้อมูลลงในไฟล์ได้มากกว่า 65535 ไบต์พร้อมกัน วิธีการเขียนไบต์จากบัฟเฟอร์ lpBuf ไปยังไฟล์ที่เปิด nCount หากเกิดข้อผิดพลาดในการเขียน เช่น ดิสก์เต็ม เมธอดจะเรียกใช้การจัดการข้อยกเว้น
วิธีฟลัช
เมื่อใช้วิธีการเขียนหรือWriteHugeในการเขียนข้อมูลลงดิสก์ อาจยังคงอยู่ในบัฟเฟอร์ชั่วคราวเป็นระยะเวลาหนึ่ง เพื่อให้แน่ใจว่ามีการเปลี่ยนแปลงที่จำเป็นกับไฟล์บนดิสก์ คุณต้องใช้วิธีฟลัช
การดำเนินการไฟล์
คลาสนี้ประกอบด้วยวิธีการที่อนุญาตให้คุณดำเนินการต่างๆ กับไฟล์ เช่น การคัดลอก การเปลี่ยนชื่อ การลบ การเปลี่ยนคุณลักษณะ
เมื่อต้องการเปลี่ยนชื่อไฟล์ คลาส CFile มีวิธีการแบบคงที่ เปลี่ยนชื่อซึ่งทำหน้าที่ของคำสั่งนี้ วิธีนี้ไม่สามารถใช้เปลี่ยนชื่อไดเร็กทอรีได้ หากมีข้อผิดพลาดเกิดขึ้น วิธีการจะส่งข้อยกเว้น
วิธีการคงที่จะรวมอยู่ในคลาส CFile เพื่อลบไฟล์ ลบซึ่งช่วยให้คุณสามารถลบไฟล์ที่ระบุได้ วิธีนี้ไม่อนุญาตให้คุณลบไดเร็กทอรี หากไม่สามารถลบไฟล์ได้ วิธีการนี้จะทำให้เกิดข้อยกเว้น
ในการกำหนดวันที่และเวลาของการสร้างไฟล์ ความยาว และคุณสมบัติของไฟล์ จะใช้วิธีการคงที่ รับสถานะ- มีวิธีการสองแบบ - วิธีแรกถูกกำหนดให้เป็นวิธีการเสมือน และวิธีที่สองถูกกำหนดเป็นวิธีคงที่
เวอร์ชันเสมือนของวิธีการ รับสถานะกำหนดสถานะของไฟล์ที่เปิดที่เกี่ยวข้องกับวัตถุคลาส CFile นี้ วิธีการนี้เรียกว่าเมื่อมีการสร้างวัตถุคลาส CFile และเปิดแฟ้มเท่านั้น
เวอร์ชันคงที่ของวิธีการ รับสถานะช่วยให้คุณสามารถกำหนดลักษณะของไฟล์ที่ไม่เกี่ยวข้องกับวัตถุของคลาส CFile หากต้องการใช้วิธีนี้ ไม่จำเป็นต้องเปิดไฟล์ก่อน
การปิดกั้น
ชั้นเรียนประกอบด้วยวิธีการ ล็อคเรนจ์และ ปลดล็อคช่วงซึ่งอนุญาตให้ล็อกข้อมูลไฟล์ตั้งแต่หนึ่งชิ้นขึ้นไปเพื่อให้กระบวนการอื่นเข้าถึงได้ หากแอปพลิเคชันพยายามที่จะล็อกข้อมูลที่ถูกล็อกก่อนหน้านี้โดยแอปพลิเคชันนี้หรือแอปพลิเคชันอื่น ข้อยกเว้นจะเกิดขึ้น การล็อคเป็นหนึ่งในกลไกที่ช่วยให้แอปพลิเคชั่นหรือกระบวนการหลายตัวสามารถทำงานในไฟล์เดียวกันพร้อมกันได้โดยไม่รบกวนซึ่งกันและกัน
คุณสามารถตั้งค่าการล็อคได้โดยใช้วิธีการ ล็อคเรนจ์- หากต้องการถอดล็อคที่ติดตั้งออกคุณต้องใช้วิธีนี้ปลดล็อคช่วง- หากมีการตั้งค่าการล็อคหลายรายการในไฟล์เดียว แต่ละการล็อคจะต้องถูกปลดล็อคโดยการเรียกเมธอดที่แยกจากกันปลดล็อคช่วง.
การวางตำแหน่ง
เมื่อต้องการย้ายตัวชี้ตำแหน่งไฟล์ปัจจุบันไปยังตำแหน่งใหม่ คุณสามารถใช้หนึ่งในวิธีการเรียนต่อไปนี้ ซีไฟล์ - แสวงหา แสวงหาเพื่อเริ่มต้น แสวงหาเพื่อสิ้นสุดถึงชั้นเรียน ซีไฟล์รวมถึงวิธีการที่ให้คุณตั้งค่าและเปลี่ยนความยาวไฟล์ -GetLength, SetLength.
เมื่อเปิดไฟล์ ตัวระบุตำแหน่งไฟล์ปัจจุบันจะอยู่ที่จุดเริ่มต้นของไฟล์ เมื่ออ่านหรือเขียนชิ้นส่วนของข้อมูล ตัวชี้ตำแหน่งปัจจุบันจะเลื่อนไปที่จุดสิ้นสุดของไฟล์ และชี้ไปที่ข้อมูลที่จะถูกอ่านหรือเขียนโดยการดำเนินการอ่านหรือเขียนครั้งถัดไปไปยังไฟล์
หากต้องการย้ายตัวชี้ตำแหน่งไฟล์ปัจจุบันไปยังตำแหน่งใด ๆ คุณสามารถใช้วิธีสากล
แสวงหา- ช่วยให้คุณสามารถย้ายตัวชี้ตามจำนวนไบต์ที่กำหนดโดยสัมพันธ์กับตำแหน่งเริ่มต้น จุดสิ้นสุด หรือตำแหน่งตัวชี้ปัจจุบันหากต้องการย้ายตัวชี้ไปที่จุดเริ่มต้นหรือจุดสิ้นสุดของไฟล์จะสะดวกที่สุดในการใช้วิธีการพิเศษ วิธี
แสวงหาเพื่อเริ่มต้นย้ายตัวชี้ไปที่จุดเริ่มต้นของไฟล์และวิธีการแสวงหาเพื่อสิ้นสุด- จนจบแต่เพื่อกำหนดความยาวของไฟล์ที่เปิดอยู่ ไม่จำเป็นต้องเลื่อนตัวชี้ คุณสามารถใช้วิธีการ
รับความยาว- วิธีนี้ยังส่งคืนความยาวของไฟล์ที่เปิดเป็นไบต์ด้วย วิธีตั้งค่าความยาวช่วยให้คุณสามารถเปลี่ยนความยาวของไฟล์ที่เปิดได้ หากวิธีนี้เพิ่มขนาดไฟล์ ค่าของไบต์สุดท้ายจะไม่ถูกกำหนดตำแหน่งตัวชี้ไฟล์ปัจจุบันสามารถกำหนดได้โดยใช้วิธีการ
รับตำแหน่ง- กลับคืนมาโดยวิธีรับตำแหน่งค่า 32 บิตระบุออฟเซ็ตตัวชี้จากจุดเริ่มต้นของไฟล์เปิดลักษณะไฟล์
ในการระบุตำแหน่งของไฟล์ที่เปิดอยู่บนดิสก์คุณต้องเรียกใช้เมธอด รับ FilePath- วิธีการนี้จะส่งกลับวัตถุของชั้นเรียนซีสตริงซึ่งมีเส้นทางแบบเต็มของไฟล์ รวมถึงชื่อไดรฟ์ ไดเร็กทอรี ชื่อไฟล์ และนามสกุลไฟล์
หากคุณเพียงต้องระบุชื่อและนามสกุลของไฟล์ที่เปิดอยู่ คุณสามารถใช้วิธีนี้ได้ รับชื่อไฟล์- จะส่งกลับวัตถุ CString ที่มีชื่อไฟล์ ในกรณีที่คุณต้องการค้นหาเฉพาะชื่อของไฟล์ที่เปิดอยู่โดยไม่มีนามสกุล ให้ใช้วิธีนี้รับ FileTitle.
วิธีการต่อไปนี้ของคลาส CFile ช่วยให้คุณสามารถตั้งค่าเส้นทางของไฟล์ได้ วิธีการนี้ไม่สร้าง คัดลอก หรือเปลี่ยนชื่อไฟล์ แต่จะเติมข้อมูลองค์ประกอบที่สอดคล้องกันในวัตถุคลาส CFile เท่านั้น
คลาสซี
MemFileไลบรารี MFC มีคลาสด้วย
CMemFileสืบทอดมาจากคลาสพื้นฐานซีไฟล์- ระดับ CMemFileหมายถึงไฟล์ที่อยู่ใน RAM ด้วยวัตถุคลาสCMemFileเช่นเดียวกับวัตถุคลาสซีไฟล์- ความแตกต่างก็คือไฟล์ที่เกี่ยวข้องกับวัตถุCMemFileไม่ได้อยู่บนดิสก์ แต่อยู่ใน RAM ของคอมพิวเตอร์ ด้วยเหตุนี้การดำเนินการกับไฟล์ดังกล่าวจึงเร็วกว่าไฟล์ปกติมากการทำงานกับคลาสออบเจ็กต์
CMemFileคุณสามารถใช้เมธอดเกือบทั้งหมดของคลาสได้ซีไฟล์ซึ่งได้อธิบายไว้ข้างต้น คุณสามารถเขียนข้อมูลลงในไฟล์ดังกล่าวหรืออ่านได้ นอกจากวิธีการเหล่านี้แล้ว คลาสยังประกอบด้วยCMemFileรวมวิธีการเพิ่มเติมด้วยมีตัวสร้างที่แตกต่างกันสองตัวสำหรับการสร้างวัตถุของคลาส CMemFile ตัวสร้าง CMemFile แรกมีพารามิเตอร์ทางเลือกเดียวเท่านั้น nGrowBytes:
CMemFile(UINT nGrowBytes=1024);ตัวสร้างนี้สร้างไฟล์ว่างใน RAM เมื่อสร้างแล้ว ไฟล์จะถูกเปิดโดยอัตโนมัติ (ไม่จำเป็นต้องเรียกใช้เมธอด Ope
น)เมื่อเริ่มเขียนลงในไฟล์ดังกล่าว บล็อกหน่วยความจำจะถูกจัดสรรโดยอัตโนมัติ เพื่อให้ได้เมธอดคลาสหน่วยความจำ
CMemFileเรียกใช้ฟังก์ชันมาตรฐานมัลลอค, เรียลลอคและ ฟรี- หากบล็อกหน่วยความจำที่จัดสรรไม่เพียงพอ ขนาดของบล็อกจะเพิ่มขึ้น บล็อกหน่วยความจำของไฟล์จะเพิ่มขึ้นในส่วนของไบต์ nGrowBytes หลังจากลบวัตถุคลาสแล้วCMemFileหน่วยความจำที่ใช้จะถูกส่งกลับเข้าสู่ระบบโดยอัตโนมัติตัวสร้างที่สองของคลาส CMemFile มีต้นแบบที่ซับซ้อนมากขึ้น ตัวสร้างนี้ใช้ในกรณีที่โปรแกรมเมอร์จัดสรรหน่วยความจำสำหรับไฟล์เอง:
CMemFile(BYTE* lpBuffer, UINT nBufferSize, UINT nGrowBytes=0);พารามิเตอร์ lpBuffer ระบุบัฟเฟอร์ที่จะใช้สำหรับไฟล์ ขนาดบัฟเฟอร์ถูกกำหนดโดยพารามิเตอร์ nBufferSize
พารามิเตอร์ nGrowBytes เผื่อเลือกถูกใช้อย่างครอบคลุมมากกว่าในตัวสร้างคลาสแรก หาก nGrowBytes มีศูนย์ ไฟล์ที่สร้างขึ้นจะมีข้อมูลจาก lpBuffer ความยาวของไฟล์ดังกล่าวจะเท่ากับ nBufferSize
ถ้า nGrowBytes มากกว่าศูนย์ เนื้อหาของ lpBuffer จะถูกละเว้น นอกจากนี้ หากมีการเขียนข้อมูลลงในไฟล์ดังกล่าวเกินกว่าที่จะใส่ลงในบัฟเฟอร์ที่จัดสรรได้ ขนาดไฟล์จะเพิ่มขึ้นโดยอัตโนมัติ บล็อกหน่วยความจำของไฟล์จะเพิ่มขึ้นในส่วนของไบต์ nGrowBytes
CMemFileอนุญาตให้คุณรับตัวชี้ไปยังพื้นที่หน่วยความจำที่ไฟล์ใช้ ด้วยตัวชี้นี้ คุณสามารถทำงานกับเนื้อหาของไฟล์ได้โดยตรง โดยไม่จำกัดเฉพาะวิธีการเรียนซีไฟล์- เมื่อต้องการรับตัวชี้ไปยังบัฟเฟอร์ไฟล์ คุณสามารถใช้วิธีแยกออก ก่อนดำเนินการนี้จะมีประโยชน์ในการกำหนดความยาวของไฟล์ (และขนาดของบัฟเฟอร์หน่วยความจำ) โดยการเรียกเมธอดรับความยาว. ถอดออกปิดไฟล์ที่กำหนดและส่งคืนตัวชี้ไปยังบล็อกหน่วยความจำที่ใช้อยู่ หากคุณต้องการเปิดไฟล์อีกครั้งและเชื่อมโยงบล็อก RAM กับไฟล์นั้น คุณจะต้องเรียกใช้เมธอดแนบ.ควรสังเกตว่าในการจัดการคลาสบัฟเฟอร์ไฟล์
CMemFileเรียกใช้ฟังก์ชันมาตรฐานมัลลอค, เรียลลอคและ ฟรี- ดังนั้น เพื่อไม่ให้กลไกการจัดการหน่วยความจำเสียหาย ฟังก์ชันจะต้องสร้างบัฟเฟอร์ lpBufferมอลลอคหรือ โทรล็อค.คลาส CStdioFile
ผู้ที่เคยใช้ฟังก์ชัน stream I/O จากไลบรารีมาตรฐาน C และ C++ ควรให้ความสนใจกับคลาส
CStdioFileสืบทอดมาจากคลาสพื้นฐานซีไฟล์- คลาสนี้อนุญาตให้คุณดำเนินการบัฟเฟอร์ I/O ในโหมดข้อความและไบนารี สำหรับวัตถุคลาสCStdioFileคุณสามารถเรียกเมธอดเกือบทั้งหมดของคลาส CFileCStdioFileรวมองค์ประกอบข้อมูล m_pStream ซึ่งมีตัวชี้ไปยังไฟล์ที่เปิด ถ้าเป็นวัตถุคลาสCStdioFileสร้างแล้ว แต่ไฟล์ยังไม่เปิดหรือปิด ดังนั้น m_pStream จึงมีค่าคงที่ NULLCStdioFileมีตัวสร้างที่แตกต่างกันสามตัว ตัวสร้างแรกของคลาส CStdioFile ไม่มีพารามิเตอร์ Constructor นี้สร้างเฉพาะคลาสอ็อบเจ็กต์ แต่ไม่ได้เปิดไฟล์ใดๆ หากต้องการเปิดไฟล์คุณต้องเรียกใช้เมธอดเปิดคลาสพื้นฐานซีไฟล์.ตัวสร้างชั้นสอง
CStdioFileสามารถเรียกได้หากไฟล์เปิดอยู่แล้วและคุณจำเป็นต้องสร้างอ็อบเจ็กต์ใหม่ของคลาส CStdioFile และเชื่อมโยงไฟล์ที่เปิดอยู่ด้วย ตัวสร้างนี้สามารถใช้ได้หากไฟล์ถูกเปิดด้วยฟังก์ชันมาตรฐานโฟเพน- พารามิเตอร์วิธีการต้องมีตัวชี้ไปยังไฟล์ที่ได้รับจากการเรียกใช้ฟังก์ชันมาตรฐานโฟเพน.ตัวสร้างที่สามสามารถใช้ได้หากคุณต้องการสร้างคลาสอ็อบเจ็กต์
CStdioFileให้เปิดไฟล์ใหม่และเชื่อมโยงกับวัตถุที่สร้างขึ้นใหม่สำหรับการอ่านและเขียนลงในไฟล์ข้อความ คลาส CStdioFile จะมีวิธีการใหม่สองวิธี:
ReadStringและ WriteString- วิธีแรกให้คุณอ่านสตริงอักขระจากไฟล์ได้ และวิธีที่สองให้คุณเขียนได้ตัวอย่างการเขียนและอ่านจากไฟล์
ต่อไปนี้คือส่วนของโค้ดที่สาธิตการใช้แผงโต้ตอบการเลือกไฟล์มาตรฐานและขั้นตอนในการอ่านและเขียนลงในไฟล์
การเปิดไฟล์และอ่านจากไฟล์นั้น
CString m_Text; -// สร้างแผงการเลือกไฟล์มาตรฐานเปิด CFileDialog DlgOpen(TRUE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY,(LPCSTR)" ไฟล์ข้อความ (*.txt) |*.txt||");// แสดงแผงการเลือกไฟล์มาตรฐานเปิด ถ้า(DlgOpen.DoModal()==IDOK) (// สร้างวัตถุและเปิดไฟล์เพื่ออ่าน แฟ้ม CStdioFile(DlgOpen.GetPathName(),CFile::modeRead|CFile::typeBinary);// อ่านสตริงจากไฟล์ CString& ref=m_Text; File.ReadString(อ้างอิง- // การอ้างอิงถึงสตริงถูกส่งผ่าน
CString m_Text; m_ข้อความ)การเปิดและเขียนจากไฟล์ // สร้างแผงการเลือกไฟล์ SaveAs มาตรฐาน CFileDialog DlgSaveAs(FALSE,(LPCSTR)"txt",NULL, OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT, (LPCSTR)" ไฟล์ข้อความ (*.txt) |*.txt||"); // แสดงแผงการเลือกไฟล์ SaveAs มาตรฐานถ้า(DlgSaveAs.DoModal()==IDOK) ( // สร้างวัตถุและเปิดไฟล์เพื่อเขียนแฟ้ม CStdioFile (DlgSaveAs.GetPathName(), CFile::modeCreate|CFile::modeWrite|CFile::typeBinary);- // เขียนลงในไฟล์สตริง
ไฟล์.WriteString((LPCTSTR)m_Text);
-
มีรหัสการทำงานของโปรแกรมที่ออกแบบมาเพื่อความเรียบง่ายเป็นแอปพลิเคชันคอนโซลภายใต้ MFC เพื่อให้โปรแกรมใช้งานได้อย่าลืมทำดังนี้:
เรียกใช้โปรแกรม - สร้าง / สร้างใหม่ทั้งหมด (จะมีข้อผิดพลาด) เลือกสร้าง / ตั้งค่าการกำหนดค่าที่ใช้งานอยู่ - Win 32 Realise เลือกรายการเมนู "โครงการ" จากนั้นเลือก "การตั้งค่า ... " แท็บ "C/C++" หมวดหมู่ - การสร้างโค้ด และในรายการ "ใช้ไลบรารีรันไทม์" เลือก "มัลติเธรด" หลังจากนั้นให้ทำ Build / Rebuild ทั้งหมดอีกครั้ง แล้วโปรแกรมก็จะทำงาน
ไฟล์ข้อความ
ลองดูการทำงานกับไฟล์ข้อความในภาษา C โดยใช้ตัวอย่าง สร้างไฟล์ข้อความบนไดรฟ์ C ชื่อ TextFile.txt พิมพ์บรรทัดต่อไปนี้ในไฟล์นี้:
สตริง_1 123 สตริง_11, 456
สตริง_2
สตริง_3
และนี่คือโค้ดสำหรับโปรแกรม C ที่เปิดไฟล์ของเราและอ่านบรรทัดจากมัน:
/* *ผู้เขียน: @author Subbotin B.P..h> #include
อาร์กิวเมนต์แรกของฟังก์ชัน fopen ชี้ไปที่ไฟล์ และอาร์กิวเมนต์ที่สองบอกว่าไฟล์นั้นเปิดให้อ่านได้
เราอ่านบรรทัดโดยใช้ฟังก์ชัน fgets:
fgets(cArray, LEN, pTextFile);
อาร์กิวเมนต์แรกของฟังก์ชัน fgets ชี้ไปที่อาร์เรย์อักขระที่จะเก็บสตริงที่ได้รับ อาร์กิวเมนต์ที่สองคือจำนวนอักขระสูงสุดที่จะอ่าน และอาร์กิวเมนต์ที่สามคือไฟล์ของเรา
หลังจากทำงานกับไฟล์เสร็จแล้ว คุณต้องปิดมัน:
fclose(pTextFile);
เราได้รับ:
ตัวอักษรรัสเซียก็ปรากฏอยู่ในบรรทัดด้วย
อีกอย่างผมสร้างโปรแกรมนี้ใน Eclipse คุณสามารถดูวิธีทำงานกับ C/C++ ได้ใน Eclipse
ดังนั้นเราจึงเปิดและอ่านข้อมูลจากไฟล์ข้อความ
ตอนนี้เรามาเรียนรู้วิธีสร้างไฟล์ข้อความโดยทางโปรแกรมและเขียนข้อมูลลงไป
/* ผู้แต่ง: @author Subbotin B.P..h> #include
สร้างไฟล์ข้อความเพื่อเขียนข้อมูลไปที่:
ไฟล์ *pTextFile = fopen("C:\\TextFileW.txt", "w");
หากไฟล์มีอยู่แล้ว ไฟล์นั้นจะถูกเปิดและข้อมูลทั้งหมดจากไฟล์นั้นจะถูกลบ
C-string cString และหมายเลข nVal ถูกเขียนโดยโปรแกรมไปยังไฟล์ข้อความ cNewLine เป็นเพียงบรรทัดใหม่
เราเขียนข้อมูลลงในไฟล์ข้อความโดยใช้ฟังก์ชัน fprintf:
fprintf(pTextFile, "%s%c", cString, cNewLine);
อาร์กิวเมนต์แรกที่นี่คือไฟล์ของเรา อาร์กิวเมนต์ที่สองคือสตริงรูปแบบ อาร์กิวเมนต์ที่สามขึ้นไปคือจำนวนอาร์กิวเมนต์ที่จำเป็นสำหรับรูปแบบนี้
สำหรับโปรแกรมเมอร์ ไฟล์ที่เปิดอยู่จะแสดงเป็นลำดับของข้อมูลที่อ่านหรือเขียน เมื่อเปิดไฟล์ขึ้นมาก็จะมีความเกี่ยวพันกับ สตรีม I/O - ข้อมูลเอาต์พุตจะถูกเขียนไปยังสตรีม ข้อมูลอินพุตจะถูกอ่านจากสตรีม
เมื่อเปิดสตรีมสำหรับ I/O สตรีมจะเชื่อมโยงกับโครงสร้าง FILE มาตรฐาน ซึ่งกำหนดไว้ใน stdio.h โครงสร้าง FILE ประกอบด้วยข้อมูลที่จำเป็นเกี่ยวกับไฟล์
การเปิดไฟล์ทำได้โดยใช้ฟังก์ชัน fopen() ซึ่งจะส่งคืนตัวชี้ไปยังโครงสร้างประเภท FILE ที่สามารถใช้สำหรับการดำเนินการกับไฟล์ในภายหลัง
FILE *fopen(ชื่อ, ประเภท);
ชื่อ – ชื่อของไฟล์ที่จะเปิด (รวมถึงเส้นทาง)
type - ตัวชี้ไปยังสตริงอักขระที่กำหนดวิธีการเข้าถึงไฟล์:
· "r" - เปิดไฟล์เพื่ออ่าน (ต้องมีไฟล์อยู่)
· "w" - เปิดไฟล์เปล่าเพื่อเขียน หากมีไฟล์อยู่ เนื้อหาจะสูญหาย
· "a" - เปิดไฟล์เพื่อเขียนต่อท้าย (เพื่อต่อท้าย) ไฟล์จะถูกสร้างขึ้นหากไม่มีอยู่
· "r+" - เปิดไฟล์เพื่ออ่านและเขียน (ต้องมีไฟล์อยู่)
· "w+" - เปิดไฟล์ว่างเพื่ออ่านและเขียน หากมีไฟล์อยู่ เนื้อหาจะสูญหาย
· "a+" - เปิดไฟล์เพื่ออ่านและต่อท้าย หากไม่มีไฟล์อยู่ ไฟล์นั้นจะถูกสร้างขึ้น
ค่าที่ส่งกลับเป็นตัวชี้ไปยังกระแสเปิด หากตรวจพบข้อผิดพลาด จะส่งคืนค่า NULL
ฟังก์ชัน fclose() จะปิดสตรีมหรือสตรีมที่เกี่ยวข้องกับไฟล์ที่เปิดโดยใช้ฟังก์ชัน fopen() สตรีมที่จะปิดถูกกำหนดโดยอาร์กิวเมนต์ของฟังก์ชัน fclose()
ค่าส่งคืน: ค่า 0 หากปิดสตรีมสำเร็จ EOF คงที่หากเกิดข้อผิดพลาด
#รวม
int หลัก()
ชื่อถ่าน = "my.txt";
ถ้า (fp = fopen (ชื่อ "r")! = NULL)
// เป็นไปได้ไหมที่จะเปิดไฟล์?
... // การดำเนินการที่จำเป็นกับข้อมูล
else printf("ไม่สามารถเปิดไฟล์ได้");
การอ่านอักขระจากไฟล์:
ถ่าน fgetc (สตรีม);
อาร์กิวเมนต์ของฟังก์ชันเป็นตัวชี้ไปยังสตรีมประเภท FILE ฟังก์ชันส่งคืนรหัสของอักขระที่อ่าน หากถึงจุดสิ้นสุดของไฟล์หรือมีข้อผิดพลาดเกิดขึ้น ค่าคงที่ EOF จะถูกส่งกลับ
การเขียนสัญลักษณ์ลงในไฟล์:
fputc(ถ่าน, สตรีม);
อาร์กิวเมนต์ของฟังก์ชันคืออักขระและตัวชี้ไปยังสตรีมประเภท FILE ฟังก์ชันส่งคืนรหัสของอักขระที่อ่าน
ฟังก์ชัน fscanf() และ fprintf() คล้ายคลึงกับฟังก์ชัน scanf() และ printf() แต่ทำงานกับไฟล์ข้อมูลได้ และมีตัวชี้ไปยังไฟล์เป็นอาร์กิวเมนต์แรก
fscanf(สตรีม, "รูปแบบอินพุต", อาร์กิวเมนต์);
fprintf (สตรีม "รูปแบบเอาต์พุต" อาร์กิวเมนต์);
ฟังก์ชัน fgets() และ fputs() ได้รับการออกแบบมาสำหรับอินพุต/เอาต์พุตแบบสตริง ซึ่งคล้ายคลึงกับฟังก์ชัน gets() และ puts() สำหรับการทำงานกับไฟล์
fgets (ตัวชี้ไปที่บรรทัด, จำนวนอักขระ, สตรีม);
อักขระจะถูกอ่านจากสตรีมจนกว่าจะอ่านอักขระขึ้นบรรทัดใหม่ "\n" ซึ่งรวมอยู่ในสตริง หรือจนกว่าสตรีมจะสิ้นสุด EOF หรืออ่านอักขระถึงจำนวนสูงสุดแล้ว ผลลัพธ์จะถูกวางไว้ในตัวชี้สตริงและลงท้ายด้วยอักขระว่าง "\0" ฟังก์ชันส่งคืนที่อยู่ของสตริง
fputs (ตัวชี้ไปที่สตริง, สตรีม);
คัดลอกสตริงไปยังสตรีมจากตำแหน่งปัจจุบัน อักขระ null ที่สิ้นสุดจะไม่ถูกคัดลอก
ตัวอย่าง
ป้อนหมายเลขและบันทึกลงในไฟล์ s1.txt อ่านตัวเลขจากไฟล์ s1.txt เพิ่ม 3 และบันทึกลงในไฟล์ s2.txt
การทำงานกับไฟล์ข้อความใน C ++
ไฟล์มีสองประเภทหลัก: ข้อความและไบนารี ไฟล์อนุญาตให้ผู้ใช้สามารถอ่านข้อมูลจำนวนมากได้โดยตรงจากดิสก์โดยไม่ต้องป้อนข้อมูลจากแป้นพิมพ์
ข้อความไฟล์ที่ประกอบด้วยอักขระใดๆ จะถูกเรียก จัดเรียงเป็นบรรทัด โดยแต่ละบรรทัดลงท้ายด้วยอักขระท้ายบรรทัด จุดสิ้นสุดของไฟล์จะมีสัญลักษณ์ "สิ้นสุดไฟล์" ระบุ เมื่อเขียนข้อมูลลงในไฟล์ข้อความ ซึ่งสามารถดูได้โดยใช้โปรแกรมแก้ไขข้อความ ข้อมูลทั้งหมดจะถูกแปลงเป็นประเภทอักขระและจัดเก็บในรูปแบบอักขระ
ใน ไบนารี่ในไฟล์ ข้อมูลจะถูกอ่านและเขียนในรูปแบบของบล็อกขนาดหนึ่ง ซึ่งสามารถจัดเก็บข้อมูลประเภทและโครงสร้างใดก็ได้
ในการทำงานกับไฟล์พิเศษ ประเภทข้อมูล, เรียกว่า ลำธาร- ไหล ถ้าสตรีมใช้เพื่อทำงานกับไฟล์ในโหมดการอ่านและ ของกระแสในโหมดบันทึก ในการทำงานกับไฟล์ทั้งในโหมดการเขียนและการอ่านจะใช้สตรีม สตรีม.
ในโปรแกรม C++ เมื่อทำงานกับไฟล์ข้อความ คุณต้องรวมไลบรารี iostream และ fstream ไว้ด้วย
เพื่อ บันทึกข้อมูลเป็นไฟล์ข้อความ คุณต้องมี:
อธิบายตัวแปรประเภทกระแสน้ำ
ข้อมูลส่งออกไปยังไฟล์
อย่าลืมปิดไฟล์
สำหรับ การอ่านข้อมูลจากไฟล์ข้อความ คุณต้องมี:
อธิบายตัวแปรประเภท ifstream
เปิดไฟล์โดยใช้ฟังก์ชันเปิด
ปิดไฟล์
บันทึกข้อมูลเป็นไฟล์ข้อความ
ตามที่กล่าวไว้ข้างต้น เพื่อเริ่มทำงานกับไฟล์ข้อความ คุณต้องกำหนดตัวแปรประเภทสตรีม ตัวอย่างเช่นเช่นนี้:
ตัวแปร F จะถูกสร้างขึ้นเพื่อเขียนข้อมูลลงในไฟล์
ในขั้นตอนต่อไปจะต้องเปิดไฟล์เพื่อเขียน โดยทั่วไป ตัวดำเนินการเปิดสตรีมจะมีลักษณะดังนี้:
F.open("ไฟล์", โหมด);
โดยที่ F เป็นตัวแปรที่อธิบายว่าเป็นกระแส
ไฟล์ - ชื่อเต็มของไฟล์บนดิสก์
โหมด - โหมดการทำงานกับไฟล์ที่กำลังเปิด
โปรดทราบว่าเมื่อระบุชื่อไฟล์เต็ม คุณต้องใช้เครื่องหมายทับคู่ ตัวอย่างเช่นชื่อเต็มของไฟล์ noobs.txt ซึ่งอยู่ในโฟลเดอร์เกมบนไดรฟ์ D: จะต้องเขียนดังนี้:
D:\\เกม\\noobs.txt
ไฟล์สามารถเปิดได้ในโหมดใดโหมดหนึ่งต่อไปนี้:
ios::in - เปิดไฟล์ในโหมดอ่านข้อมูล โหมดนี้เป็นโหมดเริ่มต้นสำหรับ ifstreams
ios::out - เปิดไฟล์ในโหมดการเขียนข้อมูล (ในกรณีนี้ข้อมูลเกี่ยวกับไฟล์ที่มีอยู่จะถูกทำลาย) โหมดนี้เป็นโหมดเริ่มต้นสำหรับ ofstreams
ios::app - เปิดไฟล์ในโหมดเขียนข้อมูลลงท้ายไฟล์
ios::ate - ย้ายไปที่ส่วนท้ายของไฟล์ที่เปิดอยู่แล้ว
ios::trunc - ล้างไฟล์ สิ่งนี้จะเกิดขึ้นในโหมด ios::out เช่นกัน
ios::nocreate - อย่าเปิดไฟล์หากไม่มีอยู่
ios::noreplace - ห้ามเปิดไฟล์ที่มีอยู่
พารามิเตอร์โหมดอาจหายไป ในกรณีนี้ ไฟล์จะถูกเปิดในโหมดเริ่มต้นสำหรับสตรีมนี้
หลังจากเปิดไฟล์สำเร็จ (ในโหมดใดก็ได้) ตัวแปร F จะเก็บค่าจริง มิเช่นนั้นจะเป็นค่าเท็จ ซึ่งจะช่วยให้คุณสามารถตรวจสอบความถูกต้องของการดำเนินการเปิดไฟล์ได้
คุณสามารถเปิดไฟล์ (ลองใช้ไฟล์ D:\\game\\noobs.txt เป็นตัวอย่าง) ในโหมดบันทึกด้วยวิธีใดวิธีหนึ่งต่อไปนี้:
// อันดับแรก ทาง
กระแส F;
F.open("D:\\game\\noobs.txt", ios::out);
// วิธีที่สอง โหมด ios::out เป็นโหมดเริ่มต้น
// สำหรับ ไหลของกระแส
กระแส F;
// วิธีที่สามรวมคำอธิบายของตัวแปรและประเภทสตรีม
//และเปิดไฟล์ในคำสั่งเดียว
ofstream F("D:\\game\\noobs.txt", ios::out);
หลังจากเปิดไฟล์ในโหมดเขียน ไฟล์เปล่าจะถูกสร้างขึ้นซึ่งคุณสามารถเขียนข้อมูลได้
หากคุณต้องการเปิดไฟล์ที่มีอยู่ในโหมดเขียนก่อน คุณควรใช้ ios::app เป็นโหมด
หลังจากเปิดไฟล์ในโหมดบันทึก คุณสามารถเขียนไฟล์ในลักษณะเดียวกับบนหน้าจอ แทนอุปกรณ์เอาท์พุตมาตรฐานเท่านั้นศาลคุณต้องระบุชื่อของไฟล์ที่เปิด
ตัวอย่างเช่น ในการเขียนตัวแปร a ไปยังสตรีม F คำสั่งเอาต์พุตจะมีลักษณะดังนี้:
สำหรับเอาต์พุตตามลำดับเพื่อสตรีม G ของตัวแปร b, c, d ตัวดำเนินการเอาต์พุตจะเป็นดังนี้:
ช< การปิดสตรีมทำได้โดยใช้โอเปอเรเตอร์: ตัวอย่าง: สร้างไฟล์ข้อความ D:\\game\\noobs.txt และเขียนตัวเลขจำนวนจริงลงไป #รวม "stdafx.h" #รวม #รวม #รวม ใช้เนมสเปซมาตรฐาน; int หลัก() setlocale(LC_ALL, "มาตุภูมิ"); ฉัน, n; ดับเบิ้ลเอ; //อธิบายกระแสสำหรับการเขียนข้อมูลลงไฟล์ ของกระแส
ฉ;
//เปิดไฟล์ในโหมดเขียน //โหมดไอโอเอส::
ออกติดตั้งโดยค่าเริ่มต้น f.open("D:\\game\\noobs.txt", ios::out); //ใส่จำนวนจำนวนจริง ศาล<<"
n=";
ซิน>>
n;
//วนซ้ำสำหรับการป้อนจำนวนจริง //และเขียนลงในไฟล์ สำหรับ (i=0; i ศาล<<"a=";
//ป้อนตัวเลข ซิน>>ก; ฉ< //ปิดสตรีม ฉ.ปิด(); ระบบ("หยุดชั่วคราว"); กลับ 0; _______________________________________________________________ เพื่อที่จะอ่านข้อมูลจากไฟล์ข้อความ คุณจะต้องอธิบายตัวแปรเช่น ถ้าสตรีม- หลังจากนี้คุณจะต้องเปิดไฟล์เพื่ออ่านโดยใช้โอเปอเรเตอร์ เปิด- หากตัวแปรชื่อ F ดังนั้นสองคำสั่งแรกจะเป็นดังนี้: F.open("D:\\game\\noobs.txt", ios::in); หลังจากเปิดไฟล์ในโหมดการอ่าน คุณสามารถอ่านข้อมูลจากไฟล์ในลักษณะเดียวกับจากคีย์บอร์ดเท่านั้นซินระบุชื่อของสตรีมที่จะอ่านข้อมูล ตัวอย่างเช่น หากต้องการอ่านจากสตรีม F ไปยังตัวแปร a คำสั่งอินพุตจะมีลักษณะดังนี้: ตัวเลขสองตัวในโปรแกรมแก้ไขข้อความจะถือว่าแยกจากกันหากมีอักขระอย่างน้อยหนึ่งตัวอยู่ระหว่างตัวเลข: ช่องว่าง แท็บ จุดสิ้นสุดบรรทัด เป็นการดีถ้าโปรแกรมเมอร์รู้ล่วงหน้าว่าจะเก็บค่าไว้ในไฟล์ข้อความจำนวนเท่าใดและค่าใด อย่างไรก็ตามบ่อยครั้งที่ทราบประเภทของค่าที่เก็บไว้ในไฟล์ แต่จำนวนอาจแตกต่างกันไป เพื่อแก้ปัญหานี้ คุณต้องอ่านค่าจากไฟล์ทีละค่า และก่อนอ่านแต่ละครั้ง ให้ตรวจสอบว่าถึงจุดสิ้นสุดของไฟล์แล้วหรือไม่ มีฟังก์ชั่นสำหรับสิ่งนี้ เอฟ.
อีฟ().
โดยที่ F คือชื่อของเธรด ฟังก์ชันจะส่งกลับค่าบูลีน: จริงหรือเท็จ ขึ้นอยู่กับว่าถึงจุดสิ้นสุดของไฟล์หรือไม่ ดังนั้นการวนซ้ำเพื่ออ่านเนื้อหาของไฟล์ทั้งหมดจึงสามารถเขียนได้ดังนี้: //จัดระเบียบการอ่านค่าจากไฟล์, การดำเนินการ //การวนซ้ำจะขาดเมื่อเราไปถึงจุดสิ้นสุดของไฟล์ //ในกรณีนี้ F.eof() จะคืนค่าเป็นจริง ในขณะที่ (!F.eof()) ตัวอย่าง: ไฟล์ข้อความ D:\\game\\noobs.txt เก็บตัวเลขจริง แสดงบนหน้าจอ และคำนวณตัวเลข #รวม "stdafx.h" #รวม #รวม #รวม #รวม ใช้เนมสเปซมาตรฐาน; int หลัก() setlocale(LC_ALL, "มาตุภูมิ"); อินท์n=0; ลอย; สตรีม F; //เปิดไฟล์ในโหมดการอ่าน F.open("D:\\game\\noobs.txt"); //หากเปิดไฟล์ถูกต้องแล้ว //วนซ้ำสำหรับอ่านค่าจากไฟล์; การดำเนินการวนซ้ำจะถูกขัดจังหวะ //เมื่อเราไปถึงจุดสิ้นสุดของไฟล์ ในกรณีนี้ F.eof() จะคืนค่าเป็นจริง ในขณะที่ (!F.eof()) //อ่านค่าถัดไปจากสตรีม F ไปยังตัวแปร a ฉ>>ก; //ส่งออกค่าของตัวแปร a ไปยังหน้าจอ ศาล< //เพิ่มจำนวนตัวเลขที่อ่าน //ปิดสตรีม F.ปิด(); //กรอกจำนวนตัวเลขที่อ่านบนหน้าจอ ศาล<<"n="< //หากเปิดไฟล์ไม่ถูกต้อง แสดงว่าเอาต์พุต //ข้อความเกี่ยวกับการไม่มีไฟล์ดังกล่าว อย่างอื่นก็น่าสนใจ<<" Файл не существует"< ระบบ("หยุดชั่วคราว"); กลับ 0; ซี++ การประมวลผลไฟล์ไบนารี เมื่อเขียนข้อมูลลงในไฟล์ไบนารี อักขระและตัวเลขจะถูกเขียนเป็นลำดับไบต์ เพื่อ เขียนลงไปข้อมูลเป็นไฟล์ไบนารี่ คุณต้องมี: อธิบายตัวแปรไฟล์ประเภท FAIL * โดยใช้ตัวดำเนินการ FILE * ชื่อไฟล์ในที่นี้คือชื่อของตัวแปรที่จะจัดเก็บตัวชี้ไปยังไฟล์ เขียนข้อมูลลงไฟล์โดยใช้ฟังก์ชัน fwrite เพื่อ นับ b ข้อมูลจากไฟล์ไบนารี คุณต้องการ: อธิบายตัวแปรประเภท FILE * เปิดไฟล์โดยใช้ฟังก์ชัน fopen ปิดไฟล์โดยใช้ฟังก์ชัน fclose ฟังก์ชันพื้นฐานที่จำเป็นสำหรับการทำงานกับไฟล์ไบนารี สำหรับ ช่องเปิดไฟล์นี้มีไว้สำหรับฟังก์ชัน fopen FILE *fopen(const *ชื่อไฟล์, const char *โหมด) ในที่นี้ชื่อไฟล์คือสตริงที่เก็บชื่อเต็มของไฟล์ที่กำลังเปิด โหมดคือสตริงที่กำหนดโหมดสำหรับการทำงานกับไฟล์ ค่าต่อไปนี้เป็นไปได้: “ rb” - เปิดไฟล์ไบนารีในโหมดอ่าน “ wb” - สร้างไฟล์ไบนารีสำหรับการบันทึก หากมีอยู่เนื้อหาจะถูกล้าง “ab” - สร้างหรือเปิดไฟล์ไบนารี่เพื่อต่อท้ายไฟล์ “rb+” - เปิดไฟล์ไบนารีที่มีอยู่ในโหมดอ่าน-เขียน “ wb+” - เปิดไฟล์ไบนารีในโหมดอ่าน-เขียน ไฟล์ที่มีอยู่จะถูกล้าง "ab+" - เปิดหรือสร้างไฟล์ไบนารี่เพื่อแก้ไขข้อมูลที่มีอยู่และเพิ่มข้อมูลใหม่ต่อท้ายไฟล์ ฟังก์ชันคืนค่า NULL ในตัวแปรไฟล์ f หากไฟล์เปิดไม่สำเร็จ หลังจากเปิดไฟล์ ไบต์ที่ 0 จะพร้อมใช้งาน ตัวชี้ไฟล์คือ 0 ซึ่งค่าที่อ่านหรือเขียนจะถูกเลื่อนตามจำนวนไบต์ที่อ่าน (เขียน) ค่าปัจจุบันของตัวชี้ไฟล์คือหมายเลขไบต์ที่การดำเนินการอ่านหรือเขียนจะเกิดขึ้น สำหรับ ปิดไฟล์นี้มีไว้สำหรับฟังก์ชัน fclose int fclose(FILE *ชื่อไฟล์); ส่งคืน 0 หากปิดไฟล์สำเร็จ มิฉะนั้นจะเป็น NULL ฟังก์ชั่นการลบมีไว้สำหรับ การกำจัดไฟล์. int ลบ (const char * ชื่อไฟล์); ฟังก์ชั่นนี้จะลบไฟล์ชื่อ filenema ออกจากดิสก์ ไฟล์ที่จะลบจะต้องถูกปิด ฟังก์ชันจะส่งกลับค่าที่ไม่ใช่ศูนย์หากไม่สามารถลบไฟล์ได้ สำหรับ เปลี่ยนชื่อไฟล์ต่างๆ ฟังก์ชันการเปลี่ยนชื่อมีจุดประสงค์: int เปลี่ยนชื่อ (const char *oldfilename, const char *newfilename); พารามิเตอร์แรกคือชื่อไฟล์เก่า พารามิเตอร์ที่สองคือชื่อใหม่ ส่งคืนค่า 0 หากโปรแกรมยุติการทำงานสำเร็จ การอ่านจากไฟล์ไบนารี่เสร็จสิ้นโดยใช้ฟังก์ชัน fread: fread(โมฆะ *ptr, ขนาด, n, FILE *ชื่อไฟล์); ฟังก์ชั่น fread อ่านองค์ประกอบขนาด n จากชื่อไฟล์ไปยังอาร์เรย์ PTR ฟังก์ชันส่งคืนจำนวนองค์ประกอบที่อ่าน หลังจากอ่านจากไฟล์ ตัวชี้จะเลื่อนไปเป็นไบต์ขนาด n* บันทึกไปยังไฟล์ไบนารี่ทำได้โดยใช้ฟังก์ชัน fwrite: fwrite(const void *ptr, size, n, FILE *ชื่อไฟล์); ฟังก์ชั่น fwrite เขียนไปยังชื่อไฟล์จากอาร์เรย์ ptr ขององค์ประกอบขนาด n ฟังก์ชันส่งคืนจำนวนองค์ประกอบที่เขียน หลังจากเขียนข้อมูลลงในไฟล์ ตัวชี้จะเลื่อนไปเป็นไบต์ขนาด n* สำหรับ การควบคุมการสิ้นสุดไฟล์มีฟังก์ชัน feof: int feof(FILE *ชื่อไฟล์); จะส่งกลับค่าที่ไม่ใช่ศูนย์หากถึงจุดสิ้นสุดของไฟล์ ตัวอย่าง: สร้างไฟล์ไบนารี่ D:\\game\\noobs.dat และเขียนจำนวนเต็ม n และจำนวนจริง n ลงไป #รวม "stdafx.h" #รวม ใช้เนมสเปซมาตรฐาน; int หลัก() setlocale(LC_ALL, "มาตุภูมิ"); int n, ฉัน; ดับเบิ้ลเอ; //สร้างไฟล์ไบนารี่ในโหมดเขียน f=fopen("D:\\game\\noobs.dat", "wb"); //
ป้อนข้อมูล
ตัวเลขn ศาล<<"n=";
cin>>น; fwrite(&n, ขนาดของ(int), 1, f); //วนซ้ำเพื่อป้อนจำนวนจริง สำหรับ (i=0; i //ป้อนจำนวนจริงถัดไป ศาล<<"a=";
ซิน>>ก; //เขียนจำนวนจริงลงในไฟล์ไบนารี่ fwrite(&a, ขนาดของ (สองเท่า), 1, f); //
ปิด
ไฟล์ fclose(f); ระบบ("หยุดชั่วคราว"); กลับ 0; ตัวอย่าง: แสดงเนื้อหาของไฟล์ไบนารี D:\\game\\noobs.dat ที่สร้างในงานก่อนหน้า #รวม "stdafx.h" #รวม ใช้เนมสเปซมาตรฐาน; int หลัก() setlocale(LC_ALL, "มาตุภูมิ"); int n, ฉัน; สองเท่า *ก; ไฟล์ *ฉ; //อธิบายตัวแปรไฟล์ //เปิดไฟล์ไบนารี่ที่มีอยู่ในโหมดอ่าน //อ่านจำนวนเต็มหนึ่งตัวจากไฟล์ไปยังตัวแปร n // ส่งออก n ไปที่หน้าจอ ศาล<<"n="< //การจัดสรรหน่วยความจำสำหรับอาร์เรย์จำนวน n ตัว a=ใหม่ สองเท่า[n]; //อ่านจำนวนจริงจากไฟล์ไปยังอาร์เรย์ a //ส่งออกอาร์เรย์ไปที่หน้าจอ สำหรับ (i=0; i ศาล< ศาล< //
ปิด
ไฟล์ fclose(f); ระบบ("หยุดชั่วคราว"); กลับ 0; ไฟล์ไบนารี- โครงสร้างข้อมูลตามลำดับ หลังจากเปิดไฟล์ ไบต์แรกที่จัดเก็บไว้ในนั้นจะพร้อมใช้งาน คุณสามารถเขียนหรืออ่านข้อมูลจากไฟล์ตามลำดับได้ สมมติว่าคุณต้องนับเลขสิบห้าแล้วนับเลขตัวแรก การใช้การเข้าถึงตามลำดับสามารถทำได้ด้วยวิธีต่อไปนี้: int n, ฉัน; ดับเบิ้ลเอ; ไฟล์ *ฉ; f=fopen("D:\\game\\noobs.dat", "rb"); สำหรับ (i=0; i<15; i++)
fclose(f); f=fopen("D:\\game\\noobs.dat", "rb"); fread(&a, ขนาดของ (สองเท่า), 1, f); fclose(f); อย่างที่คุณเห็น การอ่านตัวเลขจากไฟล์แล้วเปิดไฟล์อีกครั้งไม่ใช่วิธีที่สะดวกที่สุด การใช้ฟังก์ชัน fseek จะสะดวกกว่ามากเพื่อย้ายตัวชี้ไฟล์ไปยังไบต์ที่กำหนด int fseek(FILE *ชื่อไฟล์, int offset แบบยาว, int origin); ฟังก์ชันนี้จะตั้งค่าตัวชี้ตำแหน่งไฟล์ปัจจุบัน F ตามค่ากำเนิดและค่าออฟเซ็ต พารามิเตอร์ออฟเซ็ตจะเท่ากับจำนวนไบต์ที่ตัวชี้ไฟล์จะถูกออฟเซ็ตโดยสัมพันธ์กับจุดเริ่มต้นที่ระบุโดยพารามิเตอร์ต้นกำเนิด ค่าสำหรับพารามิเตอร์ต้นกำเนิดจะต้องเป็นหนึ่งในค่าออฟเซ็ตต่อไปนี้ซึ่งกำหนดไว้ในส่วนหัว stdio.h: SEEK_SET - จากจุดเริ่มต้นของไฟล์ SEEK_CUR - จากตำแหน่งปัจจุบัน SEEK_END - จากท้ายไฟล์ ฟังก์ชันจะส่งกลับค่าศูนย์หากการดำเนินการสำเร็จ และจะส่งกลับค่าที่ไม่ใช่ศูนย์หากออฟเซ็ตล้มเหลว ฟังก์ชัน fseek ใช้การเข้าถึงโดยตรงไปยังค่าใดๆ ในไฟล์ คุณจะต้องทราบตำแหน่ง (หมายเลขไบต์) ของค่าในไฟล์เท่านั้น ลองดูที่การใช้การเข้าถึงโดยตรงในไฟล์ไบนารีโดยใช้ปัญหาต่อไปนี้เป็นตัวอย่าง ตัวอย่าง ในไฟล์ไบนารี่ D:\\game\\noobs.dat ที่สร้างไว้ก่อนหน้านี้ ให้สลับจำนวนจริงที่ใหญ่ที่สุดและเล็กที่สุด อัลกอริทึมสำหรับการแก้ปัญหาประกอบด้วยขั้นตอนต่อไปนี้: อ่านค่าจริงจากไฟล์ลงในอาร์เรย์ a ค้นหาในอาร์เรย์ a เพื่อดูค่าสูงสุด (สูงสุด) และต่ำสุด (นาที) และตัวเลข (imax, imin) ย้ายตัวชี้ไฟล์ไปที่ค่าสูงสุดและเขียนขั้นต่ำ ย้ายตัวชี้ไฟล์ไปที่ค่าต่ำสุดและเขียนค่าสูงสุด ด้านล่างนี้เป็นข้อความของโปรแกรมสำหรับแก้ไขปัญหาพร้อมความคิดเห็น #รวม "stdafx.h" #รวม ใช้เนมสเปซมาตรฐาน; int หลัก() setlocale(LC_ALL, "มาตุภูมิ"); int n, i, imax, imin; สองเท่า *a, สูงสุด, นาที; ไฟล์ *ฉ; //เปิดไฟล์ในโหมดอ่าน-เขียน f=fopen("D:\\game\\noobs.dat", "rb+"); //อ่านตัวเลขจากไฟล์ไปเป็นตัวแปร n //จำนวนจริงในไฟล์ fread(&n, ขนาดของ(int), 1, f); ศาล<<"n="< //จัดสรรหน่วยความจำสำหรับเก็บจำนวนจริง //ซึ่งจะถูกเก็บไว้ในอาร์เรย์ a a=ใหม่ สองเท่า[n]; //อ่านจากไฟล์ไปยังอาเรย์และจำนวนจริง fread(a, ขนาดของ(สองเท่า), n, f); //ค้นหาองค์ประกอบสูงสุดและต่ำสุด // ในอาร์เรย์ a และดัชนีของพวกเขา สำหรับ (imax=imin=0, สูงสุด=นาที=a, i=1; i ถ้า (a[i]>สูงสุด) สูงสุด=a[i]; ถ้า (เป็น[i] นาที=a[i]; //
การย้าย
ตัวชี้
ถึง
สูงสุด
องค์ประกอบ fseek(f, ขนาดของ(int)+imax*ขนาดของ(สองเท่า), SEEK_SET); //เขียน min แทนองค์ประกอบไฟล์สูงสุด fwrite(&min, ขนาดของ (สองเท่า), 1, f); //
การย้าย
ตัวชี้
ถึง
ขั้นต่ำ
องค์ประกอบ fseek(f, ขนาดของ(int)+imin*ขนาดของ(สองเท่า), SEEK_SET); //เขียนสูงสุดแทนองค์ประกอบไฟล์ขั้นต่ำ fwrite(&max, sizeof(double), 1, f); //ปิดไฟล์ fclose(f); //เพิ่มหน่วยความจำ ลบ [
]ก; ระบบ("หยุดชั่วคราว"); โปรแกรมคอมพิวเตอร์ส่วนใหญ่ทำงานกับไฟล์ได้ ดังนั้นจึงจำเป็นต้องสร้าง ลบ เขียน อ่าน และเปิดไฟล์ ไฟล์คืออะไร? ไฟล์คือชุดไบต์ที่มีชื่อซึ่งสามารถจัดเก็บไว้ในอุปกรณ์จัดเก็บข้อมูลบางชนิดได้ ตอนนี้เป็นที่ชัดเจนแล้วว่าไฟล์หมายถึงลำดับไบต์ที่มีชื่อเฉพาะของตัวเอง เช่น file.txt ไฟล์ที่มีชื่อเดียวกันไม่สามารถอยู่ในไดเร็กทอรีเดียวกันได้ ชื่อไฟล์ไม่เพียงแต่อ้างอิงถึงชื่อเท่านั้น แต่ยังรวมถึงนามสกุลด้วย เช่น file.txt และ file.dat —
ไฟล์ต่างๆ แม้ว่าชื่อจะเหมือนกันก็ตาม มีสิ่งที่เรียกว่าชื่อไฟล์แบบเต็ม - นี่คือที่อยู่แบบเต็มของไดเร็กทอรีไฟล์ที่ระบุชื่อไฟล์ เช่น D:\docs\file.txt สิ่งสำคัญคือต้องเข้าใจแนวคิดพื้นฐานเหล่านี้ ไม่เช่นนั้นการทำงานกับไฟล์จะเป็นเรื่องยาก ในการทำงานกับไฟล์ คุณต้องรวมไฟล์ส่วนหัวไว้ด้วย File I/O คล้ายกับ I/O มาตรฐาน ข้อแตกต่างเพียงอย่างเดียวคือ I/O จะดำเนินการกับไฟล์ แทนที่จะดำเนินการกับหน้าจอ หาก I/O ไปยังอุปกรณ์มาตรฐานดำเนินการโดยใช้อ็อบเจ็กต์ cin และ cout ดังนั้นเพื่อจัดระเบียบไฟล์ I/O ก็เพียงพอแล้วที่จะสร้างอ็อบเจ็กต์ของคุณเองที่สามารถนำมาใช้คล้ายกับตัวดำเนินการ cin และ cout ตัวอย่างเช่น คุณต้องสร้างไฟล์ข้อความและเขียนบรรทัดการทำงานกับไฟล์ในภาษา C++ ลงไป ในการทำเช่นนี้คุณต้องทำตามขั้นตอนต่อไปนี้: เหตุใดจึงจำเป็นต้องสร้างวัตถุ ofstream แทนที่จะเป็นวัตถุ ifstream เนื่องจากคุณจำเป็นต้องเขียนลงไฟล์ และหากคุณต้องการอ่านข้อมูลจากไฟล์ คลาสอ็อบเจ็กต์ ifstream จะถูกสร้างขึ้น // สร้าง object สำหรับเขียนไฟล์ ofstream /*object name*/; // วัตถุของคลาส ofstream ลองเรียกวัตถุ fout นี่คือสิ่งที่เราได้รับ: ออฟสตรีม fout; ทำไมเราถึงต้องการวัตถุ? วัตถุจะต้องสามารถเขียนลงไฟล์ได้ วัตถุได้ถูกสร้างขึ้นแล้ว แต่ไม่เกี่ยวข้องกับไฟล์ที่ต้องเขียนสตริงลงไป Fout.open("cppstudio.txt"); // เชื่อมโยงวัตถุกับไฟล์ ด้วยการดำเนินการแบบจุด เราสามารถเข้าถึงเมธอดคลาส open() ซึ่งเราระบุชื่อไฟล์ในวงเล็บ ไฟล์ที่ระบุจะถูกสร้างขึ้นในไดเร็กทอรีปัจจุบันพร้อมกับโปรแกรม หากมีไฟล์ชื่อเดียวกัน ไฟล์ที่มีอยู่จะถูกแทนที่ด้วยไฟล์ใหม่ ดังนั้นไฟล์จึงเปิดอยู่ สิ่งที่เหลืออยู่คือการเขียนบรรทัดที่ต้องการลงไป ทำเช่นนี้: ฟูต<< "Работа с файлами в С++"; // запись строки в файл
การใช้การดำเนินการสตรีมร่วมกับอ็อบเจ็กต์ fout สตริงการทำงานกับไฟล์ในภาษา C++ จะถูกเขียนลงในไฟล์ เนื่องจากไม่จำเป็นต้องเปลี่ยนเนื้อหาของไฟล์อีกต่อไป จึงต้องปิด กล่าวคือ จะต้องแยกอ็อบเจ็กต์ออกจากไฟล์ Fout.ปิด(); //ปิดไฟล์ ผลลัพธ์ - ไฟล์ถูกสร้างขึ้นโดยมีบรรทัดการทำงานกับไฟล์ใน C ++ ขั้นตอนที่ 1 และ 2 สามารถรวมเข้าด้วยกันได้ กล่าวคือ สร้างออบเจ็กต์และเชื่อมโยงกับไฟล์ในบรรทัดเดียว ทำเช่นนี้: Ofstream fout("cppstudio.txt"); // สร้างอ็อบเจ็กต์ของคลาส ofstream และเชื่อมโยงกับไฟล์ cppstudio.txt มารวมโค้ดทั้งหมดเข้าด้วยกันและรับโปรแกรมต่อไปนี้ // file.cpp: กำหนดจุดเริ่มต้นสำหรับแอปพลิเคชันคอนโซล #รวม "stdafx.h" #รวม ยังคงต้องตรวจสอบว่าโปรแกรมทำงานอย่างถูกต้องหรือไม่ และหากต้องการทำสิ่งนี้ ให้เปิดไฟล์ cppstudio.txt และดูเนื้อหาแล้วมันควรจะเป็น-การทำงานกับไฟล์ในภาษา C++ โปรแกรมแสดงวิธีการอ่านจากไฟล์ได้ 2 วิธี วิธีแรกใช้การถ่ายโอนไปยังสตรีม วิธีที่สองใช้ฟังก์ชันรับสาย() - ในกรณีแรก เฉพาะคำแรกเท่านั้นที่จะถูกอ่าน และในกรณีที่สอง สตริงที่มีความยาว 50 อักขระจะถูกอ่าน แต่เนื่องจากไฟล์มีอักขระน้อยกว่า 50 ตัว ระบบจึงอ่านอักขระจนถึงและรวมอักขระสุดท้ายด้วย โปรดทราบว่าการอ่านครั้งที่สอง (บรรทัดที่ 17) ต่อเนื่องหลังคำแรก ไม่ใช่ตั้งแต่ต้น เนื่องจากอ่านคำแรกแล้วบรรทัดที่ 14- ผลลัพธ์ของโปรแกรมแสดงในรูปที่ 1 การทำงานกับไฟล์ในภาษา C++ หากต้องการดำเนินการต่อ ให้กดปุ่มใดก็ได้ - - รูปที่ 1 - การทำงานกับไฟล์ในภาษา C++ โปรแกรมทำงานได้อย่างถูกต้อง แต่สิ่งนี้ไม่ได้เกิดขึ้นเสมอไปแม้ว่าทุกอย่างจะเป็นไปตามรหัสก็ตาม ตัวอย่างเช่นชื่อของไฟล์ที่ไม่มีอยู่ถูกส่งไปยังโปรแกรมหรือมีข้อผิดพลาดในชื่อ แล้วไงล่ะ? ในกรณีนี้จะไม่มีอะไรเกิดขึ้นเลย ไม่พบไฟล์ซึ่งหมายความว่าจะไม่สามารถอ่านได้ ดังนั้นคอมไพเลอร์จะละเว้นบรรทัดที่ทำงานบนไฟล์ ส่งผลให้โปรแกรมออกอย่างถูกต้อง แต่ไม่มีสิ่งใดปรากฏบนหน้าจอ ดูเหมือนว่านี่จะเป็นปฏิกิริยาปกติอย่างสมบูรณ์ต่อสถานการณ์เช่นนี้ แต่ผู้ใช้ทั่วไปจะไม่เข้าใจว่าเกิดอะไรขึ้นและเหตุใดบรรทัดจากไฟล์จึงไม่ปรากฏบนหน้าจอ ดังนั้นเพื่อให้ทุกอย่างชัดเจน C++ จึงจัดให้มีฟังก์ชันดังกล่าว - is_open() ซึ่งส่งคืนค่าจำนวนเต็ม: 1 - หากเปิดไฟล์ได้สำเร็จ 0 - หากเปิดไฟล์ไม่ได้ มาแก้ไขโปรแกรมด้วยการเปิดไฟล์ เพื่อว่าถ้าไฟล์นั้นไม่ได้เปิดอยู่ ข้อความที่เกี่ยวข้องก็จะปรากฏขึ้น // file_read.cpp: กำหนดจุดเริ่มต้นสำหรับแอปพลิเคชันคอนโซล #รวม "stdafx.h" #รวม ผลลัพธ์ของโปรแกรมแสดงในรูปที่ 2 ไม่สามารถเปิดไฟล์ได้! หากต้องการดำเนินการต่อ ให้กดปุ่มใดก็ได้ - - รูปที่ 2 - การทำงานกับไฟล์ในภาษา C++ ดังจะเห็นได้จากรูปที่ 2 โปรแกรมแจ้งว่าไม่สามารถเปิดไฟล์ได้ ดังนั้นหากโปรแกรมทำงานกับไฟล์ได้ ขอแนะนำให้ใช้ฟังก์ชันนี้ is_open() แม้ว่าคุณจะแน่ใจว่าไฟล์นั้นมีอยู่จริงก็ตาม โหมดการเปิดไฟล์จะกำหนดวิธีการใช้ไฟล์ ในการตั้งค่าโหมด คลาส ios_base จัดเตรียมค่าคงที่ที่กำหนดโหมดการเปิดไฟล์ (ดูตารางที่ 1) โหมดการเปิดไฟล์สามารถตั้งค่าได้โดยตรงเมื่อสร้างวัตถุหรือเมื่อเรียกใช้ฟังก์ชัน open() .
Ofstream fout("cppstudio.txt", ios_base::app); // เปิดไฟล์เพื่อผนวกข้อมูลต่อท้ายไฟล์ fout.open("cppstudio.txt", ios_base::app); // เปิดไฟล์เพื่อผนวกข้อมูลต่อท้ายไฟล์ โหมดการเปิดไฟล์สามารถรวมกันได้โดยใช้การดำเนินการทางลอจิคัลระดับบิต หรือ- ตัวอย่างเช่น: ios_base::out | ios_base::trunc - เปิดไฟล์เพื่อเขียนหลังจากล้างข้อมูลแล้ว ออบเจ็กต์ของคลาส ofstream เมื่อเชื่อมโยงกับไฟล์ โดยค่าเริ่มต้นจะมีโหมดการเปิดไฟล์ ios_base::out | ios_base::trunc .
นั่นคือไฟล์จะถูกสร้างขึ้นหากไม่มีอยู่ หากมีไฟล์อยู่ เนื้อหาจะถูกลบ และตัวไฟล์จะพร้อมสำหรับการเขียน ออบเจ็กต์ของคลาส ifstream เมื่อเชื่อมโยงกับไฟล์ จะมีโหมดการเปิดไฟล์เริ่มต้น ios_base::in - ไฟล์เป็นแบบเปิดอ่านอย่างเดียว โหมดการเปิดไฟล์เรียกอีกอย่างว่าแฟล็ก เพื่อให้อ่านง่าย เราจะใช้คำนี้ในอนาคต ตารางที่ 1 ไม่ได้แสดงรายการแฟล็กทั้งหมด แต่สิ่งเหล่านี้น่าจะเพียงพอสำหรับการเริ่มต้นของคุณ โปรดทราบว่าคำอธิบายของ ate และ app นั้นคล้ายกันมาก โดยทั้งคู่จะเลื่อนตัวชี้ไปที่ท้ายไฟล์ แต่แฟล็กของแอปอนุญาตให้เขียนได้เฉพาะที่ท้ายไฟล์เท่านั้น และแฟล็ก ate ก็ย้ายแฟล็กไปที่จุดสิ้นสุด ของไฟล์และไม่จำกัดตำแหน่งในการเขียน มาพัฒนาโปรแกรมที่ใช้การดำเนินการ sizeof() เพื่อคำนวณคุณสมบัติของประเภทข้อมูลหลักใน C++ และเขียนลงในไฟล์ ข้อมูลจำเพาะ: ไฟล์จะต้องเขียนในรูปแบบต่อไปนี้: /* ประเภทข้อมูลไบต์ค่าสูงสุด bool = 1 255.00 char = 1 255.00 int สั้น = 2 32767.00 int สั้นที่ไม่ได้ลงนาม = 2 65535.00 int = 4 2147483647.00 int ที่ไม่ได้ลงนาม = 4 4294967295.00 long int = 4 .00 int ยาวที่ไม่ได้ลงนาม = 4 4294967295.00 ทศนิยม = 4 2147483647.00 ลอยยาว = 8 9223372036854775800.00 สองเท่า = 8 9223372036854775800.00 */ โปรแกรมดังกล่าวได้รับการพัฒนาแล้วก่อนหน้านี้ในส่วนนี้ แต่มีข้อมูลทั้งหมดเกี่ยวกับประเภทข้อมูลถูกส่งออกไปยังอุปกรณ์เอาต์พุตมาตรฐาน และเราจำเป็นต้องสร้างโปรแกรมใหม่เพื่อให้ข้อมูลถูกเขียนลงในไฟล์ ในการดำเนินการนี้ คุณต้องเปิดไฟล์ในโหมดเขียน โดยมีการตัดข้อมูลไฟล์ปัจจุบันออกเบื้องต้น ( บรรทัดที่ 14- เมื่อสร้างไฟล์และเปิดได้สำเร็จ (บรรทัดที่ 16 - 20) แทนที่จะเป็นคำสั่ง cout บรรทัดที่ 22เราใช้วัตถุ fout ดังนั้นข้อมูลประเภทข้อมูลจะถูกเขียนลงไฟล์แทนหน้าจอ // write_file.cpp: กำหนดจุดเริ่มต้นสำหรับแอปพลิเคชันคอนโซล #รวม "stdafx.h" #รวม เป็นไปไม่ได้เลยที่จะไม่สังเกตว่าการเปลี่ยนแปลงในโปรแกรมมีเพียงเล็กน้อย และต้องขอบคุณความจริงที่ว่าอินพุต/เอาท์พุตมาตรฐานและอินพุต/เอาท์พุตของไฟล์ถูกใช้ในลักษณะเดียวกันทุกประการ ท้ายโปรแกรมเวลา.บรรทัดที่ 45เราปิดไฟล์อย่างชัดเจน แม้ว่าจะไม่จำเป็น แต่ก็ถือว่าเป็นแนวทางการเขียนโปรแกรมที่ดี เป็นที่น่าสังเกตว่าฟังก์ชันและเครื่องมือจัดการทั้งหมดที่ใช้ในการจัดรูปแบบอินพุต/เอาท์พุตมาตรฐานนั้นเกี่ยวข้องกับอินพุต/เอาท์พุตของไฟล์ด้วย ดังนั้นจึงไม่มีข้อผิดพลาดเกิดขึ้นเมื่อมีการกล่าวคำสั่งศาล ถูกแทนที่ด้วยวัตถุสู้
// file_read.cpp: กำหนดจุดเริ่มต้นสำหรับแอปพลิเคชันคอนโซล #รวม "stdafx.h" #รวม โหมดการเปิดไฟล์
