Bir metin dosyasına veri nasıl yazılır c. Dosya okuma ve yazma. FileStream sınıfı

Programcıya göre açık bir dosya, okunan veya yazılan bir veri dizisi olarak temsil edilir. Bir dosya açıldığında, onunla ilişkilendirilir. G/Ç akışı . Çıkış bilgileri akışa yazılır, giriş bilgileri akıştan okunur.

G/Ç için bir akış açıldığında stdio.h'de tanımlanan standart bir FILE yapısıyla ilişkilendirilir. FILE yapısı dosya hakkında gerekli bilgileri içerir.

Bir dosyanın açılması, dosya üzerinde sonraki işlemler için kullanılabilecek FILE tipindeki yapıya bir işaretçi döndüren fopen() işlevi kullanılarak yapılır.

DOSYA *fopen(isim, tür);

name – açılacak dosyanın adı (yol dahil),
type - dosyaya nasıl erişildiğini tanımlayan bir karakter dizisinin işaretçisi:

· "r" - dosyayı okumak için açın (dosya mevcut olmalıdır);

· "w" - yazmak için boş bir dosya açın; dosya mevcutsa içeriği kaybolur;

· "a" - dosyayı sonuna kadar yazmak üzere açın (eklemek için); dosya mevcut değilse oluşturulur;

· "r+" - dosyayı okumak ve yazmak için açın (dosya mevcut olmalıdır);

· "w+" - okumak ve yazmak için boş bir dosya açın; dosya mevcutsa içeriği kaybolur;

· "a+" - dosyayı okumak ve eklemek için açın, eğer dosya mevcut değilse oluşturulur.

Dönüş değeri açık akışın bir işaretçisidir. Bir hata tespit edilirse NULL döndürülür.

fclose() işlevi akışı veya fopen() ile açılan dosyalarla ilişkili akışları kapatır. Kapatılacak akış fclose() fonksiyonunun argümanı tarafından belirlenir.

Dönüş değeri: akış başarıyla kapatılmışsa 0 değeri; Bir hata meydana gelirse sabit EOF.

#katmak
int ana()

karakter adı = "my.txt";

if(fp = fopen(isim, "r")!=NULL)

// dosyayı açmak mümkün müydü?
... // veriler üzerinde gerekli işlemler

else printf("Dosya açılamadı");

Dosyadan karakter okuma:

char fgetc(akış);

İşlev bağımsız değişkeni, FILE türündeki bir akışın işaretçisidir. Fonksiyon okunan karakterin kodunu döndürür. Dosyanın sonuna gelindiğinde veya bir hata meydana geldiğinde EOF sabiti döndürülür.
Bir dosyaya sembol yazma:

fputc(karakter, akış);

Fonksiyonun argümanları bir karakter ve FILE tipindeki bir akışı gösteren bir işaretçidir. Fonksiyon okunan karakterin kodunu döndürür.

fscanf() ve fprintf() işlevleri, scanf() ve printf() işlevlerine benzer, ancak veri dosyaları üzerinde çalışır ve ilk argümanları olarak bir dosya işaretçisine sahiptir.

fscanf(akış, "Giriş Formatı", argümanlar);
fprintf(akış, "Çıktı Formatı", argümanlar);

fgets() ve fputs() işlevleri dize girişi/çıkışı için tasarlanmıştır; dosyalarla çalışmak için kullanılan gets() ve puts() işlevlerine benzerler.

fgets(Dize İşaretçisi, Karakter Sayısı, Akış);

Dizenin içerdiği yeni satır karakteri "\n" okununcaya veya akış EOF bitene veya maksimum sayıda karakter okunana kadar akıştan karakterler okunur. Sonuç bir dize işaretçisine yerleştirilir ve "\0" boş karakteriyle sonlandırılır. Fonksiyon dizenin adresini döndürür.

fputs(Dize İşaretçisi, akış);

Geçerli konumdan akışa bir dize kopyalar. Sonlandırıcı boş karakter kopyalanmaz.
Örnek Bir sayı girin ve bunu s1.txt dosyasına kaydedin. Sayıyı s1.txt dosyasından okuyun, 3 artırın ve s2.txt dosyasına kaydedin.

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 bir dosyadan verileri okuruz. Daha sonra ele alacağımız birçok nüans var. Yapılacak başlıca işlemler şunlardır

