Thực đơn
trang chủẢnh và video

Với các ví dụ về tập tin và chuỗi. Nhập từ tập tin và xuất ra tập tin

Tệp văn bản

Hãy xem xét cách làm việc với một tệp văn bản trong C bằng một ví dụ. Tạo một file văn bản trên ổ C có tên TextFile.txt. Nhập các dòng sau vào tệp này:

Chuỗi_1 123 Chuỗi_11, 456
Chuỗi_2
Chuỗi_3

Lưu các tập tin.

Và đây là mã cho chương trình C mở tệp của chúng tôi và đọc các dòng từ nó:

/* *Tác giả: @author Subbotin B.P..h> #include #define LEN 50 int main(void) ( put("Thao tác tệp văn bản"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( put("Sự cố"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile);

Để mở tệp văn bản trong C, hãy sử dụng hàm fopen:

TẬP_TIN *pTextFile = fopen("C:\\TextFile.txt", "r");

Đối số đầu tiên của hàm fopen trỏ đến một tệp và đối số thứ hai cho biết rằng tệp đang mở để đọc từ nó.

Chúng tôi đọc các dòng bằng hàm fgets:

fgets(cArray, LEN, pTextFile);

Đối số đầu tiên của hàm fgets trỏ đến một mảng ký tự trong đó các chuỗi nhận được sẽ được lưu trữ, đối số thứ hai là số ký tự tối đa có thể đọc và đối số thứ ba là tệp của chúng ta.

Sau khi làm việc xong với file, bạn cần đóng nó lại:

fclose(pTextFile);

Chúng tôi nhận được:

Các chữ cái tiếng Nga cũng xuất hiện trên dòng chữ.

Nhân tiện, tôi đã tạo chương trình này trong Eclipse. Bạn có thể xem cách làm việc với C/C++ trong Eclipse.

Vì vậy, chúng tôi đã mở và đọc dữ liệu từ một tệp văn bản.

Bây giờ hãy tìm hiểu cách tạo một tệp văn bản và ghi dữ liệu vào đó theo chương trình.

/* Tác giả: @author Subbotin B.P..h> #include int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Đây là một chuỗi"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) (đặt("Sự cố"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine ;

Tạo một tệp văn bản để ghi dữ liệu vào:

TẬP_TIN *pTextFile = fopen("C:\\TextFileW.txt", "w");

nếu tệp đã tồn tại, nó sẽ được mở và tất cả dữ liệu trong đó sẽ bị xóa.

Chuỗi cString và số nVal được chương trình ghi vào một tệp văn bản. cNewLine chỉ đơn giản là một dòng mới.

Chúng tôi ghi dữ liệu vào tệp văn bản bằng hàm fprintf:

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

đối số đầu tiên ở đây là file của chúng ta, đối số thứ hai là chuỗi định dạng, đối số thứ ba trở lên là số lượng đối số cần thiết cho định dạng này.

Để dễ dàng truy cập, thông tin trong thiết bị lưu trữ được lưu trữ dưới dạng tệp.

Tệp là vùng được đặt tên của bộ nhớ ngoài được phân bổ để lưu trữ một mảng dữ liệu. Dữ liệu chứa trong các tệp có tính chất rất đa dạng: các chương trình bằng thuật toán hoặc ngôn ngữ máy; dữ liệu ban đầu về hoạt động của chương trình hoặc kết quả thực hiện chương trình; văn bản miễn phí; hình ảnh đồ họa, v.v.

Thư mục (thư mục, thư mục) - một tập hợp byte được đặt tên trên phương tiện lưu trữ chứa tên của các thư mục con và tệp, được sử dụng trong hệ thống tệp để đơn giản hóa việc tổ chức tệp.

Hệ thống tập tinđược gọi là phần chức năng của hệ điều hành thực hiện các thao tác trên tệp. Ví dụ về các hệ thống tập tin là FAT (FAT - File Allocation Table), NTFS, UDF (được sử dụng trên đĩa CD).

Có ba phiên bản chính của FAT: FAT12, FAT16 và FAT32. Chúng khác nhau về độ sâu bit của các bản ghi trong cấu trúc đĩa, tức là. số bit được phân bổ để lưu trữ số cụm. FAT12 được sử dụng chủ yếu cho đĩa mềm (tối đa 4 KB), FAT16 - cho đĩa dung lượng nhỏ, FAT32 - cho ổ FLASH dung lượng cao (tối đa 32 GB).

Hãy xem cấu trúc của hệ thống tập tin sử dụng FAT32 làm ví dụ.

Cấu trúc tệp FAT32

Các thiết bị bộ nhớ ngoài trong hệ thống FAT32 có địa chỉ khối thay vì địa chỉ byte. Thông tin được ghi vào thiết bị bộ nhớ ngoài theo khối hoặc cung.

Một khu vực là đơn vị lưu trữ thông tin có địa chỉ tối thiểu trên các thiết bị lưu trữ bên ngoài. Thông thường, kích thước cung được cố định ở mức 512 byte. Để tăng không gian địa chỉ của thiết bị bộ nhớ ngoài, các cung được kết hợp thành các nhóm gọi là cụm.

Cụm là sự kết hợp của một số lĩnh vực, có thể được coi là một đơn vị độc lập với một số thuộc tính nhất định. Thuộc tính chính của cụm là kích thước của nó, được đo bằng số cung hoặc số byte.

Hệ thống tệp FAT32 có cấu trúc sau.

Các cụm dùng để ghi tập tin được đánh số bắt đầu từ 2. Theo quy định, cụm số 2 được sử dụng bởi thư mục gốc và bắt đầu từ cụm số 3 mảng dữ liệu được lưu trữ. Các lĩnh vực được sử dụng để lưu trữ thông tin phía trên thư mục gốc không được nhóm lại.
Kích thước tệp tối thiểu được yêu cầu trên đĩa tương ứng với 1 cụm.

Khu vực khởi động bắt đầu với thông tin sau:

  • EB 58 90 – nhảy và ký vô điều kiện;
  • 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
  • 00 02 – số byte trong khu vực (thường là 512);
  • 1 byte – số cung trong cụm;
  • 2 byte – số lượng lĩnh vực dự trữ.

Ngoài ra, khu vực khởi động còn chứa các thông tin quan trọng sau:

  • 0x10 (1 byte) – số bảng FAT (thường là 2);
  • 0x20 (4 byte) – số lượng cung trên đĩa;
  • 0x2С (4 byte) – số cụm của thư mục gốc;
  • 0x47 (11 byte) – nhãn âm lượng;
  • 0x1FE (2 byte) – chữ ký khu vực khởi động (55 AA).

Khu vực thông tin hệ thống tập tin chứa:

  • 0x00 (4 byte) – chữ ký (52 52 61 41);
  • 0x1E4 (4 byte) – chữ ký (72 72 41 61);
  • 0x1E8 (4 byte) – số cụm miễn phí, -1 nếu không xác định;
  • 0x1EC (4 byte) – số cụm được ghi cuối cùng;
  • 0x1FE (2 byte) – chữ ký (55 AA).

Bảng FAT chứa thông tin về trạng thái của từng cụm trên đĩa. 2 byte thấp hơn của bảng FAT lưu trữ F8 FF FF 0F FF FF FF FF (tương ứng với trạng thái của cụm 0 và 1, không có mặt vật lý). Tiếp theo, trạng thái của mỗi cụm chứa số cụm mà tệp hiện tại tiếp tục hoặc thông tin sau:

  • 00 00 00 00 – cụm miễn phí;
  • FF FF FF 0F – kết thúc tập tin hiện tại.
  • 8 byte – tên tệp;
  • 3 byte – phần mở rộng tập tin;

Thư mục gốc chứa một tập hợp các bản ghi thông tin 32 bit về mỗi tệp, chứa các thông tin sau:

Khi làm việc với tên tệp dài (bao gồm cả tên tiếng Nga), tên tệp được mã hóa bằng hệ thống mã hóa UTF-16. Trong trường hợp này, 2 byte được phân bổ để mã hóa từng ký tự. Trong trường hợp này, tên tệp được viết theo cấu trúc sau:

  • 1 byte trình tự;
  • 10 byte chứa 5 ký tự thấp hơn của tên tệp;
  • thuộc tính 1 byte;
  • dành riêng 1 byte;
  • 1 byte – tổng kiểm tra tên DOS;
  • 12 byte chứa 3 ký tự thấp hơn của tên tệp;
  • 2 byte – số của cụm đầu tiên;
  • các ký tự còn lại của tên dài.

Làm việc với các tập tin bằng ngôn ngữ C

Đối với người lập trình, một tệp đang mở được biểu diễn dưới dạng một chuỗi dữ liệu được đọc hoặc ghi. Khi một tập tin được mở, nó được liên kết với Luồng vào/ra. Thông tin đầu ra được ghi vào luồng, thông tin đầu vào được đọc từ luồng.

Khi một luồng được mở cho I/O, nó sẽ được liên kết với cấu trúc FILE tiêu chuẩn, được xác định trong stdio.h. Cấu trúc FILE chứa thông tin cần thiết về tệp.

Việc mở một tệp được thực hiện bằng cách sử dụng hàm fopen(), hàm này trả về một con trỏ tới cấu trúc kiểu FILE có thể được sử dụng cho các thao tác tiếp theo trên tệp.

TẬP TIN *fopen(tên, loại);


name – tên của file cần mở (bao gồm cả đường dẫn),
type là một con trỏ tới một chuỗi ký tự xác định cách truy cập tệp:
  • "r" - mở tệp để đọc (tệp phải tồn tại);
  • "w" - mở một tập tin trống để viết; nếu tệp tồn tại, nội dung của nó sẽ bị mất;
  • "a" - mở tệp để ghi đến cuối (để nối thêm); tập tin được tạo nếu nó không tồn tại;
  • "r+" - mở tệp để đọc và ghi (tệp phải tồn tại);
  • "w+" - mở một tệp trống để đọc và ghi; nếu tệp tồn tại, nội dung của nó sẽ bị mất;
  • "a+" - mở tệp để đọc và nối thêm; nếu tệp không tồn tại thì nó sẽ được tạo.

Giá trị trả về là một con trỏ tới luồng đang mở. Nếu gặp lỗi, giá trị NULL sẽ được trả về.

Hàm fclose() đóng luồng hoặc các luồng liên kết với tệp được mở bằng hàm fopen(). Luồng cần đóng được xác định bởi đối số của hàm fclose().

Giá trị trả về: giá trị 0 nếu luồng được đóng thành công; EOF không đổi nếu xảy ra lỗi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

#bao gồm
int chính() (
TẬP TIN *fp;
tên char = "my.txt";
if ((fp = fopen(tên, "r")) == NULL )
{
printf( "Không thể mở tập tin");
getchar();
trả về 0;
}
// mở file thành công
... // các hành động bắt buộc trên dữ liệu
fclose(fp);
getchar();
trả về 0;
}

Đọc một ký tự từ một tập tin:

char fgetc(luồng);


Đối số của hàm là một con trỏ tới luồng kiểu FILE. Hàm trả về mã của ký tự đã đọc. Nếu đến cuối tệp hoặc xảy ra lỗi, hằng số EOF sẽ được trả về.

Viết ký hiệu vào một tập tin:

fputc(char, luồng);

Các đối số của hàm là một ký tự và một con trỏ tới luồng kiểu FILE. Hàm trả về mã của ký tự đã đọc.

Các hàm fscanf() và fprintf() tương tự như các hàm scanf() và printf() nhưng hoạt động với các tệp dữ liệu và có một con trỏ tệp làm đối số đầu tiên của chúng.

fscanf(stream, "InputFormat", đối số);

Đối với người lập trình, một tệp đang mở được biểu diễn dưới dạng một chuỗi dữ liệu được đọc hoặc ghi. Khi một tập tin được mở, nó được liên kết với Luồng vào/ra . Thông tin đầu ra được ghi vào luồng, thông tin đầu vào được đọc từ luồng.

Khi một luồng được mở cho I/O, nó sẽ được liên kết với cấu trúc FILE tiêu chuẩn, được xác định trong stdio.h. Cấu trúc FILE chứa thông tin cần thiết về tệp.

Việc mở một tệp được thực hiện bằng cách sử dụng hàm fopen(), hàm này trả về một con trỏ tới cấu trúc kiểu FILE có thể được sử dụng cho các thao tác tiếp theo trên tệp.

TẬP TIN *fopen(tên, loại);

name – tên của file cần mở (bao gồm cả đường dẫn),
type - con trỏ tới một chuỗi ký tự xác định cách truy cập tệp:

· "r" - mở tệp để đọc (tệp phải tồn tại);

· "w" - mở một tập tin trống để viết; nếu tệp tồn tại, nội dung của nó sẽ bị mất;

· "a" - mở file để ghi đến cuối (để nối thêm); tập tin được tạo nếu nó không tồn tại;

· "r+" - mở tệp để đọc và ghi (tệp phải tồn tại);

· "w+" - mở một tập tin trống để đọc và ghi; nếu tệp tồn tại, nội dung của nó sẽ bị mất;

· "a+" - mở tệp để đọc và nối thêm; nếu tệp không tồn tại, nó sẽ được tạo.

Giá trị trả về là một con trỏ tới luồng đang mở. Nếu phát hiện lỗi, giá trị NULL sẽ được trả về.

Hàm fclose() đóng luồng hoặc các luồng liên kết với tệp được mở bằng hàm fopen(). Luồng cần đóng được xác định bởi đối số của hàm fclose().

Giá trị trả về: giá trị 0 nếu luồng được đóng thành công; EOF không đổi nếu xảy ra lỗi.

#bao gồm
int chính()

tên char="my.txt";

if(fp = fopen(tên, "r")!=NULL)

// có thể mở tập tin được không?
... // các hành động bắt buộc trên dữ liệu

else printf("Không mở được file");

Đọc một ký tự từ một tập tin:

char fgetc(luồng);

Đối số của hàm là một con trỏ tới luồng kiểu FILE. Hàm trả về mã của ký tự đã đọc. Nếu đến cuối tệp hoặc xảy ra lỗi, hằng số EOF sẽ được trả về.
Viết ký hiệu vào một tập tin:

fputc(char, luồng);

Các đối số của hàm là một ký tự và một con trỏ tới luồng kiểu FILE. Hàm trả về mã của ký tự đã đọc.

Các hàm fscanf() và fprintf() tương tự như các hàm scanf() và printf() nhưng hoạt động với các tệp dữ liệu và có một con trỏ tới tệp làm đối số đầu tiên của chúng.

fscanf(stream, "Định dạng đầu vào", đối số);
fprintf(luồng, "Định dạng đầu ra", đối số);

Các hàm fgets() và fputs() được thiết kế để nhập/xuất chuỗi; chúng tương tự như các hàm gets() và put() để làm việc với các tệp.

fgets(Con trỏ tới dòng, Số ký tự, luồng);

Các ký tự được đọc từ luồng cho đến khi ký tự dòng mới "\n" được đọc, được bao gồm trong chuỗi hoặc cho đến khi luồng kết thúc EOF hoặc số lượng ký tự tối đa đã được đọc. Kết quả được đặt trong một con trỏ chuỗi và kết thúc bằng ký tự null "\0". Hàm trả về địa chỉ của chuỗi.

fputs(Con trỏ tới chuỗi, luồng);

Sao chép một chuỗi vào luồng từ vị trí hiện tại. Ký tự null kết thúc không được sao chép.
Ví dụ Nhập số và lưu vào file s1.txt. Đọc số từ tệp s1.txt, tăng lên 3 và lưu vào tệp s2.txt.

Chúng ta đã học cách ghi thông tin vào một tệp văn bản. – Nếu bạn chưa học được cách thực hiện, hãy xem bài viết trước. Nó được kể và mô tả chi tiết

Nhưng nếu tệp đã tồn tại và chúng ta cần đọc thông tin từ nó để xử lý thì sao? May mắn thay, điều này cũng khá đơn giản. Hãy để tôi nhắc bạn rằng có một số lựa chọn để thực hiện nhiệm vụ này; tôi chỉ mô tả một trong số đó. Điều được mô tả là điều mà vì lý do nào đó đối với cá nhân tôi, điều đó có vẻ dễ hiểu nhất.

#bao gồm

int chính()
{
ký tự s1 //Biến sẽ đọc chuỗi
ifstream trong (“C:\\\FromC\\myfile.txt” ); //Mở file để đọc thông tin
trong >>s1 ; //đọc dòng
in.close() //Đóng tập tin

cout<Xuất giá trị s1đến màn hình
trả về 0;
}

Đây là chương trình đơn giản nhất để đọc dòng đầu tiên từ tệp văn bản nằm dọc theo đường dẫn
C:\\\FromC\\myfile.txt –
Vì đây là phần tiếp theo của bài viết trước nên tôi quyết định sử dụng tệp mà chúng tôi đã tạo ở đó. Có lẽ sẽ không có bất kỳ khó khăn nào với việc này.
Nhưng hãy quay lại với đoạn mã. Đầu tiên chúng ta mở tệp để đọc thông tin từ nó, để làm điều này, chúng ta sử dụng lệnh nếu dòng trong ngoặc, chúng tôi chỉ ra tên tệp hoặc đường dẫn đến tệp, như tôi đã làm. (“C:\\\FromC\\myfile.txt” );
Khi chúng tôi mở một tệp để đọc nội dung nào đó từ nó, chúng tôi đã khai báo một biến như char –
char s1
Bây giờ tất cả những gì chúng ta phải làm là gán cho biến giá trị của chuỗi từ tệp. Chúng tôi làm điều này như một đội TRONG
Chú ý đến các dấu ngoặc nhọn trong >>
Trên thực tế, như đã nói rõ trong các nhận xét về mã chương trình, để biến có thể gán giá trị đọc, chúng ta phải viết nó sau trong >>
trong >>s1 ;

Đây dường như không phải là một nhiệm vụ đặc biệt khó khăn, đặc biệt nếu bạn đã thành thạo và học cách sử dụng tài liệu từ bài viết trước - mọi thứ hoàn toàn giống nhau, chỉ có 2 lệnh khác nhau

Tạo một tệp và ghi thông tin C++ vào nó

ngoài dòng ngoài ( Tên tập tin );
ngoài<< (Chuỗi cần viết);
ngoài.đóng();
=============================

Đọc văn bản từ tệp và in văn bản ra màn hình trong C++

nếu dòng TRONG (Tên tệp );
TRONG>> (Đọc dòng);
TRONG.đóng();(Đóng tập tin)
============================
Hãy viết một chương trình đơn giản để đọc văn bản nhập từ bàn phím và ghi nó vào một tệp:

#bao gồm
#bao gồm

int chính()
{
\\ 3 dòng tương lai
clrscsr(); // Xóa màn hình

cout<<“Wwedi pervuu stroku” ; cin >>a ; cuối cùng ;
cout<<“Wwedi wtoruu stroku” ; cin >>b ; cuối cùng ;
cout<<“Wwedi tretuu stroku” ; cin >>c ; cuối cùng ;
clrscr(); //

/*Bắt đầu làm việc với file*/
ofstream out (“C:\\\FromC\\myfile.txt” ); //Mở một tập tin để viết
ngoài<Viết dòng đầu tiên
ngoài<Viết dòng thứ hai
ngoài<Viết dòng thứ ba
out.close(); //Đóng tập tin

