Перегрузка оператора ++ , деструктор и конструктор копий

#include "io.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include <malloc.h> 
#include <fcntl.h>
 
#define BUFF_SIZE 512
 
typedef unsigned int  uint_t;      // 4 - bytes ; 0 to 4,294,967,295 
 
class File_pos
{
    char * file_name;       /* Хранит имя файла */
    char * buffer;          /* Указатель на массив  содержимого файла */
 
    uint_t file_size;       /* Количество символов в файле*/
 
    /* количество элементов в буфере м. быть от 1 до BUFF_SIZE | file_size */
    uint_t readed_elements;  /* если равно file_size то перезагрузка не нужна */
    
    uint_t cur_pos;         /* Текущее полож. курсора, / 1 до file_size */
 
    uint_t line;            /* текущая строка    / от 1 и до 4,294,967,295 */  
    uint_t cursor;          /* позиция в строке  / от 1 и до 4,294,967,295 */
 
    uint_t blocnum;         /* номер прочитанного блока */    
 
    bool need_reload;       /* нужна ли будет "до-загрузка файла" */
 
    bool eof;       /* Ни конец ли файла? */
    //bool bof;       /* Ни начало ли файла */
 
 
    //char * load_file( const char * filename, /* out */ uint_t * count_symb );
    
    char * load_buff ();
  
 
    inline void get_file_size ();
 
    int read_buff ( uint_t buff_size, bool backflag );
 
    
public :
 
    File_pos (const char * filename );
    File_pos (const File_pos &obj ); /* Конструктор копирования */
    ~File_pos ();
 
    File_pos operator++();
    //File_pos operator--();
 
    uint_t  get_Line ()     { return line; }
    uint_t  get_Cursor ()   { return cursor; }
    
    char    get_Symb ()     { return *buffer; } /*Текущий символ */
 
    bool    is_eof ()       { return  eof; }
    
 /* FIXME  Проверить правильно ли определяю начало файла */
    bool    is_begin ()     { return ( cur_pos == 0 ); }
 
 
    //int set_New_file ( const char * filename );
 
  
 
    void Print() 
    { 
        switch ( this->get_Symb() )
        {
        case '\r' :
            printf ("Текущий символ \" \\r\" на позиции Ln (%i) Cur (%i)\n", line, cursor);
            break;
        case '\n' :
            printf ("Текущий символ \" \\n\" на позиции Ln (%i) Cur (%i)\n", line, cursor);
            break;
        case '\t' :
            printf ("Текущий символ \" \\t\" на позиции Ln (%i) Cur (%i)\n", line, cursor);
            break;
        case '\0' :
            printf ("Текущий символ \" \\0\" на позиции Ln (%i) Cur (%i)\n", line, cursor);
            break;
        default :
            printf ( "Текущий символ \" %-2c\" на позиции Ln (%i) Cur (%i)\n",
                    this->get_Symb(), line, cursor ); 
            break;
        }
    }
};

#include "file_pos.h"
 
/* Конструктор */
File_pos::File_pos (const char * filename )
{
 
    this->file_name = _strdup ( filename );
 
    this->get_file_size();  /* Инициализируем длину файла */
 
    this->blocnum = 0;
 
    cur_pos = 1;
 
    read_buff( BUFF_SIZE, false ); // Загружаем первый блок в память
 
    need_reload = (file_size > readed_elements );
 
    eof = file_size == 0;
    
    line    = 1;
    cursor  = 1;       
}
/*-----------------*/
 
/* Конструктор копирования */
File_pos::File_pos(const File_pos &obj)
{
    size_t sz;
    this->blocnum   = obj.blocnum;
    this->cur_pos   = obj.cur_pos;
    this->cursor    = obj.cursor;
    this->eof       = obj.eof;
    this->file_size = obj.file_size;
    this->line      = obj.line;
    this->need_reload       = obj.need_reload;
    this->readed_elements   = obj.readed_elements;
 
    this->file_name = _strdup ( obj.file_name );
    this->buffer = new char[ sz = obj.readed_elements ];
/*FIXME Добавить оработку исключительных ситуаций */
    
    for (size_t i = 0; i < sz; ++i)
        this->buffer[i] = obj.buffer[i];
 
}
 
 
/*-----Деструктор-----*/
File_pos::~File_pos()
{
/*FIXME Переделать под delete*/
    free ( this->file_name );
    free ( this->buffer );      
    printf ("Destructor... \n" );
}
 
/*--Определяет длину файла--*/
void
File_pos::get_file_size ()
{
    int fh;
    if ( (fh = _open( this->file_name, _O_BINARY | O_RDONLY )) == -1)
    {
        perror("Open File");
        return;
    }
 
    _lseek ( fh, 0L, SEEK_SET );  // Переводим курсор вначало    
 
    /* определяем количество символов в файле */
 
    if ( (this->file_size = _lseek ( fh, 0L, SEEK_END ) ) == 0 )
    {
        puts( "File is empty..." );
        return;
    }
    _close ( fh );
}
 