• 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çok hata da meydana gelebilir; dosya mevcut olmayabilir, yanlış dosya türü olabilir, dosyayla çalışma izniniz olmayabilir, vb. Bütün bunlar dikkate alınmalıdır.
• 2. Doğrudan dosyayla çalışın - yazma ve okuma. Burada ayrıca rastgele erişim belleğiyle değil, kendi özelliklerini ekleyen arabelleğe alınmış bir akışla çalıştığımızı hatırlamamız gerekir.
• 3. Dosyayı kapatın. Dosya programın dışında bir kaynak olduğundan kapatılmadığı takdirde muhtemelen program kapatıldıktan sonra bile bellekte takılmaya devam edecektir (örneğin, açık bir dosyayı silmek veya değişiklik yapmak mümkün olmayacaktır), vesaire.). Ek olarak, bazen erişim modunu değiştirmek için dosyayı kapatmak değil, "yeniden açmak" gerekir.

Ek olarak, dosyanın içeriğine erişmemize gerek olmadığında bir dizi görev vardır: yeniden adlandırma, taşıma, kopyalama vb. Ne yazık ki C standardı bu ihtiyaçlara yönelik işlevlerin bir tanımını sağlamamaktadır. Derleyici uygulamalarının her biri için kesinlikle mevcutturlar. 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şlemlerin yapılması gerekebilir: dosyada istenen konuma gidin, geçerli konumu hatırlayın, dosyanın uzunluğunu belirleyin, vb.

Bir dosyayla çalışmak için bir FILE nesnesine ihtiyacınız vardır. Bu nesne, arabelleğe yönelik bir işaretçi, bir dosya konumu göstergesi ve durum göstergeleri dahil olmak üzere, dosya akışının tanımlayıcısını ve onu yönetmek için gereken bilgileri saklar.

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

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

Fopen işlevi bir dosyayı açar. İki argüman alır; dosya adresini içeren bir dize ve dosya erişim modunu içeren bir dize. Dosya adı mutlak veya göreceli olabilir. fopen, dosyaya daha fazla 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);

Örnek olarak bir dosya açalım ve içine Merhaba Dünya yazalım.

#katmak #katmak #katmak void main() ( //Dosya değişkenini kullanarak dosyaya erişeceğiz FILE *file; //Yazma izinlerine sahip bir metin dosyası açın file = fopen("C:/c/test.txt", "w+t") ; //Dosyaya yaz fprintf(dosya, "Merhaba, Dünya!"); //Dosyayı kapat fclose(dosya); 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

Dosyayı ikili modda açmak gerekiyorsa 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çılacaktır. Uygulamaya bağlıdır. Yeni C standardında (2011), x harfi, dosya zaten mevcutsa fopen'in başarısız olması gerektiği anlamına gelir. Eski programımıza ek yapalım: dosyayı yeniden açın ve orada yazdıkları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(tampon, 127, dosya); printf("%s", arabellek); fclose(dosya); getch(); )

fgets işlevi yerine fscanf kullanabilirsiniz, ancak bunun yalnızca ilk boşluğa kadar olan satırı okuyabildiğini unutmamanız gerekir.
fscanf(dosya, "%127s", arabellek);

Ayrıca, bir dosyayı açıp kapatmak yerine, dosyayı yeni erişim haklarıyla "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", dosya); fgets(tampon, 127, dosya); printf("%s", arabellek); fclose(dosya); getch(); )

fprintf ve fscanf işlevleri, çıktı alacakları veya veri okuyacakları DOSYA'ya yönelik bir işaretçiyi ilk argüman olarak almaları bakımından printf ve scanf işlevlerinden farklıdır. 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 düşünüyoruz) üç standart akış vardır: standart çıkış akışı stdout, standart giriş akışı stdin ve standart hata çıkış akışı stderr. Uygulama başlatıldığında 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", (float) a / (float) b); ) getch(); )

Dosya açılırken hata oluştu

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

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

Sorun, aynı anda birden fazla dosyanın açılması durumundan kaynaklanmaktadır: eğer bunlardan biri açılamıyorsa, geri kalanının da kapatılması gerekir.

DOSYA *girişDosyası, *çıkışDosyası; imzasız m, n; imzasız i, j; inputFile = fopen(INPUT_FILE, READ_ONLY); if (inputFile == NULL) ( printf("%s dosyası açılırken hata oluştu", INPUT_FILE); getch(); çıkış(3); ) çıktıFile = 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); ) çıkış(4); ) ...

Basit durumlarda, önceki kod parçasında olduğu gibi doğrudan 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 belirttiğimiz gibi, veri çıkışı yaptığımızda ilk olarak ara belleğe alınır. Tampon temizlendi

• 1) Doluysa
• 2) Akış kapalıysa
• 3) Tamponun temizlenmesi gerektiğini açıkça belirtirsek (burada da istisnalar vardır :)).
• 4) Programın başarıyla tamamlanması durumunda da işaret kaldırılır. Aynı zamanda tüm dosyalar kapatılır. Bir çalışma zamanı hatası durumunda bu gerçekleşmeyebilir.

