Bir prizmada ışınların yolunun inşası. Üçgen prizmada ışınların yolu

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'ye kadar), FAT16 - küçük kapasiteli diskler için, FAT32 - yüksek kapasiteli FLASH sürücüler için (32 GB'a kadar) kullanılır.

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

FAT32 dosya yapısı

FAT32 sistemindeki harici bellek cihazlarında bayt adresleme yerine blok adresleme bulunur. 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, bağımsız bir birim olarak düşünülebilecek birçok sektörün birleşimidir. belirli özellikler. 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:

İle çalışma durumunda uzun isimler dosyalar (Rusça adlar dahil), dosya adı UTF-16 kodlama sisteminde kodlanmıştı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);

• "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ıldıysa değer 0; 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ış);

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 dosyaya yönelik bir işaretçiye sahiptir.

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

Daha önce, veri girerken ve çıkarırken standart akışlarla (klavye ve monitör) çalışıyorduk. Şimdi C dilinin dosyalardan veri almayı ve oraya yazmayı nasıl uyguladığına bakalım. Bu işlemleri gerçekleştirmeden önce dosyayı açmanız ve ona erişmeniz gerekir.

C programlama dilinde, bir dosyaya yönelik işaretçi FILE türündedir ve bildirimi şu şekilde görünür:
DOSYA *dosyam;

Öte yandan, fopen() işlevi, okuma modunda ("r"), yazma modunda ("w") veya ekleme modunda ("a") ilk argümanı olarak belirtilen adresteki bir dosyayı açar ve bir işaretçi döndürür ona programa. Bu nedenle, bir dosyayı açma ve onu programa bağlama işlemi şuna benzer:
dosyam = fopen("merhaba.txt", "r");

Bir dosyaya veri okurken veya dosyaya veri yazarken, ona bir dosya işaretçisi (bu durumda dosyam) aracılığıyla erişilir.

Herhangi bir nedenden dolayı (belirtilen adreste dosya yoksa, ona erişim reddedildiyse), fopen() işlevi dosyayı açamıyorsa NULL değerini döndürür. Gerçek programlarda, neredeyse her zaman if dalındaki dosya açma hatasını ele alırlar, ancak biz bunu daha fazla atlayacağız.

Fopen() işlev bildirimi stdio.h başlık dosyasında bulunur, dolayısıyla dahil edilmesi gerekir. Ayrıca stdio.h'de FILE yapı tipi bildirildi.

Bir dosyayla çalışma bittikten sonra, arabelleği verilerden kurtarmak için ve diğer nedenlerle dosyayı kapatmak gelenekseldir. Bu, özellikle programın dosyayla çalıştıktan sonra çalışmaya devam etmesi durumunda önemlidir. Harici bir dosya ile ona programdan gelen bir işaretçi arasındaki bağlantıyı kesmek, fclose() işlevi kullanılarak yapılır. Dosyaya bir işaretçi parametre olarak iletilir:
fclose(dosyam);

Programda birden fazla dosya açılabilmektedir. Bu durumda her dosyanın kendi dosya işaretçisiyle ilişkilendirilmesi gerekir. Ancak program önce bir dosyayla çalışıp ardından onu kapatırsa işaretçi ikinci bir dosyayı açmak için kullanılabilir.

Bir metin dosyasından okuma ve metin dosyasına yazma

fscanf()

fscanf() işlevi, anlam olarak scanf() işlevine benzer, ancak ondan farklı olarak, standart girdi yerine bir dosyadan biçimlendirilmiş girdi sağlar. fscanf() işlevi parametreleri alır: dosya işaretçisi, biçim dizesi, veri yazmak için bellek alanlarının adresleri:
fscanf(dosyam, "%s%d", str, &a);

Başarıyla okunan veri veya EOF sayısını döndürür. Boşluklar ve yeni satır karakterleri veri sınırlayıcı olarak sayılır.

Diyelim ki nesnelerin aşağıdaki tanımını içeren bir dosyamız var:

Elma 10 23,4 Muz 5 25,0 Ekmek 1 10,3