// Đặt lại biến về 0

vì (int i =0 ;i<=255 ;i ++)
(a =*“” ; b =*“” ; c =*“” ;)


ifstream trong(“C:\\\FromC\\myfile.txt” );
trong >>a >>b >>c ; //Chúng tôi đọc mỗi dòng mới vào một biến mới
ghim theo(); //Đóng tập tin

/* */

cho (i =0 ;a !=*“” ;i ++)
{
nếu (i >sizeof(a )) phá vỡ ;
cout<
}
cout<<“\n” ; \\

/* */


{
nếu (i >sizeof(b)) phá vỡ ;
cout<
}
cout<<“\n” ; \\ Đã di chuyển con trỏ sang dòng mới

/* */

vì (i =0 ;с !=*“” ;i ++)
{
nếu (i >sizeof(c )) phá vỡ ;
cout<<с ;
}

trả về 0;
 }
===================

Trong các ví dụ trên có một ví dụ như vậy TO LỚN lỗ hổng. Nếu chúng ta cố gắng nhập một dòng chứa khoảng trắng, chương trình sẽ không hoạt động như chúng ta cần. Chắc hẳn không chỉ riêng tôi mà nhiều người khác cũng gặp phải lỗi này. Vì vậy, tôi để lại mã không chính xác để bạn có thể xem những gì bạn có thể gặp phải.