fflush(File *) işlevini çağırarak ara belleğin boşaltılmasını zorlayabilirsiniz. İki örneğe bakalı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 boyutunuzu ayarlayarak kendinize bir dosya arabelleği atayabilirsiniz. Bu fonksiyon kullanılarak yapılır

Void setbuf(DOSYA * akışı, karakter * arabellek);

bu zaten açık olan bir DOSYA'yı ve yeni bir ara belleğe işaret eden bir işaretçiyi alır. Yeni arabelleğin boyutu BUFSIZ'den az olmamalıdır (örneğin, mevcut iş istasyonunda BUFSIZ 512 bayttır). NULL'u arabellek olarak iletirseniz akış arabelleğe alınmaz hale gelir. Fonksiyonu da kullanabilirsiniz

Int setvbuf(DOSYA * akış, karakter * arabellek, int modu, size_t boyut);

bu, isteğe bağlı boyuttaki bir arabelleği kabul eder. Mod aşağıdaki değerleri alabilir

• _IOFBF- tam tamponlama. Dosya dolduğunda veri yazılır. Okuma sırasında, bir giriş işlemi istendiğinde arabellek dolu kabul edilir ve arabellek boştur.
• _IOLBF- doğrusal tamponlama. Dosya dolduğunda veya yeni satır karakteriyle karşılaşıldığında veri yazılır. Okuma sırasında, bir giriş işlemi istendiğinde arabellek yeni satır karakterine kadar doldurulur ve arabellek boştur.
• _IONBF– ara belleğe alma yok. Bu durumda boyut ve arabellek parametreleri dikkate alınmaz.

Örnek: Kendi tamponumuzu 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 olsun ve onu karakter karakter okuyalım.

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

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

feof

int feof(DOSYA * akışı); dosyanın sonuna ulaşılırsa true değerini döndürür. İşlev, dosyanın tamamını baştan sona 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österiyoruz.

#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(); çıkış(0); ) while (!feof(giriş)) ( c = fgetc(giriş); fprintf(stdout, "%c", c); ) fclose(giriş); _getch(); )

Her şey yoluna girecek ama feof fonksiyonu doğru çalışmıyor... Bunun nedeni “dosya sonu” kavramının tanımlanmamış olmasıdır. Feof kullanırken sıklıkla oluşan bir hata, okunan son verinin iki kez yazdırılmasıdır. Bunun nedeni, verinin giriş arabelleğine yazılması, son okumanın hatalı gerçekleşmesi ve fonksiyonun eski okunan değeri 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(); çıkış(0); ) while (!feof(giriş)) ( fscanf(giriş, "%c", &c); fprintf(stdout, "%c", c); ) fclose(giriş); _getch(); )

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

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

#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(); çıkış(0); ) while (fscanf(giriş, "%c", &c) == 1) ( fprintf(stdout, "%c", c); ) fclose(giriş); _getch() ;)

Örnekler

1. Bir dosya iki sayı içerir - dizinin boyutları. İkinci dosyayı bir dizi rastgele sayıyla 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 için maksimum değer boyut #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 oluştu", INPUT_FILE); getch(); çıkış(ERROR_OPEN_FILE); ) OutputFile = fopen(OUTPUT_FILE, WRITE_ONLY); if (outputFile == NULL) ( printf("Hata %s dosyası açılıyor", OUTPUT_FILE); getch(); //Dosya okuma için başarıyla açıldıysa, o zaman kapatılması gerekir if (inputFile != NULL) ( fclose(inputFile); ) çıkış(ERROR_OPEN_FILE); ) fscanf (inputFile, "%ud %ud", &m, &n); if (m > MAX_DIMENSION) ( m = MAX_DIMENSION; ) if (n > MAX_DIMENSION) ( n = MAX_DIMENSION; ) srand(time(NULL)); for (i = 0; ben< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. Kullanıcı, ilk önce çalışma modunu seçerken dosyayı kopyalar: dosya hem konsola çıkarılabilir 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 mode; printf("Dosya adını girin: "); scanf("%1023s", dosya adı); Origin = fopen (dosya adı, "r"); if (origin == NULL) ( printf("%s dosyası açılırken hata oluştu", dosya adı); getch(); çıkış(ERROR_FILE_OPEN); ) printf("modu girin: "); scanf( "%d", &mode); if (mode == 1) ( printf("Dosya adını girin: "); scanf("%1023s", dosya adı); çıktı = fopen(dosya adı, "w"); if (çıkış = = NULL) ( printf("%s dosyası açılırken hata oluştu", dosya adı); getch(); fclose(origin); çıkış(ERROR_FILE_OPEN); ) ) else ( çıktı = stdout; ) while (!feof(origin)) ( fprintf (çıkış, "%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ı inceleyin ve görün. geri tuşuna bastığınızda nasıl davranır: dosyaya ne çıktı ve konsola ne çıktı.

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