/*-------------------*/
 
 
/*Читает "кусочек" данный в массив */
int
File_pos::read_buff ( uint_t buff_size, bool backflag )
{
    int fh;
    if ( (fh = _open( this->file_name, _O_BINARY | O_RDONLY )) == -1)
    {
        perror("Open File");
        return -1;
    }
 
    /*FIXME тут как раз и будет разветвление читать вперед или назад */
    /* возможно изменять память нужно с помощью realloc() */
 
    if ( backflag )
    {
        
    }
    else
    {
        size_t bufsz = ( file_size - blocnum * buff_size < buff_size ) ? 
                                    ( file_size - blocnum * buff_size ) : buff_size;  
        
        /* Выделяем память для элементов массива */
/*FIXME Переделать под new*/
        if ( ( this->buffer = (char *) malloc ( bufsz * sizeof ( char ) ) ) == NULL )
        {
            perror ( "Can't allocate memory..." );
            return -2;
        }
        
        if ( ( readed_elements = _read ( fh, buffer, buff_size ) ) == -1)
        {
            perror ( "reading problem..." );
            return NULL;
        }
        ++blocnum;  /*ТОЛЬКО в блоке NEXT */
 
    }
    _close ( fh );
 
    return 0;
}
/*----------------------------*/
 
File_pos
File_pos::operator++ ()
{
    /* если достигли последнего элемента в буфере и есть еще что перезагрузить */
    /*if ( cur_pos == readed_elements && need_reload )
    {
        reload_file();
    }
    else
    */
 
    if ( cur_pos == file_size )    
        this->eof = true;
   
 
    /* Можно ли сместить курсор */
    if ( cur_pos < file_size )
    { 
        if ( this->get_Symb() != '\n')
        {
            ++cursor;
        }
        else
        {
            ++line;
            cursor = 1;            
        }
 
        ++buffer;                
 
        ++cur_pos;           
    }
    
    return *this;
}
 
/*----------------*/

#include <iostream>
#include "file_pos.h"
#include "locale.h"
 
int main()
{ 
    setlocale( LC_ALL, "" );
 
    File_pos f1( "test.txt" );
 
    while ( !f1.is_eof() )
    {
        f1.Print();
        ++f1;
    }
 
    system ("PAUSE");
    exit ( EXIT_SUCCESS );
}

/* Конструктор копирования */
File_pos::File_pos(const File_pos &obj)
{
    size_t sz;
    this->blocnum   = obj.blocnum;
    this->cur_pos   = obj.cur_pos;
    this->cursor    = obj.cursor;
    this->eof       = obj.eof;
    this->file_size = obj.file_size;
    this->line      = obj.line;
    this->need_reload       = obj.need_reload;
    this->readed_elements   = obj.readed_elements;
 
    this->file_name = _strdup ( obj.file_name );
    this->buffer = new char[ sz = obj.readed_elements ];
/*FIXME Добавить оработку исключительных ситуаций */
    
    for (size_t i = 0; i < sz; ++i)
        this->buffer[i] = obj.buffer[i];
 
}

#include "io.h"
#include <fcntl.h>  /* _open() */
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include <iostream>
#include <new>
 
#define BUFF_SIZE   5
#define DEBUG_VER
 
typedef unsigned int  uint_t;      // 4 - bytes ; 0 to 4,294,967,295 
typedef std::string   str_t;
 
class File_pos
{
 
private:
    str_t   file_name;       /* Хранит имя файла */
    char *  buffer;          /* Указатель на массив  содержимого файла */
    uint_t  file_size;       /* Количество символов в файле*/
 
    uint_t  glob_pos;         /* Текущее полож. курсора, / 1 до file_size */
    uint_t  line;            /* текущая строка    / от 1 и до 4,294,967,295 */  
    uint_t  cursor;          /* позиция в строке  / от 1 и до 4,294,967,295 */
 
    uint_t  blocnum;         /* номер прочитанного блока */
    bool    eof;            /* Ни конец ли файла? */
   
 
    inline void get_file_size ();
    int read_buff ( char*& p_buf, uint_t bloc_num, uint_t buff_size/*, bool is_back*/ );
    
public :
 
    File_pos (const str_t filename );
    File_pos (const File_pos  &obj ); /* Конструктор копирования */
   ~File_pos ();
 
    File_pos operator++();
    File_pos operator--();
 
    void    set_new_file ( str_t f_name );
 
    uint_t  get_Line()      { return line; }
    uint_t  get_Cursor()    { return cursor; }
    
