Bir c dosyasından bir kelime okuyun. Dosyadan veri girişi ve dosyaya çıktı

Program bir dosyadan okumanın iki yolunu gösterir, birincisi akışa aktarım işlemini kullanmak, ikincisi ise işlevi kullanmaktır. hat almak() . Birinci durumda sadece ilk kelime okunur ve ikinci durumda 50 karakterlik bir dizi okunur. Ancak dosyada 50'den az karakter kaldığı için karakterler son karakter dahil olmak üzere okunur. İkinci kez okumanın (satır 17) ilk kelime okunduğu için baştan değil, ilk kelimeden sonra devam etti.satır 14. Programın sonucu Şekil 1'de gösterilmiştir.

C++'da Dosyalarla Çalışmak Devam etmek için herhangi bir tuşa basın. . .

Şekil 1 - C++'da dosyalarla çalışma

Program düzgün çalıştı, ancak her şey kodla uyumlu olsa bile durum her zaman böyle değil. Örneğin var olmayan bir dosyanın adı programa geçmiş ya da adında hata yapılmış. Sonra ne? Bu durumda, hiçbir şey olmayacak. Dosya bulunmayacak, bu da onu okumanın mümkün olmadığı anlamına gelir. Bu nedenle, derleyici, dosyanın değiştirildiği satırları yok sayacaktır. Sonuç olarak, programdan doğru bir şekilde çıkılacak, ancak ekranda hiçbir şey gösterilmeyecektir. Görünüşe göre bu, böyle bir duruma tamamen normal bir tepki. Ancak basit bir kullanıcı, sorunun ne olduğunu ve neden dosyadan bir satırın ekranda görünmediğini anlamayacaktır. Bu nedenle, her şeyi netleştirmek için C++, tamsayı değerleri döndüren is_open() gibi bir işlev sağlar: 1 - dosya başarıyla açıldıysa, 0 - dosya açılmadıysa. Dosyanın açılması ile programı sonlandıralım öyle ki dosya açılmazsa buna karşılık gelen bir mesaj görüntülenir.

// file_read.cpp: konsol uygulaması için giriş noktasını tanımlar. #include "stdafx.h" #include #katmak ad alanı std kullanarak; int main(int argc, char* argv) ( setlocale(LC_ALL, "rus"); // Kiril char buff'ının doğru gösterimi; // dosyadan okunan metnin ara depolaması için arabellek ifstream fin("cppstudio.doc"); // (DOSYA ADI GİRİLMİŞ YANLIŞ) if (!fin.is_open()) // eğer dosya açık değilse cout<< "Файл не может быть открыт!\n"; // сообщить об этом else { fin >> buff; // cout dosyasındaki ilk kelimeyi oku<< buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку } system("pause"); return 0; }

Programın sonucu Şekil 2'de gösterilmiştir.

Dosya açılamıyor! Devam etmek için herhangi bir tuşa basın. . .

Şekil 2 - C++'da dosyalarla çalışma

Şekil 2'den de görebileceğiniz gibi, program dosyanın açılamadığını bildirdi. Bu nedenle, program dosyalarla çalışıyorsa, dosyanın var olduğundan emin olsanız bile is_open() adlı bu işlevi kullanmanız önerilir.

Dosya açma modları

Dosya açma modları, dosyaların nasıl kullanılacağını belirler. Modu ayarlamak için ios_base sınıfı, dosya açma modunu belirleyen sabitler sağlar (bkz. Tablo 1).

Dosya açma modları, bir nesne oluşturulurken veya open() işlevi çağrılırken doğrudan ayarlanabilir .

Akış dışı fout("cppstudio.txt", ios_base::app); // dosyanın sonuna bilgi eklemek için dosyayı aç fout.open("cppstudio.txt", ios_base::app); // dosyanın sonuna bilgi eklemek için dosyayı aç

Dosya açma modları, bit düzeyinde bir boole işlemi kullanılarak birleştirilebilir veya| , örneğin: ios_base::out | ios_base::trunc - bir dosyayı temizledikten sonra yazmak için açın.

ofstream sınıfının nesneleri, dosyalarla ilişkilendirildiklerinde, varsayılan olarak dosya açma kiplerini içerir ios_base::out | ios_base::trunc . Yani, dosya yoksa oluşturulacaktır. Dosya varsa, içeriği silinecek ve dosyanın kendisi kayda hazır olacaktır. ifstream sınıfının nesneleri, bir dosyayla ilişkilendirildiklerinde, varsayılan olarak ios_base::in dosya açma kipine sahiptir - dosya yalnızca okumaya açıktır. Dosya açma modu aynı zamanda bayrak olarak da adlandırılır, okunabilirlik için bu terimi gelecekte kullanacağız. Tablo 1'de tüm işaretler listelenmez, ancak bunlar başlamanız için yeterli olacaktır.

Lütfen ate ve app bayraklarının açıklama açısından çok benzer olduğunu unutmayın, her ikisi de işaretçiyi dosyanın sonuna taşır, ancak uygulama bayrağı yalnızca dosyanın sonuna yazmaya izin verir ve ate bayrağı sadece bayrağı dosyanın sonuna kadar yeniden düzenler ve kayıt alanını sınırlamaz.

Sizeof() işlemini kullanarak C++'daki ana veri türlerinin özelliklerini hesaplayacak ve bunları bir dosyaya yazacak bir program geliştirelim. Özellikler:

1. veri türü için ayrılan bayt sayısı
2. belirli bir veri türünün saklayabileceği maksimum değer.

Bir dosyaya yazmak aşağıdaki formatta olmalıdır:

/* veri tipi bayt maks. değer bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 long int = 4 214748364 7.00 unsigned long int = 4 4294967295.00 float = 4 2147483647.00 long float = 8 9223372036854775800.00 double = 8 9223372036854775800.00 */

Bu tür bir program bu bölümde daha önce geliştirilmiştir, ancak orada veri türleri hakkındaki tüm bilgiler standart çıktı aygıtına verildi ve bilgilerin bir dosyaya yazılması için programı yeniden oluşturmamız gerekiyor. Bunu yapmak için, dosyayı geçerli dosya bilgilerinin ön kesilmesiyle yazma modunda açmanız gerekir ( satır 14). Dosya oluşturulduktan ve başarıyla açıldıktan sonra (satır 16 - 20), cout ifadesi yerine, satır 22 fout nesnesini kullanın. böylece ekran yerine veri türleri ile ilgili bilgiler bir dosyaya yazılacaktır.

// write_file.cpp: konsol uygulaması için giriş noktasını tanımlar. #include "stdafx.h" #include #katmak // dosyalarla çalış #include // ad alanı std kullanan G/Ç manipülatörleri; int main(int argc, char* argv) ( setlocale(LC_ALL, "rus"); // nesneyi dosyaya bağla, dosyayı yazma kipinde açarken, önce içindeki tüm verileri silerek fout("data_types.txt", ios_base::out | ios_base::trunc); if (!fout.is_open()) // dosya açılmadıysa ( cout<< "Файл не может быть открыт или создан\n"; // напечатать соответствующее сообщение return 1; // выполнить выход из программы } fout << " data type " << "byte" << " " << " max value "<< endl // sütun başlıkları <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "long float = " << sizeof(long float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long float*/ << (pow(2,sizeof(long float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; fout.close(); // программа больше не использует файл, поэтому его нужно закрыть cout << "Данные успешно записаны в файл data_types.txt\n"; system("pause"); return 0; }