4. Dosya tamsayılar içeriyor. Bunların maksimumunu bulun. Fscanf fonksiyonunun doğru okunan ve eşleşen nesnelerin sayısını döndürmesinin avantajından yararlanalım. Her seferinde 1 rakamı döndürülmelidir.

#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"); _getch(); çıkış(ERROR_FILE_OPEN); ) maxn = INT_MIN; hasRead = 1; while (hasRead == 1) ( hasRead = fscanf(input, "%d", &num); if (hasRead != 1) ( devam et; ) if (num >

Diğer bir çözüm ise dosyanın sonuna ulaşana 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"); _getch(); çıkış(ERROR_FILE_OPEN); ) maxn = INT_MIN; while (!feof(input)) ( fscanf(input, "%d", &num); if (num > maxn) ) ( maxn = sayı; ) ) printf("max sayı = %d", maxn); fclose(input); _getch(); )

5. Dosya şu kelimeleri içerir: Birkaç satır halinde Rusça kelime, tablolama, İngilizce kelime. Kullanıcı İngilizce bir kelime girer, Rusça olanı çıkarmak gerekir.

Çeviri dosyası şuna benzer

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

ve cp866 kodlamasıyla (OEM 866) kaydedildi. Önemli: Son kelime çifti de satır beslemeyle bitiyor.

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

#katmak #katmak #katmak #katmak #define ERROR_FILE_OPEN -3 void main() ( FILE *input = NULL; char buffer; 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("sözcüğü girin: "); fgets(usrWord, 127, stdin ); wasFound = 0; while (!feof(input)) ( fgets(buffer, 511, input); uzunluk = strlen(buffer); for (index = 0; indeks< 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 karakteriyle karşılaşıncaya kadar "\n" karakter sayısını sayarak dosyayı karakter karakter okuyacağız. EOF, girişin tamamlandığını ve okunacak veri kalmadığını belirten özel bir karakterdir. Hata durumunda fonksiyon 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.

#define _CRT_SECURE_NO_WARNINGS #include #katmak #katmak int cntLines(const char *dosyaadı) ( intlines = 0; int herhangi biri; //herhangi biri int türündedir çünkü EOF int türündedir! FILE *f = fopen(dosyaadı, "r"); if (f == NULL ) ( return -1; ) do ( any = fgetc(f); //printf("%c", herhangi biri);//debug if (any == "\n") ( satırlar++; ) ) while(any ! = 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 Sypaçevöğrenciler

Hala net değil mi? – posta kutusuna sorular yazın

Çoğu bilgisayar programı dosyalarla çalışır ve bu nedenle dosyaları oluşturmaya, silmeye, yazmaya, okumaya, açmaya ihtiyaç vardır. Dosya nedir? Dosya, bazı depolama aygıtlarında saklanabilen adlandırılmış bir bayt kümesidir. Artık bir dosyanın kendine özgü bir adı olan belirli bir bayt dizisi anlamına geldiği açıktır, örneğin file.txt. Aynı isimdeki dosyalar aynı dizinde bulunamaz. Dosya adı yalnızca adını değil aynı zamanda uzantısını da ifade eder; örneğin: file.txt ve file.dat — aynı adlara sahip olmalarına rağmen farklı dosyalar. Tam dosya adı diye bir şey vardır; bu, dosya adını belirten dosya dizininin tam adresidir, örneğin: D:\docs\file.txt. Bu temel kavramları anlamak önemlidir, aksi takdirde dosyalarla çalışmak zor olacaktır.

Dosyalarla çalışmak için bir başlık dosyası eklemeniz gerekir . İÇİNDE çeşitli sınıflar tanımlanmış ve başlık dosyaları dahil edilmiştir — dosya girişi ve — dosya çıktısı.

Dosya G/Ç, standart G/Ç'ye benzer; tek fark, G/Ç'nin ekran yerine bir dosyaya gerçekleştirilmesidir. Standart cihazlara G/Ç, cin ve cout nesneleri kullanılarak gerçekleştiriliyorsa, dosya G/Ç'sini düzenlemek için cin ve cout operatörlerine benzer şekilde kullanılabilecek kendi nesnelerinizi oluşturmanız yeterlidir.

Örneğin, bir metin dosyası oluşturmanız ve bu dosyaya C++'da dosyalarla çalışma satırını yazmanız gerekir. Bunu yapmak için aşağıdaki adımları uygulamanız gerekir:

1. akış sınıfının bir nesnesini yarat ;
2. bir sınıf nesnesini yazılacak dosyayla ilişkilendirin;
3. bir dosyaya bir satır yazın;
4. dosyayı kapatın.

