Fonksiyonlar
Fonksiyon Nedir? Bir amaca hizmet eden program parçacıklarıdır. Fonksiyon çalıştırıldığında, bir işlemi yerine getirmesi yada bir değer döndürmesi istenecektir. Çağrılmış olan bir fonksiyon ya geriye bir sonuç değeri döndürür ve/veya fonksiyon içerisindeki operasyonlarını işlemlerini tamamlayıp çağrılan yere geri döner. Diğer programlama dillerinde metod, prosedür (yordam) v.b. isimlendirme ile adlandırılırlar. Programcılar, programların yapacağı işi fonksiyonlar vasıtasıyla anlamlı parçalara bölerek programlarının modülerlik kazanmalarını sağlar.
Fonksiyon Türleri Bildiğiniz gibi, C++'da iki fonksiyon türü ile karşılaşıyoruz. C++'nın kullanıma sunduğu hazır fonksiyonlar. Kullanıcı tarafından oluşturulan fonksiyonlardır.
Hazır Fonksiyonların Tanımı ve Kullanılması C++'nın hazır fonksiyonları, adından da anlaşılabileceği gibi, programcıya hazır olarak sunulan fonksiyonlardır. Bu fonksiyonlar bir C++ kitaplığında yer alır. Bu kitaplık dosyası programın başında #include <...> deyimi ile programa dahil edilir. Böylece program bu kitaplık içinde yer alan tüm fonksiyonları doğrudan kullanabilir.
Örnek: Program içinde C++'nın karakök alma sqrt() matematiksel fonksiyonu kullanmak istiyoruz. Bu fonksiyonun kullanılabilmesi için, programın başında matematik kitaplığı programa #include <cmath> şeklinde dahil edilme ve program içerisinde sqrt(sayi) şeklinde fonksiyon çağrılmalıdır.
<cmath> Kütüphanesi
Kullanıcı Tanımlı Fonksiyonların Tanımı ve Uygulaması Fonksiyonun Deklarasyonu (Function Definitions) Bir fonksiyon main veya diğer bir fonksiyon tarafından kullanılmadan önce deklare edilmesi ve tanımlanması gerekmektedir. Bu yapı aşağıda belirtildiği biçimde olacaktır. Her şeyden önce bir fonksiyonun mutlaka bir adı olmalıdır. <dönüş değeri tipi> <fonksiyon adı/ismi> (<parametreleri>) {... return...
Fonksiyon deklerasyonu ve tanımlanması iki farklı yoldan yapılabilir; (1) Fonksiyon çağırılmadan önce mutlaka ayrı ayrı fonksiyon deklarasyonu ve tanımı yapılmalıdır. (2) Fonksiyon çağırılmadan önce mutlaka fonksiyon deklarasyonu ve tanımı birlikte yapılmalıdır.
Prototip ve Tanımın Yapılması #include <iostream> using namespace std; int hesap1(int); // 1.tip int hesap2(int x); // 2.tip int hesap3(int x=25, int y=25); // 3.tip int hesap4(int x) // 4.tip { x=66; return x; int main() { int a=3, b=4, c=5, d=6, e=7; int hesap5 (int x); // 5.tip cout <<"a="<<hesap1(a)<<endl; cout <<"b="<<hesap2(b)<<endl; cout <<"c="<<hesap3(a,e)<<endl; cout <<"c="<<hesap3()<<endl;//dikkat! cout <<"d="<<hesap4(a)<<endl; cout <<"e="<<hesap5(d)<<endl; return 0; int hesap1 (int a) { a=33; return a; int hesap2 (int a) { a=44; return a; int hesap3 (int a, int b) { return a+b; int hesap5 (int a) { a=55; return a;
Fonksiyonun Değer Döndürmesi Bir fonksiyon çalıştığında, bir sonuç üretecektir ve bu sonucu kendisini çağıran fonksiyona istenmesi (return sonuc) durumunda gönderecektir. Bu sonucun, kendisini çağıran fonksiyona gönderilmesi veya bir başka deyişle döndürülmesi söz konusu ise, fonksiyon içinde return deyimine yer vermek gerekecektir. Fonksiyon tanımlamasında aksi belirtilmediği sürece fonksiyonların int tipinde değer döndürdükleri kabul edilir. Eğer fonksiyonumuzun farklı tipte bir değer döndürmesini istiyorsak fonksiyon tanımlamasında bu dönüş değer tipini belirtmemiz gerekmektedir.
Foksiyonlar return anahtar kelimesi aracılığıyla değer döndürür ve program akışı sırasında return anahtar kelimesine ulaşıldığında foksiyondan çıkılır. Örneğin bir sayının karesini alan bir fonksiyon yazalım; kareal(int sayi) { return (sayi * sayi); veya kareal(int sayi) { int k = sayi * sayi; return k;
Eğer geri döndürdüğü değer tipi void ise, fonksiyondan bir değer dönmez ve return yazılmaz. Eğer geri döndürdüğü değer tipi void değilse, fonksiyonda en az bir tane return ifadesi olmalıdır. #include <iostream> using namespace std; void hesap(int); int main() { int a=3; hesap(a); cout <<a<<endl; return 0; void hesap(int b) { b=33; #include <iostream> using namespace std; int hesap(int); int main() { int a=3; a=hesap(a); cout <<a<<endl; return 0; int hesap(int b) { b=33; return b;
Örneğin, sayi isimli fonksiyon; tamsayı değer döndürecek ise int sayi(); biçiminde tanımlanabilir. herhangi bir parametre listesi içermiyorsa int sayi(void); biçiminde ifade edilebilir. tamsayı türünde bir x parametresine sahip ise, int sayi(int x); tanımı yapılır. herhangi bir değer döndürmeyecek ise, void sayi(); biçiminde tanımı yapılabilir. herhangi bir değer döndürmeyecek ve tamsayı türünde bir x parametresini kullanacak ise, void sayi(int x); tanımı yapılabilir.
Fonksiyonlar Arasında Parametre Geçirme Her fonksiyon bir diğerinden bağımsız olarak düzenlenir. Bir fonksiyon içinde yer alan bir değişkeni bir başka fonksiyon içinde aynen kullanamayız. Bunun için farklı yöntemlere başvurulur. Bunlardan birincisi, fonksiyonlar arasında parametre geçirilmesidir. Hiç parametresi olmayan fonksiyonlar da olabilir. Bu gibi durumlarda parametre listesi boş bırakılabileceği gibi void de yazılabilir. Bir fonksiyon yardımıyla üs alma işlemlerini yerine getirmek istiyoruz. Bu işlem, x ve y verildiğinde ifadesinin değerini hesaplayacaktır. Amacımıza uygun C++ programını fonksiyonlardan yararlanmak suretiyle şu şekilde düzenleyebiliriz.
Global Değişkenler (:: Scope Resolution) :: operatörü yardımıyla Fonksiyonlar Arasında Değer Taşımak Fonksiyonlar arasında parametre geçirerek veri aktarılması işleminin nasıl gerçekleştirilebildiğini gördük. Benzer bir sonuca ulaşmak için küresel değişkenlerden de yararlanabiliriz. Küresel değişkenleri dersimizin başlarında ele alarak incelemiştik. Küresel değişkenler, programın çalışması boyunca, fonksiyonlar dahil, değeri geçerli olan değişkenlerdir. Küresel değişkenler fonksiyonların içinde değil, ondan önce tanımlanır. Bir küresel değişken tanımından sonra yer alan tüm fonksiyonlar için bu değişkenin değeri geçerlidir.
Static Değişkeninin Fonksiyonlarda Kullanımı static değişkenler fonksiyon terkedildiğinde değerlerini kaybetmezler. Aynı fonksiyon bir daha çalıştırıldığında, daha önceki değer yeniden kullanılabilir. Program içindeki bir fonksiyonun ya da küresel değişkenin başına static tanımı yapıldığı takdirde, bu fonksiyon veya değişken diğer kaynak program dosyalarına karşı erişilmez olacaktır. Bunun anlamı, diğer dosyalardan yapılacak erişimlere karşı "gizli" kalacaktır.
Fonksiyon Çağırma Yöntemleri C++ programlama dilinde fonksiyonların çağrılması iki farklı yöntemle gerçekleştirilmektedir: 1) Değer ile çağırma int topla(int a, int b) şeklinde fonksiyon tanımlı z=topla(x,y); şeklinde çağırıyoruz. bu durumda a=x ve b=y olur. 2) Referans (Başvuru) ile çağırma Bellek adresleri kullanılır. void hesap (int &p) şeklinde fonksiyon tanımlı hesap(x); şeklinde çağırıyoruz.
Değer ile çağırma Çağıran fonksiyondan çağrılan fonksiyona aktarılan değişken değerlerinde bir değişiklik olsa bile, bu değişiklik çağıran programdaki değişken değerlerine etki etmez. Bu değişiklikler çağrılan fonksiyon içinde parametrelerin kopyaları üzerinde gerçekleşir. #include <iostream> using namespace std; int hesap(int); int main() { int x=5; x=hesap(x); cout <<x; return 0; int hesap (int a) { a=55; return a;
Buradan şu sonuç çıkmaktadır; Fonksiyonlar değere göre çağrıldığında, çağrılan fonksiyon içinde parametrenin değeri değiştirilse bile bu değişiklik çağıran programda aynı isimli değişkenin değerine etki yapmaz.
Referans (Başvuru) ile çağırma Bellek adreslerini kullanarak fonksiyonları çağırabiliriz. Bu durumda, çağrılan fonksiyon içinde parametre değerleri üzerinde yapılacak değişikliklerin, onu çağıran fonksiyon üzerinde de etkili olduğu görülecektir. #include <iostream> using namespace std; void hesapla(int&, int&); int main() { int x=3,y=5; cout <<x<<" "<<y<<endl;// 3 5 hesapla(x,y); cout <<x<<" "<<y; //13 15 return 0; void hesapla (int& x, int& y) { x=x+10; y=y+10;
#include <iostream> using namespace std; void hesap(); int main () { int x=7; cout<< x <<endl; hesap(); cout<< x <<endl; return 0; void hesap() { x=77; #include <iostream> using namespace std; int hesap(int); int main () { int x=7; cout<< x <<endl; x=hesap(x); cout<< x <<endl; return 0; int hesap(int a) { a=77; return a;
#include <iostream> using namespace std; void hesap(); int x=7; int main() { cout<< ::x <<endl; hesap(); cout<< ::x <<endl; return 0; void hesap () { ::x=77; #include <iostream> using namespace std; void hesap(int &); int main() { int x=7; cout<< x <<endl; hesap(x); cout<< x <<endl; return 0; void hesap (int &p) { p=77;
Kendini çağıran fonksiyonlar Bir fonksiyon kendi kendini sürekli çağırarak çalıştırabilir. Bu tür fonksiyonlara özçağrılı (recursive) fonksiyonlar denir.
Fonksiyonların Aşırı Yüklenmesi (Function Overloading) İki yada daha fazla fonksiyon aynı isime sahipseler, aşırı yüklenmişlerdir. Aşırı yüklenmiş fonksiyonları kullanarak birbirleriyle ilişkili işlemleri aynı isimle çağırarak program daha sade bir hale gelir, çok fazla fonksiyon isimlerinden oluşabilecek muhtemel hatalar önlenmiş olur. Birden fazla fonksiyon argüman sayıları ve/veya argüman tipleri farklı ise aynı ismi kullanabilirler. Aşırı yüklenmiş fonksiyon tanımlanırken, fonksiyonun tüm versiyonları deklare edilir. Bu farklı versiyonlardan derleyici, argüman sayısı ve tipine göre otomatik olarak çağıracaktır.
Aşağıdaki örnek programda tarih dataları string ve tamsayı olarak iki farklı şekilde kullanılmıştır. Tarih isimli fonksiyon çağrılırken derleyici bu farklı tiplere göre tarih fonksiyonunu icra edecektir.
Fonksiyonların Aşırı Yüklenmesi
Esnek Argümanlı Fonksiyonlar #include <cstdarg> kütüphanesi kullanılır. Esnek argümanları oluşturan küme ardışık olarak listeye eklenmelidir. Bu türden argümanlar fonksiyonun parametre listesi kısmında üç nokta... ile belirtilir.
Esnek Argümanlı Fonksiyonlar cstdarg da tanımlı macro fonksiyonlar Esnek Argumanlı Fonksiyon tanımlaması yapabilmek için cstdarg kütüphanesinde üç adet makro fonksiyon bir adet tip tanımlanmıştır. Tip / Fonksiyon va_list va_start(a, n) va_arg(a, tip) va_end(a) Açıklama Tip: ardışık esnek argümalar için tip belirleyici. macro: va_list tipinde bildirilmiş a göstericisi için bellekten n elemanlı yer ayırır. macro: Veri tipi tip (int, double v.b.) ile belirlenmiş küme elemanlarına eriştirir. macro: va_list tipinde bildirilmiş a göstericisi için bellekten bölgeyi boşaltır.
Esnek Argümanlı Fonksiyonların Tanımlanması dönüş_tipi fonksiyon_adı( tip_değişke_listesi, int liste adedi,...) { macro fonksiyon ve diğer işlemler return donen_deger; dönüş_tipi= int fonksiyon_adı = Hesapla tip_değişke_listesi = int a, double b, float c int liste adedi = 5...= 3,4,5,6 Burada değerler va_arg(a, tip) tip tanımına göre yapılır. Örneğin double olsaydı 3.0, 4.0, 5.0, 6.0 şeklinde tanımlanmalıdır.
Esnek Argümanlı Fonksiyonların
Esnek Argümanlı Fonksiyonların
Esnek Argümanlı Fonksiyonların
Esnek Argümanlı Fonksiyonlar Polinom hesabı P(x,n) = a 0 + a 1 x + a 2 x 2 +... + a n x n double phesap(double x, int n,... ) { macro fonksiyon ve diğer işlemler x=1.5 ve n=4 için; phesap(1.5, 4, 1.0, -2.0, 0.2, 1.1) a 4 için : a 1 =1.0, a 2 =-2.0, a 3 =0.2, a 4 =1.1 olur.
Polinom hesabı : P(x,n) = a 0 + a 1 x + a 2 x 2 +... + a n x n a i (i = 0, 1, 2,..., n) katsayları esnek argüman olarak bildirilmiştir.
Dosya İşlemleri
Dosyalar Yoluyla Inpıt/Output İşlemleri Şimdiye kadar standart input output iostream kütüphanesi cin/cout klavyeden okuma, ekrana yazma Dosyadan okuma ve dosyaya yazma yapmak için fstream adlı standart C++ kütüphanesi Dosyadan/dosyaya bilgi akışı için kullanılacak sınıflar: ofstream: Dosyaya yazmak için kullanılacak olan akış sınıfı ifstream: Dosyadan okuma yapmak için kullanılacak olan akış sınıfı fstream: Okuma/yazma yapmayı sağlayacak olan akış sınıfı
Basit Örnek Bu sınıflar direk ya da endirekt olarak istream ve ostream sınıflarından türetilmişlerdir cin/cout da bu sınıflardan türetilmişlerdir. Dosya akış sınıflarını da benzer şekilde kullanabiliriz Burada artık akış dosyalar yoluyla olacak // Basit bir dosya işlemi #include <iostream> #include <fstream> using namespace std; int main () { ofstream dosyam; dosyam.open ("ornek.txt"); dosyam << "Bu yazilanlar dosyada olacak.\n"; dosyam.close(); return 0; ofstream sınıfı için open kullanılabilir. kullanım şekli: <ofstream_adı>.open (dosyaadi) dosyaadi : içine yazma işleminin yapılacağı dosyanın ismi artık ofstrean sınıfına ait olan bu nesneyi (dosyam) cout gibi kullanabilirim. Unutmayın: Artık yazma yerim cout ta olduğu gibi ekran değil dosyaadi ile belirtilmiş olan dosya output stream olarak açıyorum: sadece yazma yapacağım için yazma yapacağım akışın (stream) adı Nesnemizi kapatmayı unutmayalım
Basit Örnek // Basit bir dosya işlemi #include <iostream> #include <fstream> using namespace std; int main () { ofstream dosyam; dosyam.open ("ornek.txt"); dosyam << "Bu yazilanlar dosyada olacak.\n"; dosyam.close(); return 0; Sonuç olarak ornek.txt adında bir dosya yaratılır ve içine de Bu yazilanlar dosyada olacak. yazılarak alt satıra geçilir
Adım adım ofstream/ifstream/fstream sınıfları için uygulanacak ilk işlem bu nesneleri gerçek (fiziksel) bir dosya ile ilişkilendirmektir. Bu işlem bir dosyayı açmak (open) olarak bilinir. Açılan dosya program tarafından bir akış nesnesi (stream object) olarak tanınır. Bu akış nesnesi bu 3 sınıftan biri tarafından başlatılır. Örnekte bu ofstream sınıfına ait bir nesne idi adı da dosyam idi. ofstream dosyam; Bu akış üzerinde yapılacak giriş/çıkış işlemleri bu akış ile ilişkilendirilen fiziksel dosya üzerinde yapılcaktır. örnekte bu dosya ornek.txt idi. İlişkilendirme için yapılan işlem: dosyam.open ("ornek.txt");
open open fonksiyonunun genel kullanım şekli: open (dosyaninadi, mod); mod dosyanın ne şekilde açılacağını gösteren seçeneğe bağlı (optional) bir parametredir. Kullanılabilecek modlar: ios::in ios::out ios::binary ios::ate ios::app ios::trunc Giriş (input) işlemleri için aç Çıkış (output) işlemleri için aç Binary modda aç. Başlama noktasını ayarla. Eğer bu etikete değer verilmezse başlama noktası dosyanın başlangıcı olarak set edilir Her türlü çıkış işleminin dosyanın sonuna yapılmasını sağlar, kısacası yeni içeriği dosyanın içeriğinin sonuna ekler (append işlemi) Bu etiket sadece çıkış işlemleri için açılmış olan akışlarda kullanılabilir. Eğer açılan dosya zaten önceden varsa, önceki içerik silinir ve yeni içerik ile değiştirilir.
open open (dosyaninadi, mod); mod seçeneğe bağlıdır, kullanılmayabilir Kullanılmazsa open (dosyaninadi) şeklinde kullanılır. bu durumda varsayılan etiketler: ofstream ifstream fstream Sınıf Varsayılan mod ios::out ios::in ios::in ios::out
Örnek kullanımlar // Basit bir örnek #include <iostream> #include <fstream> using namespace std; int main () { ofstream dosyam; dosyam.open ("ornek.txt"); dosyam << "Bu yazilanlar burada kalsin"; dosyam<<"\nbaska bir sey olmasin\n"; dosyam.close(); return 0; ornek.txt dosyasının içeriği Bu yazilanlar burada kalsin Baska bir sey olmasin // Basit bir örnek #include <iostream> #include <fstream> using namespace std; int main () { ofstream dosyam; dosyam.open ("ornek.txt"); dosyam << "yeniden dusundum\n"; dosyam.close(); return 0; ornek.txt dosyasının içeriği yeniden dusundum Dikkat: Eski içerik silindi, yenisi yazıldı.
Örnek kullanımlar // Basit bir ornek #include <iostream> #include <fstream> using namespace std; int main () { ofstream dosyam; dosyam.open ("ornek.txt",ios::app); dosyam << "append kullanilirsa boyle oluyor iste"; dosyam.close(); return 0; ornek.txt dosyasının içeriği yeniden dusundum append kullanilirsa boyle oluyor iste Dikkat: ios::in olarak açılırsa, yazmaya çalışınca üzerine yazacaktır.. // Basit bir k #include <iostream> #include <fstream> using namespace std; int main () { ofstream dosyam; dosyam.open ("ornek.txt",ios::in ios::out); dosyam << "ios::in ios::out kullandim"; dosyam.close(); return 0; ornek.txt dosyasının içeriği ios::in ios::out kullandimlanilirsa boyle oluyor iste Dikkat: Yeni içerik baştan yazılmaya başlandı. Toplamda 28 karakter. Eski içeriğin üzerine yazıldı. Alt satıra geçmenin de karakter olduğunu unutmayın.
Dosya işlemleri ios::in ile açılırsa dosyanın başından başlayarak üzerine yazdığını gördük Ayrıca bu şekilde açılabilmesi için açılan dosyanın var olması gerekir. Eğer o isimde fiziksel bir dosya yoksa açılamayacak ve yapılan işlemler gerçekleşmeyecektir ios::out ile açılmaya çalışılan dosya için ise o isimde dosya yoksa yaratılır.
Dosya işlemleri Dosya açılışının başarılı olup olmadığı şu şekilde tespit edilir. <akışdosyaismi>.is_open() // Deneme1 #include <iostream> #include <fstream> using namespace std; int main () { ofstream dosyam; dosyam.open ("dene1.txt"); if (dosyam.is_open()) cout<<"acildi "<<endl; else cout<<"acilamadi yazamiyor tabii"<<endl; dosyam << "Deneme1 dosyası"; dosyam.close(); return 0; dene1.txt adında içeriği Deneme1 dosyası olan bir dosya yaratılır. Ayrıca Ekranda şu görünür: Acildi // Deneme2 #include <iostream> #include <fstream> using namespace std; int main () { fstream dosyam; dosyam.open ("dene2.txt"); if (dosyam.is_open()) cout<<"acildi "<<endl; else cout<<"acilamadi yazamiyor tabii"<<endl; dosyam << "Deneme2 dosyası"; dosyam.close(); return 0; Herhangi bir dosya yaratılamaz. Ekranda şu görünür: Acilamadi yazamiyor tabii
Örnek Kullanım fstream için varsayılan modun ios::in ios::out olduğunu unutmayın fstream ile dosya açarken o isimde fiziksel bir dosya olmasa da açmak isterseniz out veya app olarak açmalısınız // Deneme2 #include <iostream> #include <fstream> using namespace std; int main () { fstream dosyam; dosyam.open ("dene2.txt",ios::app); //ya da //dosyam.open ("dene2.txt",ios::out); if (dosyam.is_open()) cout<<"acildi "<<endl; else cout<<"acilamadi yazamiyor tabii"<<endl; dosyam << "Deneme2 dosyası"; dosyam.close(); return 0;
Dosya Kapatma Dosya ile yapılacak işlemler sona erdiğinde kapatılmalıdır Böylece tekrar bu dosyaya erişim sağlama imkanımız olur. Dosyayı kapatmak için close() fonksiyonu kullanılır Bu fonksiyon içine parametre almaz. Yaptığı iş bu dosya ile ilişkilendirilen akışı kapatıp buna ait olan buffer ları temizlemektir. Dosya kapandıktan sonra içine dosya giriş/çıkış işlemleri sona erecektir..is_open() fonksiyonu yanlış (0) olarak cevap verecektir.
Dosyadan okuma işlemi Okuma işlemi yapabilmek için getline komutunu kullanabiliriz. Hatırlatma: klavyeden satır okuma için getline(cin,str) kullanılarak okunan satır bilgisi str değişkeninin içine yazılıyordu. getline fonksiyonuna ilk parametre olarak cin girilmesi okuma işleminin klavyeden olacağını gösterir Dosyadan okuma yapmak için ise ilk parametre olarak akış nesnesinin ismini girmeliyiz.
#include <iostream> #include <fstream> using namespace std; int main () { fstream dosyam; string line; dosyam.open ("ornek.txt", ios::out); if (dosyam.is_open()) { dosyam << "Ornek.txt dosyasi"<<endl; dosyam << "Icine bazi bilgiler yazildi.\n"; dosyam << "Sonuc olarak bu dosya olustu"; else cout<<"acilamadi yazamiyor tabii"<<endl; dosyam.close(); return 0; Ornek.txt adlı dosya yaratıldı ve içine aşağıdaki bilgiler yazıldı Ornek.txt dosyasi Icine bazi bilgiler yazildi. Sonuc olarak bu dosya olustu #include <iostream> #include <fstream> using namespace std; int main () { ifstream dosyam; string line; //varsaylan olarak ios::inş eklinde aç dosyam.open ("ornek.txt"); while ( dosyam.good() ) { getline (dosyam,line); cout << line << endl << endl; dosyam.close(); return 0; Ekran çıktısı: Ornek.txt dosyasi Icine bazi bilgiler yazildi. Sonuc olarak bu dosya olustu
Dosya İşlemleri while ( dosyam.good() ) ne için yazıldı? good() fonksiyonu akış yazma/okuma işlemlerine hazır ise doğru değilse yanlış cevabını verecektir. Bu örnekte dosya sonuna ulaşılıncaya kadar okuma yapmaya devam etmek için kullanılmıştır
Etiketler.good() fonksiyonu dosyanın sonu gelene ya da herhangi bir hata ile karşılaşıncaya kadar doğru cevabını verecektir. Diğer etiketler: bad() fonksiyonu okuma ya da yazma işleminde bir hata ortaya çıkarsa doğru cevabını vercktir. Kısacası good() fonksiyonunun tersini yapar Örneğin açık olmayan bir dosyaya yazma ya da içerisinde hiç boş yer kalmayan bir dosyaya yazma yapmaya kalk ıştığımız durumda.
Etiketler fail() bad() fonksiyonuna benzer durumlarda doğru cevabını verecektir. Bunun yanında format hatalarında da doğru cevabını verir. Örneğin okunacak karakterler alfabetik karakter olduğu halde tamsayı okumak istediğimiz durum. eof() Açık olan dosyanın sonuna geldiğimizde doğru, diğer durumlarda yanlış cevabını verir
Akış Yeri Belirleme Okuma ya da yazma yerlerine işaret eden işaretçiler şu üye fonksiyonlar aracılığıyla manipüle edilebilir tellg() ve tellp() Giriş parametresi almayan ve get stream (tellg) ya da put stream (tellp) işaretçilerinin o an bulunduğu yeri tamsayı tipinde geri yollayan fonksiyonlardır Get stream seekg() ve seekp() Bu fonksiyonlar get ve put stream lerin pozisyonunu değiştirmemize yarar 2 farkklı prototip ile aşırı yüklenmişlerdir 1. prototip: içine tek parametre al ır o seekg ( position ); seekp ( position ); 2. prototip: içine tek parametre al ır o seekg ( offset, direction ); seekp ( offset, direction );
Akış Yeri Belirleme 1. prototip: seekg ( position ); seekp ( position ); Akışın yerini position ile belirtilen noktaya taşır Başlangıç noktası dosyanın başıdır 2. prototip:seekg ( offset, direction ); direction ile belirtilen parametreye göre bir noktaya taşır direction parametresinin alabileceği değerler: ios::beg ios::cur ios::end offset noktası akışın başından sayılır offset noktası akışın o anki pozisyonundan sayılır offset noktası akışın sonundan sayılır
// obtaining file size #include <iostream> #include <fstream> using namespace std; int main () { long begin,end; ofstream mfile ("example.txt"); mfile<<"deneme dosyasi olussun"<<endl; mfile<<"ornek biseyler yazalim"<<endl; mfile.close(); ifstream myfile ("example.txt"); begin = myfile.tellg(); myfile.seekg (0, ios::end); end = myfile.tellg(); myfile.close(); cout << "Bas: " << begin<<endl; cout << "son: " << end<< endl; cout << "Fark: " << (end-begin) << " byte.\n"; return 0; Dosya açılınca varsayılan olarak dosyanın başındayız Dosya sonundan başlayarak 0 byte git. Bu da bize dosyanın sonuncu karakterinin kaçıncı byte olduğu bilgisine ulaşmamızı sağlar. Neredeyim: Dosyanın son karakterinde. Ekran çıktısı: Bas: 0 son: 48 Fark: 48 byte.
Örnekler Ornek.txt Ornek.txt dosyasi Icine bazi bilgiler yazildi. Sonuc olarak bu dosya olustu #include <iostream> #include <iomanip> #include <fstream> using namespace std; int main () { fstream dosyam; dosyam.open ("ornek.txt", ios::out); if (dosyam.is_open()) { dosyam << "Ornek.txt dosyasi"<<endl; dosyam << "Icine bazi bilgiler yazildi.\n"; dosyam << "Sonuc olarak bu dosya olustu"; else cout<<"acilamadi yazamiyor tabii"<<endl; dosyam.close(); ifstream mfile; mfile.open("ornek.txt"); string str; int yer; while(mfile.good()) { mfile>>str; yer=mfile.tellg(); cout<<setw(15)<<str<<setw(15)<<yer<<endl; mfile.close(); return 0;