Vì ở nhà không có sách nên tôi lại bắt đầu lùng sục trên Internet và tìm thấy rất nhiều thứ vô nghĩa phức tạp. Nhưng bằng cách nào đó tôi đã tìm ra giải pháp cho vấn đề của mình.
Nó đã giúp tôi đọc nó coutủng hộ phương pháp của anh ấy. Và trên Internet, mọi lời khuyên đều hướng tới việc sử dụng chức năng theo hàng Thật may mắn cho tôi, tôi đã nhanh chóng tìm ra cách sử dụng chức năng này và sau đó sử dụng nó trong mã.
Nói chung là đáng nói và mô tả chức năng này, nhưng đến giờ mình cũng chưa hiểu lắm, chỉ hiểu là nó cần được sử dụng và mình hiểu cách sử dụng nên mình sẽ đưa ra một ví dụ chính xác hơn về chương trình của mình đang được phát triển :

#bao gồm
#bao gồm

int chính()
{
ký tự a,b,c; \\ 3 dòng tương lai
clrscsr(); // Xóa màn hình

/*Nhập giá trị cho biến*/

cout<<“Wwedi pervuu stroku” ; cin.getline(a,sizeof(a)); cuối cùng ;
cout<<“Wwedi wtoruu stroku” ; cin.getline(a,sizeof(b)); cuối cùng ;
cout<<“Wwedi tretuu stroku” ; cin.getline(a,sizeof(c)); cuối cùng ;
clrscr(); //Sau khi nhập giá trị, màn hình sẽ bị xóa

/*Bắt đầu làm việc với file*/
ofstream out (“C:\\\FromC\\myfile.txt”); // Mở một tập tin để viết
ngoài<Viết dòng đầu tiên
ngoài<Viết dòng thứ hai
ngoài<Viết dòng thứ ba
out.close(); //Đóng tập tin

// Đặt lại biến về 0

vì (int i =0 ;i<=255 ;i ++)
(a =*“” ; b =*“” ; c=*“” ;)

/*Tiếp tục làm việc với tập tin*/

nếu truyền vào (“C:\\\FromC\\myfile.txt” );
in.getline(a,sizeof(a));// MỘT
in.getline(b,sizeof(b));// Đọc một dòng vào một biến b
in.getline(c,sizeof(c)); // Đọc một dòng vào một biến c
ghim theo(); //Đóng tập tin

/* Ta đọc từng ký tự dòng đầu tiên và hiển thị ra màn hình */

cho (i =0 ;a !=*“” ;i++)
{
nếu (i >sizeof(a )) phá vỡ ;
cout<
}
cout<<“\n” ; \\ Đã di chuyển con trỏ sang dòng mới

/* Chúng ta đọc từng ký tự dòng thứ 2 và hiển thị ra màn hình */

cho (i =0 ;b !=*“” ;i ++)
{
nếu (i >sizeof(b)) phá vỡ ;
cout<
}
cout<<“\n” ; \\ Đã di chuyển con trỏ sang dòng mới

/* Chúng ta đọc từng ký tự dòng thứ ba và hiển thị trên màn hình */

cho (i =0 ;с !=*“” ;i++)
{
if (i>sizeof (c )) phá vỡ ;
cout<<с[i];
}

getch(); \\Đang chờ nhấn phím Enter
trả về 0;
 }
