C++ Giriş/Çıkış (I/O)

1. ios sınıfının üyelerine doğrudan erişerek, sınıf içindeki üye fonksiyonları ve değişkenleri kullanabiliriz.

2. Manipülatörler adı verilen özel fonksiyonları kullanabiliriz.

enum _Ios_Fmtflags 
{ 
  _S_boolalpha 		  = 1L << 0,
  _S_dec 			  = 1L << 1,
  _S_fixed 			  = 1L << 2,
  _S_hex 		      = 1L << 3,
  _S_internal 	      = 1L << 4,
  _S_left 		      = 1L << 5,
  _S_oct 		      = 1L << 6,
  _S_right 		      = 1L << 7,
  _S_scientific 	  = 1L << 8,
  _S_showbase 	      = 1L << 9,
  _S_showpoint 	      = 1L << 10,
  _S_showpos 	      = 1L << 11,
  _S_skipws 		  = 1L << 12,
  _S_unitbuf 	      = 1L << 13,
  _S_uppercase 	      = 1L << 14,
  _S_adjustfield 	  = _S_left | _S_right | _S_internal,
  _S_basefield 	      = _S_dec | _S_oct | _S_hex,
  _S_floatfield 	  = _S_scientific | _S_fixed,
  _S_ios_fmtflags_end = 1L << 16 
};

typedef _Ios_Fmtflags fmtflags;

static const fmtflags boolalpha = _S_boolalpha;
static const fmtflags dec = _S_dec;
static const fmtflags fixed = _S_fixed;
static const fmtflags hex = _S_hex;
static const fmtflags internal = _S_internal;
static const fmtflags left = _S_left;
static const fmtflags oct =  _S_oct;
static const fmtflags right = _S_right;
static const fmtflags scientific = _S_scientific;
static const fmtflags showbase = _S_showbase;
static const fmtflags showpoint = _S_showpoint;
static const fmtflags showpos = _S_showpos;
static const fmtflags skipws = _S_skipws;
static const fmtflags unitbuf = _S_unitbuf;
static const fmtflags uppercase = _S_uppercase;
static const fmtflags adjustfield = _S_adjustfield;
static const fmtflags basefield = _S_basefield;
static const fmtflags floatfield = _S_floatfield;

#include <iostream>
#include <stdlib.h>

using namespace std;

void deger_yaz(const char *cdeger, long int val)
{
  int bitsayi = 32;
  char *cdizi = (char*) malloc(bitsayi+1);
  cdizi[bitsayi] = '\0';

  unsigned long int u = *(unsigned long int*)&val;
  unsigned long int mask = 1 << (bitsayi-1);
  int id;

  for (id=0; id<bitsayi; id++, mask >>= 1) {
       cdizi[id] = (u & mask) ? '1' : '0';
  }

  printf("%-15s %5ld : %s\n", cdeger, val, cdizi);
  free(cdizi);
}