    char    get_Symb()      { return *buffer; } /*Текущий символ */
    
    bool    is_eof()        { return  eof; } 
    bool    is_begin()      { return ( glob_pos == 0 ); }
   
    void    Print();    
};

#include "file_pos.h"
 
/* Конструктор */
File_pos::File_pos (const str_t filename )
{
    this->file_name = filename;
 
    this->get_file_size();  /* Инициализируем длину файла */
 
    this->blocnum   = 1;
    this->glob_pos  = 1;
 
    // Загружаем первый блок длиной BUFF_SIZE в память(buffer)
    read_buff ( this->buffer, this->blocnum, BUFF_SIZE );
 
    eof = file_size == 0;
    
    line    = 1;
    cursor  = 1;       
}
/*-----------------*/
 
/* Конструктор копирования */
File_pos::File_pos(const File_pos &obj)
{
    try 
    {        
        this->blocnum       = obj.blocnum;
        this->glob_pos      = obj.glob_pos;
        this->cursor        = obj.cursor;
        this->eof           = obj.eof;
        this->file_name     = obj.file_name ;
        this->file_size     = obj.file_size;
        this->line          = obj.line;        
 
        register size_t sz  = 0;
        this->buffer        = new char[ sz = strlen ( obj.buffer ) ];
    
        for (size_t i = 0; i < sz; ++i)
            this->buffer[i] = obj.buffer[i];
    }
    catch ( std::bad_alloc )
    {
        printf ( "error: in operator 'new' \n");
    }
    catch ( ... )
    {
        printf ( "error in copy constructor\n");
    }
}
 
/*-----Деструктор-----*/
File_pos::~File_pos()
{
    delete [] this->buffer;
 
/*#ifdef DEBUG_VER
    printf ("Destructor... \n" );
#endif*/ 
 
}
 
/*-- Определяет длину файла --*/
void
File_pos::get_file_size ()
{
    int fh;
 
    /* открываем файл для чтени в бинарном режиме */
    if ( (fh = _open( this->file_name.c_str(), _O_BINARY | O_RDONLY )) == -1)
    {
        perror("Open File...");
        return;
    }
 
    _lseek ( fh, 0L, SEEK_SET );  // Переводим курсор вначало файла   
 
    
    /* определяем количество символов в файле */
 
    if ( (this->file_size = _lseek ( fh, 0L, SEEK_END ) ) == 0 )    
        puts( "File is empty..." );        
    
    _close ( fh );
}
 
