ไฟล์ข้อความ

ลองดูการทำงานกับไฟล์ข้อความในภาษา C โดยใช้ตัวอย่าง สร้างไฟล์ข้อความบนไดรฟ์ C ชื่อ TextFile.txt พิมพ์บรรทัดต่อไปนี้ในไฟล์นี้:

สตริง_1 123 สตริง_11, 456
สตริง_2
สตริง_3

บันทึกไฟล์.

และนี่คือโค้ดสำหรับโปรแกรม C ที่เปิดไฟล์ของเราและอ่านบรรทัดจากมัน:

/* *ผู้เขียน: @author Subbotin B.P..h> #include #define LEN 50 int main(void) ( puts("การดำเนินการกับไฟล์ข้อความ"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("Problems"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile); กลับ EXIT_SUCCESS;

หากต้องการเปิดไฟล์ข้อความในภาษา C ให้ใช้ฟังก์ชัน fopen:

ไฟล์ *pTextFile = fopen("C:\\TextFile.txt", "r");

อาร์กิวเมนต์แรกของฟังก์ชัน fopen ชี้ไปที่ไฟล์ และอาร์กิวเมนต์ที่สองบอกว่าไฟล์นั้นเปิดให้อ่านได้

เราอ่านบรรทัดโดยใช้ฟังก์ชัน fgets:

fgets(cArray, LEN, pTextFile);

อาร์กิวเมนต์แรกของฟังก์ชัน fgets ชี้ไปที่อาร์เรย์อักขระที่จะเก็บสตริงที่ได้รับ อาร์กิวเมนต์ที่สองคือจำนวนอักขระสูงสุดที่จะอ่าน และอาร์กิวเมนต์ที่สามคือไฟล์ของเรา

หลังจากทำงานกับไฟล์เสร็จแล้ว คุณต้องปิดมัน:

fclose(pTextFile);

เราได้รับ:

ตัวอักษรรัสเซียก็ปรากฏอยู่ในบรรทัดด้วย

อีกอย่างผมสร้างโปรแกรมนี้ใน Eclipse คุณสามารถดูวิธีทำงานกับ C/C++ ได้ใน Eclipse

ดังนั้นเราจึงเปิดและอ่านข้อมูลจากไฟล์ข้อความ

ตอนนี้เรามาเรียนรู้วิธีสร้างไฟล์ข้อความโดยทางโปรแกรมและเขียนข้อมูลลงไป

/* ผู้แต่ง: @author Subbotin B.P..h> #include int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "นี่คือสตริง"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts("ปัญหา"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine);

สร้างไฟล์ข้อความเพื่อเขียนข้อมูลไปที่:

ไฟล์ *pTextFile = fopen("C:\\TextFileW.txt", "w");

หากไฟล์มีอยู่แล้ว ไฟล์นั้นจะถูกเปิดและข้อมูลทั้งหมดจากไฟล์นั้นจะถูกลบ

C-string cString และหมายเลข nVal ถูกเขียนโดยโปรแกรมไปยังไฟล์ข้อความ cNewLine เป็นเพียงบรรทัดใหม่

เราเขียนข้อมูลลงในไฟล์ข้อความโดยใช้ฟังก์ชัน fprintf:

fprintf(pTextFile, "%s%c", cString, cNewLine);

อาร์กิวเมนต์แรกที่นี่คือไฟล์ของเรา อาร์กิวเมนต์ที่สองคือสตริงรูปแบบ อาร์กิวเมนต์ที่สามขึ้นไปคือจำนวนอาร์กิวเมนต์ที่จำเป็นสำหรับรูปแบบนี้

ส่วนนี้จะครอบคลุมถึงสองวิธีในการทำงานกับไฟล์และคลาส MFC CFileDialog มาตรฐาน

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 (คลาส CFile, CStdioFile, ... ) และคลาส MFC มาตรฐาน CFileDialog

ไลบรารี MFC มีหลายคลาสสำหรับการทำงานกับไฟล์ คลาสที่กล่าวถึงด้านล่างนี้สืบทอดมาจากคลาสพื้นฐาน

ซีไฟล์.

คลาส CF ile

ซีไฟล์ออกแบบมาเพื่อทำงานกับไฟล์ ทำให้ไฟล์ใช้งานได้ง่ายขึ้นโดยการแสดงไฟล์เป็นออบเจ็กต์ที่สามารถสร้าง อ่าน เขียน ฯลฯ

ในการเข้าถึงไฟล์ คุณต้องสร้างอ็อบเจ็กต์ของคลาส CFile ก่อน ตัวสร้างคลาสช่วยให้คุณสามารถเปิดไฟล์ได้ทันทีหลังจากสร้างวัตถุดังกล่าว แต่คุณสามารถเปิดไฟล์ได้ในภายหลังโดยใช้วิธีการ

เปิด.

การเปิดและสร้างไฟล์

หลังจากสร้างวัตถุคลาสแล้ว ซีไฟล์คุณสามารถเปิดไฟล์ได้โดยการเรียกเมธอดเปิด- วิธีการจะต้องระบุเส้นทางไปยังไฟล์ที่จะเปิดและโหมดการใช้งาน ต้นแบบวิธีการเปิดมีแบบฟอร์มดังนี้

เปิดบูลเสมือน (LPCTSTR lpszFileName, UINT nOpenFlags, CFileException * pError = NULL);

เนื่องจากเป็นพารามิเตอร์ lpszFileName คุณต้องระบุชื่อของไฟล์ที่จะเปิด คุณสามารถระบุเพียงชื่อไฟล์หรือชื่อไฟล์เต็มที่มีเส้นทางแบบเต็มได้

พารามิเตอร์ตัวที่สอง nOpenFlags ระบุการดำเนินการที่เมธอด Open ดำเนินการกับไฟล์ รวมถึงแอตทริบิวต์ของไฟล์ ด้านล่างนี้เป็นค่าที่เป็นไปได้สำหรับพารามิเตอร์ nOpenFlags:

• CFile::modeCreate - สร้างไฟล์ใหม่ หากมีไฟล์ที่ระบุอยู่ เนื้อหาจะถูกลบและความยาวไฟล์จะถูกตั้งค่าเป็นศูนย์
• CFile::modeNoTruncate - ไฟล์นี้มีวัตถุประสงค์เพื่อใช้ร่วมกับไฟล์ CFile::modeCreate หากสร้างไฟล์ที่มีอยู่ เนื้อหาจะไม่ถูกลบ

CFile::modeRea d - ไฟล์ถูกเปิดแบบอ่านอย่างเดียว

CFile::modeReadWrite - ไฟล์นี้เปิดขึ้นเพื่อเขียนและอ่าน

CFile::modeWrite - ไฟล์นี้เปิดเพื่อการเขียนเท่านั้น

CFile::typeText - ใช้โดยคลาสที่ได้รับจากคลาส CFile เช่น CStdioFile เพื่อทำงานกับไฟล์ในโหมดข้อความ โหมดข้อความจะแปลงอักขระขึ้นบรรทัดใหม่และอักขระป้อนบรรทัดรวมกัน

CFile::Binary - ใช้โดยคลาสที่ได้รับจากคลาส CFile เช่น CStdioFile เพื่อทำงานกับไฟล์ในโหมดไบนารี

พารามิเตอร์เผื่อเลือก 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 ตัวชี้ไปยังไฟล์จะเป็นประเภท FILE และการประกาศจะมีลักษณะดังนี้:

ไฟล์ *ไฟล์ของฉัน;

หากด้วยเหตุผลใดก็ตาม (ไม่มีไฟล์ตามที่อยู่ที่ระบุ การเข้าถึงไฟล์นั้นถูกปฏิเสธ) ฟังก์ชัน fopen() ไม่สามารถเปิดไฟล์ได้ ฟังก์ชันจะคืนค่า NULL ในโปรแกรมจริง พวกเขามักจะจัดการกับข้อผิดพลาดในการเปิดไฟล์ในสาขา if แต่เราจะละเว้นสิ่งนี้ต่อไป

การประกาศฟังก์ชัน fopen() มีอยู่ในไฟล์ส่วนหัว stdio.h ดังนั้นจึงต้องรวมไว้ด้วย นอกจากนี้ใน stdio.h มีการประกาศประเภทโครงสร้าง FILE

หลังจากทำงานกับไฟล์เสร็จสิ้น เป็นธรรมเนียมที่จะต้องปิดไฟล์เพื่อล้างบัฟเฟอร์จากข้อมูลและด้วยเหตุผลอื่นๆ นี่เป็นสิ่งสำคัญอย่างยิ่งหากโปรแกรมยังคงทำงานต่อไปหลังจากทำงานกับไฟล์แล้ว การตัดการเชื่อมต่อระหว่างไฟล์ภายนอกและตัวชี้ไปยังไฟล์จากโปรแกรมทำได้โดยใช้ฟังก์ชัน fclose() ตัวชี้ไปยังไฟล์ถูกส่งผ่านไปเป็นพารามิเตอร์:
fclose (ไฟล์ของฉัน);

สามารถเปิดไฟล์ได้มากกว่าหนึ่งไฟล์ในโปรแกรม ในกรณีนี้ แต่ละไฟล์จะต้องเชื่อมโยงกับตัวชี้ไฟล์ของตัวเอง อย่างไรก็ตาม หากโปรแกรมทำงานกับไฟล์เดียวก่อนแล้วจึงปิดไป ตัวชี้ก็สามารถใช้เพื่อเปิดไฟล์ที่สองได้

การอ่านและการเขียนลงในไฟล์ข้อความ

เอฟสแกนเอฟ()

ฟังก์ชัน fscanf() มีความหมายคล้ายกับฟังก์ชัน scanf() แต่ต่างจากฟังก์ชันตรงตรงที่ให้อินพุตที่จัดรูปแบบจากไฟล์ แทนที่จะเป็นสตรีมอินพุตมาตรฐาน ฟังก์ชัน fscanf() รับพารามิเตอร์: ตัวชี้ไฟล์, สตริงรูปแบบ, ที่อยู่ของพื้นที่หน่วยความจำสำหรับการเขียนข้อมูล:
fscanf(myfile, "%s%d", str, &a);

ส่งกลับจำนวนข้อมูลที่อ่านสำเร็จหรือ EOF ช่องว่างและอักขระขึ้นบรรทัดใหม่จะนับเป็นตัวคั่นข้อมูล

สมมติว่าเรามีไฟล์ที่มีคำอธิบายของวัตถุดังต่อไปนี้:

แอปเปิ้ล 10 23.4 กล้วย 5 25.0 ขนมปัง 1 10.3

#รวม main () ( FILE * file; struct food ( char name[ 20 ] ; unsigned qty; float price; ) ; struct food shop[ 10 ] ; char i= 0 ; file = fopen ( "fscanf.txt" , "r" ) ; ในขณะที่ (fscanf (ไฟล์, "%s%u%f" , ร้านค้า[ i].name , & (ร้านค้า[ i].qty ) , & (ร้านค้า[ i].price ) != EOF) ( printf ( "%s %u %.2f \n", ร้านค้า[ i].ชื่อ, ร้านค้า[ i].จำนวน, ร้านค้า[ i].price);

ฉัน++;

-

ฟังก์ชัน fgets() คล้ายกับฟังก์ชัน gets() และทำการป้อนข้อมูลทีละบรรทัดจากไฟล์ การเรียก fgets() หนึ่งครั้งจะอ่านหนึ่งบรรทัด ในกรณีนี้คุณไม่สามารถอ่านทั้งบรรทัดได้ แต่จะอ่านได้เพียงบางส่วนตั้งแต่ต้นเท่านั้น พารามิเตอร์ fgets() มีลักษณะดังนี้:
fgets (Character_array, number_of_Characters_read, pointer_to_file)

ตัวอย่างเช่น:
fgets(str, 50, มายไฟล์)

การเรียกฟังก์ชันนี้จะอ่านจากไฟล์ที่เกี่ยวข้องกับตัวชี้ myfile หนึ่งบรรทัดของข้อความหากความยาวน้อยกว่า 50 อักขระ รวมถึงอักขระ "\n" ซึ่งฟังก์ชันจะจัดเก็บไว้ในอาร์เรย์ด้วย องค์ประกอบสุดท้าย (อันดับที่ 50) ของอาร์เรย์ str จะเป็นอักขระ "\0" ที่เพิ่มโดย fgets() หากสตริงยาวกว่านี้ ฟังก์ชันจะอ่านอักขระ 49 ตัวและเขียน "\0" ต่อท้าย ในกรณีนี้ "\n" จะไม่อยู่ในบรรทัดการอ่าน

#รวม #define N 80 main () ( FILE * file; char arr[ N] ; file = fopen ( "fscanf.txt" , "r" ) ; while (fgets (arr, N, file) != NULL) printf (" %s" , arr) ; printf (" \n"- fclose (ไฟล์);

-

ในโปรแกรมนี้ ต่างจากโปรแกรมก่อนหน้านี้ ข้อมูลจะถูกอ่านทีละบรรทัดในอาร์เรย์ arr เมื่ออ่านบรรทัดถัดไป บรรทัดก่อนหน้าจะหายไป ฟังก์ชัน fgets() จะคืนค่า NULL หากไม่สามารถอ่านบรรทัดถัดไปได้

getc() หรือ fgetc()

ฟังก์ชัน getc() หรือ fgetc() (ใช้งานได้ทั้งคู่) ช่วยให้คุณรับอักขระตัวถัดไปจากไฟล์ได้ \n"ในขณะที่ ((arr[ i] = fgetc (ไฟล์) ) != EOF) ( ถ้า (arr[ i] == " \0 " ) (arr[i] = " \n"- printf("%s \0 " ) (arr[i] = " \n", ถึงแล้ว) ;

ฉัน = 0 ;

) อื่น ๆ ฉัน++;

)arr[i] = "

• , ถึงแล้ว) ;
• โค้ดตัวอย่างจะแสดงข้อมูลจากไฟล์บนหน้าจอ
• การเขียนลงในไฟล์ข้อความ

เช่นเดียวกับอินพุต เอาต์พุตไปยังไฟล์อาจแตกต่างกัน

เอาต์พุตที่จัดรูปแบบแล้ว ฟังก์ชัน fprintf (file_index, format_string, ตัวแปร)

เอาต์พุตแบบโพสต์ต่อบรรทัด ฟังก์ชั่น fputs(string, file_pointer) \n"เอาต์พุตอักขระต่ออักขระ ฟังก์ชัน fputc() หรือ putc(สัญลักษณ์, file_pointer)

ด้านล่างนี้เป็นตัวอย่างโค้ดที่ใช้สามวิธีในการส่งออกข้อมูลไปยังไฟล์

การเขียนฟิลด์ของโครงสร้างเดียวลงในแต่ละบรรทัดของไฟล์: \n"ไฟล์ = fopen ("fprintf.txt" , "w" ) ;

ในขณะที่ (scanf ("%s%u%f" , ร้านค้า[ i].name , & (ร้านค้า[ i].qty ) , & (ร้านค้า[ i].price ) ) != EOF) ( fprintf (ไฟล์ " %s %u %.2f

ในขณะที่ ((i = getchar () ) != EOF) putc (i, ไฟล์);

อ่านและเขียนลงในไฟล์ไบนารี

คุณสามารถทำงานกับไฟล์ได้ไม่ใช่เป็นลำดับอักขระ แต่เป็นลำดับไบต์ โดยหลักการแล้ว ไม่สามารถทำงานกับไฟล์ที่ไม่ใช่ข้อความได้ด้วยวิธีอื่น อย่างไรก็ตาม คุณสามารถอ่านและเขียนลงในไฟล์ข้อความได้ด้วยวิธีนี้ ข้อดีของวิธีการเข้าถึงไฟล์นี้คือความเร็วในการอ่าน-เขียน: บล็อกข้อมูลที่สำคัญสามารถอ่าน/เขียนได้ในการเข้าถึงครั้งเดียว

เมื่อเปิดไฟล์สำหรับการเข้าถึงแบบไบนารี พารามิเตอร์ตัวที่สองที่จะ fopen() คือสตริง "rb" หรือ "wb"

หัวข้อการทำงานกับไฟล์ไบนารี่ค่อนข้างซับซ้อนและต้องมีบทเรียนแยกต่างหากเพื่อศึกษา ที่นี่จะมีการบันทึกเฉพาะคุณสมบัติของฟังก์ชั่นการอ่านและเขียนไฟล์ซึ่งถือเป็นสตรีมไบต์เท่านั้น

ฟังก์ชัน fread() และ fwrite() ใช้เป็นพารามิเตอร์:

1. ที่อยู่ของพื้นที่หน่วยความจำที่ข้อมูลถูกเขียนหรืออ่าน
2. ขนาดเท่าของประเภทใดประเภทหนึ่ง
3. จำนวนข้อมูลที่อ่านตามขนาดที่ระบุ
4. ดัชนีไฟล์.

ฟังก์ชันเหล่านี้จะส่งคืนจำนวนข้อมูลที่อ่านหรือเขียนได้สำเร็จ เหล่านั้น. คุณสามารถ "สั่ง" การอ่านองค์ประกอบข้อมูล 50 รายการได้ แต่จะได้รับเพียง 10 รายการ จะไม่มีข้อผิดพลาด

ตัวอย่างการใช้ฟังก์ชัน fread() และ fwrite()

#รวม #รวม main () ( ไฟล์ * file; ถ่านชั้นวาง 1[ 50 ], ชั้นวาง 2 [ 100 ] ; int n, m; file = fopen ("shelf1.txt" , "rb" ) ; n= fread (ชั้นวาง 1, ขนาดของ (ถ่าน) , 50 , ไฟล์) ; fclose (ไฟล์) ; file = fopen ("shelf2.txt" , "rb" ) ; m= fread (shelf2, sizeof (ถ่าน) , 50 , ไฟล์) ; \0 " - ชั้นวาง2[m] = " \n"- ชั้นวาง2[ ม+ 1 ] = " \0 " - ไฟล์ = fopen ("shop.txt" , "wb" ) ;

fwrite (strcat (ชั้นวาง2, ชั้นวาง1) , ขนาดของ (ถ่าน ) , n+ m, ไฟล์);

fclose (ไฟล์);

1. -
2. นี่เป็นการพยายามอ่านอักขระ 50 ตัวจากไฟล์แรก n เก็บจำนวนอักขระที่อ่านจริง ค่าของ n สามารถเป็น 50 หรือน้อยกว่าได้ ข้อมูลจะถูกวางเรียงกันเป็นแถว สิ่งเดียวกันนี้เกิดขึ้นกับไฟล์ที่สอง ถัดไป บรรทัดแรกจะถูกต่อท้ายบรรทัดที่สอง และข้อมูลจะถูกเทลงในไฟล์ที่สาม

เราได้เรียนรู้วิธีการเขียนข้อมูลลงในไฟล์ข้อความแล้ว – หากคุณยังไม่ได้เรียนรู้วิธีการ โปรดดูบทความก่อนหน้านี้ มีการเล่าและอธิบายอย่างละเอียด

แต่จะเกิดอะไรขึ้นถ้ามีไฟล์อยู่แล้วและเราจำเป็นต้องอ่านข้อมูลจากไฟล์นั้นเพื่อการประมวลผล? โชคดีที่นี่ก็ค่อนข้างง่ายเช่นกัน ฉันขอเตือนคุณว่ามีหลายตัวเลือกในการดำเนินงานนี้ ฉันได้อธิบายไว้เพียงตัวเลือกเดียวเท่านั้น สิ่งที่อธิบายไว้คือสิ่งที่เข้าใจง่ายที่สุดสำหรับฉันเป็นการส่วนตัวด้วยเหตุผลบางประการ

#รวม

int หลัก()
{
ถ่าน s1 //ตัวแปรจะอ่านสตริง
ifstream ใน (“C:\\\FromC\\myfile.txt” ); -เปิดไฟล์เพื่ออ่านข้อมูล
ใน >>s1 ; -อ่านบรรทัด
in.close() //กำลังปิดไฟล์

ศาล<ส่งออกค่า s1ไปที่หน้าจอ
กลับ 0 ;
}

นี่เป็นโปรแกรมที่ง่ายที่สุดในการอ่านบรรทัดแรกจากไฟล์ข้อความที่อยู่ตามเส้นทาง
C:\\\FromC\\myfile.txt –
เนื่องจากนี่เป็นความต่อเนื่องของบทความที่แล้ว ฉันจึงตัดสินใจใช้ไฟล์ที่เราสร้างขึ้นที่นั่น ไม่น่าจะมีปัญหาใด ๆ กับเรื่องนี้
แต่กลับมาที่โค้ดกัน ขั้นแรกเราเปิดไฟล์เพื่ออ่านข้อมูลจากนั้นเราใช้คำสั่ง ถ้าสตรีมในวงเล็บเราจะระบุชื่อไฟล์หรือเส้นทางไปยังไฟล์เหมือนอย่างที่ฉันเคยทำ (“C:\\\FromC\\myfile.txt” );
เมื่อเราเปิดไฟล์เพื่ออ่านอะไรบางอย่างจากไฟล์นั้น เราก็ได้ประกาศตัวแปรหนึ่งตัวเช่น ถ่าน –
ถ่าน s1
ตอนนี้สิ่งที่เราต้องทำคือกำหนดค่าของสตริงจากไฟล์ให้กับตัวแปร เราทำสิ่งนี้กันเป็นทีม ใน
ให้ความสนใจกับวงเล็บมุม ใน >>
จริงๆ แล้วอย่างที่ควรจะชัดเจนตั้งแต่คอมเม้นท์ถึงโค้ดโปรแกรม เพื่อให้ตัวแปรกำหนดค่าที่อ่านได้เราต้องเขียนไว้ทีหลัง ใน >>
ใน >>s1 ;

ดูเหมือนจะไม่ใช่เรื่องยากโดยเฉพาะหากคุณเชี่ยวชาญและเรียนรู้การใช้เนื้อหาจากบทความที่แล้วอย่างสมบูรณ์ - ทุกอย่างเหมือนกันทุกประการมีเพียง 2 คำสั่งเท่านั้นที่แตกต่างกัน

การสร้างไฟล์และเขียนข้อมูล C++ ลงไป

ของกระแส ออก (ชื่อไฟล์ );
ออก<< (สตริงที่จะเขียน);
ออก.ปิด();
=============================

การอ่านข้อความจากไฟล์และการพิมพ์ข้อความไปยังหน้าจอใน C ++

ถ้าสตรีม ใน (ชื่อไฟล์ );
ใน>> (กำลังอ่านบรรทัด);
ใน.ปิด();(ปิดไฟล์)
============================
มาเขียนโปรแกรมง่ายๆ ที่จะอ่านข้อความที่ป้อนจากคีย์บอร์ดและเขียนลงในไฟล์:

#รวม
#รวม

int หลัก()
{
\\ 3 บรรทัดในอนาคต
clrscsr(); -การล้างหน้าจอ

ศาล<<“Wwedi pervuu stroku” ; ซิน >>ก ; สิ้นสุด ;
ศาล<<“Wwedi wtoruu stroku” ; ซิน >>ข ; สิ้นสุด ;
ศาล<<“Wwedi tretuu stroku” ; ซิน >>ค ; สิ้นสุด ;
clrscr(); -

/*เริ่มทำงานกับไฟล์*/
ofstream ออก (“C:\\\FromC\\myfile.txt” ); -การเปิดไฟล์เพื่อเขียน
ออก<เขียนบรรทัดแรก
ออก<เขียนบรรทัดที่สอง
ออก<เขียนบรรทัดที่สาม
ออก.ปิด(); -กำลังปิดไฟล์