int main(void)
{
  deger_yaz((const char*) "boolalpha", ios::boolalpha);
  deger_yaz((const char*) "dec", ios::dec);
  deger_yaz((const char*) "fixed", ios::fixed);
  deger_yaz((const char*) "hex", ios::hex);
  deger_yaz((const char*) "internal", ios::internal);
  deger_yaz((const char*) "left", ios::left);
  deger_yaz((const char*) "oct", ios::oct);
  deger_yaz((const char*) "right", ios::right);
  deger_yaz((const char*) "scientific", ios::scientific);
  deger_yaz((const char*) "showbase", ios::showbase);
  deger_yaz((const char*) "showpoint", ios::showpoint);
  deger_yaz((const char*) "showpos", ios::showpos);
  deger_yaz((const char*) "skipws", ios::skipws);
  deger_yaz((const char*) "unitbuf", ios::unitbuf);
  deger_yaz((const char*) "uppercase", ios::uppercase);
  deger_yaz((const char*) "adjustfield", ios::adjustfield);
  deger_yaz((const char*) "basefield", ios::basefield);
  deger_yaz((const char*) "floatfield", ios::floatfield);

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

boolalpha           1 : 00000000000000000000000000000001
dec                 2 : 00000000000000000000000000000010
fixed               4 : 00000000000000000000000000000100
hex                 8 : 00000000000000000000000000001000
internal           16 : 00000000000000000000000000010000
left               32 : 00000000000000000000000000100000
oct                64 : 00000000000000000000000001000000
right             128 : 00000000000000000000000010000000
scientific        256 : 00000000000000000000000100000000
showbase          512 : 00000000000000000000001000000000
showpoint        1024 : 00000000000000000000010000000000
showpos          2048 : 00000000000000000000100000000000
skipws           4096 : 00000000000000000001000000000000
unitbuf          8192 : 00000000000000000010000000000000
uppercase       16384 : 00000000000000000100000000000000
adjustfield       176 : 00000000000000000000000010110000
basefield          74 : 00000000000000000000000001001010
floatfield        260 : 00000000000000000000000100000100

Program, deger_yaz() fonksiyonunu kullanarak ios_base.h dosyasındaki veri yapılandırma değerlerinin önce isimlerini sonra onluk ve ikili sayı sistemine göre değerlerini ekrana yazar.

Veri yapılandırma değerlerine doğrudan erişim sağlandığından, değer isimlerinden önce ios:: ön eki kullanılmaktadır.

#include <iostream>

using namespace std;

int main(void)
{
  cout << 795248 << endl;

  cout.unsetf(ios::dec);
  cout.setf(ios::hex);
  cout.setf(ios::showbase);

  cout << 795248 << endl;

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

795248
0xc2270

Program, önce long int bir değeri onlu sayı sisteminde ekrana yazar. Sonra, unsetf() fonksiyonunu kullanarak onluk sayı sisteminin devreden çıkarır, setf() fonksiyonunu kullanarak onaltılık sayı sistemini ve sayı sistemini gösterme özelliğini devreye sokar. Son olarak, long int değeri onaltılık sayı sisteminde ekrana yazar.

#include <iostream>

using namespace std;

int main(void)
{
  cout << 795248 << endl;

  cout.setf(ios::hex, ios::basefield);
  cout.setf(ios::showbase);

  cout << 795248 << endl;

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

795248
0xc2270

Program, önce long int bir değeri onlu sayı sisteminde ekrana yazar. Sonra, sadece setf() fonksiyonunu kullanarak ikinci parametre ile tüm sayı sistemlerini devreden çıkarır, birinci parametre ile onaltılık sayı sistemini devreye sokar. Yine setf() fonksiyonunu kullanarak sayı sistemini gösterme özelliğini devreye sokar. Son olarak, long int değeri onaltılık sayı sisteminde ekrana yazar.

#include <iostream>

using namespace std;

void deger_yaz(void)
{
  ios::fmtflags fmt = cout.flags();   // flag değerlerini okuma
  int bitsayi = 32;

  unsigned long int mask = 1 << (bitsayi-1); // 2.147.483.648

  cout << fmt << " = ";

  for ( ; mask; mask >>= 1) {
       cout << ((fmt & mask) ? "1" : "0");
  }

  cout << endl;
}

int main(void)
{
  deger_yaz();               // Mevcut flag değerini ekrana yazar.

  cout.setf(ios::basefield); // dec, hex ve oct flag değerlerini aktif hale getirir.

  deger_yaz();               // Değişiklik sonrası flag değerini ekrana yazar.

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

4098 = 00000000000000000001000000000010
4170 = 00000000000000000001000001001010

Program, önce deger_yaz() fonksiyonu içinde flags() fonksiyonunu kullanarak mevcut veri yapılandırma flag değerlerini ekrana yazar. Sonra, setf() fonksiyonu ile basefield flag değerini devreye sokarak dec, hex ve oct flag devrelerini aktif hale getirir. Daha sonra, deger_yaz() fonksiyonu içinde flags() fonksiyonunu kullanarak veri yapılandırma flag değerlerinin son halini tekrar ekrana yazar.

#include <iostream>

using namespace std;

void deger_yaz(void)
{
  ios::fmtflags fmt = cout.flags();   // flag değerlerini okuma
  int bitsayi = 32;

  unsigned long int mask = 1 << (bitsayi-1); // 2.147.483.648

  cout << fmt << " = ";

  for ( ; mask; mask >>= 1) {
       cout << ((fmt & mask) ? "1" : "0");
  }

  cout << endl;
}

int main(void)
{
  deger_yaz();                 // Mevcut flag değerini ekrana yazar.

  // dec, hex ve oct flag değerlerini aktif hale getirir. Diğer tüm flag değerlerini devre dışı bırakır.
  cout.flags(ios::basefield);  

  deger_yaz();                 // Değişiklik sonrası flag değerini ekrana yazar.

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

4098 = 00000000000000000001000000000010
74 =   00000000000000000000000001001010

Program, önce deger_yaz() fonksiyonu içinde flags() fonksiyonunu kullanarak mevcut veri yapılandırma flag değerlerini ekrana yazar. Sonra, flags() fonksiyonunu ios::basefield parametresi ile kullanarak, dec, hex ve oct flag değerlerini aktif hale getirir. Diğer tüm flag değerleri devreden çıkarılır. Daha sonra, deger_yaz() fonksiyonu içinde flags() fonksiyonunu kullanarak veri yapılandırma flag değerlerinin son halini tekrar ekrana yazar.

Bir önceki programda, setf() fonksiyonu ile kullanılan ios::basefield parametresi sadece dec, hex ve oct değerlerini aktif hale getirirken, burada flags() fonksiyonu ile kullanıldığında, dec, hex ve oct değerlerini aktif hale getirirken diğer tüm değerleri devreden çıkarır.

#include <iostream>

using namespace std;

int main(void)
{
  cout << 21.754f << endl;
  cout.width(10);
  cout << 21.754f << endl;

  cout << 526 << endl;
  cout.width(10);
  cout << 526 << endl;
  
  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

21.754
    21.754
526
       526

Program, önce float bir değeri ekrana yazar. Veri genişliğini width() fonksiyonu ile 10 değerine ayarladıktan sonra aynı bir değeri tekrar ekrana yazar. Toplam genişlik 10 ve veri genişliği 6 karakter olduğundan verinin sol tarafına 4 adet boşluk karakteri eklenir. Aynı işlemler int bir değer için tekrarlanır.

#include <iostream>

using namespace std;

int main(void)
{
  cout << 125.83541f << endl;
  cout.precision(8);
  cout << 125.83541f << endl;
  
  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

125.835
125.83541

Program, önce 3 basamaklı tamsayı ve 5 basamaklı olmak üzere toplam 8 basamaklı float bir değeri ekrana yazar. Ancak, ön tanımlı basamak sayısı 6 olduğundan, ondalık kısmının son iki rakamı yazılmaz. Ondalık sayı basamak sayısını, precision() fonksiyonu ile 8 değerine ayarladıktan sonra, aynı değeri tekrar ekrana yazar. Bu kez sayı normal bir şekilde ekrana yazılır.

#include <iostream>

using namespace std;

int main(void)
{
  cout.width(10);
  cout << 7452 << endl;

  cout.width(10);
  cout.fill('&');
  cout << 7452 << endl;

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

      7452
&&&&&&7452

Program, veri genişliğini 10 karakter olarak ayarlayarak 4 basamaklı bir int değeri ekrana yazar. Ön tanımlı boşluk doldurma karakteri boşluk karakteri olduğundan sayının sol tarafına 4 adet boşluk karakteri ekler. Veri genişliğini tekrar 10 karakter olarak ayarladıktan ve fill() fonksiyonu ile boşluk doldurma karakterini & olarak ayarladıktan sonra, int değeri tekrar ekrana yazar. Bu kez sayının sol tarafına 4 adet & karakteri ekler.

#include <iostream>
#include <iomanip>

using namespace std;

int main(void)
{
  // ios sınıfı width() fonksiyonu ile akış veri genişliğini ayarlama
  cout.width(10);
  cout << 142.843f << endl;

  // Manipülatör ile akış veri genişliğini ayarlama
  cout << setw(10) << 142.843f << endl;

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

   142.843
   142.843

Program, akış veri genişliğini önce ios sınıfı width() fonksiyonu ile yaparak float bir değeri ekrana yazar. Sonra, aynı işlemi manipülatör setw() ile yaparak değeri tekrar ekrana yazar.

#include <iostream>
#include <iomanip>

using namespace std;

int main(void)
{
  cout << 46325 << endl;

  // ios sınıfı setf() fonksiyonu ile onaltılık sayı sistemine geçiş
  cout.setf(ios::hex, ios::basefield);
  cout.setf(ios::showbase);

  cout << 46325 << endl;

  // Manipülatör ile onaltılık sayı sistemine geçiş
  cout << hex << showbase << 46325 << endl;

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

46325
0xb4f5
0xb4f5

Program, akış veri genişliğini önce ios sınıfı setf() fonksiyonu ile yaparak int bir değeri ekrana yazar. Sonra, aynı işlemi hex() ve showbase() manipülatörleri ile yaparak değeri tekrar ekrana yazar.

#include <iostream>

using namespace std;

class sinif {
  public:
    int pubid1, pubid2, pubid3;
    sinif(int pid1, int pid2, int pid3)
    {
      pubid1 = pid1; pubid2 = pid2; pubid3 = pid3;
    }
    void deger_goster()
    {
      cout << "Değişken değerleri (Sınıf fonksiyonu ile): " << pubid1 << " " << pubid2 << " " << pubid3 << endl;
    }
};

// Çoklu görev tanımlanmış << işlemci fonksiyonu
ostream &operator<<(ostream &stream, const sinif &nes)
{
  stream << "Değişken değerleri (<< fonksiyonu ile): " << nes.pubid1 << " " << nes.pubid2 << " " << nes.pubid3 << endl;

  return stream;
}

int main(void)
{
  sinif nes(7, 21, 143);

  nes.deger_goster(); // Değerlerin sınıf fonksiyonu ile gösterilmesi

  cout << nes;        // Değerlerin çoklu görev tanımlanmış << işlemci fonksiyonu ile gösterilmesi

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

Değişken değerleri (Sınıf fonksiyonu ile): 7 21 143
Değişken değerleri (<< fonksiyonu ile): 7 21 143

Program, üç adet public int değer, bu int değerlere birer değer atayan constructor fonksiyonu ve bu değerleri ekranda gösteren bir fonksiyon içeren bir sınıf oluşturur. Ayrıca, << işlemcisine çoklu görev tanımlayarak, kendisine geçirilen nesne yoluyla bir sınıf kopyası içindeki değişken değerlerini ekranda gösteren, bir fonksiyon oluşturur. Sonra, oluşturduğu sınıftan bir nesne bildirimi yapar. Nesne yoluyla, sınıf kopyası içinde yer alan değişken değerlerini önce sınıf fonksiyonu ile sonra da çoklu görev tanımlama ile oluşturulan fonksiyon ile ekrana yazar.

#include <iostream>

using namespace std;

class sinif {
  private:
    int priid1, priid2, priid3;

  public:
    sinif(int pid1, int pid2, int pid3)
    {
      priid1 = pid1; priid2 = pid2; priid3 = pid3;
    }
    void deger_goster()
    {
      cout << "Değişken değerleri (Sınıf fonksiyonu ile): " << priid1 << " " << priid2 << " " << priid3 << endl;
    }

    friend ostream &operator<<(ostream &stream, const sinif &nes);
};

// Çoklu görev tanımlanmış << işlemci fonksiyonu
ostream &operator<<(ostream &stream, const sinif &nes)
{
  stream << "Değişken değerleri (<< fonksiyonu ile): " << nes.priid1 << " " << nes.priid2 << " " << nes.priid3 << endl;

  return stream;
}

int main(void)
{
  sinif nes(7, 21, 143);

  nes.deger_goster(); // Değerlerin sınıf fonksiyonu ile gösterilmesi

  cout << nes;        // Değerlerin çoklu görev tanımlanmış << işlemci fonksiyonu ile gösterilmesi

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

Değişken değerleri (Sınıf fonksiyonu ile): 7 21 143
Değişken değerleri (<< fonksiyonu ile): 7 21 143

Program, üç adet private int değer, bu int değerlere birer değer atayan constructor fonksiyonu ve bu değerleri ekranda gösteren bir fonksiyon içeren bir sınıf oluşturur. Ayrıca, << işlemcisine çoklu görev tanımlayarak, kendisine geçirilen nesne yoluyla bir sınıf kopyası içindeki değişken değerlerini ekranda gösteren, friend bir fonksiyon oluşturur. Sonra, oluşturduğu sınıftan bir nesne bildirimi yapar. Nesne yoluyla, sınıf kopyası içinde yer alan değişken değerlerini önce sınıf fonksiyonu ile sonra da çoklu görev tanımlama ile oluşturulan fonksiyon ile ekrana yazar.

#include <iostream>

using namespace std;

class sinif {
  private:
    int priid1, priid2, priid3;

  public:
    sinif() {
      priid1=0; priid2=0; priid3=0;
    }
    sinif(int pid1, int pid2, int pid3)
    {
      priid1 = pid1; priid2 = pid2; priid3 = pid3;
    }
    void deger_goster(void)
    {
      cout << "Değişken değerleri (Sınıf fonksiyonu ile): " << priid1 << " " << priid2 << " " << priid3 << endl;
    }
    friend ostream &operator<<(ostream &stream, const sinif &nes);
    friend istream &operator>>(istream  &stream, sinif &nes);
};

ostream &operator<<(ostream &stream, const sinif &nes)
{
  stream << "Değişken değerleri (<< fonksiyonu ile): " << nes.priid1 << " " << nes.priid2 << " " << nes.priid3 << endl;

  return stream;
}

istream &operator>>(istream &stream, sinif &nes)
{
  cout << "1.değişken değerini giriniz: ";
  stream >> nes.priid1;

  cout << "2.değişken değerini giriniz: ";
  stream >> nes.priid2;

  cout << "3.değişken değerini giriniz: ";
  stream >> nes.priid3;

  return stream;
}

int main(void)
{
  sinif nes;

  cin >> nes;         // Değerlerin çoklu görev tanımlanmış >> işlemci fonksiyonu ile girilmesi

  nes.deger_goster(); // Değerlerin sınıf fonksiyonu ile gösterilmesi

  cout << nes;        // Değerlerin çoklu görev tanımlanmış << işlemci fonksiyonu ile gösterilmesi

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

1.değişken değerini giriniz: 7
2.değişken değerini giriniz: 21
3.değişken değerini giriniz: 35
Değişken değerleri (Sınıf fonksiyonu ile): 7 21 35
Değişken değerleri (<< fonksiyonu ile): 7 21 35

Program, üç adet private int değer, bu int değerlere parametre almadan sıfır değeri atayan bir constructor fonksiyonu, birer int değer atayan parametre alan bir constructor fonksiyonu ve bu değerleri ekranda gösteren bir fonksiyon içeren bir sınıf oluşturur. Sonra, >> işlemcisine çoklu görev tanımlayarak, kendisine geçirilen nesne referansı yoluyla bir sınıf kopyası içindeki değişken değerlerine klavyeden değer alan friend bir fonksiyon oluşturur ve << işlemcisine çoklu görev tanımlayarak, kendisine geçirilen nesne yoluyla bir sınıf kopyası içindeki değişken değerlerini ekranda gösteren, friend bir fonksiyon oluşturur. Oluşturduğu sınıftan bir nesne bildirimi yapar. Nesne yoluyla, sınıf kopyası içinde yer alan değişken değerlerine çoklu görev tanımlama ile oluşturulan fonksiyon ile değer atar. Sonra, değişken değerlerini önce sınıf fonksiyonu ile sonra da çoklu görev tanımlama ile oluşturulan fonksiyon ile ekrana yazar.

#include <iostream>

using namespace std;

// Özel manipülatör fonksiyonu
ostream &bg_hex(ostream &stream)
{
  stream.setf(ios::showbase);
  stream.setf(ios::hex, ios::basefield);

  return stream;
}

int main(void)
{
  int id = 21864;

  cout << id << endl;
  cout << bg_hex << id; // Özel manipülatör fonksiyonu kullanımı

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

21864
0x5568

Program, ios sınıfı içinde yer alan setf() fonksiyonunun iki farklı kullanımını tek bir fonksiyon içinde yaparak, çıkış işlemi için bir manipülatör fonksiyon oluşturur. Bildirimini yaptığı int bir değeri önce onluk sayı sisteminde sonra manipülatör fonksiyonunu kullanarak onaltılık sayı sisteminde ekrana yazar.

#include <iostream>

using namespace std;

// Giriş özel manipülatör fonksiyonu
istream &deger_al(istream &deger)
{
  cout << "Bir değer giriniz: ";

  return deger;
}
// Çıkış özel manipülatör fonksiyonu
ostream &deger_goster(ostream &deger)
{
  deger << "Girilen değer: ";

  return deger;
}

int main(void)
{
  string str, id;

  cin >> deger_al >> str;
  cout << deger_goster << str;

  cout << endl;

  cin >> deger_al >> id;
  cout << deger_goster << id;

  return 0;
}

Yukarıdaki programı derleyip çalıştırdığımızda, aşağıdaki ifadeleri ekrana yazar:

Bir değer giriniz: Program
Girilen değer: Program
Bir değer giriniz: 21
Girilen değer: 21

Program, deger_al() isimli giriş manipülatör fonksiyonu ve deger_goster() isimli çıkış manipülatör fonksiyonu oluşturur. Bu fonksiyonları sırasıyla çalıştırarak önce bir karakter dizisi sonra int bir değer için işlem yapar ve girilen değerleri ekrana yazar.