#katmak main () ( FILE * file; struct food ( karakter adı[ 20 ] ; unsigned adet; float fiyat; ) ; struct food shop[ 10 ] ; char i= 0 ; file = fopen ( "fscanf.txt" , "r" ) ); while (fscanf (file, "%s%u%f" , mağaza[ i].isim , & (mağaza[ i].qty ) , & (mağaza[ i].fiyat ) != EOF) ( printf ( "%s %u %.2f \N", mağaza[i].adı, mağaza[i].adet, mağaza[i].fiyat) ; i++; ))

Bu durumda bir yapı ve bir dizi yapı bildirilir. Dosyadaki her satır dizinin bir öğesine karşılık gelir; dizi öğesi, bir dize ve iki sayısal alan içeren bir yapıdır. Döngü yineleme başına bir satır okur. Dosya sonuyla karşılaşıldığında fscanf(), EOF değerini döndürür ve döngü sona erer.

fgets()

fgets() işlevi, get() işlevine benzer ve bir dosyadan satır satır giriş gerçekleştirir. fgets()'a yapılan bir çağrı bir satır okuyacaktır. Bu durumda satırın tamamını okuyamazsınız, yalnızca bir kısmını baştan okuyabilirsiniz. fgets() parametreleri şuna benzer:
fgets (karakter_dizisi, okunan_karakterlerin_sayısı, dosyaya_işaretçi)

Örneğin:
fgets(str, 50, dosyam)

Bu işlev çağrısı, dosyam işaretçisiyle ilişkili dosyadan, işlevin aynı zamanda bir dizide depolayacağı "\n" karakteri de dahil olmak üzere uzunluğu 50 karakterden azsa bir tam satırlık metin okuyacaktır. str dizisinin son (50.) elemanı fgets() tarafından eklenen "\0" karakteri olacaktır. Eğer string daha uzunsa fonksiyon 49 karakter okuyacak ve sonuna "\0" yazacaktır. Bu durumda okuma satırında "\n" bulunmayacak.

#katmak #define N 80 main () ( FILE * file; char arr[ N] ; file = fopen ("fscanf.txt" , "r" ) ; while (fgets (dizi, N, dosya) != NULL) printf (" %s", arr) ; printf (" \N") ); fclose(dosya); )

Bu programda öncekinden farklı olarak veriler arr dizisine satır satır okunur. Bir sonraki satır okunduğunda önceki satır kaybolur. fgets() işlevi, sonraki satırı okuyamazsa NULL değerini döndürür.

getc() veya fgetc()

getc() veya fgetc() işlevi (her ikisi de çalışır), bir dosyadan sonraki tek karakteri almanızı sağlar.

while ((dizi[ i] = fgetc (dosya) ) != EOF) ( if (dizi[ i] == " \N") (dizi[i] = " \0 " ; printf("%s \N", arr); ben = 0; ) aksi takdirde i++; )arr[i] = " \0 " ; printf("%s \N", arr);

Örnek kod, ekranda bir dosyadaki verileri görüntüler.

Bir metin dosyasına yazma

Tıpkı girdi gibi, bir dosyanın çıktısı da farklı olabilir.

• Biçimlendirilmiş çıktı. fprintf işlevi (dosya_index, biçim_dizgesi, değişkenler) .
• Satır bazında çıktı. İşlev fputs(string, file_pointer) .
• Karakter karakter çıktısı. fputc() veya putc(symbol, file_pointer) işlevi.

Aşağıda, bir dosyaya veri çıkışı sağlamak için üç yöntem kullanan kod örnekleri verilmiştir.

Dosyanın her satırına bir yapıya ait alanların yazılması:

dosya = fopen ("fprintf.txt", "w"); while (scanf ("%s%u%f" , shop[ i].name , & (shop[ i].qty ) , & (shop[ i].price ) ) != EOF) ( fprintf (file, " %s %u %.2f \N", mağaza[i].adı, mağaza[i].adet, mağaza[i].fiyat) ; i++; )