Standart giriş/çıkış ve dosya giriş/çıkışının tamamen aynı şekilde kullanılması sayesinde programdaki değişikliklerin minimum düzeyde olduğunu fark etmemek imkansızdır. Programın sonunda,satır 45dosyayı açıkça kapattık, bu gerekli olmasa da, iyi bir programlama uygulaması olarak kabul edilir. Standart girdi/çıktıyı biçimlendirmek için kullanılan tüm işlevlerin ve manipülatörlerin, dosya girdi/çıktısıyla da ilgili olduğunu belirtmek gerekir. Bu nedenle, operatör çalışırken herhangi bir hata oluşmadı. cout bir nesne ile değiştirildi kavga

Etiketler: Metin dosyaları, fopen, fclose, feof, setbuf, setvbuf, fflush, fgetc, fprintf, fscanf, fgets, arabelleğe alınmış akış, arabelleğe alınmamış akış.

Metin dosyalarıyla çalışma

Bir metin dosyasıyla çalışmak, konsolla çalışmaya benzer: biçimlendirilmiş giriş işlevlerini kullanarak verileri bir dosyaya kaydederiz, biçimlendirilmiş çıktı işlevlerini kullanarak verileri bir dosyadan okuruz. Daha sonra ele alacağımız birçok nüans var. Yapılacak başlıca işlemler;

• 1. Erişilebilmesi için dosyayı açın. Buna göre okuma, yazma, okuma ve yazma, yeniden yazma veya dosyanın sonuna kadar yazma vb. için açabilirsiniz. Bir dosyayı açtığınızda bir dizi hata da meydana gelebilir - dosya mevcut olmayabilir, doğru dosya türü olmayabilir, dosya üzerinde çalışma izniniz olmayabilir vb. Bütün bunlar dikkate alınmalıdır.
• 2. Doğrudan dosyayla çalışın - yazma ve okuma. Burada, rastgele erişimli bellekle değil, kendi özelliklerini ekleyen arabelleğe alınmış bir akışla çalıştığımızı da hatırlamamız gerekiyor.
• 3. Dosyayı kapatın. Dosya, programla ilgili olarak bir dış kaynak olduğundan, kapatılmazsa, muhtemelen program kapatıldıktan sonra bile bellekte asılı kalmaya devam edecektir (örneğin, açık bir dosyayı silmek veya değişiklik yapmak vb. mümkün olmayacaktır). Ek olarak, bazen örneğin erişim modunu değiştirmek için dosyayı kapatmak değil, "yeniden açmak" gerekir.

Ayrıca, bir dosyanın içeriğine erişmemiz gerekmediğinde bir dizi görev vardır: yeniden adlandırma, taşıma, kopyalama vb. Ne yazık ki, C standardında bu ihtiyaçlara yönelik fonksiyonların bir açıklaması yoktur. Derleyici uygulamalarının her biri için kesinlikle varlar. Bir dizinin (klasör, dizin) içeriğini okumak aynı zamanda bir dosyaya erişmektir, çünkü klasörün kendisi meta bilgi içeren bir dosyadır.

Bazen bazı yardımcı işlemleri gerçekleştirmek gerekir: dosyada istenen konuma gidin, geçerli konumu hatırlayın, dosyanın uzunluğunu belirleyin vb.

Bir dosyayla çalışmak için bir FILE nesnesi gereklidir. Bu nesne, bir dosya akış tanıtıcısını ve onu yönetmek için gerekli olan, arabelleğe bir işaretçi, bir dosya konumu göstergesi ve durum göstergeleri dahil olmak üzere bilgileri depolar.

FILE nesnesinin kendisi bir yapıdır, ancak alanlarına erişilmemelidir. Taşınabilir bir program, bir dosyayı dosya akışına erişime izin veren soyut bir nesne olarak ele almalıdır.

FILE türündeki bir nesne için belleğin oluşturulması ve tahsisi, fopen veya tmpfile işlevleri kullanılarak gerçekleştirilir (başkaları da vardır, ancak biz yalnızca bunlara odaklanacağız).

fopen işlevi bir dosyayı açar. İki bağımsız değişken alır - dosyanın adresini içeren bir dize ve dosyanın erişim modunu içeren bir dize. Dosya adı mutlak veya göreli olabilir. fopen, daha sonra dosyaya erişmek için kullanılabilecek bir FILE nesnesine bir işaretçi döndürür.

DOSYA* fopen(const char* dosya adı, const char* modu);

Örneğin bir dosya açalım ve içine Hello World yazalım.

#katmak #katmak #katmak void main() ( //Dosya değişkenini kullanarak FILE *file dosyasına erişeceğiz; //Yazma izinlerine sahip bir metin dosyası aç file = fopen("C:/c/test.txt", "w+t"); //Dosyaya yaz fprintf(file, "Hello, World!"); //Dosyayı kapat fclose(file); getch(); )

Fopen işlevinin kendisi nesne için bellek ayırır, temizleme fclose işlevi tarafından gerçekleştirilir. Dosyayı kapatmalısınız, kendi kendine kapanmayacaktır.

fopen işlevi, bir dosyayı metin veya ikili modda açabilir. Varsayılan metindir. Erişim modu aşağıdaki gibi olabilir

Bir dosyayı ikili modda açmanız gerekirse, satırın sonuna b harfi eklenir, örneğin "rb", "wb", "ab" veya karma mod için "ab+", "wb+", "ab+". B yerine t harfini ekleyebilirsiniz, ardından dosya metin modunda açılır. Uygulamaya bağlıdır. Yeni C standardında (2011), x harfi, dosya zaten varsa fopen işlevinin başarısız olması gerektiği anlamına gelir. Eski programımızı tamamlayalım: dosyayı yeniden açın ve onu oraya yazdığımızı düşünün.

#katmak #katmak #katmak void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); fprintf(file, "Merhaba, Dünya!"); fclose(file); file = fopen("C:/c/test.txt", "r"); fgets(buffer, 127, file); printf("%s", buffer); fclose(file); getch(); )

fgets yerine fscanf kullanabilirsiniz, ancak onun yalnızca ilk boşluğa kadar olan bir diziyi okuyabildiğini unutmayın.
fscanf(dosya, "%127s", arabellek);

Ayrıca, dosyayı açıp kapatmak yerine, dosyayı yeni izinlerle "yeniden açan" freopen işlevini kullanabilirsiniz.

#katmak #katmak #katmak void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); fprintf(file, "Merhaba, Dünya!"); freopen("C:/c/test.txt", "r", file); fgets(buffer, 127, file); printf("%s", buffer); fclose(file); getch(); )

fprintf ve fscanf işlevleri, printf ve scanf'ten yalnızca, çıktı alacakları veya verileri okuyacakları bir DOSYA işaretçisini ilk argümanları olarak almaları bakımından farklılık gösterir. Burada, printf ve scanf işlevlerinin kolayca fprintf ve fscanf işlevleriyle değiştirilebileceğini hemen eklemeye değer. İşletim sisteminde (en yaygın ve yeterli işletim sistemlerini göz önünde bulunduruyoruz), üç standart akış vardır: standart çıkış stdout'u, standart giriş stdin ve standart hata stderr. Uygulama başlatılırken otomatik olarak açılırlar ve konsolla ilişkilendirilirler. Örnek

