/* 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++ sẽ 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 đang 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"

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) ( đặt("Sự cố"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile); return EXIT_SUCCESS; )

Để 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ờ chúng ta sẽ 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); fprintf(pTextFile, "%d", nVal); return EXIT_SUCCESS ; )

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 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.

Làm việc với các tập tin văn bản trong C++.

Có hai loại tệp chính: văn bản và nhị phân. Tệp cho phép người dùng đọc lượng lớn dữ liệu trực tiếp từ đĩa mà không cần phải nhập dữ liệu từ bàn phím.

Chữ các tập tin bao gồm bất kỳ ký tự nào được gọi. Chúng được tổ chức thành các dòng, mỗi dòng kết thúc bằng một ký tự cuối dòng. Bản thân phần cuối của tệp được biểu thị bằng ký hiệu "cuối tệp". Khi ghi thông tin vào tệp văn bản, tệp này có thể được xem bằng bất kỳ trình soạn thảo văn bản nào, tất cả dữ liệu sẽ được chuyển đổi thành loại ký tự và được lưu trữ ở dạng ký tự.

TRONG nhị phân Trong các tệp, thông tin được đọc và ghi dưới dạng các khối có kích thước nhất định, trong đó dữ liệu thuộc bất kỳ loại và cấu trúc nào có thể được lưu trữ.

Để làm việc với các tập tin, đặc biệt Loại dữ liệu, gọi điện dòng. Chảy nếu dòngđược sử dụng để làm việc với các tập tin ở chế độ đọc và ngoài dòngở chế độ ghi. Để làm việc với các tập tin ở cả chế độ ghi và đọc, một luồng được sử dụng dòng chảy.

Trong các chương trình C++, khi làm việc với các tệp văn bản, bạn phải bao gồm thư viện iostream và fstream.

Để viết ra dữ liệu vào một tệp văn bản, bạn cần:

mô tả một biến thuộc loại dòng.

xuất thông tin ra file.

hãy chắc chắn đóng tập tin.

Vì đọc dữ liệu từ một tệp văn bản, bạn cần:

mô tả một biến kiểu ifstream.

mở một tập tin bằng chức năng mở.

đóng tập tin.

Ghi thông tin vào một tập tin văn bản

Như đã đề cập trước đó, để bắt đầu làm việc với một tệp văn bản, bạn cần xác định một biến thuộc loại dòng. Ví dụ như thế này:

Biến F sẽ được tạo để ghi thông tin vào file.

Ở giai đoạn tiếp theo, tập tin phải được mở để ghi. Nói chung, toán tử mở luồng sẽ trông như sau:

F.open("tập tin", chế độ);

Ở đây F là một biến được mô tả là ofstream,

tập tin - tên đầy đủ của tập tin trên đĩa,

chế độ - chế độ làm việc với tệp đang được mở.

Xin lưu ý rằng khi chỉ định tên file đầy đủ, bạn phải sử dụng dấu gạch chéo kép. Ví dụ: tên đầy đủ của tệp noobs.txt, nằm trong thư mục trò chơi trên ổ D:, sẽ cần được viết như sau:

D:\\game\\noobs.txt.

Tệp có thể được mở ở một trong các chế độ sau:

ios::in - mở file ở chế độ đọc dữ liệu, chế độ này là chế độ mặc định cho ifstreams;

ios::out - mở tệp ở chế độ ghi dữ liệu (trong trường hợp này, thông tin về tệp hiện có bị hủy), chế độ này là chế độ mặc định cho luồng;

ios::app - mở tệp ở chế độ ghi dữ liệu vào cuối tệp;

ios::ate - di chuyển đến cuối tệp đã mở;

ios::trunc - xóa tệp, điều này cũng xảy ra ở chế độ ios::out;

ios::nocreate - không mở tệp nếu nó không tồn tại;

ios::noreplace - không mở tệp hiện có.

Tham số chế độ có thể vắng mặt, trong trường hợp đó tệp được mở ở chế độ mặc định cho luồng này.

Sau khi mở file thành công (ở chế độ bất kỳ), biến F sẽ lưu giá trị true, ngược lại là false. Điều này sẽ cho phép bạn kiểm tra tính chính xác của thao tác mở tệp.

Bạn có thể mở một tệp (hãy lấy tệp D:\\game\\noobs.txt làm ví dụ) ở chế độ ghi theo một trong các cách sau:

// Đầu tiên đường

của dòng F;

F.open("D:\\game\\noobs.txt", ios::out);

//phương thức thứ hai, chế độ ios::out là chế độ mặc định

// Vì chảyngoài dòng

của dòng F;

// phương thức thứ ba kết hợp mô tả biến và kiểu luồng

// và mở tệp bằng một câu lệnh

ofstream F("D:\\game\\noobs.txt", ios::out);

Sau khi mở tệp ở chế độ ghi, một tệp trống sẽ được tạo để bạn có thể ghi thông tin vào đó.

Nếu bạn muốn mở một tệp hiện có ở chế độ ghi đầu tiên, bạn nên sử dụng chế độ ios::app.

Sau khi mở tệp ở chế độ ghi, bạn có thể ghi vào tệp đó theo cách tương tự như trên màn hình, chỉ thay vì thiết bị đầu ra tiêu chuẩncoutbạn phải chỉ định tên của tệp đang mở.

Ví dụ: để ghi biến a vào luồng F, câu lệnh đầu ra sẽ như sau:

Để đầu ra tuần tự ra luồng G của các biến b, c, d, toán tử đầu ra sẽ trở thành như sau:

G<

Việc đóng luồng được thực hiện bằng toán tử:

VÍ DỤ:

Tạo một tệp văn bản D:\\game\\noobs.txt và viết n số thực vào đó.

#include "stdafx.h"

#bao gồm

#bao gồm

#bao gồm

sử dụng không gian tên std;

int chính()

setlocale(LC_ALL, "RUS");

int tôi, n;

gấp đôi;

// mô tả luồng ghi dữ liệu vào file

ngoài dòng f;

//mở file ở chế độ ghi,

//cách thứcios:: ngoàiđược cài đặt theo mặc định

f.open("D:\\game\\noobs.txt", ios::out);

//nhập số số thực

cout<<" N="; cin>> N;

//vòng lặp nhập số thực

// và ghi chúng vào một tập tin

với (i=0; tôi

cout<<"a=";

//Nhập một số

cin>>a;

f<

//đóng luồng

f.close();

hệ thống ("tạm dừng");

trả về 0;

_______________________________________________________________

Để đọc thông tin từ tệp văn bản, bạn cần mô tả một biến như nếu dòng. Sau này, bạn cần mở tệp để đọc bằng toán tử mở. Nếu biến được gọi là F thì hai câu lệnh đầu tiên sẽ như sau:

F.open("D:\\game\\noobs.txt", ios::in);

Sau khi mở tệp ở chế độ đọc, bạn có thể đọc thông tin từ tệp đó giống như từ bàn phím, chỉ thay vìcinchỉ định tên của luồng mà dữ liệu sẽ được đọc.

Ví dụ: để đọc từ luồng F vào biến a, câu lệnh đầu vào sẽ như sau:

Hai số trong trình soạn thảo văn bản được coi là tách biệt nếu có ít nhất một trong các ký tự giữa chúng: dấu cách, tab, cuối dòng. Thật tốt nếu lập trình viên biết trước có bao nhiêu và giá trị nào cần lưu trữ trong tệp văn bản. Tuy nhiên, thường loại giá trị được lưu trữ trong tệp được biết đơn giản nhưng số lượng của chúng có thể khác nhau. Để giải quyết vấn đề này, bạn cần đọc từng giá trị từ tệp một lần và trước mỗi lần đọc, hãy kiểm tra xem đã đến cuối tệp chưa. Có một chức năng cho việc này F. ôi().

Ở đây F là tên của thread, hàm trả về giá trị Boolean: true hoặc false, tùy thuộc vào việc có đến cuối file hay không. Do đó, một vòng lặp để đọc nội dung của toàn bộ tệp có thể được viết như sau:

//tổ chức đọc giá trị từ file, thực thi

//vòng lặp sẽ ngắt khi chúng ta đến cuối tập tin,

// trong trường hợp này F.eof() sẽ trả về true

trong khi (!F.eof())

VÍ DỤ:

Tệp văn bản D:\\game\\noobs.txt lưu trữ số thực, hiển thị trên màn hình và tính số của chúng.

#include "stdafx.h"

#bao gồm

#bao gồm

#bao gồm

#bao gồm

sử dụng không gian tên std;

int chính()

setlocale(LC_ALL, "RUS");

int n=0;

thả nổi một;

dòng chảy F;

//mở file ở chế độ đọc

F.open("D:\\game\\noobs.txt");

// nếu file được mở đúng cách thì

//vòng lặp đọc giá trị từ file; việc thực hiện vòng lặp sẽ bị gián đoạn,

// khi đến cuối file, trong trường hợp này F.eof() sẽ trả về true.

trong khi (!F.eof())

//đọc giá trị tiếp theo từ luồng F vào biến a

F>>a;

//xuất giá trị của biến a ra màn hình

cout<

// tăng số lượng số đọc

//đóng luồng

F.close();

//nhập ra màn hình số lượng vừa đọc được

cout<<"n="<

//nếu việc mở tệp không chính xác thì kết quả đầu ra

// thông báo về sự vắng mặt của tập tin đó

cách khác<<" Файл не существует"<

hệ thống ("tạm dừng");

trả về 0;

C++. Xử lý tệp nhị phân

Khi ghi thông tin vào tệp nhị phân, các ký tự và số được ghi dưới dạng một chuỗi byte.

Để viết ra dữ liệu sang tệp nhị phân, bạn cần:

mô tả một biến tệp thuộc loại FAIL * bằng cách sử dụng toán tử FILE *filename;. Ở đây tên tệp là tên của biến nơi con trỏ tới tệp sẽ được lưu trữ.

ghi thông tin vào một tập tin bằng hàm fwrite

Để đếm b dữ liệu từ tệp nhị phân, bạn cần:

mô tả một biến kiểu FILE *

mở file bằng hàm fopen

đóng một tập tin bằng hàm fclose

Các hàm cơ bản cần có để làm việc với tệp nhị phân.

Vì khám phá Tệp này được dành cho chức năng fopen.

TẬP_TIN *fopen(const *tên tệp, const char *chế độ)

Ở đây tên file là một chuỗi lưu tên đầy đủ của file đang được mở, mode là một chuỗi xác định chế độ làm việc với file; có thể có các giá trị sau:

“rb” - mở tệp nhị phân ở chế độ đọc;

“wb” - tạo một tệp nhị phân để ghi; nếu nó tồn tại, nội dung của nó sẽ bị xóa;

“ab” - tạo hoặc mở tệp nhị phân để thêm vào cuối tệp;

“rb+” - mở tệp nhị phân hiện có ở chế độ đọc-ghi;

“wb+” - mở tệp nhị phân ở chế độ đọc-ghi, tệp hiện có sẽ bị xóa;

"ab+" - một tệp nhị phân được mở hoặc tạo để sửa thông tin hiện có và thêm thông tin mới vào cuối tệp.

Hàm trả về NULL trong biến tệp f nếu tệp mở không thành công. Sau khi mở một tệp, byte thứ 0 của nó có sẵn, con trỏ tệp là 0, giá trị của nó khi được đọc hoặc ghi sẽ được dịch chuyển theo số byte được đọc (được ghi). Giá trị hiện tại của con trỏ tệp là số byte mà thao tác đọc hoặc ghi sẽ diễn ra.

Vì đóng cửa tập tin được dành cho chức năng fclose

int fclose(TẬP TIN *tên tệp);

Trả về 0 nếu tệp được đóng thành công, nếu không thì trả về NULL.

Chức năng loại bỏ là dành cho gỡ bỏ các tập tin.

int xóa(const char *tên tệp);

Hàm này xóa một tập tin có tên filenema khỏi đĩa. Tập tin cần xóa phải được đóng lại. Hàm trả về giá trị khác 0 nếu không thể xóa tệp.

Vì đổi tên tập tin, chức năng đổi tên được dự định:

int đổi tên(const char *oldfilename, const char *newfilename);

Tham số đầu tiên là tên tệp cũ, tham số thứ hai là tên mới. Trả về 0 nếu chương trình kết thúc thành công.

Đọc từ một tệp nhị phân được thực hiện bằng hàm fread:

fread(void *ptr, size, n, FILE *filename);

Hàm fread đọc n phần tử có kích thước từ tên tệp vào một mảng ptr. Hàm trả về số phần tử đã đọc. Sau khi đọc từ một tập tin, con trỏ của nó được dịch chuyển bởi byte có kích thước n*.

Ghi sang tệp nhị phân được thực hiện bằng hàm fwrite:

fwrite(const void *ptr, size, n, FILE *tên tệp);

Hàm fwrite ghi vào tên tệp từ một mảng ptr gồm n phần tử có kích thước. Hàm trả về số phần tử đã viết. Sau khi ghi thông tin vào tệp, con trỏ sẽ được dịch chuyển theo byte có kích thước n*.

Vì kiểm soát cuối tập tin có một hàm feof:

int feof(FILE *tên file);

Nó trả về giá trị khác 0 nếu đến cuối tệp.

VÍ DỤ:

Tạo một tệp nhị phân D:\\game\\noobs.dat và viết n số nguyên và n số thực vào đó.

#include "stdafx.h"

#bao gồm

sử dụng không gian tên std;

int chính()

setlocale(LC_ALL, "RUS");

int n, tôi;

gấp đôi;

//tạo file nhị phân ở chế độ ghi

f=fopen("D:\\game\\noobs.dat", "wb");

// đầu vào con sốN

cout<<"n="; cin>>n;

fwrite(&n, sizeof(int), 1, f);

//vòng lặp nhập n số thực

với (i=0; tôi

//nhập số thực tiếp theo

cout<<"a=";

cin>>a;

//ghi số thực vào file nhị phân

fwrite(&a, sizeof(double), 1, f);

// đóng tài liệu

fclose(f);

hệ thống ("tạm dừng");

trả về 0;

VÍ DỤ:

Hiển thị nội dung file nhị phân D:\\game\\noobs.dat đã tạo ở tác vụ trước

#include "stdafx.h"

#bao gồm

sử dụng không gian tên std;

int chính()

setlocale(LC_ALL, "RUS");

int n, tôi;

gấp đôi;

TẬP TIN *f; // mô tả biến tập tin

// mở tệp nhị phân hiện có ở chế độ đọc

//đọc một số nguyên từ file vào biến n

// xuất n ra màn hình

cout<<"n="<

// cấp phát bộ nhớ cho mảng n số

a=gấp đôi mới[n];

//đọc n số thực từ file vào mảng a

// xuất mảng ra màn hình

với (i=0; tôi

cout<

cout<

// đóng tài liệu

fclose(f);

hệ thống ("tạm dừng");

trả về 0;

Tập tin nhị phân- Cấu trúc dữ liệu tuần tự, sau khi mở một file thì byte đầu tiên lưu trong đó sẽ có sẵn. Bạn có thể ghi hoặc đọc dữ liệu từ một tập tin một cách tuần tự. Giả sử bạn cần đếm số thứ mười lăm, sau đó là số đầu tiên. Sử dụng truy cập tuần tự, điều này có thể được thực hiện theo cách sau:

int n, tôi;

gấp đôi;

TẬP TIN *f;

f=fopen("D:\\game\\noobs.dat", "rb");

với (i=0; tôi<15; i++)

fclose(f);

f=fopen("D:\\game\\noobs.dat", "rb");

fread(&a, sizeof(double), 1, f);

fclose(f);

Như bạn có thể thấy, việc đọc số từ một tệp rồi mở lại tệp đó không phải là cách thuận tiện nhất. Sẽ thuận tiện hơn nhiều khi sử dụng hàm fseek để di chuyển con trỏ tệp đến một byte nhất định.

int fseek(FILE *tên tệp, int offset dài, int Origin);

Hàm đặt con trỏ vị trí tệp hiện tại F theo giá trị gốc và giá trị offset. Tham số offset bằng số byte mà con trỏ tệp sẽ được offset so với điểm gốc được chỉ định bởi tham số gốc. Giá trị cho tham số Origin phải là một trong các giá trị offset sau được xác định trong tiêu đề stdio.h:

SEEK_SET - từ đầu tệp;

SEEK_CUR - từ vị trí hiện tại;

SEEK_END - từ cuối tệp.

Hàm trả về giá trị 0 nếu thao tác thành công, giá trị khác 0 nếu offset không thành công.

Hàm fseek thực sự triển khai quyền truy cập trực tiếp vào bất kỳ giá trị nào trong tệp. Bạn chỉ cần biết vị trí (số byte) của giá trị trong tệp. Hãy xem xét việc sử dụng quyền truy cập trực tiếp vào các tệp nhị phân bằng cách sử dụng vấn đề sau làm ví dụ.

VÍ DỤ

Trong tệp nhị phân D:\\game\\noobs.dat được tạo trước đó, hoán đổi số thực lớn nhất và nhỏ nhất.

Thuật toán giải bài toán bao gồm các giai đoạn sau:

đọc số thực từ một tập tin vào mảng a.

tìm kiếm trong mảng a các giá trị tối đa (tối đa) và tối thiểu (tối thiểu) cũng như số của chúng (imax, imin).

di chuyển con trỏ tệp đến giá trị tối đa và ghi giá trị tối thiểu.

di chuyển con trỏ tệp đến giá trị tối thiểu và ghi tối đa.

Dưới đây là nội dung của chương trình giải quyết vấn đề bằng nhận xét.

#include "stdafx.h"

#bao gồm

sử dụng không gian tên std;

int chính()

setlocale(LC_ALL, "RUS");

int n, i, imax, imin;

gấp đôi *a, tối đa, tối thiểu;

TẬP TIN *f;

//mở file ở chế độ đọc-ghi

f=fopen("D:\\game\\noobs.dat", "rb+");

//đọc số từ file vào biến n

// số thực trong tệp

fread(&n, sizeof(int), 1, f);

cout<<"n="<

// cấp phát bộ nhớ để lưu trữ số thực,

// sẽ được lưu trữ trong mảng a

a=gấp đôi mới[n];

//đọc từ file vào mảng và số thực

fread(a, sizeof(double), n, f);

//tìm kiếm phần tử lớn nhất và nhỏ nhất

// trong mảng a và các chỉ số của chúng

vì (imax=imin=0, max=min=a, i=1; i

nếu (a[i]>tối đa)

max=a[i];

nếu (a[i]

phút=a[i];

// di chuyển con trỏ ĐẾN tối đa yếu tố

fseek(f, sizeof(int)+imax*sizeof(double), SEEK_SET);

// ghi phần tử tối thiểu thay vì phần tử tệp tối đa

fwrite(&min, sizeof(double), 1, f);

// di chuyển con trỏ ĐẾN tối thiểu yếu tố

fseek(f, sizeof(int)+imin*sizeof(double), SEEK_SET);

// ghi giá trị tối đa thay vì phần tử tệp tối thiểu

fwrite(&max, sizeof(double), 1, f);

//đóng tập tin

fclose(f);

// giải phóng bộ nhớ

xóa bỏ [ ]Một;

hệ thống ("tạm dừng");