Открытие бинарного файла для чтения

float detect(string name)
{
    int t;
    
    ofstream ff(name,ios::binary|ios::in);
    ff.open(name,ios::binary|ios::in);
    ff.read((char*)&t, sizeof(int));
}

int c,i,n=5;
string name="numbers.dat";
 
float detect(string name)
{
    int t;
    ifstream ff(name,ios::binary|ios::in);
    ff.open(name,ios::binary|ios::in);
    if (!ff) cout<<"error";
}
 
 
void main()
{
    srand(time(0));
    fstream f(name,ios::binary|ios::out);
    
    for (i=0;i<n;i++) //заполняю файл
    {
        c=rand()%20;
        f.write((char*)&c, sizeof(int));
    }
    f.close();
 
    f.open(name,ios::binary|ios::in);
    for (i=0;i<n;i++)  //вывожу файл на экран
    {
        f.read((char*)&c, sizeof(int));
        cout<<c<<' ';
    }
    cout<<'\n';
    f.close();
 
    detect(name);
    getch();
}

ostream& write(const char *str, streamsize count);

int i = 5;
to.write((char *)&i, sizeof(i));
TMoney d(200.56);
to.write(reinterpret_cast<char *>(&d), sizeof(TMoney));

long t[10];
to.write((char *)&t[0], sizeof(t));

istream& read(char *str, streamsize count);

int ii; TMoney dd;
from.read((char *)&ii, sizeof(ii));
from.read(reinterpret_cast<char *>(&dd), sizeof(TMoney));
long t[10];
from.read((char *)&t[0], sizeof(t));

streamsize readsome(char *str, streamsize count);

Листинг 10.27. Создание и обработка двоичных файлов
#include <fstream>
#include <iostream>
#include <ctime>
using namespace std;
int main()
{   int m[10]={0};
    srand((unsigned)time(NULL));        // инициализация датчика случайных чисел
   /* заполняем массив m числами */
    for(int i = 0; i < 10; i++)
    { m[i] = rand()%10;
      cout << m[i] << ' ';          // контрольный вывод
    }
    cout << '\n';
     /* открываем файл для записи */
    ofstream outstrm ("c:/binfiles/oonumber1.bin", std::ios::binary);
    if(outstrm.is_open())
    { for(int i = 0; i < 10; i++)   // выводим массив в файл поэлементно
        outstrm.write((char *)&m[i], sizeof(int));  
      outstrm.close();
    }
    /* открываем другой файл для записи */
    outstrm.open("c:/binfiles/oonumber2.bin", std::ios::binary);
    if(outstrm.is_open()) 
    { outstrm.write((char*)m, sizeof(m));   // выводим массив в файл 
      outstrm.close();
    }
// вывод двоичного файла на экран 
    // открываем второй файл для чтения 
    {   ifstream instrm ("c:/binfiles/oonumber2.bin", std::ios::binary);
        int a = 0;
        // читаем числа по одному из файла и выводим 
        while(instrm.read((char *)&a, sizeof(int))) 
            cout << a << ' ';
        cout << '\n';
    }
// открываем первый файл для чтения 
  ifstream instrm ("c:/binfiles/oonumber1.bin", std::ios::binary);
  int t[10] = {0};
  instrm.read((char *)t, sizeof(t));    // чтение файла в массив
  instrm.close();                       // закрываем
  for(int i = 0; i < 10; i++)           
        cout << t[I] << ' ';
  cout << '\n';  
 char ch = getchar();
return 0;
}

// копирование файлов
{ ifstream instrm ("c:/binfiles/oonumber1.bin", std::ios::binary);
  ofstream outstrm("c:/binfiles/oonumber.new", std::ios::binary);
  if (instrm) filecopy(instrm, outstrm);
}
// дозапись нового файла в конец старого
{ ifstream instrm ("c:/binfiles/oonumber2.bin", std::ios::binary);
  ofstream outstrm("c:/binfiles/oonumber.new",
                    std::ios::app|std::ios::binary);
  if (instrm) filecopy(instrm, outstrm);
}

ios::pos_type p = file.tellg();

streampos pos = file.tellp();

file.seekp(pos);

file.seekg(0);

static const seekdir beg,   // позиционирование от начала потока 
                     cur,   // позиционирование от текущей позиции
                     end;   // позиционирование от конца потока

file.seekg(0, ios::end);

