kopiowanie lancuchow z pliku

#include <cstdio>
#include <cstdlib>
#include <cstring>

typedef struct {
    char * data;
    unsigned int max_elems;
    unsigned int max_strlength;
    unsigned int first_avail;
} strtable;


strtable * create_table( unsigned int max_elems, unsigned int max_length ) {
    if( max_elems == 0 ) max_elems = 10;
   
    if( max_length == 0 ) max_length = 30;
   
    strtable * result =( strtable * ) malloc( sizeof( strtable ) );
    result->max_elems = max_elems;
    result->max_strlength = max_length;
    result->first_avail = 0;
    result->data =( char * ) malloc( result->max_elems * result->max_strlength );
    return result;
}

void expand_table( strtable * data, unsigned int elems_to_expand ) {
    if( data == NULL ) return;
   
    unsigned int new_max = data->max_elems + elems_to_expand;
   
    char * newtable =( char * ) malloc( new_max * data->max_strlength );
    memcpy( newtable, data->data,( data->max_elems * data->max_strlength ) );
    data->max_elems = new_max;
    free( data->data );
    data->data = newtable;
    printf( "Table expanded\n" );
}

int save_string( strtable * dest, const char * str ) {
    if( strlen( str ) > dest->max_strlength )
         return - 1;
   
    if( dest->first_avail == dest->max_elems )
         expand_table( dest, dest->max_elems );
   
    char * ptr = dest->data +( dest->first_avail * dest->max_strlength );
    strcpy( ptr, str );
    return dest->first_avail++;
}

const char * get_string( strtable * src, unsigned int idx ) {
    if( idx >= src->max_elems )
         return NULL;
   
    char * result = src->data +( idx * src->max_strlength );
    return result;
}

void save_to_file( strtable * data, const char * file_name, bool binary ) {
    if( data == NULL || file_name == NULL ) return;
   
    FILE * outf = fopen( file_name, "w" );
    if( !outf ) return;
   
    if( binary ) {
        int desc = 0x46525453;
        fwrite( & desc, sizeof( int ), 1, outf );
        desc = data->first_avail - 1; fwrite( & desc, sizeof( int ), 1, outf );
        desc = data->max_strlength; fwrite( & desc, sizeof( int ), 1, outf );
        fwrite( data->data, data->max_strlength, data->first_avail - 1, outf );
    }
    else {
        char * ptr = data->data;
        for( unsigned i = 0; i < data->first_avail; ++i ) {
            fprintf( outf, "%s\n", ptr );
            ptr += data->max_strlength;
        }
    }
    fclose( outf );
}

strtable * load_from_file( const char * filename ) {
    FILE * inf = fopen( filename, "rb" );
    if( inf == NULL ) return NULL;
   
    int desc = 0;
    strtable * strings =( strtable * ) malloc( sizeof( strtable ) );
    memset( strings, 0x00, sizeof( strtable ) );
    fread( & desc, sizeof( int ), 1, inf );
    if( desc == 0x46525453 ) {
        fread( & strings->max_elems, sizeof( unsigned int ), 1, inf );
        fread( & strings->max_strlength, sizeof( unsigned int ), 1, inf );
        strings->data =( char * ) malloc( strings->max_elems * strings->max_strlength );
        fseek( inf, 0x0C, SEEK_SET );
        fread( strings->data, strings->max_strlength, strings->max_elems, inf );
        strings->first_avail = strings->max_elems;
    }
    else {
        rewind( inf );
        strings->max_strlength = 50;
        strings->max_elems = 100;
        strings->data =( char * ) malloc( strings->max_strlength * strings->max_elems );
        char * ptr = strings->data;
        unsigned int len = 0;
        while( fgets( ptr, strings->max_strlength, inf ) ) {
            len = strlen( ptr );
            memset( & ptr[ len - 2 ], 0x00, 2 );
            ptr += strings->max_strlength;
            ++strings->first_avail;
        }
    }
    fclose( inf );
    return strings;
}

void clear_table( strtable * data ) {
    if( data == NULL )
         return;
   
    free( data->data );
    data->first_avail = 0;
    data->max_elems = 0;
    data->max_strlength = 0;
}

int main( int argc, char ** argv ) {
    if( argc < 2 )
         return 1;
   
    strtable * strings = load_from_file( argv[ 1 ] );
    if( strings != NULL ) {
        for( unsigned i = 0; i < strings->first_avail - 1; ++i )
             printf( "[%d] -> %s\n", i, get_string( strings, i ) );
       
        clear_table( strings );
    }
    return 0;
}