===================

Tài liệu này mô tả một ví dụ về cách đọc thông tin theo từng ký tự. Vì tôi không mô tả cách làm việc với các biến như ký tự, thì người mới bắt đầu có thể gặp một số bất tiện trong việc hiểu mã. Tôi chỉ không biết loại nào ký tự có một số đặc thù và nghĩ rằng mọi thứ đều đơn giản hơn. Vì vậy, một số khoảnh khắc khó hiểu của chương trình trên có thể được đọc trong bài viết sau làm việc với char V. C++ cho người mới bắt đầu

Mặt khác, ví dụ đã cho về cách đọc dòng từ tệp văn bản trong C++ phải dễ hiểu và dễ hiểu. Đây không phải là tùy chọn triển khai tối ưu ngay bây giờ và tôi đã bỏ lỡ một số điểm quan trọng, nhưng vì chúng ta đang bắt đầu học ngôn ngữ C++ nên hiện tại điều này là khá đủ. Sau này có lẽ tôi sẽ đạt được những gì tôi đã bỏ lỡ, nhưng bây giờ tôi chỉ cần nhận thức những điều cần thiết nhất.

Nếu bạn và tôi hiểu tài liệu này, điều đó có nghĩa là chúng tôi đã tiến được một bước nhỏ hướng tới tính chuyên nghiệp của mình.