Bir dosyaya satır satır çıktı (fputs(), puts()'un kendisinden farklı olarak satırın sonuna “\n” yerleştirmez):

while (gets (arr) != NULL) ( fputs (dizi, dosya); fputs (" \N", dosya);

)

Karakter karakter çıktı örneği:

while ((i = getchar () ) != EOF) putc (i, dosya) ;

İkili dosyadan okuma ve ikili dosyaya yazma

Bir dosyayla karakter dizisi olarak değil, bayt dizisi olarak çalışabilirsiniz. Prensip olarak metin olmayan dosyalarla başka şekilde çalışmak mümkün değildir. Ancak bu aynı zamanda metin dosyalarını okumak ve yazmak için de kullanılabilir. Bir dosyaya erişmenin bu yönteminin avantajı okuma-yazma hızıdır: tek erişimde önemli miktarda bilgi bloğu okunabilir/yazılabilir.

Bir dosyayı ikili erişim için açarken fopen()'ın ikinci parametresi "rb" veya "wb" dizisidir.

İkili dosyalarla çalışma konusu oldukça karmaşıktır ve üzerinde çalışılması ayrı bir ders gerektirir. Burada sadece bayt akışı olarak kabul edilen bir dosyaya okuma ve yazma fonksiyonlarının özellikleri not edilecektir.

1. fread() ve fwrite() işlevleri parametre olarak alır:
2. Verinin yazıldığı veya okunduğu hafıza alanının adresi,
3. Belirli bir türün boyutu,
4. Belirtilen boyutta okunan veri miktarı,

dosya dizini.

Bu işlevler başarıyla okunan veya yazılan veri sayısını döndürür. Onlar. 50 veri öğesinin okunmasını “sipariş edebilirsiniz” ancak yalnızca 10 tanesini alabilirsiniz. Hiçbir hata olmayacaktır.

#katmak fread() ve fwrite() işlevlerinin kullanımına bir örnek: #katmak \0 " main () ( FILE * file; char raf1[ 50 ], raf2[ 100 ] ; int n, m; dosya = fopen ("shelf1.txt" , "rb" ) ; n= fread (shelf1, sizeof (char ) , 50, dosya) ; fclose (dosya) ; dosya = fopen ("shelf2.txt", "rb") ; m= fread (shelf2, sizeof (char), 50, dosya) = " \N"; raf2[m] = " \0 " ; raf2[ m+ 1 ] = "

Burada ilk dosyadan 50 karakter okunmaya çalışılıyor. n gerçekte okunan karakter sayısını saklar. N'nin değeri 50 veya daha az olabilir. Veriler bir sıraya yerleştirilir. İkinci dosyada da aynı şey oluyor. Daha sonra ilk satır ikinciye eklenir ve veriler üçüncü dosyaya aktarılır.

Problem çözme

1. Kullanıcıdan bir metin dosyasının adını (adresini) soran, ardından dosyayı açan ve içindeki karakter ve satır sayısını sayan bir program yazın.
2. Başka bir dosyadan alınan ve yazmadan önce bir şekilde değiştirilen verileri bir dosyaya yazan bir program yazın. Bir dosyadan elde edilen her veri satırının bir yapıya uyması gerekir.

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 bakacağımız birçok nüans var. Yapılması gereken 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ışma - 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ı içermemektedir. Bunlar elbette derleyici uygulamalarının her biri için mevcuttur. 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 gerekebilir: dosyada istediğiniz konuma gidin, unutmayın şu anki pozisyon, dosya uzunluğunu vb. belirleyin.

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);

Fopen işlevinin kendisi nesne için bellek ayırır; temizleme işlemi fclose işlevi tarafından gerçekleştirilir. Dosyayı kapatmak gerekiyor; 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. Haydi tamamlayalım eski program: Dosyayı tekrar açalım ve orada yazdıklarımızı düşünelim.

#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", tampon(dosya);

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 olanı düşünüyoruz) işletim sistemi) üç standart akış vardır: standart çıktı stdout, standart girdi stdin ve standart hata çıktısı 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 sık meydana gelir, bu nedenle bir dosyayı her 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(file); ; )

Sorun aynı anda birden fazla dosya açıldığında ortaya çıkıyor: eğer bunlardan biri açılamıyorsa geri kalanının da kapatılması gerekiyor

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