Листинг 10.38. Относительное позиционирование
int main()
{   fstream strm ("c:/binfiles/number2.bin", ios::binary|ios::in|ios::out);
    int a = 0;
    // читаем числа из файла и выводим 
    strm.seekg(2*sizeof(int), ios::beg);        // выставляемся от начала
    strm.read((char *)&a, sizeof(int));         // читаем
    cout << a << ' ' << '\n';
    // записываем новое число на ту же позицию
    a = 12021;
    strm.seekp(2*sizeof(int), ios::beg);        // выставляешься от начала
    strm.write((char *)&a, sizeof(int));    // записываем
    // возвращаемся, читаем снова и выводим
    strm.seekg(2*sizeof(int), ios::beg);        // выставляемся от начала
    strm.read((char *)&a, sizeof(int));         // опять читаем
    cout << a << ' ' << '\n';
    return EXIT_SUCCESS;
}

strm.read((char *)&record, sizeof(T));

strm.write((char *)&record, sizeof(T));

strm.seekg(k*sizeof(T), beg);

// эквивалентные вызовы seekg
stream.seekg(stream.tellg() + sizeof(T));   // абсолютная позиция
stream.seekg(sizeof(T), ios::cur);          // относительная позиция

stream.seekg(stream.tellg() - sizeof(T));   // абсолютная позиция
stream.seekg(-sizeof(T), ios::cur);         // относительная позиция

Листинг 10.28. Вывод объекта с виртуальными функциями
#include <iostream>
#include <fstream>
#include <conio.h>
using namespace std;
class Object                            // класс с виртуальными функциями
{  public:
   virtual void print() { cout << "virtual method!" << endl; }
};
int main(int argc, char* argv[])
{  Object t;                            // объект создан
   cout << sizeof(Object) << endl;      // в памяти занимает 4 байта
   ofstream outstrm ("d:/oonumber1.bin", std::ios::binary);
// выводим объект в файл
   if(outstrm.is_open()) outstrm.write((char *)&t, sizeof(Object));
   outstrm.close();
   return 0;
}

Листинг 9.1. Интерфейс динамического массива с изменяемым размером
template<typename T> 
class TArray {
public:
  // типы
  typedef T                                     value_type;            
  typedef T*                                    iterator;              
  typedef const T*                              const_iterator;        
  typedef T&                                    reference;             
  typedef const T&                              const_reference;       
  typedef std::size_t                           size_type;             
  // конструкторы/копирование/деструктор
  TArray(const size_type& n = minsize);
  TArray(const TArray<T>& array);
  template <class Iterator> TArray(Iterator first, Iterator last);
  ~TArray() { delete [] elems; elems = 0; }
  Tarray<T>& operator=(const TArray<T>&);
  template<typename U> TArray& operator=(const TArray<U>&);
// итераторы
  iterator begin() { return elems; }
  const_iterator begin() const { return elems; }
  iterator end() { return elems+Count; }
  const_iterator end() const { return elems+Count; }
// размеры
  size_type size() const                // длина массива
  { return Count; }
  bool empty() const                    // есть ли элементы
  { return (Count == 0); }
  size_type capacity() const            // потенциальный размер
  { return Size; }
  void resize(size_type newsize);       // изменить размер
// доступ к элементам
  reference operator[](size_type)
  { rangecheck(i);                      // проверка индекса
    return elems[i]; 
  }
  const_reference operator[](size_type) const 
  { rangecheck(i);                      // проверка индекса
    return elems[i]; 
  }
  reference front() { return elems[0]; }
  const_reference front() const { return elems[0]; }
  reference back() { return elems[size()-1]; }
  const_reference back() const { return elems[size()-1]; }  
// методы-модификаторы
  void push_back(const T& v);
  void pop_back()                        // удалить последний элемент
  { if (!empty()) --Count; 
    else throw std::domain_error("array<>: empty array!");
  }
  void clear() { Count = 0; }           // очистить массив
  void swap(TArray<T>& other)           // обменять с другим массивом
  {  std::swap(elems, v.elems);         // стандартная функция обмена
     std::swap(Size, v.Size);
     std::swap(Count, v.Count);
  }
  void assign(const T& v)               // заполнить массив
  { if (!empty()) 
      for(size_type i = 0; i < Count; ++i) 
          elems[i] = v;
  } 
private:
  static const size_type minsize = 10;  // минимальный размер массива
  size_type Size;                       // выделено элементов в памяти
  size_type Count;                      // количество элементов
  value_type * elems;                   // указатель на данные
// проверка индекса
    void rangecheck (size_type i) 
    { if (i >= size()) 
        throw std::range_error("array<>: index out of range");
    }
};
// обмен – внешняя функция
template<typename T> void swap(TArray<T>&, TArray<T>&)
inline void swap(TArray<T>& x, TArray<T>& y)
{ x.swap(y); }
// сравнения
template<typename T> 
bool operator==(const TArray<T>& x, const TArray<T>& y)
{ if (x.size() == y.size())
  { for(size_type i = 0; i < x.size(); ++i) 
        if (x[i]!=y[i]) return false;
    return true;
  }
  else return false;
}
template<typename T> 
bool operator!=(const TArray<T>& x, const TArray<T>& y)
{ return !(x==y); }