#katmak #katmak #katmak void main() ( int a, b; fprintf(stdout, "İki sayı girin\n"); fscanf(stdin, "%d", &a); fscanf(stdin, "%d", &b); if (b == 0) ( fprintf(stderr, "Hata: sıfıra bölme"); ) else ( fprintf(stdout, "%.3f", (kayan) a / (kayan) b); ) getch() ;)

Dosya açma hatası

Fopen işlev çağrısı başarısız olursa, NULL döndürür. Dosyalarla çalışırken hatalar oldukça yaygındır, bu nedenle bir dosyayı her açtığımızda, çalışmanın sonucunu kontrol etmemiz gerekir.

#katmak #katmak #katmak #define ERROR_OPEN_FILE -3 void main() ( FILE *file; char buffer; file = fopen("C:/c/test.txt", "w"); if (file == NULL) ( printf("Dosya açılırken hata oluştu"); getch(); exit(ERROR_OPEN_FILE); ) fprintf(file, "Merhaba, Dünya!"); freopen("C:/c/test.txt", "r", dosya ); if (dosya = = NULL) ( printf("Dosya açılırken hata"); getch(); exit(ERROR_OPEN_FILE); ) fgets(buffer, 127, file); printf("%s", tampon); fclose(dosya); getch(); )

Sorun, aynı anda birkaç dosyanın açılması durumundan kaynaklanır: bunlardan biri açılamıyorsa, geri kalanı da kapatılmalıdır.

DOSYA *girişDosyası, *çıktıDosyası; işaretsiz m, n; işaretsiz i, j; girdiDosyası = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) ( printf("%s dosyası açılırken hata oluştu", INPUT_FILE); getch(); exit(3); ) outputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) ( printf("%s dosyası açılırken hata oluştu", OUTPUT_FILE); getch(); if (inputFile != NULL) ( fclose(inputFile); ) exit(4); ) ...

Basit durumlarda, önceki kod parçasında olduğu gibi yandan hareket edebilirsiniz. Daha karmaşık durumlarda, RAII'yi C ++'dan değiştiren yöntemler kullanılır: sarmalayıcılar veya derleyici özellikleri (GCC'de temizleme), vb.

Veri Arabelleğe Alma

Daha önce de belirtildiği gibi, veri çıkışı yaptığımızda, önce arabelleğe alınır. arabellek temizlendi

• 1) Dolu ise
• 2) Akış kapanırsa
• 3) Tamponu temizlemenin gerekli olduğunu açıkça belirtirsek (burada da istisnalar vardır :)).
• 4) Program başarıyla tamamlandıysa da silinir. Aynı zamanda, tüm dosyalar kapatılır. Çalışma zamanı hatası durumunda bu gerçekleşmeyebilir.

fflush(File *) işlevini çağırarak arabellek boşaltmayı zorlayabilirsiniz. İki örneği ele alalım - temizlemeli ve temizlemesiz.

#katmak #katmak #katmak void main() ( FILE *file; char c; file = fopen("C:/c/test.txt", "w"); do ( c = getch(); fprintf(file, "%c", c); fprintf(stdout, "%c", c); //fflush(dosya); ) while(c != "q"); fclose(dosya); getch(); )

fflush çağrısının açıklamasını kaldırın. Çalışma zamanında, metin dosyasını açın ve davranışa bakın.

Kendi boyutunu ayarlayarak kendinize bir dosya arabelleği atayabilirsiniz. Bu, işlev kullanılarak yapılır.

geçersiz setbuf(FILE*stream, char*buffer);

bu zaten açılmış bir DOSYA ve yeni bir arabelleğe bir işaretçi alır. Yeni arabelleğin boyutu en az BUFSIZ olmalıdır (örneğin, mevcut iş istasyonunda BUFSIZ 512 bayttır). NULL'u arabellek olarak iletirseniz, akış arabelleğe alınmaz hale gelir. işlevini de kullanabilirsiniz.

int setvbuf(FILE*stream, char*buffer, int modu, size_t boyutu);

bu, keyfi boyutta bir arabellek alır. modu aşağıdaki değerleri alabilir

• _IOFBF- tam tamponlama. Veriler dolduğunda dosyaya yazılır. Bir okumada, bir giriş işlemi istendiğinde arabellek dolu kabul edilir ve arabellek boştur.
• _IOLBF- doğrusal tamponlama. Veriler, dosya dolduğunda veya yeni satır karakteriyle karşılaşıldığında dosyaya yazılır. Bir okumada, bir giriş işlemi istendiğinde arabellek yeni satır karakterine kadar doldurulur ve arabellek boştur.
• _IONBF- tamponlama yok. Bu durumda boyut ve arabellek parametreleri dikkate alınmaz.

Örnek: kendi arabelleğimizi ayarlayalım ve bir dosyadan okumanın nasıl yapıldığını görelim. Dosyanın kısa olmasına izin verin (Merhaba, Dünya gibi bir şey!) ve onu karakter karakter okuruz

#katmak #katmak #katmak void main() ( FILE *input = NULL; char c; char tamponu = (0); input = fopen("D:/c/text.txt", "rt"); setbuf(input, buffer); while (!feof(input)) ( c = fgetc(input); printf("%c\n", c); printf("%s\n", tampon); _getch(); ) fclose(input); )

Verilerin zaten arabellekte olduğu görülebilir. Karakter karakter okuma zaten arabellekten yapılır.

feof

function int feof(DOSYA*akış); dosyanın sonuna ulaşıldıysa true değerini döndürür. İşlev, baştan sona tüm dosyayı gözden geçirmeniz gerektiğinde kullanışlıdır. Metin içeriği text.txt olan bir dosya olsun. Dosyayı karakter karakter okuyup ekranda görüntülüyoruz.

#katmak #katmak #katmak void main () (dosya *giriş = null; char c; input = fopen ("d: /c/text.txt", "rt"); if (input == null) ("hata açma dosyası"); _getch (); exit (0););) ; _getch ();)

Her şey yoluna girecek, sadece feof işlevi düzgün çalışmıyor ... Bunun nedeni "dosya sonu" kavramının tanımlanmamış olmasıdır. feof kullanırken, okunan son veri iki kez yazdırıldığında yaygın bir hata oluşur. Bunun nedeni, verilerin giriş arabelleğine yazılması, son okumanın bir hata ile gerçekleşmesi ve fonksiyonun eski okuma değerini döndürmesidir.

#katmak #katmak #katmak void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt"); if (input == NULL) ( printf("Dosya açılırken hata"); _getch(); exit(0); ) while (!feof(input)) ( fscanf(input, "%c", &c); fprintf(stdout, "%c", c); ) fclose(input); _getch() ; )

Bu örnek başarısız olur (büyük olasılıkla) ve dosyanın son karakterini iki kez yazdırır.

Çözüm, feof kullanmamaktır. Örneğin, toplam kayıt sayısını saklayın veya fscanf işlevlerinin vb. genellikle doğru okunan ve eşleşen değerlerin sayısını döndürmesi gerçeğini kullanın.

#katmak #katmak #katmak void main() ( FILE *input = NULL; char c; input = fopen("D:/c/text.txt", "rt") tc(); )

örnekler

1. Bir dosyaya iki sayı yazılır - dizinin boyutları. İkinci dosyayı bir dizi rasgele sayı ile dolduralım.