Bir ifstream nesnesi yerine bir akış dışı nesne oluşturmak neden gereklidir? Bir dosyaya yazmanız gerektiğinden ve bir dosyadan veri okumanız gerekiyorsa, bir ifstream sınıfı nesnesi oluşturulur.

// akış dosyasına yazmak için bir nesne oluşturun /*nesne adı*/; // akış sınıfının nesnesi

Nesneye fout adını verelim ve şunu elde ederiz:

Akış dışı fout;

Neden bir nesneye ihtiyacımız var? Nesnenin bir dosyaya yazılabilmesi için gereklidir. Nesne zaten oluşturulmuş ancak dizenin yazılması gereken dosyayla ilişkilendirilmemiş.

Fout.open("cppstudio.txt"); // nesneyi dosyayla ilişkilendir

Nokta işlemi aracılığıyla, parantez içinde dosya adını belirttiğimiz open() sınıfı yöntemine erişim sağlıyoruz. Belirtilen dosya programla birlikte geçerli dizinde oluşturulacaktır. Aynı isimde bir dosya varsa mevcut dosya yenisiyle değiştirilecektir. Yani dosya açık, geriye sadece gerekli satırı içine yazmak kalıyor. Bu şu şekilde yapılır:

Fout<< "Работа с файлами в С++"; // запись строки в файл

Akışa dönüştürme işlemini fout nesnesiyle birlikte kullanarak, C++'daki Dosya İşleme dizesi bir dosyaya yazılır. Artık dosyanın içeriğini değiştirmeye gerek olmadığından kapatılması, yani nesnenin dosyadan ayrılması gerekir.

Fout.close(); // dosyayı kapat

Sonuç - C++'da dosyalarla çalışma satırıyla bir dosya oluşturuldu.

1. ve 2. adımlar birleştirilebilir, yani tek satırda bir nesne oluşturulabilir ve onu bir dosyayla ilişkilendirebilirsiniz. Bu şu şekilde yapılır:

Akış dışı fout("cppstudio.txt"); // akış sınıfından bir nesne oluşturun ve onu cppstudio.txt dosyasıyla ilişkilendirin

Tüm kodları birleştirip aşağıdaki programı elde edelim.

// file.cpp: Konsol uygulaması için giriş noktasını tanımlar. #include "stdafx.h" #include ad alanı std'sini kullanma; int main(int argc, char* argv) ( ofstream fout("cppstudio.txt"); // kayıt için ofstream sınıfından bir nesne oluşturun ve onu cppstudio.txt fout dosyasıyla ilişkilendirin<< "Работа с файлами в С++"; // запись строки в файл fout.close(); // закрываем файл system("pause"); return 0; }

Programın doğru çalıştığını kontrol etmek ve bunu yapmak için dosyayı açmak kalır. cppstudio.txt ve içeriğine bakın, şöyle olmalı - C++'da dosyalarla çalışma.

1. ifstream sınıfının bir nesnesini oluşturun ve onu okumanın gerçekleştirileceği dosyayla ilişkilendirin;
2. dosyayı oku;
3. dosyayı kapatın.

#katmak ad alanı std'sini kullanma; int main(int argc, char* argv) ( setlocale(LC_ALL, "rus"); // Kiril karakter buffının doğru gösterimi; // bir dosyadan okunan metnin ara depolanması için arabellek ifstream fin("cppstudio.txt") ; // okumak için dosya açıldı >><< buff << endl; // напечатали это слово fin.getline(buff, 50); // считали строку из файла fin.close(); // закрываем файл cout << buff << endl; // напечатали эту строку system("pause"); return 0; }

Program bir dosyadan okumanın iki yolunu gösterir; birincisi bir akışa aktarım işlemini kullanmak, ikincisi ise işlevi kullanmaktır hat almak() . İlk durumda yalnızca ilk kelime okunur, ikinci durumda ise 50 karakter uzunluğunda bir dize okunur. Ancak dosyada 50 karakterden az kaldığı için son karaktere kadar olan karakterler okunur. Lütfen ikinci kez okuduğunuzu unutmayın (17. satır) ilk kelime okunduğu için baştan değil, ilk kelimeden sonra devam etti.14. satır. Programın sonucu Şekil 1'de gösterilmektedir.

C++'da dosyalarla çalışma Devam etmek için herhangi bir tuşa basın. . .

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

Program doğru çalıştı, ancak her şey kodla uyumlu olsa bile bu her zaman gerçekleşmez. Örneğin, var olmayan bir dosyanın adı programa aktarıldı veya adında bir hata oluştu. Sonra ne? Bu durumda hiçbir şey olmayacak. Dosya bulunamayacak, bu da onu okumanın mümkün olmayacağı anlamına geliyor. Bu nedenle derleyici, dosya üzerinde çalışma yapılan satırları dikkate almaz. 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 dosyadaki bir satırın neden ekranda görünmediğini anlamayacaktır. Yani, her şeyi açıklığa kavuşturmak için C++, tamsayı değerlerini döndüren is_open() gibi bir işlev sağlar: 1 - eğer dosya başarıyla açıldıysa, 0 - eğer dosya açılmadıysa. Programı, dosya açılmazsa ilgili mesajın görüntüleneceği şekilde, dosyayı açarak sonlandıralım.

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

