Файловый ввод/вывод

#include <stdio.h>
 
void write( const char * fileName );
void read( const char * fileName );
 
int main()
{
    write( "test_file.txt" );
    read( "test_file.txt" );
 
    return 0;
}
 
void write( const char * fileName )
{
    const char * data = "Hello, world!"; //14 байт (учитывая 0x00 в конце)
    FILE * myFile = fopen( fileName, "w" );
 
    if( myFile == 0 )
    {
       printf( "Error opening %s for writing.\n", fileName );
       return;
    }
 
    int wrote = fwrite( data, sizeof(char), 14, myFile );
    printf( "Wrote %i bytes\n", wrote );
 
    fclose( myFile );
}
 
void read( const char * fileName )
{
    char data[255] = {0};
 
    FILE * myFile = fopen( fileName, "r" );
 
    if( myFile == 0 )
    {
       printf( "Error opening %s for reading.\n", fileName );
       return;
    }
 
    int read = fread( data, sizeof(char), 254, myFile );
    printf( "Read %i bytes:\n%s\n", read, data );
 
    fclose( myFile );
}

void Distance::write()
{
    ofstream outFile;
    outFile.open("DIST.DD", ios::trunc|ios::binary);
    if(!outFile)
    {cerr << "\nНевозможно открыть файл для записи данных.\n"; _getch(); exit(1);}
 
    for(int i=0; i<count; i++)
    {
        outFile.write((char*)(arrap[i]), sizeof(Distance));
    }
    if(!outFile)
    {cerr << "\nЗапись в файл невозможна.\n"; _getch(); exit(1);}
    outFile.close();
}
 
void Distance::read()
{
    ifstream inFile;
    inFile.open("DIST.DD", ios::binary);
    if(!inFile)
    {cerr << "\nНевозможно открыть файл для чтения данных.\n"; _getch(); exit(1);}
    int i=0;
    while(true)
    {
        arrap[i] = new Distance;
        inFile.read((char*)arrap[i], sizeof(Distance));
        if(inFile.eof())
            break;
        i++;
    }
    if(!inFile)
    {cerr << "\nНевозможно произвести чтение из файла.\n"; _getch(); exit(1);}
    inFile.close();
}

#include <iostream>
#include <fstream>
#include <string.h>
 
using namespace std;
 
const int count = 15;
 
struct Distance
{
    int x, y;
}
* arrap[ count ];
 
 
void write()
{
    ofstream outFile;
    outFile.open("DIST.DD", ios::trunc|ios::binary);
    if(!outFile)
    {
        cerr << "\nCould not open for writing.\n";
        return;
    }
 
    for(int i=0; i<count; i++)
    {
            outFile.write((char*)(arrap[i]), sizeof(Distance));
    }
 
    if(!outFile)
    {
        cerr << "\nWrighting is impossible.\n";
        return;
    }
    outFile.close();
 
}
 
void read()
{
    ifstream inFile;
    inFile.open("DIST.DD", ios::binary);
 
    if(!inFile)
    {
        cerr << "\nCould not open for reading.\n";
        return;
    }
 
    int i=0;
    while(true) //тут бы так: while( i < count ), иначе рискуете схватить переполнение буфера.
    {
            arrap[i] = new Distance;
            memset( arrap[i], 0, sizeof(Distance) ); //если не прочитает - значения x и y будут == 0
            inFile.read((char*)arrap[i], sizeof(Distance));
 
            if(inFile.eof())
                break;
 
            i++;
    }
    if(!inFile)
    {
        cerr << "\nReading is impossible.\n";
        return;
    }
 
    inFile.close();
}
 
int main()
{
    for( int i = 0; i < count; i++ )
    {
        arrap[i] = new Distance;
        arrap[i]->x = 5; //инициализировать заведомо известными числами
        arrap[i]->y = 8; //инициализировать заведомо известными числами
    }
 
    write();
 
    for( int i = 0; i < count; i++ )
    {
        delete [] arrap[i];
    }
 
    read();
 
    cout << "\n-- Read data: ---------------------\n";
 
    for( int i = 0; i < count; i++ )
    {
        cout << arrap[i]->x << ';' << arrap[i]->y;
 
        if( arrap[i]->x == 5 && arrap[i]->y == 8 )
           cout << " - OK" << endl;
        else
           cout << " - FAIL" << endl;
 
        delete [] arrap[i];
    }
}

if(!inFile)
{
    cerr << "\nНевозможно произвести чтение из файла.\n";
    _getch();
    exit(1); //это завершало программу преждевременно. Я просто вернул из функции.
               //кроме того, вторая такая проверка после цикла чтения (как и после цикла записи) избыточна
               //и не имеет смысла.
}

void Distance::read()
{
    ifstream inFile;
    inFile.open("DIST.DD", ios::in|ios::binary);
    if(!inFile)
    {cerr << "\nНевозможно открыть файл для чтения данных.\n"; return;}
    inFile.seekg(0,ios::end);
    int endpos = inFile.tellg();
    int num = endpos/sizeof(Distance);
    cout << "\nИдет чтение " << num << " записей.\n";
    for(int i=0; i<num; i++)
    {
        arrap[i] = new Distance;
        memset( arrap[i], 0, sizeof(Distance) );
        inFile.read((char*)arrap[i], sizeof(Distance));
    }
    if(!inFile)
    {cerr << "\nНевозможно произвести чтение из файла.\n"; return;}
    inFile.close();
}

if(!inFile)
        {cerr << "\nНевозможно произвести чтение из файла.\n"; return;}
        inFile.close();