#katmak #katmak #katmak #katmak //Dosya adları ve izinler #define INPUT_FILE "D:/c/input.txt" #define OUTPUT_FILE "D:/c/output.txt" #define READ_ONLY "r" #define WRITE_ONLY "w" //Dizi boyutu için maksimum değer #define MAX_DIMENSION 100 //Dosyayı açarken hata #define ERROR_OPEN_ FILE -3 void main() ( FILE *inputFile, *outputFile; unsigned m, n; unsigned i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) ( printf("%s dosyası açılırken hata", INPUT_FILE); getch(); exit(ERROR_OPEN_FILE); ) outputFile = fopen(OUTPUT_FILE, WR) ITE_ONLY); if (outputFile == NULL) ( printf("%s dosyası açılırken hata", OUTPUT_FILE); getch(); //Dosya okuma için başarıyla açıldıysa, kapatılmalıdır if (inputFile != NULL) ( fclose(inputFile); ) exit(ERROR_OPEN_FILE); ) fscanf(inputFile, "%ud %ud", &m, &n); if (m > MAX_ BOYUT) ( m = MAX_DIMENSION; ) if (n > MAX_DIMENSION) ( n = MAX_DIMENSION; ) srand(time(NULL)); for (i = 0; i< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. Kullanıcı, önce çalışma modunu seçerken dosyayı kopyalar: dosya hem konsola çıktılanabilir hem de yeni bir dosyaya kopyalanabilir.

#katmak #katmak #katmak #define ERROR_FILE_OPEN -3 void main() ( FILE *origin = NULL; FILE *output = NULL; char dosya adı; int modu; printf("Enter filename: "); scanf("%1023s", dosyaadı); orijin = fopen(dosyaadı, "r"); if (origin == NULL) ( printf("%s dosyası açılırken hata", dosyaadı); getch(); çıkış(ERROR_FILE _OPE N); ) printf("giriş modu: "); scanf("%d", &mode); if (mode == 1) ( printf("Dosya adını girin: "); scanf("%1023s", dosyaadı); output = fopen(dosyaadı, "w"); if (output == NULL) ( printf("%s dosyası açılırken hata", dosyaadı); getch(); fclose(origin); exit(ERROR_FILE_OPEN ); ) ) else ( output = stdout; ) while (!feof(origin)) ( fprintf(output, "%c", fgetc(origin)); ) fclose(origin); fclose(output); getch(); )

3. Kullanıcı konsoldan veri girer ve esc tuşuna basılana kadar bir dosyaya yazılır. Programı kontrol edin ve görün. backspace yazarsanız nasıl davranır: bir dosyanın çıktısı nedir ve konsolun çıktısı nedir.

#katmak #katmak #katmak #define ERROR_FILE_OPEN -3 void main() ( FILE *output = NULL; char c; output = fopen("D:/c/test_output.txt", "w+t"); if (output == NULL) ( printf("Dosya açılırken hata oluştu"); _getch(); exit(ERROR_FILE_OPEN); ) for (;;) ( c = _getch(); if (c == 27) ) ( mola ; ) fputc(c, çıktı); fputc(c, stdout); ) fclose(çıktı); )

4. Dosya tamsayılar içeriyor. Bunların maksimumunu bulun. fscanf işlevinin doğru okunan ve eşleşen nesnelerin sayısını döndürmesinden yararlanalım. 1 sayısı her seferinde iade edilmelidir.

#katmak #katmak #katmak #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (input == NULL) ( printf("Dosya açılırken hata oluştu"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; hasRead = 1; while (hasRead) == 1) ( hasRead = fscanf(input, "%d", &num); if (hasRead != 1) ( devam; ) if (num >

Başka bir çözüm de dosyanın sonuna gelene kadar sayıları okumaktır.

#katmak #katmak #katmak #katmak #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; int num, maxn, hasRead; input = fopen("D:/c/input.txt", "r"); if (input == NULL) ( printf("Dosya açılırken hata oluştu"); _getch(); exit(ERROR_FILE_OPEN); ) maxn = INT_MIN; while (!feof(input)) ( fscan f(input, "%d", &num); if (num > maxn) ( maxn = num; ) ) printf("max sayı = %d", maxn); fclose(input); _getch(); )

5. Dosya kelimeler içerir: Rusça kelime, tablolama, İngilizce kelime, birkaç satırda. Kullanıcı İngilizce bir kelime girer, Rusça olanı göstermesi gerekir.

Çeviri dosyası şuna benzer

Güneş Güneş
kurşun kalem tükenmez kalem
tükenmez kalem kalem
kapı kapısı
pencere penceresi
sandalye
koltuk

ve cp866 kodlamasında (OEM 866) kaydedilmiştir. Burada önemlidir: son kelime çifti de yeni bir satırla biter.

Algoritma şu şekildedir - dosyadan bir satır okuruz, satırda bir sekme buluruz, sekmeyi sıfırla değiştiririz, Rusça kelimeyi tampondan kopyalarız, İngilizce kelimeyi tampondan kopyalarız, eşitliği kontrol ederiz.

#katmak #katmak #katmak #katmak #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; char tamponu; char enWord; char ruWord; char usrWord; unsigned index; int uzunluk; int wasFound; input = fopen("D:/c/input.txt", "r"); if (input == NULL) ( printf("Dosya açılırken hata"); _getch(); çıkış(ERROR_ FILE _OPEN); ) printf("kelime gir: "); fgets(usrWord, 127, stdin); wasFound = 0; while (!feof(input)) ( fgets(buffer, 511, input); uzunluk = strlen(buffer); for (index = 0; index)< length; index++) { if (buffer == "\t") { buffer = "\0"; break; } } strcpy(ruWord, buffer); strcpy(enWord, &buffer); if (!strcmp(enWord, usrWord)) { wasFound = 1; break; } } if (wasFound) { printf("%s", ruWord); } else { printf("Word not found"); } fclose(input); _getch(); }

6. Dosyadaki satır sayısını sayın. EOF karakteri ile karşılaşana kadar "\n" karakter sayısını sayarak dosyayı karakter karakter okuyacağız. EOF, girişin sona erdiğini ve okunacak veri kalmadığını gösteren özel bir karakterdir. İşlev, hata durumunda negatif bir değer döndürür.
NOT: EOF, int türündedir, dolayısıyla karakterleri okumak için int kullanmanız gerekir. Ayrıca, EOF değeri standart tarafından tanımlanmamıştır.

#tanımla _CRT_SECURE_NO_WARNINGS #dahil et #katmak #katmak int cntLines(const char *dosyaadı) ( intlines = 0; int any; //int türünden herhangi biri çünkü EOF, int türündedir! FILE *f = fopen(dosyaadı, "r"); if (f == NULL) ( dönüş -1; ) do ( any = fgetc(f); //printf("%c", any);//debug if (any == "\n") (lines++; ) ) while( herhangi != EOF); ​​​​fclose(f); dönüş satırları; ) void main() ( printf("%d\n", cntLines("C:/c/file.txt")); _getch(); )

Ru-Cyrl 18-öğretici Sypachev S.S. 1989-04-14 [e-posta korumalı] Stepan Sypachevöğrenciler

Hala net değil mi? - kutuya soru yaz

Metin dosyaları

Bir örnek kullanarak C dilinde bir metin dosyasıyla çalışmayı düşünelim. C sürücüsünde TextFile.txt adlı bir metin dosyası oluşturun. Bu dosyaya şu satırları yazın:

Dize_1 123 Dize_11, 456
Dize_2
Dize_3

Dosya 'yı kaydet.