Programın sonucu Şekil 2'de gösterilmektedir.

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

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

Şekil 2'den görülebileceği gibi program, dosyayı açmanın imkansız olduğunu bildirdi. Bu nedenle, program dosyalarla çalışıyorsa, dosyanın var olduğundan emin olsanız bile is_open() işlevini 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. .

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

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

ofstream sınıfının nesneleri, dosyalarla ilişkilendirildiklerinde varsayılan olarak dosya açma modlarını içerir ios_base::out | ios_base::trunc . Yani, dosya mevcut değilse oluşturulacaktır. Dosya mevcutsa içeriği silinecek ve dosyanın kendisi yazılmaya hazır hale gelecektir. ifstream sınıfının nesneleri, bir dosyayla ilişkilendirildiklerinde varsayılan dosya açma moduna ios_base::in sahiptir - dosya salt okunurdur. Dosya açma moduna bayrak da denir; okunabilirlik açısından gelecekte bu terimi kullanacağız. Tablo 1 tüm bayrakları listelemiyor ancak bunlar başlamanız için yeterli olacaktır.

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ğı yalnızca bayrağı sonuna taşır. dosyanın ve nereye yazılacağı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 depolayabileceği maksimum değer.

Dosya aşağıdaki formatta yazılmalıdır:

/* veri türü bayt maksimum 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 uzun kayan nokta = 8 9223372036854775800,00 çift = 8 9223372036854775800,00 */

Böyle bir program bu bölümde daha önce geliştirilmişti, ancak orada veri türleriyle ilgili tüm bilgiler standart çıktı cihazına çıktı ve bilgilerin bir dosyaya yazılması için programı yeniden yapmamız gerekiyor. Bunu yapmak için, mevcut dosya bilgilerinin önceden kesilmesiyle dosyayı yazma modunda açmanız gerekir ( 14. satır). Dosya oluşturulduğunda ve başarıyla açıldığında (satır 16 - 20), cout ifadesi yerine 22. satır fout nesnesini kullanıyoruz. böylece veri türü bilgileri ekran yerine bir dosyaya yazılacaktır.

// write_file.cpp: Konsol uygulaması için giriş noktasını tanımlar. #include "stdafx.h" #include #katmak // dosyalarla çalışma #include // ad alanı std'sini kullanan giriş/çıkış manipülatörleri; int main(int argc, char* argv) ( setlocale(LC_ALL, "rus"); // nesneyi dosyayla ilişkilendirin ve dosyayı yazma modunda açın, önce içindeki tüm verileri silin ofstream 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 saat45. satırGerekli olmasa da, iyi bir programlama uygulaması olarak kabul edilmesine rağmen dosyayı açıkça kapattık. Standart giriş/çıkışı biçimlendirmek için kullanılan tüm işlevlerin ve manipülatörlerin aynı zamanda dosya girişi/çıkışıyla da ilgili olduğunu belirtmekte fayda var. Bu nedenle açıklamada herhangi bir hata oluşmadı. cout yerini bir nesne aldı fout.

Erişim kolaylığı için depolama cihazlarındaki bilgiler dosya biçiminde saklanır.

Dosya, bir dizi veriyi depolamak için ayrılmış harici belleğin adlandırılmış bir alanıdır. Dosyalarda bulunan veriler çok çeşitli niteliktedir: algoritmik veya makine dilindeki programlar; program işlemine veya program yürütme sonuçlarına ilişkin başlangıç ​​verileri; serbest metinler; grafik görüntüler vb.

Dizin (klasör, dizin) - dosya sisteminde dosyaların organizasyonunu basitleştirmek için kullanılan, alt dizinlerin ve dosyaların adlarını içeren bir depolama ortamındaki adlandırılmış bir bayt koleksiyonu.