//รีเซ็ตตัวแปร

สำหรับ (int i =0 ;i<=255 ;i ++)
(ก =*“” ; ข =*“” ; ค =*“” ;)

ถ้าสตรีมใน (“C:\\\FromC\\myfile.txt” );
ใน >>ก >>ข >>ค ; -เราอ่านแต่ละบรรทัดใหม่เป็นตัวแปรใหม่
ใน.ปิด(); -กำลังปิดไฟล์

/* */

สำหรับ (i =0 ;a !=*“” ;i ++)
{
ถ้า (i >ขนาดของ(a )) หยุดพัก ;
ศาล<
}
ศาล<<“\n” ; \\

/* */

{
ถ้า (i >ขนาดของ(b)) หยุดพัก ;
ศาล<
}
ศาล<<“\n” ; \\ ย้ายเคอร์เซอร์ไปที่บรรทัดใหม่

/* */

สำหรับ (i =0 ;с !=*“” ;i ++)
{
ถ้า (i >ขนาดของ(c )) หยุดพัก ;
ศาล<<с ;
}

กลับ 0 ;
}
===================

ในตัวอย่างข้างต้นมีอยู่อย่างหนึ่ง ใหญ่ ข้อบกพร่อง หากเราพยายามป้อนบรรทัดที่มีการเว้นวรรค โปรแกรมจะไม่ทำงานตามที่เราต้องการ อาจไม่ใช่แค่ฉันเท่านั้น แต่ยังมีคนอื่นอีกหลายคนที่เจอข้อผิดพลาดนี้ ดังนั้นฉันจึงทิ้งรหัสที่ไม่ถูกต้องไว้เพื่อให้คุณเห็นว่าคุณอาจพบอะไรบ้าง