Bu da dosyamızı açan ve ondan satırlar okuyan C programının kodudur:

/* *Yazar: @author Subbotin B.P..h> #include #define LEN 50 int main(void) ( puts("Metin dosyası işlemleri"); char cArray; FILE *pTextFile = fopen("C:\\TextFile.txt", "r"); if(pTextFile == NULL) ( puts("Sorunlar"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) ! = NULL) ( printf("%s", cArray); ) fclose(pTextFile); return EXIT_SUCCESS; )

Bir metin dosyasını C'de açmak için fopen işlevini kullanın:

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

fopen işlevinin ilk argümanı bir dosyaya işaret eder ve ikincisi dosyanın ondan okumak için açık olduğunu söyler.

Satırları fgets işlevini kullanarak okuruz:

fgets(cArray, LEN, pTextFile);

fgets işlevinin ilk argümanı, alınan dizgelerin saklanacağı bir karakter dizisini işaret eder, ikinci argüman okunacak maksimum karakter sayısıdır, üçüncüsü dosyamızdır.

Dosyayla çalışmayı bitirdikten sonra onu kapatmanız gerekir:

fclose(pTextFile);

Biz:

Satırlardaki Rus harfleri de geçer.

Bu arada bu programı Eclipse'de yaptım. Eclipse'de C/C++ ile nasıl çalışılacağını görebilirsiniz.

Böylece, bir metin dosyasından veri açıp okuduk.

Şimdi programlı olarak bir metin dosyası oluşturmayı ve ona veri yazmayı öğrenelim.

/* Yazar: @author Subbotin B.P..h> #include int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Bu bir dizedir"; char cNewLine = "\n"; int nVal = 123; if(pTextFile == NULL) ( puts("Problems"); return EXIT_FAILURE; ) fprintf(pText Dosya, "%s%c", c String, cNewLine); fprintf(pTextFile, "%d", nVal); return EXIT_SUCCESS; )

Veri yazmak için bir metin dosyası oluşturun:

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

dosya zaten varsa açılır ve içindeki tüm veriler silinir.

C-string cString ve nVal sayısı program tarafından bir metin dosyasına yazılır. cNewLine sadece bir satır sonudur.

Verileri fprintf işlevini kullanarak bir metin dosyasına yazıyoruz:

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

buradaki ilk argüman dosyamız, ikincisi format dizgisi, üçüncü veya daha fazlası bu format için gerekli argüman sayısı.

1. C'deki dosyalarla çalışma (C++'da da çalışır)..

Geçersiz ana (geçersiz)
{
DOSYA *dosya;
char* dosya_adı = "dosya.txt";
charload_string = "yok";

Dosya = fopen(dosya_adı, "w");

Fputs("dize", dosya);

Dosya = fopen(dosya_adı, "r");
eğer(dosya != 0)
{
fgets(load_string, 50 , dosya);
kesmek)
başka
{
kesmek)
fclose(dosya);
) Dosyalarla çalışma işlevlerinin açıklamaları kitaplıkta bulunur stdio.h
Öncelikle FILE () türünde bir değişkene işaretçi oluşturmanız gerekir. DOSYA* dosyası;).
Bir dosyanın açılması, fopen işlevi çağrılarak yapılır ( dosya = fopen(dosya_adı, "w");)
Bu fonksiyonun ilk parametresi dosya adıdır, ikincisi ise dosyanın hangi modda açılması gerektiğini belirtir. "w"- yazmaya açık, "R"- okumaya açık, "A"- dosya ekleme (başkaları olmasına rağmen bunlar en çok kullanılan modlardır). Bir dosyadan veri yazma ve okuma aşağıdaki işlevlerle gerçekleştirilir: fputc, fputs, fgetc, fgets, fprintf, fscanf(Bu işlevlerin açıklaması için bkz. stdio.h).
Bir dosyanın kapatılması, fclose ( fclose(dosya);).

MFC (CFile, CStdioFile, ... sınıfları) ve standart MFC sınıfı CFileDialog kullanarak dosyalarla çalışma.

CF dosya sınıfı

Sınıf nesnesini oluşturduktan sonra Dosyayöntemi çağırarak dosyayı açabilirsinizaçık. Yöntem, açılacak dosyanın yolunu ve kullanım modunu belirtmelidir. Yöntem Prototipiaçıkaşağıdaki forma sahiptir:

Virtual BOOL Open(LPCTSTR lpszFileName, UINT nOpenFlags, CFileException* pError=NULL);

lpszFileName parametresi açılacak dosyanın adı olmalıdır. Tam yolu da dahil olmak üzere yalnızca dosya adını veya tam dosya adını belirtebilirsiniz.

İkinci parametre olan nOpenFlags, Open yönteminin dosya üzerinde gerçekleştirdiği eylemi ve dosyanın özniteliklerini belirtir. nOpenFlags parametresi için bazı olası değerler aşağıdadır:

• CFile::modeCreate - Yeni bir dosya oluşturuluyor. Belirtilen dosya varsa içeriği silinir ve dosya uzunluğu sıfırlanır.
• CFile::modeNoTruncate - Bu dosyanın CFile::modeCreate dosyasıyla birlikte kullanılması amaçlanmıştır. Halihazırda var olan bir dosya oluşturulursa içeriği silinmez.

Bir sınıf nesnesine işaretçi olan isteğe bağlı bir pError parametresi CFileException, yalnızca dosya üzerinde işlem yapılması hataya neden olacaksa kullanılır. Bu durumda pError tarafından işaret edilen nesneye ek bilgiler yazılacaktır.

Yöntem açıkdosya açıksa ve hata durumunda sıfırsa sıfır olmayan bir değer döndürür. Bir dosyayı açarken bir hata oluşabilir, örneğin, okuma için Open yönteminde var olmayan bir dosya belirtilirse.

CFile sınıfı, UINT tipindeki m_hFile veri üyesini içerir. Açılan dosyanın kimliğini saklar. CFile sınıfından bir nesne zaten oluşturulmuşsa ancak dosya henüz açılmamışsa m_hFile değişkenine hFileNull sabiti yazılır.

Genellikle açık bir dosyanın kimliği doğrudan kullanılmaz. Sınıf Yöntemleri Dosyadosyalar üzerinde neredeyse tüm işlemleri gerçekleştirmenize izin verir ve bir dosya tanımlayıcısı belirtmenizi gerektirmez. m_hFile sınıfın bir üyesi olduğundan, yöntemlerinin uygulanması her zaman ona ücretsiz erişime sahiptir.

Dosyayla çalışmayı bitirdikten sonra kapatılmalıdır. Sınıf Dosyabunun için özel bir Kapatma yöntemi vardır. CFile sınıfından bir nesne oluşturulursa ve bir dosya açılırsa ve ardından nesne silinirse, onunla ilişkili dosyanın yıkıcı kullanılarak otomatik olarak kapatılacağına dikkat edilmelidir.

Dosyalara erişmek için birkaç sınıf yöntemi vardır. Dosya: Okuma, OkumaKocaman, Yazma, YazmaKocaman, Flush. Yöntemler Çok Okuyun ve Okuyunönceden açılmış bir dosyadan veri okumak için tasarlanmıştır. 32 bit işletim sistemlerinde, her iki yöntem de bir dosyadan aynı anda 65535 bayttan fazlasını okuyabilir. ReadHuge özelliği kullanımdan kaldırılmıştır ve yalnızca 16 bit işletim sistemleriyle uyumluluk için tutulmuştur.

Dosyadan okunan veriler lpBuf tamponuna yazılır. nCount parametresi, dosyadan okunacak bayt sayısını belirtir. Aslında, dosyadan nCount parametresinin talep ettiğinden daha az bayt okunabilir. Okuma sırasında dosyanın sonuna ulaşılırsa bu olur. Yöntemler, dosyadan okunan bayt sayısını döndürür.

Write ve WriteHuge yöntemleri, bir dosyaya yazmak için tasarlanmıştır. 32 bit işletim sistemlerinde, her iki yöntem de bir dosyaya aynı anda 65535 bayttan fazlasını yazabilir. Yöntemler, lpBuf arabelleğinden açık dosyaya nCount bayt yazar. Disk dolu gibi bir yazma hatası oluşursa, yöntem istisna işlemeyi başlatır.

Verileri diske yazmak için Write veya WriteHuge yöntemi kullanıldığında, geçici bir arabellekte kalması biraz zaman alabilir. Diskteki dosyada gerekli değişikliklerin yapıldığından emin olmak için Flush yöntemini kullanmanız gerekir.

Sınıf, dosyalar üzerinde kopyalama, yeniden adlandırma, silme, öznitelikleri değiştirme gibi çeşitli işlemleri gerçekleştirmenize izin veren yöntemleri içerir.

Dosya adını değiştirmek için CFile sınıfı statik bir yöntem içerir. Yeniden isimlendirmekBu komutun işlevlerini yerine getiren. Yöntem, dizinleri yeniden adlandırmak için kullanılamaz. Bir hata oluşursa, yöntem bir istisna atar.

CFile sınıfındaki dosyaları silmek için statik bir yöntem eklenmiştir. KaldırmakBelirtilen dosyayı silmenizi sağlayan A. Bu yöntem, dizinleri silmenize izin vermez. Dosya silinemezse, yöntem bir istisna oluşturur.

Dosyanın oluşturulduğu tarih ve saati, uzunluğunu ve özniteliklerini belirlemek için statik yöntem getstatus. İki tür yöntem vardır - birincisi sanal bir yöntem olarak tanımlanır ve ikincisi statik bir yöntem olarak tanımlanır.

Yöntemin sanal versiyonu getstatusbu CFile nesnesiyle ilişkili açık dosyanın durumunu tanımlar. Bu yöntem yalnızca bir CFile nesnesi oluşturulduğunda ve dosya açıkken çağrılır.

Yöntemin statik versiyonu getstatusCFile sınıfının bir nesnesiyle ilişkili olmayan bir dosyanın özelliklerini belirlemenizi sağlar. Bu yöntemi kullanmak için önce dosyayı açmanız gerekmez.

Sınıfta yer alan yöntemler kilit aralığı Ve aralığın kilidini aç, bu da bir veya daha fazla dosya verisi parçasını diğer işlemlerden erişime karşı kilitlemenize olanak tanır. Bir uygulama, daha önce bu veya başka bir uygulama tarafından kilitlenmiş verileri yeniden kilitlemeye çalışırsa, bir istisna atılır. Kilit, birden fazla uygulamanın veya işlemin aynı dosya üzerinde aynı anda birbirini etkilemeden çalışmasına izin veren mekanizmalardan biridir.

Yöntemi kullanarak bir kilit ayarlayabilirsiniz. kilit aralığı. Takılı kilitleri kaldırmak için yöntemi kullanmanız gerekir.aralığın kilidini aç. Bir dosyada birkaç kilit ayarlanmışsa, her birinin ayrı bir yöntem çağrısıyla kaldırılması gerekir.aralığın kilidini aç.

Geçerli dosya konumu işaretçisini yeni bir konuma taşımak için aşağıdaki sınıf yöntemlerinden birini kullanabilirsiniz. Dosya - Ara, Başla Ara, Sonu Ara. sınıfa Dosyadosyanın uzunluğunu ayarlamanıza ve değiştirmenize izin veren yöntemleri de içerir, -GetLength, SetLength.

Açık bir dosyanın diskteki konumunu belirlemek için yöntemi çağırmanız gerekir. GetFilePath. Bu yöntem bir sınıf nesnesi döndürürCStringsürücü adı, dizinler, dosya adı ve dosya uzantısı dahil olmak üzere dosyanın tam yolunu içeren .

Yalnızca açık bir dosyanın adını ve uzantısını belirlemek istiyorsanız, yöntemi kullanabilirsiniz. DosyaAdı Al. Dosya adını içeren bir CString nesnesi döndürür. Uzantısı olmayan açık bir dosyanın yalnızca adını bulmanız gerektiğinde, yöntemi kullanın.GetFileTitle.

C++'da metin dosyalarıyla çalışma.

İki ana dosya türü vardır: metin ve ikili. Dosyalar, kullanıcının büyük miktarda veriyi klavyeden yazmadan doğrudan diskten okumasına olanak tanır.

Metin herhangi bir karakterden oluşan dosyalar olarak adlandırılır. Her biri bir satır sonu karakteriyle biten satırlar halinde düzenlenirler. Dosyanın sonu, "dosyanın sonu" sembolü ile gösterilir. Herhangi bir metin düzenleyici kullanılarak görüntülenebilen bir metin dosyasına bilgi yazarken, tüm veriler bir karakter türüne dönüştürülür ve karakter biçiminde saklanır.

İÇİNDE ikili Dosyalarda bilgi, her tür ve yapıdaki verinin depolanabileceği belirli bir boyuttaki bloklar şeklinde okunur ve yazılır.

Dosyalarla çalışmak için, özel veri tipleri, isminde Canlı Yayınlar. Akış ifstream okuma modunda dosyalarla çalışmak için kullanılır ve akış dışı kayıt modunda. Hem yazma hem de okuma modunda dosyalarla çalışmak için bir akış kullanılır. ilk akış.

C++ programlarında metin dosyalarıyla çalışırken iostream ve fstream kitaplıklarını dahil etmek gerekir.

İçin yazmak verileri bir metin dosyasına dönüştürmek için yapmanız gerekenler:

akış türü değişkenini tanımlar.

bilgileri bir dosyaya yazdırın.

dosyayı kapattığınızdan emin olun.

İçin okumalar bir metin dosyasından veri almak için şunları yapmalısınız:

ifstream türünde bir değişken tanımlayın.

open işlevini kullanarak bir dosyayı açın.

dosyayı kapatın.

Kayıt bilgileri bir metin dosyasına

Daha önce belirtildiği gibi, bir metin dosyasıyla çalışmaya başlamak için ofstream türünde bir değişken bildirmeniz gerekir. Örneğin, bunun gibi:

Dosyaya bilgi yazmak için bir F değişkeni oluşturulacaktır.

Bir sonraki adım, dosyayı yazmak için açmaktır. Akış açma operatörü genel olarak şuna benzer:

F. open("dosya", kip);

Burada F, akış dışı olarak bildirilen bir değişkendir,

dosya - diskteki dosyanın tam adı,

mod - açılan dosya ile çalışma modu.

Lütfen tam dosya adını belirtirken çift eğik çizgi koymanız gerektiğini unutmayın. Örneğin, D: sürücüsündeki oyun klasöründe bulunan noobs.txt dosyasının tam adının şu şekilde yazılması gerekecektir:

D:\\oyun\\noobs.txt.

Dosya aşağıdaki modlardan birinde açılabilir:

ios::in - dosyayı veri okuma modunda aç, bu mod ifstream akışları için varsayılan moddur;

ios::out - dosyayı veri yazma modunda aç (bu durumda, mevcut dosya hakkındaki bilgiler yok edilir), bu mod akış akışları için varsayılan moddur;

ios::app - dosyanın sonuna veri yazma modunda bir dosya açın;

ios::ate - zaten açık olan bir dosyanın sonuna git;

ios::trunc - dosyayı temizle, aynısı ios::out modunda olur;

ios::nocreate - dosya yoksa açmayın;

ios::noreplace - Mevcut bir dosyayı açmayın.

mod parametresi olmayabilir, bu durumda dosya bu akış için varsayılan modda açılır.

Başarılı bir dosya açma işleminden sonra (herhangi bir modda), F değişkeni true'yu, aksi takdirde false'u depolar. Bu, dosya açma işleminin doğruluğunu kontrol edecektir.

Aşağıdaki yöntemlerden birini kullanarak bir dosyayı (örnek olarak D:\\game\\noobs.txt dosyasını alalım) yazma modunda açabilirsiniz:

// Birinci yol

akış dışı F;

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

//ikinci yol, ios::out modu varsayılan moddur

// İçin akışakış dışı

akış dışı F;

//üçüncü yol, değişkenin açıklamasını ve akış tipini birleştirir

// ve dosyayı tek bir ifadede aç

çıkış F("D:\\game\\noobs.txt", ios::out);

Bir dosyayı yazma modunda açtıktan sonra, içine bilgilerin yazılabileceği boş bir dosya oluşturulur.

Mevcut bir dosyayı yazma öncesi modunda açmak istiyorsanız, mod olarak ios::app kullanın.

Bir dosyayı yazma modunda açtıktan sonra, standart çıkış aygıtı yerine yalnızca ekrandakiyle aynı şekilde yazabilirsiniz.coutaçık dosyanın adını belirtmelisiniz.

Örneğin, a değişkenini F akışına yazmak için çıktı ifadesi şöyle olacaktır:

b, c, d değişkenlerini sıralı olarak G akışına yazdırmak için çıktı ifadesi şöyle olur:

G<

Akış, operatör kullanılarak kapatılır:

ÖRNEK:

Bir D:\\game\\noobs.txt metin dosyası oluşturun ve içine n gerçek sayı yazın.

#include "stdafx.h"

#katmak

#katmak

#katmak

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int ben, n;

çift ​​a;

// bir dosyaya veri yazmak için bir akışı tanımlar

akış dışı F;

//dosyayı yazma modunda aç,

// modios:: dışarıvarsayılan olarak yüklü

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

// gerçek sayıların sayısını girin

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

// gerçek sayıları girmek için döngü

//ve bunları bir dosyaya yazmak

için (i=0; ben

cout<<"a=";

//Numara giriniz

cin>>a;

F<

// akışı kapatıyoruz

f.close();

sistem("duraklat");

0 dönüşü;

_______________________________________________________________

Bir metin dosyasından bilgi okumak için, türde bir değişken bildirmek gerekir. ifstream. Bundan sonra, operatörü kullanarak dosyayı okumak için açmanız gerekir. açık. Değişken F olarak adlandırılırsa, ilk iki ifade aşağıdaki gibi olacaktır:

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

Bir dosyayı okuma modunda açtıktan sonra, bilgileri yalnızca klavyeden olduğu gibi okuyabilirsiniz.cinverilerin okunacağı akışın adını belirtin.

Örneğin, F akışından a değişkenine okumak için girdi ifadesi şöyle görünür:

Metin düzenleyicide iki sayı, aralarında şu karakterlerden en az biri varsa ayrılmış kabul edilir: boşluk, sekme, satır sonu karakteri. Programcının bir metin dosyasında kaç tane ve hangi değerlerin saklanacağını önceden bilmesi iyidir. Bununla birlikte, genellikle dosyada saklanan değerlerin türü basitçe bilinir ve sayıları değişebilir. Bu sorunu çözmek için dosyadan değerleri tek tek okumanız ve her okumadan önce dosyanın sonuna ulaşılıp ulaşılmadığını kontrol etmeniz gerekir. Bunun için bir işlev var F. eof().

Burada F akışın adıdır, işlev bir boole değeri döndürür: dosyanın sonuna ulaşılıp ulaşılmadığına bağlı olarak doğru veya yanlış. Bu nedenle, tüm dosyanın içeriğini okumak için bir döngü şu şekilde yazılabilir:

//bir dosyadan değerleri okumak için düzenleme, çalıştırma

//dosyanın sonuna geldiğimizde döngü kesilecek,

//bu durumda F.eof() true değerini döndürür

iken (!F.eof())

ÖRNEK:

Gerçek sayılar D:\\game\\noobs.txt metin dosyasında saklanır, bunları ekranda görüntüleyin ve sayılarını hesaplayın.

#include "stdafx.h"

#katmak

#katmak

#katmak

#katmak

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int=0;

yüzer bir;

f akışı F;

//dosyayı okuma modunda aç

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

//dosya doğru açıldıysa, o zaman

//bir dosyadan değerleri okumak için döngü; döngü yürütme kesintiye uğrayacak,

//dosyanın sonuna geldiğimizde, bu durumda F.eof() true değerini döndürür.

iken (!F.eof())

// F akışındaki bir sonraki değeri a değişkenine okuyoruz

F>>a;

// a değişkeninin değerini ekrana yazdır

cout<

//okunan sayıların sayısını arttır

// akışı kapatıyoruz

f.close();

//okunan sayıların ekrana girilmesi

cout<<"n="<

//dosya yanlış açıldıysa çıktı

//böyle bir dosyanın yokluğu ile ilgili mesajlar

başka türlü<<" Файл не существует"<

sistem("duraklat");

0 dönüşü;

C++. İkili dosyaların işlenmesi

Bir ikili dosyaya bilgi yazarken, karakterler ve sayılar bir bayt dizisi olarak yazılır.

İçin yazmak verileri bir ikili dosyaya dönüştürmek için şunlara ihtiyacınız vardır:

FILE *filename; deyimini kullanarak FAIL * türünde bir dosya değişkeni bildirin. Burada filename, dosyanın işaretçisinin saklanacağı değişkenin adıdır.

fwrite işlevini kullanarak bir dosyaya bilgi yazma

İçin düşünmek z verilerini bir ikili dosyadan almak için yapmanız gerekenler:

FILE * türünde bir değişkeni tanımlayın

dosyayı fopen işleviyle aç

dosyayı fclose işleviyle kapat

İkili dosyalarla çalışmak için gereken temel işlevler.

İçin keşifler dosya, fopen işlevi amaçlanmıştır.

DOSYA *fopen(const *dosyaadı, const char *mode)

Burada dosyaadı, açılan dosyanın tam adını saklayan bir dizedir, mod, dosyayla çalışma modunu tanımlayan bir dizedir; aşağıdaki değerler mümkündür:

"rb" - ikili dosyayı okuma modunda açın;

"wb" - yazmak için bir ikili dosya oluşturun; varsa içeriği temizlenir;

"ab" - dosyanın sonuna eklemek için bir ikili dosya oluşturun veya açın;

"rb+" - mevcut bir ikili dosyayı okuma-yazma modunda açın;

"wb+" - bir ikili dosyayı okuma-yazma modunda açın, mevcut dosya silinir;

"ab+" - Mevcut bilgileri düzeltmek ve dosyanın sonuna yeni bilgiler eklemek için bir ikili dosya açılır veya oluşturulur.

Dosya başarıyla açılmadıysa, işlev f dosya değişkeninde NULL değerini döndürür. Dosya açıldıktan sonra 0. baytı kullanılabilir, dosya işaretçisi 0'dır, değeri okundukça veya yazıldıkça okunan (yazılan) bayt sayısı kadar kaydırılır. Dosya işaretçisinin geçerli değeri, okuma veya yazma işleminin gerçekleşeceği bayt sayısıdır.

İçin kapanış dosya, fclose işlevi tasarlanmıştır

int fclose(DOSYA *dosyaadı);

Dosya başarıyla kapatıldıysa 0, aksi takdirde NULL döndürür.

Kaldırma işlevi içindir kaldırma Dosyalar.

int remove(const char *dosyaadı);

Bu işlev, filenema adlı bir dosyayı diskten kaldırır. Silinecek dosya kapatılmalıdır. Dosya silinemezse işlev sıfır olmayan bir değer döndürür.

İçin yeniden adlandırma dosyalarda, yeniden adlandırma işlevi amaçlanmaktadır:

int rename(const char *eski dosyaadı, const char *yenidosyaadı);

İlk parametre eski dosya adı, ikincisi ise yenisidir. Programın başarıyla tamamlanması durumunda 0 döndürür.

Okuma bir ikili dosyadan fread işlevi kullanılarak yapılır:

fread(void *ptr, boyut, n, DOSYA *dosyaadı);

fread işlevi, dosya dosya adından ptr dizisine boyut boyutunda n öğe okur. İşlev, okunan öğe sayısını döndürür. Bir dosyadan okuduktan sonra, işaretçisi n*size bayt kaydırılır.

Kayıt ikili dosyaya dönüştürme işlemi fwrite işlevi kullanılarak yapılır:

fwrite(const void *ptr, boyut, n, DOSYA *dosyaadı);

fwrite işlevi, boyut boyutunda n öğeyi ptr dizisinden dosya dosya adına yazar. İşlev, yazılan öğelerin sayısını döndürür. Bilgiler dosyaya yazıldıktan sonra işaretçi n*size bayt kaydırılır.

İçin dosya sonu kontrolü bir feof işlevi var:

int feof(DOSYA *dosyaadı);

Dosyanın sonuna ulaşıldığında sıfır olmayan bir değer döndürür.

ÖRNEK:

Bir ikili dosya D:\\game\\noobs.dat oluşturun ve içine bir tamsayı n ve n gerçek sayılar yazın.

#include "stdafx.h"

#katmak

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int n, ben;

çift ​​a;

// yazma modunda ikili dosya oluştur

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

// giriş sayılarN

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

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

// n adet gerçek sayı girmek için döngü

için (i=0; ben

//sonraki gerçek sayıyı gir

cout<<"a=";

cin>>a;

// ikili dosyaya gerçek sayı yaz

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

// kapalı dosya

fkapat(f);

sistem("duraklat");

0 dönüşü;

ÖRNEK:

Önceki görevde oluşturulan D:\\game\\noobs.dat ikili dosyasının içeriğini görüntüleyin

#include "stdafx.h"

#katmak

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int n, ben;

çift ​​a;

DOSYA *f; // dosya değişkenini tanımla

//mevcut ikili dosyayı okuma modunda aç

// dosyadan n değişkenine bir tamsayı oku

// ekrana n çıktısı

cout<<"n="<

// n sayıdan oluşan bir dizi için bellek ayır

a=yeni çift[n];

//dosyadan a dizisine n gerçek sayı okuma

//diziyi ekrana yazdır

için (i=0; ben

cout<

cout<

// kapalı dosya

fkapat(f);

sistem("duraklat");

0 dönüşü;

İkili- sıralı veri yapısı, dosyayı açtıktan sonra içinde depolanan ilk bayt kullanılabilir. Bir dosyadan sırayla veri yazabilir veya okuyabilirsiniz. On beşinci sayıyı ve ardından birinciyi saymanız gerektiğini varsayalım. Seri erişim ile bu, aşağıdaki şekilde yapılabilir:

int n, ben;

çift ​​a;

DOSYA *f;

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

için (i=0; ben<15; i++)

fkapat(f);

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

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

fkapat(f);

Gördüğünüz gibi, bir dosyadan sayıları okumak ve ardından dosyayı yeniden açmak en uygun yol değildir. Dosya işaretçisini belirli bir bayta taşımak için fseek işlevini kullanmak çok daha uygundur.

int fseek(DOSYA *dosyaadı, uzun int ofset, int kaynak);

İşlev, işaretçiyi, orijin ve ofset ofseti değerine göre F dosyasının geçerli konumuna ayarlar. Ofset parametresi, dosya işaretçisinin, Origin parametresi tarafından belirtilen orijine göre ofsetleneceği bayt sayısına eşittir. Origin parametresinin değeri, stdio.h başlığında tanımlanan ofset için aşağıdaki değerlerden biri olmalıdır:

SEEK_SET - dosyanın başından itibaren;

SEEK_CUR - geçerli konumdan;

SEEK_END - dosyanın sonundan.

İşlev, işlem başarılı olursa sıfır, ofset başarısız olursa sıfırdan farklı bir değer döndürür.

fseek işlevi aslında dosyadaki herhangi bir değere doğrudan erişim sağlar. Yalnızca dosyadaki değerin konumunu (bayt numarası) bilmeniz gerekir. Aşağıdaki sorunu çözme örneğini kullanarak ikili dosyalarda doğrudan erişim kullanmayı düşünün.

ÖRNEK

Daha önce oluşturulan D:\\game\\noobs.dat ikili dosyasında, gerçek sayıların en büyüğünü ve en küçüğünü değiştirin.

Sorunu çözmek için algoritma aşağıdaki adımlardan oluşur:

bir dosyadan bir diziye gerçekleri okumak a.

a dizisinde maksimum (maks) ve minimum (min) değerleri ve bunların numaralarını (imax, imin) arayın.

dosya işaretçisini maksimum değere taşımak ve min.

dosya işaretçisini minimum değere taşımak ve maks.

Sorunu yorumlarla çözmek için programın metni aşağıdadır.

#include "stdafx.h"

#katmak

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int n, i, imax, imin;

çift ​​*a, maks, min;

DOSYA *f;

//dosyayı okuma/yazma modunda aç

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

// dosyadan değişken n sayısına oku

// dosyadaki gerçek sayılar

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

cout<<"n="<

//gerçek sayıları depolamak için bellek ayır,

//a dizisinde saklanacak

a=yeni çift[n];

// dosyadan bir diziye ve gerçek sayılara oku

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

//maksimum ve minimum elemanları ara

//a dizisinde ve indisleri

için (imax=imin=0, maks=min=a, i=1; i

eğer (a[i]>maks)

maks=a[i];

eğer (bir[i]

min=a[i];

// hareketli Işaretçi İle maksimum eleman

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

//dosyanın maksimum elemanı yerine min kaydı

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

// hareketli Işaretçi İle minimum eleman

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

//minimum dosya elemanı yerine max kaydı

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

//dosyayı kapatıyoruz

fkapat(f);

// Boş hafıza

silmek[ ]A;

sistem("duraklat");