Ghi chú:
phá vỡ ;– Đây là lệnh thoát khỏi vòng lặp. Chúng ta có nếu bộ đếm chu kỳ vì trở nên lớn hơn kích thước khai báo của biến char, sau đó chúng tôi buộc phải thoát khỏi vòng lặp
!= – Đây là điều kiện chúng tôi đặt ra. Điều kiện này được biểu thị bằng sự bất đẳng thức
nếu(a !=b)– Đọc như thể Một không công bằng b

cuối cùng ; –Điều này là để di chuyển con trỏ đến một dòng mới bên trong bảng điều khiển (theo như tôi hiểu)
Lệnh này tương tự như "\N"

– so sánh để xác định sự bình đẳng hoặc bất bình đẳng.

Mục đích thực tế của phép liệt kê là xác định một tập hợp các hằng số ký hiệu riêng biệt của một kiểu số nguyên.

Ví dụ sử dụng biến liệt kê:

mo=1, tu, we, th, fr, sa, su ) ngày;

put(“ Nhập ngày trong tuần (từ 1 đến 7) : ”); scanf(“%d”, &t_day);

w_day = su; bắt đầu = tháng;

kết thúc = ngày_ngày -t_day;

printf(“\nThứ Hai là ngày %d trong tuần, \bây giờ là ngày %d.\n\

Cho đến cuối tuần %d ngày (ngày). ”, bắt đầu, t_day, kết thúc);