İÇİNDE basit vakalarönceki kod parçasında olduğu gibi doğrudan hareket edebilirsiniz. Daha fazlası zor vakalar RAII'yi C++'tan 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, verinin çıktısını aldığımızda, bu veri ilk olarak bir ara belleğe yerleştirilir. 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 arabelleğ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");

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 dosyaya 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ş());

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ş); ();

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 kullanmamak. Örneğin, mağaza Toplam fscanf vb. fonksiyonların genellikle doğru okunan ve eşleşen değerlerin sayısını döndürdüğü gerçeğini kaydeder veya kullanır.

#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ş());

Ö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); ) çıktıFile = fopen(OUTPUT_FILE, WRITE_ONLY) if (outputFile == NULL) ( printf("Hata) %s dosyası açılıyor", OUTPUT_FILE); getch(); //Eğer dosya okumak için açılabiliyorsa, 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));< n; i++) { for (j = 0; j < m; j++) { fprintf(outputFile, "%8d ", rand()); } fprintf(outputFile, "\n"); } //Закрываем файлы fclose(inputFile); fclose(outputFile); }

2. Kullanıcı dosyayı kopyalar ve önce çalışma modunu seçer: dosya konsola çıkarılabilir veya 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 (köken == NULL) ( printf("%s dosyası açılırken hata oluştu", dosya adı); getch(); çıkış(ERROR_FILE_OPEN); ) printf("modu girin: "); 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 (output) , "%c", fgetc(başlangıç));

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"); çıkış(ERROR_FILE_OPEN); for (;;) ( c = _getch(); if (c == 27) ( break; ) fputc(c, çıktı); fputc( c , stdout);

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 oluştu"); _getch(); çıkış(ERROR_FILE_OPEN); ) maxn = INT_MIN; while (!feof(input)) ( fscanf(input, "%d", &num); if (num > maxn) ) ( maksimumn = sayı; ) ) printf("maksimum sayı = %d", maksimumn);

