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

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

getir(); \\Enter tuşuna basılması bekleniyor
0 döndür;
}
===================

Bu materyalde, bilgilerin karakter karakter okunmasına ilişkin bir örnek analiz edilmektedir. Çalışmayı tür değişkenleriyle tanımlamadığım için karakter, o zaman yeni başlayanlar kodu anlamada bazı zorluklar yaşayabilir. sadece türünü bilmiyordum karakter bazı özellikleri var ve her şeyin daha basit olduğunu düşündü. Bu nedenle yukarıdaki programın bazı anlaşılmaz anları aşağıdaki yazıda okunabilir. karakterle çalışmak içinde 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 çıkıyoruz
!= – bu bizim durumumuz. Böyle bir koşul eşitsizliğini belirtir
if(a !=b )- sanki oku a eşit değildir B

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

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

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

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

Konum ö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 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

  offset, okunan baytların yerleştirileceği dizideki bayt cinsinden ofseti temsil eder

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

Yöntem long Seek(uzun offset, SeekOrigin orijini): offset parametresinde belirtilen bayt sayısına göre akış offsetindeki konumu ayarlar.

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

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

  offset - dizi dizisindeki bayt cinsinden offset, akışa bayt yazmaya nereden başlanır

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

Bu örneği analiz edelim. Hem okuma hem de yazma, using ifadesini kullanır. Bu ifade, kod dosyasının başında ad alanlarını içeren using yönergesiyle karıştırılmamalıdır. using ifadesi, bir kod bloğunda bir nesne oluşturmanıza olanak tanır, ardından o nesne üzerindeki 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 enum. Bu numaralandırma, 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

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

FileStream sınıfının yapıcısı, oluşturduğunuz nesneye ince ayar yapmanıza olanak tanıyan bir dizi aşırı yüklemeye de sahiptir. Bu sürümlerin tümü msdn'de görüntülenebilir.

Hem yazma hem de okuma, System.Text ad alanındaki Encoding.Default kodlama nesnesini kullanır. Bu durumda, iki yöntemini 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 dosyası değil), ancak içine sadece bir satır yazarsak, bu dosyayı bir metin düzenleyicide açarak insan tarafından 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 çekebiliriz. Bu nedenle, ayrı sınıflar doğrudan metin dosyalarıyla çalışmak üzere tasarlanmıştır - StreamReader ve StreamWriter.

Rastgele dosya erişimi

İkili dosyaların belirli bir yapıyı temsil etmesi nadir görülen bir durum değildir. Ve bu yapıyı bilerek, gerekli bilgiyi dosyadan alabilir veya tam tersine dosyada belirli bir yere belirli bir bayt kümesi yazabiliriz. Örneğin, wav dosyalarında, ses verilerinin kendisi 44 baytta 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şlangıcı

SeekOrigin.End : dosyanın sonu

SeekOrigin.Current : dosyadaki geçerli konum

Okuma 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 hareket eder - sonra ileri.

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"; // kullanarak dosyaya yazma (FileStream fstream = new FileStream(@"D:\note.dat", FileMode.OpenOrCreate)) ( // 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 eksi 5 karakter // dört karakter oku geçerli konum bayt çıktısı = yeni bayt; fstream.Read( çıktı, 0, çıktı.Length); // baytların kodunu bir dize dizesine deşifre edin textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Dosyadan metin: (0)", textFromFile); // worl // dosyada kelime dünyasını kelime evi dizgisine değiştir replaceText = "house"; fstream.Seek(-5, SeekOrigin.End); // sonundan eksi 5 karakter akış girişi = Encoding.Default.GetBytes(replaceText); fstream.Write(inpu t, 0, giriş.Uzunluk); // 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 dizeye deşifre edin textFromFile = Encoding.Default.GetString(output); Console.WriteLine("Dosyadan gelen metin: (0)", textFromFile); // merhaba ev ) Console.Read(); ))

Konsol çıktısı:

Dosyaya yazılan metin Dosyadan gelen metin: worl Dosyadan gelen metin: merhaba ev

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