Kết quả của chương trình: Nhập ngày trong tuần (từ 1 đến 7): 2

Thứ Hai là ngày đầu tiên trong tuần, bây giờ là ngày thứ 2. Còn 5 ngày (ngày) nữa là hết tuần.

18. Tệp bằng ngôn ngữ C

Tệp là một tập hợp dữ liệu nằm trên phương tiện bên ngoài và được xem xét trong quá trình xử lý dưới dạng tổng thể. Các tập tin chứa dữ liệu nhằm mục đích lưu trữ lâu dài.

Có hai loại tệp: văn bản và nhị phân. Tệp văn bản là một chuỗi các ký tự ASCII và có thể được xem và chỉnh sửa bằng bất kỳ trình soạn thảo văn bản nào.

Tệp nhị phân (nhị phân) là một chuỗi dữ liệu, cấu trúc của nó được xác định bởi phần mềm.

Ngôn ngữ C có một tập hợp lớn các hàm để làm việc với các tệp, hầu hết chúng được tìm thấy trong thư viện stdio.h và io.h.

18.1. Mở một tập tin

Mỗi tệp được gán một tên logic nội bộ, tên này sẽ được sử dụng sau này khi truy cập vào nó. Tên logic (định danh file) là

con trỏ tới tập tin, tức là vào vùng bộ nhớ chứa tất cả thông tin cần thiết về tệp. Định dạng để khai báo một con trỏ tới một tập tin như sau:

FILE * con trỏ tới tập tin;

FILE – mã định danh kiểu cấu trúc được mô tả trong thư viện chuẩn

stdio.h và chứa các thông tin sau:

gõ cấu trúc (

– số byte chưa đọc còn lại trong bộ đệm;

kích thước bộ đệm thông thường là 512 byte; ngay khi cấp độ = 0,

khối dữ liệu tiếp theo được đọc vào bộ đệm từ tệp;

– cờ trạng thái tập tin – đọc, viết, nối thêm;

– mô tả tập tin, tức là con số xác định nó không-

giữ char không dấu;

– ký tự không được truyền đi, tức là ký tự ungetc;

– kích thước của bộ đệm trung gian bên trong;

bộ đệm char không dấu;

– giá trị con trỏ để truy cập bên trong bộ đệm, tức là

chỉ định phần đầu của bộ đệm, đầu dòng hoặc giá trị hiện tại

Giá trị của con trỏ bên trong bộ đệm tùy thuộc vào chế độ

ma đệm;

ký tự không dấu *curp;

– giá trị hiện tại của con trỏ để truy cập bên trong

fera, tức là chỉ định vị trí hiện tại trong bộ đệm trao đổi

tiếp tục với chương trình;

istemp không dấu;

– cờ tập tin tạm thời;

– gắn cờ khi làm việc với một tập tin;

) TÀI LIỆU;

Trước khi bạn bắt đầu làm việc với tệp, tức là. Để có thể đọc hoặc ghi thông tin vào một tập tin, nó phải được mở để truy cập. Với mục đích này, chức năng thường được sử dụng

FILE* fopen(char* file_name, chế độ char*);

nó nhận một biểu diễn bên ngoài - tên vật lý của tệp trên phương tiện (đĩa mềm, ổ cứng) và khớp với tên logic.

Tên vật lý, tức là tên tệp và đường dẫn đến nó được chỉ định bởi tham số đầu tiên

– ví dụ một dòng, “a:Mas_dat.dat” – một tệp có tên Mas_dat.dat nằm trên đĩa mềm, “d:\\work\\Sved.txt” – một tệp có tên Sved.txt nằm trên đĩa cứng ổ đĩa trong thư mục làm việc.

Chú ý! Dấu gạch chéo ngược (\), là ký tự đặc biệt, được viết hai lần trên một dòng.

Khi mở thành công, hàm fopen trả về một con trỏ tới tệp (sau đây gọi là con trỏ tệp). Nếu có lỗi, NULL được trả về. Tình huống này thường xảy ra khi đường dẫn đến tệp cần mở được chỉ định không chính xác. Ví dụ: nếu trong lớp hiển thị của trường đại học của chúng tôi, bạn chỉ định một đường dẫn bị cấm viết (thường là d:\work\ được cho phép).