Листинг 10.35. Класс TDate, обеспечивающий форматирование дат
class TDate
{   public:
        typedef unsigned int fmtflags;
    // константы-флаги
        static const fmtflags pointDate  = 0x00;
        static const fmtflags intDate    = 0x01;
        static const fmtflags stringDate = 0x02;
    // методы доступа к флагам
        fmtflags getflags() const { return fmt; } 
        void pointdate() { fmt = pointDate; }
        void intdate()   { fmt = intDate; }
        void stringdate(){ fmt = stringDate; }
    // конструкторы даты    
        TDate():date(0) {}
        TDate(unsigned long date):date(date){}
        TDate(unsigned int d, unsigned int m, unsigned int y)
        :date(y*10000+m*100+d) {}
        TDate(unsigned int d, string month, unsigned int y);
        TDate(const TDate &d):date(d.date){}
    // ввод/вывод
        friend istream& operator>>(istream& is, TDate &data);
        friend ostream& operator<<(ostream& os, const TDate &data);
    // манипуляторы
    friend ostream& intdate   (ostream &os) { fmt = intDate; return os; }  
    friend ostream& pointdate (ostream &os) { fmt = pointDate; return os; }
    friend ostream& stringdate(ostream &os) { fmt = stringDate; return os; }  
    private:
        unsigned long date;
        static fmtflags fmt;
        static const string m[12];
};
TDate::fmtflags TDate::fmt;
const string TDate::m[12] = 
{ "янв","фев","мар","апр","май","июн","июл","авг","сен","окт","ноя","дек" };

unsigned long date;
static fmtflags fmt;

Листинг 10.36. Форматированный вывод даты
ostream& operator<<(ostream& os, const TDate &data)
{   ostringstream s;                    // строковый поток
    int day   = data.date%100;
    int year  = data.date/10000;
    int month = data.date/100%100;
    switch(TDate::fmt)                  // флаг-переключатель
    { case TDate::pointDate:                // формат dd.mm.yyyy
      s << setfill('0') 
        << setw(2) << day   << '.'
        << setw(2) << month << '.'
        << setw(4) << year;
      break;
    case TDate::intDate:                // формат yyyymmdd
      s << data.date;
      break;
    case TDate::stringDate:             // формат dd-mmm-yyyy
      s << setfill('0') 
        << setw(2) << day << '-'
        << TDate::m[month-1] << '-'
        << setw(4) << year;
      break;
    }
    return os << s.str();
}

void save();
void load();

Листинг 10.39. Методы save() и load() для TArray
template <class T>
void TArray<T>::save()
{ tmpnam(name);                 // генерация случайного имени
  if(file.is_open())
  { file.write((char*) &Size, sizeof(size_type));  
    file.write((char*) &Count, sizeof(size_type));
    file.write((char*) elems, sizeof(value_type)*Count);
  }
  file.close();
  return;
}
template <class T>
void TArray<T>::load()
{ std::ifstream file(name, std::ios::binary);
  if(file.is_open())
  { file.read((char*) &Size, sizeof(size_type));  
    file.read((char*) &Count, sizeof(size_type));
    value_type *p = elems;      // сохранили для возврата
    elems = new T[Size];        // новый массив
    file.read((char*) elems, sizeof(value_type)*Count);
    delete[]p;
  }
  file.close();
  return;
}

char name[13];

void save(ofstream &os);
void load(ifstream &is);

#include <fstream>
#include <iostream>
#include <ctime>
using namespace std;
int main()
{
    int N, M, i, j;
    srand((unsigned int)time(NULL));
    ofstream in_w("in.txt"); // открываем текстовый файл для записи
    cout << "Input count rows and colomns: ";
    cin >> N >> M;
    in_w << N << ' ' << M << endl;
    
    for (i = 0; i < N; i++)
    {
        for (j = 0; j < M; j++)
            in_w << rand() % 10 << ' '; // запись числа в файл
        in_w << endl;
    }
    in_w.close();
    ifstream in_r("in.txt");            // открываем текстовый файл для чтения
    int* temp = new int[M * N + 2];
    i = 0;
    while (in_r >> temp[i]) i++;       // Читаем за один прием из файла в массив 
    in_r.close();
 
    ofstream out_w("out.bin", std::ios::binary);
    if (out_w.is_open())
    {
        out_w.write((char*)temp, sizeof(temp)); // выводим массив в файл 
        out_w.close();
    }
    
    ifstream out_r("out.bin", std::ios::binary);
    int a = 0;
    while (out_r.read((char*)&a, sizeof(int))) // читаем числа по одному из файла и выводим 
        cout << a << ' ';
    cout << '\n';
    return 0;
}