เนื่องจากที่บ้านไม่มีหนังสือฉันจึงเริ่มค้นหาอินเทอร์เน็ตอีกครั้งและพบเรื่องไร้สาระที่ซับซ้อนมากมาย แต่อย่างใดฉันก็พบวิธีแก้ไขปัญหาของฉัน
มันช่วยให้ฉันได้อ่านสิ่งนั้น ศาลสนับสนุนวิธีการของเขา และคำแนะนำทั้งหมดบนอินเทอร์เน็ตเกี่ยวกับการใช้ฟังก์ชันนี้ รับสายโชคดีสำหรับฉัน ฉันค้นพบวิธีใช้ฟังก์ชันนี้ได้อย่างรวดเร็ว จากนั้นจึงนำไปใช้ในโค้ด
โดยทั่วไปก็น่าพูดถึงและอธิบายฟังก์ชั่นนี้นะ แต่จนถึงตอนนี้ ผมยังไม่เข้าใจจริงๆ แค่เข้าใจว่ามันต้องใช้ และเข้าใจวิธี ดังนั้นผมจะยกตัวอย่างโปรแกรมของเราที่กำลังพัฒนาให้ถูกต้องมากขึ้น : :

#รวม
#รวม

int หลัก()
{
ถ่าน a,b,c; \\ 3 บรรทัดในอนาคต
clrscsr(); -การล้างหน้าจอ

/* ใส่ค่าตัวแปร*/

ศาล<<“Wwedi pervuu stroku” ; cin.getline(ก,ขนาดของ(ก));สิ้นสุด ;
ศาล<<“Wwedi wtoruu stroku” ; cin.getline(a,ขนาดของ(b));สิ้นสุด ;
ศาล<<“Wwedi tretuu stroku” ; cin.getline(a,ขนาดของ(c));สิ้นสุด ;
clrscr(); -หลังจากป้อนค่าแล้ว หน้าจอก็ถูกล้าง

/*เริ่มทำงานกับไฟล์*/
ofstream ออก (“C:\\\FromC\\myfile.txt”); -การเปิดไฟล์เพื่อเขียน
ออก<เขียนบรรทัดแรก
ออก<เขียนบรรทัดที่สอง
ออก<เขียนบรรทัดที่สาม
ออก.ปิด(); -กำลังปิดไฟล์

//รีเซ็ตตัวแปร

สำหรับ (int i =0 ;i<=255 ;i ++)
(ก =*“” ; ข =*“” ; ค=*“” ;)

/*ทำงานกับไฟล์ต่อไป*/

ถ้าสตรีมเข้า (“C:\\\FromC\\myfile.txt” );
in.getline(a,ขนาดของ(a));// ก
in.getline(b,ขนาดของ(b));// การอ่านบรรทัดลงในตัวแปร ข
in.getline(c,ขนาดของ(c)); // การอ่านบรรทัดลงในตัวแปร ค
ใน.ปิด(); -กำลังปิดไฟล์

/* เราอ่านอักขระบรรทัดแรกทีละอักขระและแสดงบนหน้าจอ */

สำหรับ (i =0 ;a !=*“” ;i++)
{
ถ้า (i >ขนาดของ(a )) หยุดพัก ;
ศาล<
}
ศาล<<“\n” ; \\ ย้ายเคอร์เซอร์ไปที่บรรทัดใหม่

/* เราอ่านอักขระบรรทัดที่สองทีละอักขระและแสดงบนหน้าจอ */

สำหรับ (i =0 ;b !=*“” ;i ++)
{
ถ้า (i >ขนาดของ(b)) หยุดพัก ;
ศาล<
}
ศาล<<“\n” ; \\ ย้ายเคอร์เซอร์ไปที่บรรทัดใหม่

/* เราอ่านอักขระบรรทัดที่สามทีละอักขระและแสดงบนหน้าจอ */

สำหรับ (i =0 ;с !=*“” ;i++)
{
ถ้า (i>ขนาดของ (c )) หยุดพัก ;
ศาล<<с[i];
}

รับ(); -รอให้กดปุ่ม Enter
กลับ 0 ;
}
===================