/*-------------------*/
 
 
// Читает "кусочек" данных в массив 
int
File_pos::read_buff ( char * & p_buf, uint_t bloc_num, uint_t buff_size )
{
 
#ifdef DEBUG_VER
    printf ( " .... read to buffer ....  \n" );
#endif
 
    int fh;
 
    if ( (fh = _open( this->file_name.c_str(), _O_BINARY | O_RDONLY )) == -1)
    {
        perror("Open File");
        return -1;
    }
 
    register size_t bufsz;
 
    /* Определяем необходимое количество выделяемой памяти bufsz */
    _lseek ( fh, (long) ( (bloc_num-1) * buff_size ) , SEEK_SET );
    bufsz = _lseek ( fh, 0L , SEEK_END );
 
    if ( bufsz >= buff_size )
        bufsz = buff_size;
        
    try
    {
        /* Выделяем память для элементов массива */
        p_buf = new char [ bufsz + 1 ] ;
        
    }catch ( std::bad_alloc &ba )
    {
        std::cout << ba.what() << " in func read_buff()  ...\n" ;
        return -2;
    }
 
    // переводим курсор на поз. начала чтения
    _lseek ( fh, (long) ( (bloc_num-1) * buff_size ) , SEEK_SET );
 
    
    register int rd_elem = 0;
    /* Считываем данные в массив p_buf и запоминаем */
    if ( ( rd_elem = _read ( fh, p_buf, bufsz ) ) == -1)
    {
        perror ( "reading problem..." );
        return -3;
    }
 
    *( p_buf + rd_elem ) = '\0';
 
    _close ( fh );
 
    return 0;
}
/*----------------------------*/
 
 
File_pos
File_pos::operator++ ()
{
    if ( glob_pos == file_size + 1 )
    {
        this->eof = true;
        return *this;
    }
   
    /* Определяем номера строки и курсор по текущему символу.*/    
    if ( this->get_Symb() == '\n')  /* тут можно поставить '\r' и тогда glob_pos + 2 */
    {
        ++line;
        cursor = 1;
    }
    else
    {
        ++cursor;
    }
    
 
    /* если достигли последнего элемента в буфере
       и есть еще что перезагрузить */
    if ( this->glob_pos == blocnum*BUFF_SIZE && file_size - glob_pos > 0)    
        read_buff ( this->buffer, ++blocnum, BUFF_SIZE );
 
 
    if ( this->glob_pos != (blocnum-1)*BUFF_SIZE )
        ++this->buffer;
 
    ++glob_pos;
    
    return *this;
}
/*----------------*/
 
 
File_pos
File_pos::operator-- ()
{
    /* Начинаем конструирование нового объекта 
    Поскольку, из текущего элемента никакой полезной инфо. нет
    потому, сразу переводим курсор на преыдущий символ     */
 
 
    /* Если находимся на границе блока то загружаем символы в массив*/
    if ( glob_pos == (blocnum-1)*BUFF_SIZE+1 && glob_pos != 1)
    {        
        read_buff ( this->buffer, --blocnum, BUFF_SIZE );
        buffer += BUFF_SIZE-1;        
    }
    else
    {
        --buffer;
    }
 
    --glob_pos; 
 
    /* Дальше формируем номера сроки и курсора */
 
    /*Если новый символ '\n' значит нужно подсчитать
      количество символов в предыдущей строке 
      Иначе просто уменьшаем позицию курсора*/
    if ( this->get_Symb() == '\n' )
    {
        /* Подсчитываем количество символов в предыдущей строке */
        --line;
        uint_t tmp_glob_pos  = this->glob_pos; // Позиция '\n'
        uint_t tmp_blnum    = this->blocnum;
 
        char * p_buf;
 
        /* Если находимся на границе блока то загружаем символы в массив*/
        if ( tmp_glob_pos == (blocnum-1)*BUFF_SIZE+1 )        
            read_buff ( p_buf, --tmp_blnum, BUFF_SIZE );
        else        
            p_buf = this->buffer-1;
        
 
        --tmp_glob_pos;
 
        /* Ищем позицию предыдущего символа '\n' */
        while ( *(p_buf) != '\n' &&  tmp_glob_pos >= 1 )
        {
            if ( tmp_glob_pos == (tmp_blnum-1)*BUFF_SIZE+1 && tmp_glob_pos != 1 )
            {
                read_buff ( p_buf, --tmp_blnum, BUFF_SIZE );
                p_buf += BUFF_SIZE-1;
                --tmp_glob_pos;
                continue;
            }
 
            --p_buf;
            --tmp_glob_pos;
        }
 
        /* Вычисляем длину предыдущей строки */
        cursor = this->glob_pos - tmp_glob_pos;       
    }
    else
    {
        --cursor;
    }
 
    return *this;
}
/*-------------------------*/
 
// Меняем исходный файл
void
File_pos::set_new_file ( str_t f_name )
{
    this->file_name = f_name;
    this->blocnum   = 1;
    
    this->get_file_size();
 
    read_buff ( this->buffer, this->blocnum, BUFF_SIZE );
    
    this->line      = 1;
    this->cursor    = 1;
    this->glob_pos   = 1;
    this->eof       = file_size == 0;    
}
/*----------------*/
 
/*--- Печатает текущий символ и его позицию ---*/
void
File_pos::Print()
{ 
    //printf ("На позиции %2.i ) -> " );
    switch ( this->get_Symb() )
    {
    case '\r' :
        printf ("Текущий символ \" \\r\" на позиции Ln (%3.i ) Cur (%3.i )", line, cursor);
        break;
    case '\n' :
        printf ("Текущий символ \" \\n\" на позиции Ln (%3.i ) Cur (%3.i )", line, cursor);
        break;
    case '\t' :
        printf ("Текущий символ \" \\t\" на позиции Ln (%3.i ) Cur (%3.i )", line, cursor);
        break;
    case '\0' :
        printf ("Текущий символ \"EOF\" на позиции Ln (%3.i ) Cur (%3.i )", line, cursor);
        break;
    default :
        printf ( "Текущий символ \" %-2c\" на позиции Ln (%3.i ) Cur (%3.i )",
                this->get_Symb(), line, cursor ); 
        break;
    }
    printf ( " | Глоб. поз. (%3.i )\n", glob_pos );
}

#include "file_pos.h"
#include "locale.h"
 
int main()
{ 
    setlocale( LC_ALL, "" );
 
    File_pos f1( "test.txt" );
 
    while ( !f1.is_eof() )
    {
        f1.Print();
        ++f1;
    }
    
    while ( !f1.is_begin() )
    {
        //++i;
        f1.Print();
        --f1;
    }
 
    f1.set_new_file( "test2.txt" );
 
    while ( !f1.is_eof() )
    {
        f1.Print();
        ++f1;
    }
    
    while ( !f1.is_begin() )
    {
        //++i;
        f1.Print();
        --f1;
    }
 
    system ("PAUSE");
    exit ( EXIT_SUCCESS );
}