// 12_1.cpp: определяет точку входа для консольного приложения.
//
#include "stdafx.h"
#include <iostream>
#include <conio.h>
#include <fstream>
#include <process.h>
#include <windows.h>
using namespace std;    
 
const int MAXARR = 100;
 
 
class Distance
{
private:
    int feet;
    float inches;
    static int count;
    static Distance* arrap[];
public:
    void getdata()
    {
        cin.ignore(10,'\n');
        cout << "Введите футы: "; cin >> feet;
        cout << "Введите дюймы: "; cin >> inches;
    }
 
        void putdata()
    {
        cout << "Feets: " << feet;
        cout << "Inches: " << inches;
    }
 
    static void add();
    static void write();
    static void read();
    static void display();
};
 
int Distance::count=0;
Distance* Distance::arrap[MAXARR];
 
 
void Distance::add()
{
    arrap[count] = new Distance;
    arrap[count++]->getdata();
}
 
void Distance::write()
{
    ofstream outFile;
    outFile.open("DIST.DD", ios::trunc|ios::binary);
    if(!outFile)
    {cerr << "\nНевозможно открыть файл для записи данных.\n"; return;}
 
    for(int i=0; i<count; i++)
    {
        outFile.write((char*)(arrap[i]), sizeof(Distance));
    }
    if(!outFile)
    {cerr << "\nЗапись в файл невозможна.\n"; return;}
    outFile.close();
}
 
void Distance::read()
{
    ifstream inFile;
    inFile.open("DIST.DD", ios::in|ios::binary);
    if(!inFile)
    {cerr << "\nНевозможно открыть файл для чтения данных.\n"; return;}
    inFile.seekg(0,ios::end);
    int endpos = inFile.tellg();
    int num = endpos/sizeof(Distance);
    cout << "\nИдет чтение " << num << " записей.\n";
    for(int i=0; i<num; i++)
    {
        arrap[i] = new Distance;
        memset( arrap[i], 0, sizeof(Distance) );
        inFile.read((char*)arrap[i], sizeof(Distance));
    }
    //if(!inFile)
    //{cerr << "\nНевозможно произвести чтение из файла.\n"; return;}
    inFile.close();
}
 
void Distance::display()
{
    for(int i =0; i<count; i++)
        arrap[i]->putdata();
}
 
 
int _tmain(int argc, _TCHAR* argv[])
{
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    char choice;
    while(true)
    {
        cout << "\nЧто? a/w/r/d/x/p: ";
        cin >> choice;
        switch(choice)
        {
        case 'a':
            Distance::add(); break;
        case 'w':
            Distance::write(); break;
        case 'r':
            Distance::read(); break;
        case 'd':
            Distance::display(); break;
        case 'x':
            exit(0);
        default:
            cout << "Неверный атрибут.\n";
        }
    }
 
    _getch();
    return 0;
}

class Distance
{
private:
        int feet;
        float inches;
public:
        void getdata()
        {
                cin.ignore(10,'\n');
                cout << "Введите футы: "; cin >> feet;
                cout << "Введите дюймы: "; cin >> inches;
        }
 
        void putdata()
        {
                cout << "Feets: " << feet;
                cout << "Inches: " << inches;
        }
 
        void setInches( float _inches ){ inches = _inches; };
        void setFeet( int _feet ){ feet = _feet ; };
 
        float getInches(){ return inches; };
        int getFeet(){ return feet; };
};
 
const int arrap_count;
Distance* arrap[ arrap_count ];
 
 
void write()
{
//...
   file.write( (char*)(arrap_count), sizeof(arrap_count) );
 
   for( int i = 0; i < arrap_count; i++ )
   {
      float inches = arrap[i]->getInches();
      int feet = arrap[i]->getFeet;
      file.write( (char*)(inches), sizeof(inches) );
      file.write( (char*)(feet), sizeof(feet) );
   }
//...
}
 
void read()
{
//...
   float inches
   int feet
   file.read( (char*)(inches), sizeof(inches) );
   file.read( (char*)(feet), sizeof(feet) );
   arrap[i]->setInches( inches );
   arrap[i]->setFeet( feet );
//...
}

class Distance
{
private:
        int feet;
        float inches;
public:
        Distance( int feet, float inches ){ setFeet( feet ); setInches( inches ); };
 
        void getdata()
        {
                cin.ignore(10,'\n');
                cout << "Введите футы: "; cin >> feet;
                cout << "Введите дюймы: "; cin >> inches;
        }
 
        void putdata()
        {
                cout << "Feets: " << feet;
                cout << "Inches: " << inches;
        }
 
        void setInches( float _inches ){ inches = _inches; };
        void setFeet( int _feet ){ feet = _feet ; };
 
        float getInches(){ return inches; };
        int getFeet(){ return feet; };
};
 
list<Distance>arrap;
 
void write()
{
//...
   file.write( (char*)(arrap.size), sizeof(arrap.size) );
 
   list<Distance>::iterator it = arrap.begin();
 
   for( int i = 0; i < arrap.size; i++ )
   {
      float inches = (*it)->getInches();
      int feet = (*it)->getFeet;
      file.write( (char*)(inches), sizeof(inches) );
      file.write( (char*)(feet), sizeof(feet) );
      it++;
   }
//...
}
 
void read()
{
   
//...
   int size;
   file.read( (char*)(size), sizeof(size) );
 
   arrap.clear();
 
   for( int i = 0; i < size; i++ )
   {
      float inches;
      int feet;
 
      file.read( (char*)(inches), sizeof(inches) );
      file.read( (char*)(feet), sizeof(feet) );
 
      Distance dist ( feet, inches );
      arrap.push_back( dist );
   }
//...
}