เนื้อหานี้อธิบายตัวอย่างการอ่านข้อมูลทีละตัวอักษร เนื่องจากฉันไม่ได้อธิบายการทำงานกับตัวแปรเช่น ถ่านผู้เริ่มต้นอาจประสบปัญหาในการทำความเข้าใจโค้ด ฉันแค่ไม่รู้ว่าประเภทไหน ถ่านมีลักษณะเฉพาะบางอย่างและคิดว่าทุกอย่างง่ายขึ้น ดังนั้นจึงสามารถอ่านช่วงเวลาที่เข้าใจยากของโปรแกรมข้างต้นได้ในบทความต่อไปนี้ ทำงานกับถ่านวี C++ สำหรับผู้เริ่มต้น

มิฉะนั้น ตัวอย่างที่ให้ไว้ของวิธีการอ่านบรรทัดจากไฟล์ข้อความในภาษา C++ ควรสามารถเข้าถึงได้และค่อนข้างเข้าใจได้ นี่ไม่ใช่ตัวเลือกการใช้งานที่ดีที่สุดในขณะนี้ และฉันพลาดจุดสำคัญบางจุดไป แต่เนื่องจากเรากำลังเริ่มเรียนรู้ภาษา C++ ตอนนี้ก็เพียงพอแล้ว ต่อมาฉันคงจะไปถึงสิ่งที่พลาดไป แต่ตอนนี้ฉันต้องรับรู้เฉพาะสิ่งที่จำเป็นที่สุดเท่านั้น

หากคุณและฉันเข้าใจเนื้อหานี้ แสดงว่าเราได้ก้าวไปสู่ความเป็นมืออาชีพเพียงเล็กน้อย

บันทึก:
หยุดพัก ;– นี่คือคำสั่งที่ออกจากลูป เรามีถ้าตัวนับรอบ สำหรับมีขนาดใหญ่กว่าขนาดที่ประกาศของตัวแปร ถ่าน,จากนั้นเราก็ออกจากวงอย่างเข้มแข็ง
!= – นี่คือเงื่อนไขที่เราตั้งไว้ เงื่อนไขนี้แสดงโดยความไม่เท่าเทียมกัน
ถ้า(ก !=ข)- อ่านเหมือนว่า. กไม่เท่ากัน ข

สิ้นสุด ; -นี่เป็นการย้ายเคอร์เซอร์ไปที่บรรทัดใหม่ภายในคอนโซล (เท่าที่ฉันเข้าใจ)
คำสั่งนี้คล้ายกับ “\n”

การทำงานกับไฟล์ข้อความใน 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);

//เพิ่มหน่วยความจำ

ลบ [ ]ก;

ระบบ("หยุดชั่วคราว");