5. Dosya şu kelimeleri içerir: Rusça kelime, sekme, ingilizce kelime, birkaç satır halinde. 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(giriş)) ( fgets(tampon, 511, giriş); uzunluk = strlen(tampon); for (index = 0; dizin)< 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

Son güncelleme: 31.10.2015

Sınıf Dosya akışı bir dosyadan okuma ve bir dosyaya yazma yeteneklerini temsil eder. Hem metin dosyalarıyla hem de ikili dosyalarla çalışmanıza olanak tanır.

En önemli özelliklerini ve yöntemlerini ele alalım:

Uzunluk özelliği: akışın uzunluğunu bayt cinsinden döndürür

Position özelliği: akıştaki geçerli konumu döndürür

Okuma yöntemi: Bir dosyadaki verileri bir bayt dizisine okur. Üç parametre alır: int Read(byte array, int offset, int count) ve başarıyla okunan bayt sayısını döndürür. Burada aşağıdaki parametreler kullanılır:

• dizi - dosyadan okunan verilerin yerleştirileceği bayt dizisi

  ofset, okuma baytlarının yerleştirileceği dizideki bayt cinsinden uzaklığı temsil eder

  saymak - azami sayı okunacak bayt. Dosyada daha az bayt varsa hepsi okunacaktır.

Yöntem uzun Arama(uzun konum, SeekOrigin kökeni): akıştaki konumu, ofset parametresinde belirtilen bayt sayısına göre bir ofsetle ayarlar.

Yazma yöntemi: Bir bayt dizisindeki verileri bir dosyaya yazar. Üç parametre alır: Write(byte array, int offset, int count)

• dizi - verilerin dosyaya yazılacağı bayt dizisi

  ofset - baytların akışa yazılmaya başladığı dizideki bayt cinsinden uzaklık

  count - yazılacak maksimum bayt sayısı

FileStream, bayt düzeyinde dosya erişimini temsil eder; dolayısıyla, örneğin bir metin dosyasına bir veya daha fazla satır okumanız veya yazmanız gerekiyorsa, bayt dizisinin özel yöntemler kullanılarak dizelere dönüştürülmesi gerekir. Bu nedenle metin dosyalarıyla çalışmak için diğer sınıflar kullanılır.

Aynı zamanda, belirli bir yapıya sahip çeşitli ikili dosyalarla çalışırken, FileStream belirli bilgi parçalarının çıkarılması ve işlenmesi için çok yararlı olabilir.

Bir metin dosyasına okuma ve yazma örneğine bakalım:

Console.WriteLine("Dosyaya yazılacak satırı giriniz:"); string metin = Console.ReadLine(); // (FileStream fstream = new FileStream(@"C:\SomeDir\noname\note.txt", FileMode.OpenOrCreate)) kullanarak bir dosyaya yazma ( // dizeyi bayta dönüştürün bayt dizisi = System.Text.Encoding. Varsayılan. GetBytes(metin); // bir bayt dizisini bir dosyaya yazma fstream.Write(array, 0, array.Length); Console.WriteLine("Dosyaya yazılan metin"); fstream = File.OpenRead(@"C:\SomeDir\noname\note.txt")) ( // dizeyi bayta dönüştürün bayt dizisi = yeni bayt; // verileri okuyun fstream.Read(array, 0, array. Uzunluk); // baytların dizeye kodunu çöz textFromFile = System.Text.Encoding.Default.GetString(array); Console.WriteLine("Dosyadan metin: (0)", textFromFile ) Console.ReadLine();

Bu örneğe bakalım. Hem okuma hem de yazma, use ifadesini kullanır. Bu ifade, kod dosyasının başında ad alanlarını içeren kullanma yönergesiyle karıştırılmamalıdır. Use deyimi, bir kod bloğunda bir nesne oluşturmanıza olanak tanır; bunun tamamlanmasının ardından o nesnenin Dispose yöntemi çağrılır ve böylece nesne yok edilir. Bu durumda fstream değişkeni böyle bir nesne görevi görür.

fstream nesnesi iki farklı şekilde oluşturulur: yapıcı aracılığıyla ve File sınıfının statik yöntemlerinden biri aracılığıyla.

Burada yapıcıya iki parametre iletilir: dosya yolu ve FileMode numaralandırması. Bu numaralandırma, dosya erişim modunu belirtir ve aşağıdaki değerleri alabilir:

Ekle: Dosya mevcutsa metin dosyanın sonuna eklenir. Dosya mevcut değilse oluşturulur. Dosya sadece yazmak için açılmıştır.

Oluştur: Yeni bir dosya oluşturulur. Böyle bir dosya zaten mevcutsa üzerine yazılır

CreateNew : Yeni bir dosya oluşturulur. Böyle bir dosya zaten mevcutsa uygulama bir hata verir

Aç: Bir dosyayı açar. Dosya mevcut değilse bir istisna oluşturulur

OpenOrCreate : Dosya varsa açılır, yoksa yenisi oluşturulur.

Kes: Dosya mevcutsa üzerine yazılır. Dosya sadece yazmak için açılmıştır.

File sınıfının statik OpenRead yöntemi, okumak için bir dosyayı açar ve bir FileStream nesnesi döndürür.

FileStream sınıfı yapıcısı ayrıca, oluşturulan nesneyi daha hassas bir şekilde özelleştirmenize olanak tanıyan bir dizi aşırı yüklemeye sahiptir. Tüm bu sürümler msdn'de görüntülenebilir.

Hem yazma hem de okuma, System.Text ad alanındaki Encoding.Default kodlama nesnesini kullanır. Bu durumda, yöntemlerinden ikisini kullanırız: Bir dizeden bir bayt dizisi almak için GetBytes ve bir bayt dizisinden bir dize almak için GetString.

Sonuç olarak girdiğimiz string dosyaya yazılıyor not.txt. Aslında bu bir ikili dosyadır (metin dosyası değil), ancak içine yalnızca bir satır yazarsak bu dosyayı bir metin düzenleyicide açarak okunabilir bir biçimde görüntüleyebiliriz. Ancak içine rastgele baytlar yazarsak, örneğin:

Fstream.WriteByte(13); fstream.WriteByte(103);

O zaman anlamakta zorluk yaşayabiliriz. Bu nedenle, ayrı sınıflar doğrudan metin dosyalarıyla (StreamReader ve StreamWriter) çalışacak şekilde tasarlanmıştır.

Dosyalara rastgele erişim

Genellikle ikili dosyalar belirli bir yapıyı temsil eder. Ve bu yapıyı bilerek, dosyadan gerekli bilgiyi alabilir veya tam tersine, dosyanın belirli bir yerine belirli bir bayt kümesi yazabiliriz. Örneğin, wav dosyalarında ses verilerinin kendisi 44 bayttan başlar ve 44 bayta kadar çeşitli meta veriler vardır - ses kanallarının sayısı, örnekleme frekansı vb.

Seek() yöntemini kullanarak, dosyanın okunduğu veya yazıldığı yerden başlayarak akış imlecinin konumunu kontrol edebiliriz. Bu yöntem iki parametre alır: ofset ve dosyadaki konum. Bir dosyadaki konum üç değerle tanımlanır:

SeekOrigin.Begin : dosyanın başlangıcı

SeekOrigin.End : dosyanın sonu

SeekOrigin.Current : dosyadaki mevcut konum

Okumanın veya yazmanın başladığı akışın imleci, ikinci parametre olarak belirtilen konuma göre ofset kadar ileri kaydırılır. Ofset negatif olabilir, ardından imleç geriye doğru, pozitifse ileri doğru hareket eder.

Bir örneğe bakalım:

System.IO'yu kullanma; System.Text'i kullanarak; class Program ( static void Main(string args) ( string text = "merhaba dünya"; // (FileStream fstream = new FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) kullanarak bir dosyaya yazma) ( / / dizeyi bayta dönüştürün input = Encoding.Default.GetBytes(text); // bir bayt dizisini bir dosyaya yazın fstream.Write(input, 0, input.Length); Console.WriteLine("Dosyaya yazılan metin") ); işaretçiyi dosyanın sonuna, dosyanın sonuna beş bayta taşı fstream.Seek(-5, SeekOrigin.End); // akışın sonundan 5 karakter eksi // dört karakteri oku geçerli konum bayt çıkışı = yeni bayt( çıktı, 0, çıktı.Length); // baytların kodunu dize olarak çöz textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Dosyadan metin: (0)" , textFromFile); dosyadaki word world'den house string'e changeText = "house"; fstream.Seek(-5, SeekOrigin.End); // akışın sonundan itibaren eksi 5 karakter input = Encoding.Default. GetBytes(replaceText); 0, giriş.Uzunluk); // tüm dosyayı oku // işaretçiyi dosyanın başına döndür fstream.Seek(0, SeekOrigin.Begin); çıktı = yeni bayt; fstream.Read(çıkış, 0, çıkış.Length); // baytların kodunu bir dize olarak çöz textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Dosyadan metin: (0)", textFromFile); // merhaba ev ) Console.Read(); ))

Konsol çıkışı:

Dosyaya yazılan metin Dosyadaki metin: worl Dosyadaki metin: hello house

fstream.Seek(-5, SeekOrigin.End) işlevinin çağrılması, akış imlecini dosyaların sonuna, beş karakter geriye taşır:

Yani yeni bir dosyaya “merhaba dünya” satırını yazdıktan sonra imleç “w” karakterinin konumunda olacaktır.

Bundan sonra "w" karakteriyle başlayan dört byte'ı okuyoruz. Bu kodlamada 1 karakter 1 byte'ı temsil edecektir. Bu nedenle 4 byte'ı okumak dört karakteri okumaya eşdeğer olacaktır: "worl".

Daha sonra yine beş karakterin sonuna ulaşmadan (yani yine “w” karakterinin konumundan) dosyanın sonuna geçip “house” dizesini yazıyoruz. Yani "ev" dizisi "dünya" dizisinin yerini alır.

Bir konuyu kapatmak

Yukarıdaki örneklerde, bir akışı kapatmak için bir kullanma yapısı kullanılmıştır. Kullanım bloğundaki tüm ifadeler ve ifadeler işlendikten sonra FileStream nesnesi yok edilir. Ancak başka bir yol da seçebiliriz:

FileStream fstream = null; try ( fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // akışla yapılan işlemler ) catch(Exception ex) ( ) nihayet ( if (fstream != null) fstream.Close() )

Eğer kullanma yapısını kullanmazsak, Close() yöntemini açıkça çağırmamız gerekir: fstream.Close()

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);

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.