Yani, "merhaba dünya" dizesini yeni bir dosyaya yazdıktan sonra, imleç "w" karakterinin konumunda olacaktır.

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

Sonra tekrar beş karakterin sonuna ulaşmadan (yani yine "w" karakterinin konumundan) dosyanın sonuna geçiyoruz ve "house" satırını yazıyoruz. Böylece, "ev" dizesi "dünya" dizesinin 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 = boş; try ( fstream = new FileStream(@"D:\note3.dat", FileMode.OpenOrCreate); // akış işlemleri ) catch(ex) ( ) nihayet ( if (fstream != null) fstream.Close(); )

using 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ışmayı düşünelim. 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.

Ve bu, 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; )

C'de bir metin dosyası 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 okumaya açık olduğunu söyler.

Fgets fonksiyonunu kullanarak satırları okuyoruz:

fgets(cArray, LEN, pTextFile);

fgets işlevinin ilk argümanı, alınan dizelerin saklanacağı bir karakter dizisini gösterir, ikinci argüman okunacak maksimum karakter sayısıdır, üçüncü argüman bizim dosyamızdır.

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

fclose(pTextFile);

Alırız:

Satırlarda Rusça harfler de geçer.

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

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

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

/* Yazar: @author Subbotin B.P..h> #include int main(void) ( FILE *pTextFile = fopen("C:\\TextFileW.txt", "w"); char *cString = "Bu bir dizedir"; char cNewLine = "\n"; int nVal = 123 ; if(pTextFile == NULL) ( puts("Problems"); return EXIT_FAILURE; ) fprintf(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çı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 bir satır sonudur.

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

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

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

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

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

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

İÇİNDE ikili Dosyalarda bilgi, her tür ve yapıdaki verinin saklanabileceği belirli büyüklükteki bloklar şeklinde okunur ve yazılır.

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

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

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

akış türünde bir değişkeni tanımlar.

bir dosyaya çıktı bilgisi.

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

İçin okumalar bir metin dosyasındaki veriler için şunları yapmalısınız:

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

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

dosyayı kapatın.

Kayıt bir metin dosyasına bilgi

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

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

Bir sonraki adım, dosyayı yazmak için açmaktır. Genel olarak, akış açma operatörü şöyle görünecektir:

F. open("dosya", mod);

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

dosya - diskteki dosyanın tam adı,

mod - açılan dosyayla çalışma modu.

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

D:\\oyun\\noobs.txt.

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

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

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

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

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

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

ios::nocreate - mevcut değilse dosyayı açmayın;

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

mode parametresi mevcut olmayabilir, bu durumda dosya bu akım için varsayılan modda açılır.

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

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

// ilk yol

akış dışı F;

F.open("D:\\oyun\\noobs.txt", ios::çıktı);

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

// için akışakıntı dışı

akış dışı F;

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

// ve dosyayı tek bir ifadede aç

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

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

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

Bir dosyayı yazma modunda açtıktan sonra, standart çıktı cihazı yerine sadece ekrandaki gibi yazabilirsiniz.coutaçık dosyanın adını belirtmelisiniz.

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

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

G<

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

ÖRNEK VERMEK:

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

#include "stdafx.h"

#Dahil etmek

#Dahil etmek

#Dahil etmek

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int ben, n;

çift ​​a;

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

akış dışı F;

//dosyayı yazma modunda aç,

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

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

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

cout<<" n="; Cin>> n;

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

// ve bunları bir dosyaya yazmak

için (i=0; ben

cout<<"a=";

//Numara giriniz

cin>>a;

F<

// akışı kapatıyoruz

f.kapat();

sistem ("duraklat");

0 döndür;

_______________________________________________________________

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

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

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

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

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

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

//bir dosyadan değerleri okumak için düzenleme, yürütme

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

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

while (!F.eof())

ÖRNEK VERMEK:

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

#include "stdafx.h"

#Dahil etmek

#Dahil etmek

#Dahil etmek

#Dahil etmek

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

intn=0;

yüzer a;

fstream F;

//dosyayı okuma modunda aç

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

//dosya doğru açılmışsa, o zaman

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

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

while (!F.eof())

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

F>>a;

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

cout<

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

// akışı kapatıyoruz

f.kapat();

//ekranda okunan sayıların girilmesi

cout<<"n="<

//dosya yanlış açılmışsa, çıktı

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

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

sistem ("duraklat");

0 döndür;

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

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

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

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

fwrite işlevini kullanarak bir dosyaya bilgi yazma

İçin düşünmek z verilerini bir ikili dosyadan elde etmek için şunları yapmalısınız:

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

fopen işleviyle dosyayı aç

dosyayı fclose işleviyle kapat

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

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

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

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

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

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

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

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

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

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

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

İçin kapanış dosya, fclose işlevi amaçlanmaktadır

int fclose(DOSYA *dosyaadı);

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

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

int sil(const char *dosya adı);

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

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

int rename(const char *eskidosyaadı, const char *yenidosyaadı);

İlk parametre eski dosya adı, ikincisi yeni olanıdır. Programın başarıyla tamamlanması üzerine 0 döndürür.

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

fread(void *ptr, size, n, DOSYA *dosya adı);

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

Kayıt bir ikili dosyaya fwrite işlevi kullanılarak yapılır:

fwrite(const void *ptr, size, n, FILE *dosya adı);

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

İçin dosya sonu kontrolü bir feof işlevi vardır:

int feof(DOSYA *dosya adı);

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

ÖRNEK VERMEK:

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

#include "stdafx.h"

#Dahil etmek

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int n, ben;

çift ​​a;

// yazma modunda ikili dosya oluştur

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

// giriş sayılarn

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

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

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

için (i=0; ben

// sonraki gerçek sayıyı girin

cout<<"a=";

cin>>a;

// ikili dosyaya gerçek sayıyı yaz

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

// kapat dosya

fclose(f);

sistem ("duraklat");

0 döndür;

ÖRNEK VERMEK:

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

#include "stdafx.h"

#Dahil etmek

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int n, ben;

çift ​​a;

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

// mevcut ikili dosyayı okuma modunda aç

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

// ekrana n çıktısı

cout<<"n="<

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

a=yeni çift[n];

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

// diziyi ekrana yazdır

için (i=0; ben

cout<

cout<

// kapat dosya

fclose(f);

sistem ("duraklat");

0 döndür;

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

int n, ben;

çift ​​a;

DOSYA *f;

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

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

fclose(f);

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

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

fclose(f);

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

int fseek(DOSYA *dosya adı, uzun int uzaklığı, int kaynağı);

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

SEEK_SET - dosyanın başından itibaren;

SEEK_CUR - mevcut konumdan;

SEEK_END - dosyanın sonundan.

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

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

ÖRNEK VERMEK

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

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

bir dosyadan gerçekleri bir diziye okumak a.

a dizisinde maksimum (max) ve minimum (min) değerler ve sayıları (imax, imin) için arama yapın.

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

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

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

#include "stdafx.h"

#Dahil etmek

ad alanı std kullanarak;

int ana()

setlocale(LC_ALL, "RUS");

int n, i, imax, imin;

çift ​​*a, maks, min;

DOSYA *f;

//dosyayı okuma/yazma modunda aç

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

// dosyadan değişken n numarasına oku

//dosyadaki gerçek sayılar

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

cout<<"n="<

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

// a dizisinde saklanacak olan

a=yeni çift[n];

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

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

// maksimum ve minimum öğeleri ara

// a dizisinde ve indekslerinde

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

if (a[i]>maks)

max=a[i];

eğer (a[i]

min=a[i];

// hareketli Işaretçi ile maksimum eleman

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

//dosyanın maksimum öğesi yerine minimum kayıt

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

// hareketli Işaretçi ile asgari eleman

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

// minimum dosya öğesi yerine maksimumu kaydet

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

//dosya kapatılıyor

fclose(f);

// Boş hafıza

silmek[ ]a;

sistem ("duraklat");