Metin dosyalarıyla çalışma c. Metin dosyalarıyla çalışma

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
İlk önce bir işaretçi oluşturmanız gerekir tip değişkeni DOSYA ( 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 gerçekleştirilir aşağıdaki işlevler: 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. Yalnızca dosya adını veya Ad Soyad tam yolu da dahil olmak üzere dosya.

İ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 - Oluşturuldu yeni dosya. Eğer belirtilen dosya varsa, içeriği silinir ve dosya uzunluğu sıfıra ayarlanı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 meydana gelebilir, örneğin, yöntem Açık var olmayan bir dosyayı okumak için belirtildi.

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 sistemleri 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 yazar açık dosya nLpBuf arabelleğinden baytları sayın. 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ığı. Kalkmak kilitleri ayarla, yöntemi kullanmanız gerekiraralığı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.

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("Problems"); 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("Sorunlar"); return EXIT_FAILURE; ) fprintf(pTextFile, "%s%c", cString, 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ı.

Son güncelleme: 31.10.2015

Sınıf dosya akışı bir dosyadan okuma ve bir dosyaya yazma yeteneğini temsil eder. Hem metin hem de ikili dosyalarla çalışmanıza olanak tanır.

En önemli özelliklerini ve yöntemlerini göz önünde bulundurun:

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

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

Okuma yöntemi: Verileri bir dosyadan bir bayt dizisine okur. Üç parametre alır: int Read(byte dizisi, 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 bir bayt dizisi

  ofset, bayt cinsinden ofseti temsil eder. sıralamak, okuma baytlarının yerleştirileceği yer

  count - okunacak maksimum bayt sayısı. Dosyada daha az bayt varsa, tümü okunacaktır.

Yöntem uzun Arama(uzun ofset, SeekOrigin orijini): ofset parametresinde belirtilen bayt sayısına göre akış ofsetindeki konumu ayarlar.

Yazma yöntemi: Verileri bir bayt dizisinden bir dosyaya yazar. Üç parametre alır: Write(byte dizisi, int offset, int count)

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

  ofset - akışa bayt yazmaya nereden başlayacağınız dizi dizisindeki bayt cinsinden ofset

  count - yazılacak maksimum bayt sayısı

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

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

Bir metin dosyasına okuma-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 dosyaya yaz ( // dizeyi bayta dönüştür bayt dizisi = System.Text.Encoding.Default. GetBytes(text); // Bir dosyaya bir bayt dizisi yazın fstream.Write(array, 0, array.Length); Console.WriteLine("Metin bir dosyaya yazılır"); ) // Kullanarak bir dosyadan okuyun (FileStream fstream = File.OpenRead(@"C:\SomeDir\noname\note.txt")) ( // dizeyi bayta dönüştür bayt dizi = yeni bayt; // verileri oku fstream.Read(dizi, 0, dizi. Uzunluk); // baytların kodunu dizgeye çöz textFromFile = System.Text.Encoding.Default.GetString(array); Console.WriteLine("Dosyadan metin: (0)", textFromFile); ) Console.ReadLine();

Bu örneği inceleyelim. Hem okuma hem de yazma, using deyimini kullanır. kafan karışmasın verilen operatör kod dosyasının başında ad alanlarını içeren bir kullanım yönergesi ile. using deyimi, bir kod bloğunda bir nesne oluşturmanıza izin verir, ardından bu nesne üzerinde Dispose yöntemi çağrılır ve böylece nesne yok edilir. İÇİNDE bu durum fstream değişkeni böyle bir nesne görevi görür.

fstream nesnesi iki kişi tarafından oluşturulur Farklı yollar: 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 sıralaması. Bu enum, dosya erişim modunu gösterir ve aşağıdaki değerleri alabilir:

Ekle : Dosya varsa, metin dosyanın sonuna eklenir. Dosya yoksa, oluşturulur. Dosya sadece yazmak için açılır.

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

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

Aç : Bir dosya açar. Dosya yoksa, bir istisna atılır.

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

Kes : Dosya varsa, üzerine yazılır. Dosya sadece yazmak için açılır.

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

Yapıcı sınıf Dosya Akışı ayrıca oluşturulan nesneye ince ayar yapmanıza izin veren bir dizi aşırı yüklenmiş sürüme sahiptir. Bu sürümlerin tümü msdn'de görüntülenebilir.

Hem yazma hem de okuma, System.Text ad alanından 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ır. not.txt. Aslında, bu bir ikili dosyadır (metin değil), ancak içine sadece bir satır yazsak, bu dosyayı açarak insan tarafından okunabilir bir biçimde görebiliriz. Metin düzeltici. Ancak, içine rastgele baytlar yazarsak, örneğin:

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

O zaman anlamakta zorlanabiliriz. Bu nedenle, ayrı sınıflar doğrudan metin dosyalarıyla çalışmak üzere tasarlanmıştır - StreamReader ve StreamWriter.

Rastgele dosya erişimi

Sıklıkla ikili dosyalar belirli bir yapıyı temsil eder. Ve bu yapıyı bilerek, dosyadan gerekli bilgi kısmını alabilir veya tam tersine dosyada belirli bir yere 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ığı akış imlecinin konumunu kontrol edebiliriz. Bu yöntem iki parametre alır: ofset (ofset) ve dosyadaki konum. Dosyadaki konum üç değerle tanımlanır:

SeekOrigin.Begin : dosyanın başı

SeekOrigin.End : dosyanın sonu

SeekOrigin.Current : dosyadaki geçerli konum

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

Bir örneğe bakalım:

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

Konsol çıktısı:

Dosyaya yazılan metin Dosyadaki metin: dünya Dosyadaki metin: merhaba evi

fstream.Seek(-5, SeekOrigin.End) çağrısı, akış imlecini dosyaların sonuna beş karakter geri götürür:

Yani, yeni bir dosyaya "hello world" dizesini yazdıktan sonra, imleç "w" karakterinin konumunda olacaktır.

Bundan sonra "w" karakteri ile başlayan dört bayt okuruz. Bu kodlamada 1 karakter 1 baytı temsil edecektir. Bu nedenle, 4 bayt okumak, dört karakter okumakla eşdeğer olacaktır: "dünya".

Sonra yine beş karakterin sonuna ulaşmadan (yani yine "w" karakterinin konumundan) dosyanın sonuna gidiyoruz ve "ev" satırını yazıyoruz. Böylece, "ev" dizisi "dünya" dizisinin yerini alır.

Bir akışı kapatma

Yukarıdaki örnekler, akışı kapatmak için using yapısını kullanır. using bloğundaki tüm ifadeler ve ifadeler tamamlandıktan sonra FileStream nesnesi yok edilir. Ancak başka bir yol seçebiliriz:

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

using yapısını kullanmıyorsak, o zaman açıkça Close() yöntemini çağırmamız gerekir: fstream.Close()

Bir metin dosyasına nasıl bilgi yazılacağını zaten öğrendik. – Öğrenmediyseniz bir önceki makaleye bakın. Açıklanmış ve ayrıntılı

Peki ya dosya zaten varsa ve işlemek için ondan bilgi okumamız gerekiyorsa? Neyse ki, bu da oldukça basit. Size bu görevi gerçekleştirmek için birkaç seçenek olduğunu hatırlatırım, bunlardan sadece birini anlattım. Nedense bana algı için en basit görünen şey anlatılıyor.

#katmak

int ana()
{
karakter s1 //Değişken dizeyi okuyacak
ifstream in("C:\\\FromC\\myfile.txt" ); //Bilgileri okumak için dosyayı açma
>>s1'de; //satırı oku
in.close() // dosyayı kapatma

cout<Çıkış değeri s1 ekranda
0 dönüşü;
}

İşte yol boyunca bulunan bir metin dosyasından ilk satırı okumak için en basit program
C:\\\FromC\\dosyam.txt -
Bu bir önceki yazının devamı olduğu için orada oluşturduğumuz dosyayı kullanmaya karar verdim. Bununla ilgili zorluklar muhtemelen ortaya çıkmamalıdır.
Ama koda geri dönelim. İlk önce dosyayı açıyoruz ve içindeki bilgileri okuyoruz, bunun için komutu kullanıyoruz akış ise, parantez içinde, benim yaptığım gibi, dosyanın adını veya dosyanın yolunu belirtiyoruz. (“C:\\\FromC\\dosyam.txt” );
Dosyayı ondan bir şeyler okumak için açtığımızda, bir tür değişken bildirdik. karakter
karakter s1
Şimdi sadece dosyadan bir satırın değerini değişkene atamamız gerekiyor. Ekip olarak yaptığımız şey bu. içinde
Köşeli parantezlere dikkat edin >> içinde
Aslında program koduna yapılan yorumlardan da anlaşılacağı gibi değişkenin okunabilir bir değer ataması için ondan sonra yazmamız gerekiyor. >> içinde
>>s1'de;

Bu özellikle zor bir görev gibi görünmüyor, özellikle de son makalenin materyalinde mükemmel bir şekilde ustalaştıysanız ve nasıl kullanılacağını öğrendiyseniz - her şey kesinlikle aynı, sadece 2 takım farklı

Bir dosya oluşturma ve ona bilgi yazma C++

akış dışı dışarı ( Dosya adı );
dışarı<< (Yazılı dize);
dışarı.kapalı();
=============================

C++ ile bir dosyadan metin okuma ve ekranda metin görüntüleme

ifstream içinde (Dosya adı );
içinde>> (satır okuma);
içinde.kapalı();(Dosyayı kapatın)
============================
Hadi yaz basit bir program, klavyeden metin girişini okuyacak ve bir dosyaya yazacaktır:

#katmak
#katmak

int ana()
{
\\ 3 gelecek hat
clrscsr(); // Ekranı temizleme

cout<<“Wwedi pervuu stroku” ; cin >>a ; son;
cout<<“Wwedi wtoruu stroku” ; cin >>b ; son;
cout<<“Wwedi tretuu stroku” ; cin >>c ; son;
clrscr(); //

/*Dosya ile çalışmaya başla*/
ofstream out("C:\\\FromC\\myfile.txt" ); //Bir dosyayı yazmak için açma
dışarı<İlk satırı yaz
dışarı<ikinci satırı yaz
dışarı<Üçüncü satırı yazın
out.close(); // dosyayı kapatma

//Değişkenleri sıfırla

için (int ben =0 ;i<=255 ;i ++)
(a =*"" ; b =*"" ; c =*"" ;)

ifstream içinde(“C:\\\FromC\\dosyam.txt” );
>>a >>b >>c'de; //Her yeni satırı yeni bir değişkene okuruz
in.close(); // dosyayı kapatma

/* */

için (i =0 ;a !=*"" ;i ++)
{
eğer (i >sizeof(a)) kırmak ;
cout<
}
cout<<“\n” ; \\

/* */

{
eğer (i >sizeof(b)) kırmak ;
cout<
}
cout<<“\n” ; \\ İmleci yeni satıra taşı

/* */

için (i =0 ;c !=*“” ;i ++)
{
eğer (i >sizeof(c)) kırmak ;
cout<<с ;
}

0 dönüşü;
}
===================

Yukarıdaki örneklerde, böyle bir tane var BÜYÜK kusur. Boşluk içeren bir satır girmeye çalışırsak, program ihtiyacımız olduğu gibi çalışmayacaktır. Muhtemelen, sadece ben değil, birçok kişi de bu hatayla karşılaştı. Bu nedenle, neyle karşılaşabileceğinizi görebilmeniz için yanlış verilen kodu bırakıyorum.

Evde kitap olmadığı için, yine interneti aramaya başladım ve her türden pek çok kurnaz saçmalık buldum. Ancak, bir şekilde sorunuma bir çözüm buldum.
Ne hakkında okuduğuma yardımcı oldu cout yöntemlerini desteklemektedir. Ve internette tüm tavsiyeler işlevin kullanılmasına gidiyor hat almak Ne mutlu ki, bu işlevi nasıl kullanacağımı çok hızlı bir şekilde buldum ve ardından kodda kullandım.
Genel olarak, bu işlevden bahsetmeye ve açıklamaya değer, ancak şu ana kadar gerçekten anlamadım, sadece kullanılması gerektiğini anlıyorum ve nasıl yapılacağını anlıyorum, bu yüzden geliştirilmekte olan programımızın daha doğru bir örneğini veriyorum:

#katmak
#katmak

int ana()
{
char a ,b ,c ; \\ 3 gelecek hat
clrscsr(); // Ekranı temizleme

/* Değişkenler için değer girin */

cout<<“Wwedi pervuu stroku” ; cin.getline(a,sizeof(a)); son;
cout<<“Wwedi wtoruu stroku” ; cin.getline(a,sizeof(b)); son;
cout<<“Wwedi tretuu stroku” ; cin.getline(a,sizeof(c)); son;
clrscr(); //Değerleri girdikten sonra ekranı temizleyin

/*Dosya ile çalışmaya başla*/
ofstream out("C:\\\FromC\\dosyam.txt"); // Bir dosyayı yazmak için açma
dışarı<İlk satırı yaz
dışarı<ikinci satırı yaz
dışarı<Üçüncü satırı yazın
out.close(); // dosyayı kapatma

//Değişkenleri sıfırla

için (int ben =0 ;i<=255 ;i ++)
(a =*"" ; b =*"" ; c=*"" ;)

/*Dosya ile çalışmaya devam et*/

akış varsa (“C:\\\FromC\\dosyam.txt” );
in.getline(a,sizeof(a));// A
in.getline(b,sizeof(b));// Bir diziyi bir değişkene okuma B
in.getline(c,sizeof(c)); // Bir diziyi bir değişkene okuma C
in.close(); // dosyayı kapatma

/* İlk satırı karakter karakter okuyup ekranda görüntülüyoruz. */

(i =0 ;a !=*"" ;i++) için
{
eğer (i >sizeof(a)) kırmak ;
cout<
}
cout<<“\n” ; \\ İmleci yeni satıra taşı

/* İkinci satırı karakter karakter okuyup ekranda görüntülüyoruz. */

için (i =0 ;b !=*“” ;i ++)
{
eğer (i >sizeof(b)) kırmak ;
cout<
}
cout<<“\n” ; \\ İmleci yeni satıra taşı

/* Üçüncü satırı karakter karakter okuyup ekranda görüntülüyoruz. */

için (i =0 ;c !=*“” ;i++)
{
eğer (i>sizeof(c)) kırmak ;
cout<<с[i];
}

getch(); \\Enter tuşuna basılması bekleniyor
0 dönüşü;
}
===================

Bu materyalde, bilgilerin karakter karakter okunmasına bir örnek analiz edilmektedir. Çalışmayı tür değişkenlerle tanımlamadığım için karakter, o zaman yeni başlayanlar kodu anlamada bazı zorluklar yaşayabilir. sadece türünü bilemedim karakter bazı özelliklere sahiptir ve her şeyin daha basit olduğunu düşünür. Bu nedenle, yukarıdaki programın bazı anlaşılmaz anları aşağıdaki makalede okunabilir. char ile çalışmak V Yeni başlayanlar için C++

Aksi takdirde, verilen örnek, C ++ 'da bir metin dosyasından satırların nasıl okunacağı, erişilebilir ve oldukça anlaşılır olmalıdır. Bu şu anda en iyi uygulama seçeneği değil ve bazı önemli noktaları kaçırdım ama C++ dilini öğrenmeye başladığımız için şimdilik bu kadarı yeterli. Daha sonra, muhtemelen kayıplara geleceğim, ama şimdi sadece en gerekli olanı algılamanız gerekiyor.

Bu materyali sizinle birlikte anlarsak, profesyonelliğimize doğru küçük bir adım atmış oluruz.

Not:
kırmak ;– Bu, döngüden çıkan komuttur. Döngü sayacımız varsa için değişkenin beyan edilen boyutundan daha büyük olur karakter, sonra zorla döngüden çıkarız
!= – bu bizim durumumuz. Böyle bir koşul eşitsizliğini belirtir
eğer(a !=b )- sanki oku A eşit değil B

son; - Bu, konsolun içindeki yeni bir satıra imleç çevirisidir (anladığım kadarıyla)
Bu komut şuna benzer: "\N"

Kullanım kolaylığı için, depolama aygıtları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; programların çalışması için başlangıç ​​verileri veya program yürütme sonuçları; keyfi metinler; grafik 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ında adlandırılmış bir bayt koleksiyonu.

dosya sistemi dosyalar üzerinde işlemler sağlayan işletim sisteminin işlevsel bir parçasıdır. Dosya sistemlerine örnek olarak FAT (FAT - Dosya Ayırma Tablosu, dosya ayırma tablosu), NTFS, UDF (CD'lerde kullanılır) verilebilir.

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

Örnek olarak FAT32 kullanarak dosya sisteminin yapısını ele alalım.

FAT32 dosya yapısı

FAT32 sistemindeki harici bellek cihazları bayt değil blok adreslemedir. Bilgi, bloklar veya sektörler halinde harici bir bellek cihazına yazılır.

sektör - harici depolama aygıtlarında minimum adreslenebilir bilgi depolama birimi. Tipik olarak, sektör boyutu 512 bayt olarak sabitlenir. Harici bellek cihazlarının adres alanını artırmak için sektörler, küme adı verilen gruplar halinde birleştirilir.

Bir küme, belirli özelliklere sahip bağımsız bir birim olarak kabul edilebilecek birkaç 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ümelenmemiştir.
Diskteki minimum dosya boyutu 1 kümedir.

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

• EB 58 90 - koşulsuz şube 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ör sayısı;
• 2 bayt - yedek sektör sayısı.

Ek olarak, önyükleme sektörü aşağıdaki önemli bilgileri içerir:

• 0x10 (1 bayt) – FAT tablosu sayısı (genellikle 2);
• 0x20 (4 bayt) - diskteki sektör sayısı;
• 0x2C (4 bayt) – kök dizin 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) – serbest küme 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 (fiziksel olarak yok olan 0 ve 1 kümelerinin durumuna karşılık gelir). Ayrıca, her kümenin durumu, geçerli 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 sonudur.

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

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

Uzun dosya adlarıyla (Rusça adlar dahil) çalışırken, dosya adı UTF-16 kodlama sisteminde kodlanır. Bu durumda, her karakterin kodlanması için 2 bayt tahsis edilir. Bu durumda, dosya adı aşağıdaki yapı biçiminde yazılır:

• 1 bayt dizisi;
• 10 bayt, dosya adının alt 5 karakterini içerir;
• 1 bayt özniteliği;
• 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'deki Dosyalarla Çalışmak

Programcı için açık bir dosya, okunan veya yazılan bir veri dizisi olarak temsil edilir. Bir dosya açıldığında, şu dosyayla ilişkilendirilir: G/Ç akışı. Çıkış bilgisi akışa yazılır, giriş bilgisi akıştan okunur.

G/Ç için bir akış açıldığında, stdio.h içinde tanımlanan FILE türündeki standart yapı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 türünde bir yapıya bir işaretçi döndüren fopen() işlevi kullanılarak yapılır.

DOSYA *fopen(isim, tip);

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

• "r" - dosyayı okumak için açın (dosya mevcut olmalıdır);
• "w" - yazmak için boş bir dosya açın; dosya varsa içeriği kaybolur;
• "a" - sonuna kadar yazmak için açık dosya (eklemek için); dosya yoksa 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 varsa içeriği kaybolur;
• "a+" - dosyayı okumak ve eklemek için açın, dosya yoksa oluşturulur.

Dönen değer, açık akışa bir işaretçidir. Bir hata bulunursa, 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() işlevinin argümanı tarafından belirlenir.

Dönüş değeri: akış başarıyla kapatıldıysa değer 0; Bir hata oluşursa EOF sabiti.

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

#katmak
int ana() (
DOSYA *fp;
karakter adı = "benim.txt";
if ((fp = fopen(isim, "r" )) == NULL )
{
printf( "Dosya açılamadı");
getchar();
0 dönüşü;
}
// dosya açma başarılı
... // veriler üzerinde gerekli işlemler
fkapat(fp);
getchar();
0 dönüşü;
}

Bir dosyadan karakter okuma:

char fgetc(akış);

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

Bir dosyaya karakter yazmak:

fputc(karakter, akış);

İşlevin bağımsız değişkenleri, bir karakter ve FILE türündeki bir akışın işaretçisidir. İşlev, 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 bağımsız değişkenleri olarak bir dosya işaretçisine sahiptir.

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