Tham số thứ hai là dòng chỉ định chế độ truy cập tệp:

w – file được mở để ghi; nếu không có tệp nào có tên đã cho, nó sẽ được tạo; nếu một tệp như vậy tồn tại thì thông tin trước đó sẽ bị hủy trước khi mở;

r – tập tin mở ở chế độ chỉ đọc; nếu không có tệp đó thì sẽ xảy ra lỗi;

a – file được mở để thêm thông tin mới vào cuối;

r+ – tệp được mở để chỉnh sửa dữ liệu – có thể ghi và đọc thông tin;

w+ – giống như đối với r+;

a+ – giống như đối với a, chỉ có thể thực hiện việc ghi ở bất kỳ đâu trong tệp; đọc tập tin cũng có sẵn;

t – tệp mở ở chế độ văn bản; b – tệp mở ở chế độ nhị phân.

Chế độ văn bản khác với chế độ nhị phân ở chỗ khi một tệp được mở dưới dạng một cặp ký tự văn bản “nguồn cấp dữ liệu”, “trả về dòng” được thay thế bằng một ký tự duy nhất: “nguồn cấp dòng” cho tất cả các chức năng ghi dữ liệu vào tệp và đối với tất cả các chức năng đầu ra, ký tự “nguồn cấp dòng” " hiện được thay thế bằng hai ký tự: "nguồn cấp dòng", "trả về vận chuyển".

Theo mặc định, tệp sẽ mở ở chế độ văn bản. Ví dụ: TẬP TIN *f; – một con trỏ tới tập tin f được khai báo;

f = fopen("d:\\work\\Dat_sp.cpp", "w"); – một tệp có tên logic f, có tên vật lý Dat_sp.cpp, nằm trên ổ d, trong thư mục công việc, được mở để ghi; hoặc ngắn gọn hơn

FILE *f = fopen("d:\\work\\Dat_sp.cpp", "w");

18.2. Đóng một tập tin

Sau khi làm việc với một tập tin, quyền truy cập vào nó phải được đóng lại. Việc này được thực hiện bằng hàm int fclose (con trỏ tệp). Ví dụ, từ ví dụ trước, tệp được đóng như thế này: fclose (f);

Để đóng nhiều file, một hàm được đưa ra, khai báo như sau: void fcloseall (void);

Nếu bạn cần thay đổi chế độ truy cập cho một tệp, trước tiên bạn phải đóng tệp đó rồi mở lại nhưng với các quyền truy cập khác. Để thực hiện việc này, hãy sử dụng hàm tiêu chuẩn:

FILE* freopen (char*file_name, char *mode, FILE *file_pointer);

Hàm này đầu tiên đóng file đã khai báo con trỏ tập tin(như chức năng fopen thực hiện), sau đó mở tệp với "chế độ" tên tệp và quyền.

Ngôn ngữ C có khả năng làm việc với các tệp tạm thời chỉ cần thiết khi chương trình đang chạy. Trong trường hợp này, chức năng được sử dụng

TẬP_TIN* tmpfile(void);

tạo một tệp tạm thời trên đĩa với quyền truy cập “w+b”; sau khi chương trình hoàn thành hoặc sau khi tệp tạm thời bị đóng, nó sẽ tự động bị xóa.

18.3. Viết – đọc thông tin

Tất cả các hành động đọc và ghi dữ liệu vào một tập tin có thể được chia thành ba nhóm: các hoạt động đầu vào-đầu ra theo từng ký tự; hoạt động I/O theo từng dòng; chặn các hoạt động I/O.

Chúng ta hãy xem xét các chức năng chính được sử dụng trong mỗi nhóm trong ba nhóm hoạt động này.

I/O theo từng ký tự

Trong các hàm I/O theo từng ký tự, một ký tự được nhận từ một tệp hoặc một ký tự được gửi đến một tệp:

Hàng vào/ra

Các chức năng I/O dòng truyền từ một tập tin hoặc đến

Chặn I/O

Khối chức năng I/O hoạt động trên toàn bộ khối

thông tin:

int fread (void*p, intsize,

– đọc n khối có kích thước byte từ tập tin

int n, TẬP TIN *f)

la f tới vùng nhớ bằng con trỏ p (bắt buộc

int fwrite (void*p, intsize,

phân bổ bộ nhớ trước cho khối được đọc);

– ghi n khối kích thước byte từ mỗi khối

int n, TẬP TIN *f)

vùng nhớ có con trỏ p tới file f.

I/O được định dạng được tạo ra bởi các hàm.