Dosya sistemi işletim sisteminin dosyalar üzerinde işlemler gerçekleştiren işlevsel kısmına denir. Dosya sistemlerine örnek olarak FAT (FAT - Dosya Ayırma Tablosu), NTFS, UDF (CD'lerde kullanılır) verilebilir.

FAT'ın üç ana sürümü vardır: FAT12, FAT16 ve FAT32. Disk yapısındaki kayıtların bit derinliği bakımından farklılık gösterirler; küme numarasını depolamak için ayrılan bit sayısı. FAT12 esas olarak disketler (4 KB'a kadar), FAT16 - küçük kapasiteli diskler için, FAT32 - yüksek kapasiteli FLASH sürücüler (32 GB'a kadar) için kullanılır.

Örnek olarak FAT32'yi kullanarak dosya sisteminin yapısına bakalım.

FAT32 dosya yapısı

FAT32 sistemindeki harici bellek cihazları bayt adresleme yerine blok adreslemeye sahiptir. Bilgiler bloklar veya sektörler halinde harici bir bellek cihazına yazılır.

Sektör, harici depolama aygıtlarındaki minimum adreslenebilir bilgi depolama birimidir. Tipik olarak sektör boyutu 512 bayta sabitlenmiştir. Harici bellek cihazlarının adres alanını artırmak için sektörler küme adı verilen gruplar halinde birleştirilir.

Küme, belirli özelliklere sahip bağımsız bir birim olarak düşünülebilecek birçok sektörün birleşimidir. Bir kümenin ana özelliği, sektör sayısı veya bayt sayısıyla ölçülen boyutudur.

FAT32 dosya sistemi aşağıdaki yapıya sahiptir.

Dosya yazmak için kullanılan kümeler 2'den başlayarak numaralandırılır. Kural olarak 2 numaralı küme kök dizin tarafından kullanılır ve 3 numaralı kümeden başlayarak veri dizisi depolanır. Kök dizinin üzerinde bilgi depolamak için kullanılan sektörler kümelenmez.
Diskte gereken minimum dosya boyutu 1 kümeye karşılık gelir.

Önyükleme sektörü aşağıdaki bilgilerle başlar:

• EB 58 90 – koşulsuz atlama ve imza;
• 4D 53 44 4F 53 35 2E 30 MSDOS5.0;
• 00 02 – sektördeki bayt sayısı (genellikle 512);
• 1 bayt – kümedeki sektörlerin sayısı;
• 2 bayt – yedek sektörlerin sayısı.

Ayrıca önyükleme sektörü aşağıdaki önemli bilgileri içerir:

• 0x10 (1 bayt) – FAT tablolarının sayısı (genellikle 2);
• 0x20 (4 bayt) – diskteki sektör sayısı;
• 0x2С (4 bayt) – kök dizinin küme numarası;
• 0x47 (11 bayt) – birim etiketi;
• 0x1FE (2 bayt) – önyükleme sektörü imzası (55 AA).

Dosya sistemi bilgi sektörü şunları içerir:

• 0x00 (4 bayt) – imza (52 52 61 41);
• 0x1E4 (4 bayt) – imza (72 72 41 61);
• 0x1E8 (4 bayt) – boş kümelerin sayısı, bilinmiyorsa -1;
• 0x1EC (4 bayt) – son kaydedilen kümenin numarası;
• 0x1FE (2 bayt) – imza (55 AA).

FAT tablosu, diskteki her kümenin durumu hakkında bilgi içerir. FAT tablosunun alt 2 baytı F8 FF FF 0F FF FF FF FF'yi depolar (bu, fiziksel olarak bulunmayan 0 ve 1 kümelerinin durumuna karşılık gelir). Daha sonra her bir kümenin durumu, mevcut dosyanın devam ettiği kümenin numarasını veya aşağıdaki bilgileri içerir:

• 00 00 00 00 – küme ücretsizdir;
• FF FF FF 0F – geçerli dosyanın sonu.

• 8 bayt – dosya adı;
• 3 bayt – dosya uzantısı;

Kök dizin, her dosya hakkında aşağıdaki bilgileri içeren bir dizi 32 bitlik bilgi kaydı içerir:

Uzun dosya adlarıyla (Rusça adlar dahil) çalışırken, dosya adı UTF-16 kodlama sistemi kullanılarak kodlanır. Bu durumda her karakterin kodlanması için 2 bayt ayrılır. Bu durumda dosya adı aşağıdaki yapıda yazılır:

• 1 sıra baytı;
• 10 bayt, dosya adının alt 5 karakterini içerir;
• 1 baytlık öznitelik;
• 1 bayt ayrılmıştır;
• 1 bayt – DOS adı sağlama toplamı;
• 12 bayt, dosya adının alt 3 karakterini içerir;
• 2 bayt – ilk kümenin numarası;
• uzun adın kalan karakterleri.

C dilinde dosyalarla çalışma

Programcıya göre açık bir dosya, okunan veya yazılan bir veri dizisi olarak temsil edilir. Bir dosya açıldığında, onunla ilişkilendirilir. G/Ç akışı. Çıkış bilgileri akışa yazılır, giriş bilgileri akıştan okunur.

G/Ç için bir akış açıldığında stdio.h'de tanımlanan standart bir FILE yapısıyla ilişkilendirilir. FILE yapısı dosya hakkında gerekli bilgileri içerir.

Bir dosyanın açılması, dosya üzerinde daha sonraki işlemlerde kullanılabilecek bir DOSYA yapısına işaretçi döndüren fopen() işlevi kullanılarak yapılır.

DOSYA *fopen(isim, tür);

name – açılacak dosyanın adı (yol dahil),
type, dosyaya nasıl erişileceğini tanımlayan bir karakter dizisinin işaretçisidir:

• "r" - dosyayı okumak için açın (dosyanın mevcut olması gerekir);
• "w" - yazmak için boş bir dosya açın; dosya mevcutsa içeriği kaybolur;
• "a" - dosyayı sonuna kadar yazmak için açın (eklemek için); dosya mevcut değilse oluşturulur;
• "r+" - dosyayı okumak ve yazmak için açın (dosyanın mevcut olması gerekir);
• "w+" - okumak ve yazmak için boş bir dosya açın; dosya mevcutsa içeriği kaybolur;
• "a+" - dosyayı okumak ve eklemek için açın; dosya yoksa oluşturulur.

Dönüş değeri açık akışın bir işaretçisidir. Bir hatayla karşılaşılırsa NULL döndürülür.

fclose() işlevi, fopen() işlevi kullanılarak açılan dosyalarla ilişkili akışı veya akışları kapatır. Kapatılacak akış fclose() fonksiyonunun argümanı tarafından belirlenir.

Dönüş değeri: akış başarıyla kapatılmışsa 0 değeri; Bir hata meydana gelirse sabit EOF.

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

#katmak
int ana() (
DOSYA *fp;
karakter adı = "my.txt";
if ((fp = fopen(isim, "r" )) == NULL )
{
printf( "Dosya açılamadı");
getchar();
0 değerini döndür;
}
// dosyayı açmayı başardık
... // veriler üzerinde gerekli işlemler
fclose(fp);
getchar();
0 değerini döndür;
}

Dosyadan karakter okuma:

char fgetc(akış);

İşlev bağımsız değişkeni, FILE türündeki bir akışın işaretçisidir. Fonksiyon okunan karakterin kodunu döndürür. Dosyanın sonuna gelindiğinde veya bir hata meydana geldiğinde EOF sabiti döndürülür.

Bir dosyaya sembol yazma:

fputc(karakter, akış);

Fonksiyonun argümanları bir karakter ve FILE tipindeki bir akışı gösteren bir işaretçidir. Fonksiyon okunan karakterin kodunu döndürür.

fscanf() ve fprintf() işlevleri, scanf() ve printf() işlevlerine benzer, ancak veri dosyalarıyla çalışır ve ilk argümanları olarak bir dosya işaretçisine sahiptir.

fscanf(akış, "GirişFormat", argümanlar);

Metin dosyaları

Bir örnek kullanarak C'de bir metin dosyasıyla çalışmaya bakalım. C sürücüsünde TextFile.txt adlı bir metin dosyası oluşturun. Bu dosyaya aşağıdaki satırları yazın:

Dize_1 123 Dize_11, 456
Dize_2
Dize_3

Dosya 'yı kaydet.

Bu da dosyamızı açan ve içindeki satırları okuyan bir 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("Problemler"); return EXIT_FAILURE; ) while(fgets(cArray, LEN, pTextFile) != NULL) ( printf("%s", cArray); ) fclose(pTextFile); return EXIT_SUCCESS; )

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

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

Fopen fonksiyonunun ilk argümanı bir dosyayı işaret eder, ikincisi ise dosyanın okunmaya açık olduğunu söyler.

Fgets fonksiyonunu kullanarak satırları okuyoruz:

fgets(cArray, LEN, pTextFile);

fgets fonksiyonunun ilk argümanı alınan stringlerin saklanacağı karakter dizisini, ikinci argümanı okunacak maksimum karakter sayısını, üçüncü argümanı ise dosyamızı gösterir.

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

fclose(pTextFile);

Şunu elde ederiz:

Satırlarda Rusça harfler de yer alıyor.

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ındaki verileri açtık ve okuduk.

Şimdi programlı olarak bir metin dosyasının nasıl oluşturulacağını ve ona veri yazılacağını öğreneceğiz.

/* 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("Problemler"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, cNewLine); fprintf(pTextFile, "%d", nVal); return EXIT_SUCCESS ;)

Verilerin yazılacağı bir metin dosyası oluşturun:

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

dosya zaten mevcutsa açılacak ve içindeki tüm veriler silinecektir.

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

Fprintf işlevini kullanarak verileri bir metin dosyasına yazıyoruz:

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

Buradaki ilk argüman dosyamız, ikincisi format dizesi, üçüncü veya daha fazlası bu format için gereken argüman sayısıdır.