Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

Listy fread()

Ostatnio zmodyfikowano 2014-01-04 19:30
Autor Wiadomość
marcelpan
Temat założony przez niniejszego użytkownika
Listy fread()
» 2014-01-03 16:49:47
Mam problem z listami nie potrafię napisać funkcji wczytującą listę do programu.
Musze opanować tą umiejętność w C wymogi edukacyjne.

Mam takie source.
C/C++
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
struct blacklist {
    char * pImie;
    struct blacklist * next;
};
char * tab0( char * p, int n );
char * tab_pour( char * p, int n );
void tab_write( char * p, int n );
void add( struct blacklist * h );
void read( struct blacklist * p, char * path );
void blacklist_write( struct blacklist * h );
void del( struct blacklist * h, char * path );
int zwaz( char * p1, char * p2, int n );
void save( struct blacklist * h, char * path );
int zwaz_plik( char * p );
int main( int argc, char * argv[] )
{
    struct blacklist * p0;
    p0 =( struct blacklist * ) malloc( sizeof( struct blacklist ) );
    p0->pImie = tab0( p0->pImie, 5 );
    p0->pImie = tab_pour( p0->pImie, 5 );
    tab_write( p0->pImie, 5 );
    p0->next = NULL;
   
    add( p0 );
    add( p0 );
    blacklist_write( p0 ); char * p1 = tab_pour( tab0( p1, 5 ), 5 );
    printf( "Save \n" );
    save( p0, "you.bin" );
   
    printf( "Usuwanie \n" );
    del( p0, p1 );
    blacklist_write( p0 );
   
    //OD tego miejsca problemy
    struct blacklist * a;
    a->next = NULL;
    printf( "READ \n" );
    read( a, "you.bin" );
    blacklist_write( a );
    free( p0 ); free( a );
    return 0;
}
char * tab0( char * p, int n )
{
    p =( char * ) malloc( n * sizeof( char ) );
    return p;
}
char * tab_pour( char * p, int n )
{
    char * pp, * pk;
    pp = p;
    pk = p + n * sizeof( char );
    printf( "Podaj imie : " );
    for( pp; pp < pk; pp = pp + sizeof( char ) )
    {
        scanf( "%c", pp );
    }
    return p;
}
void tab_write( char * p, int n )
{
    char * pp, * pk;
    pp = p;
    pk = p + n * sizeof( char );
    printf( "Imie : " );
    for( pp; pp < pk; pp = pp + sizeof( char ) )
    {
        printf( "%c", * pp );
    } printf( "\n" );
}
void add( struct blacklist * h )
{
    struct blacklist * p, * nowy;
    p = h;
    while( p->next != NULL )
    {
        p = p->next;
    }
    nowy =( struct blacklist * ) malloc( sizeof( struct blacklist ) );
    nowy->next = NULL;
   
    nowy->pImie = tab0( nowy->pImie, 5 );
    nowy->pImie = tab_pour( nowy->pImie, 5 );
    tab_write( nowy->pImie, 5 );
   
    p->next = nowy;
}
void del( struct blacklist * h, char * path )
{
    struct blacklist * p = h;
    while( p->next != NULL )
    {
        if( zwaz(( p->next )->pImie, path, 5 ) == 1 ) /* musimy mieć wskaźnik do elementu poprzedzającego */
        {
            blacklist * usuwany = p->next; /* zapamiętujemy usuwany element */
            p->next = usuwany->next; /* przestawiamy wskaźnik next by omijał usuwany element */
            free( usuwany ); /* usuwamy z pamięci */
        } else
        {
            p = p->next; /* idziemy dalej tylko wtedy kiedy nie usuwaliśmy */
        } /* bo nie chcemy zostawić duplikatów */
    }
}
void blacklist_write( struct blacklist * h )
{
    struct blacklist * p = h;
    while( p != NULL )
    {
        tab_write( p->pImie, 5 );
        p = p->next;
    }
}
int zwaz( char * p1, char * p2, int n )
{
    char * pp1, * pk1; pp1 = p1; pk1 = p1 + n * sizeof( char );
    char * pp2, * pk2; pp2 = p2; pk2 = p2 + n * sizeof( char );
    for( pp1; pp1 < pk1; pp1 = pp1 + sizeof( char ) )
    {
        if( * pp1 ==* pp2 ) { pp2 = pp2 + sizeof( char ); continue; } else return 0;
       
    } return 1;
}
void save( struct blacklist * h, char * path )
{
    struct blacklist * p = h;
    FILE * pfile;
    pfile = fopen(( char * ) path, "awb" );
    while( p->next != NULL )
    {
        fwrite( & p, sizeof( struct blacklist ), 1, pfile );
        p = p->next;
    } fclose( pfile );
}
int zwaz_plik( char * p )
{
    FILE * pfile;
    fpos_t size;
    pfile = fopen( p, "rb" );
    fseek( pfile, 0, SEEK_END );
    fgetpos( pfile, & size );
    printf( "Rozmiar pliku: %d\n", size );
    fclose( pfile );
    return( int ) size;
}
void read( struct blacklist * p, char * path )
{
    FILE * pfile = fopen( path, "rb" );
    struct blacklist * nowy;
    nowy->next = NULL;
    int n = zwaz_plik( "you.bin" ) / sizeof( struct blacklist );
    printf( "Ilosc struktur :  %d\n", n );
    for( int i = 0; i < n; i++ )
    {
        nowy =( struct blacklist * ) malloc( sizeof( struct blacklist ) );
        tab0( nowy->pImie, 5 );
        nowy->next = p->next;
        p->next = nowy;
    } blacklist_write( p );
    while( p->next != NULL )
    {
        fread( & p, sizeof( struct blacklist ), 1, pfile );
        p = p->next;
    } fclose( pfile );
} // I W tej funkcji jest problem jest pewnie na maksa skopana.
//funkcja miała na podstawie rozmiaru pliku tworzyć listę i wczytać do niej elementy
 Jak macie przykład jakiejś eleganckiej bazy danych opartych o listy to bym prosił o source do nauki.
P-101046
marcelpan
Temat założony przez niniejszego użytkownika
» 2014-01-04 16:18:12
Dziś zdziałałem taki kod. Wszystko jest ok tylko czemu ,dokleja mi śmieci do listy po odczytaniu. Powody mogą być dwa albo skopany read albo save. Obstawiam save ,bo skoro ładnie wczytuje śmieci.

C/C++
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
struct node
{
    int val;
    struct node * prev;
    struct node * next;
};
struct node * head = NULL;
struct node * tail = NULL;

void addhead_read();
void addhead( int p );
void addtail( int p );
void showhead();
void showtail();
void delete_tail();
void delete_head();
void save();
int main( int argc, char * argv[] )
{
    addhead( 1 );
    addhead( 2 );
    addhead( 3 );
    addhead( 4 );
    showhead();
    delete_head();
    delete_tail();
    save();
    showhead();
    addhead_read();
    showhead();
    free( head );
    free( tail );
    return 0;
}

void addhead( int p )
{
    if( head == NULL )
    {
        head =( struct node * ) malloc( sizeof( struct node ) );
        head->val = p;
        head->next = NULL;
        head->prev = NULL;
        tail = head;
    }
    else
    {
        node * pom =( struct node * ) malloc( sizeof( struct node ) );
        pom->val = p;
        pom->next = head;
        pom->prev = NULL;
        head->prev = pom;
        head = pom;
        pom = NULL;
    }
}
void addtail( int p )
{
    if( tail == NULL )
    {
        head =( struct node * ) malloc( sizeof( struct node ) );
        head->val = p;
        head->next = NULL;
        head->prev = NULL;
        tail = head;
    }
    else
    {
        node * pom = tail;
        pom->next =( struct node * ) malloc( sizeof( struct node ) );
        pom = pom->next;
        pom->next = NULL;
        pom->prev = tail;
        pom->val = p;
        tail = pom;
        pom = NULL;
    }
}
void showhead()
{
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        node * pom;
        pom = head;
        while( pom->next != NULL )
        {
            printf( "%d", pom->val );
            pom = pom->next;
        }
        printf( "%d", pom->val );
    }
    printf( "\n" );
}
void showtail()
{
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        node * pom;
        pom = tail;
        while( pom->prev != NULL )
        {
            printf( "%d", pom->val );
            pom = pom->prev;
        }
        printf( "%d", pom->val );
    }
    printf( "\n" );
}
void delete_tail()
{
    if( tail == NULL ) printf( "Pustak!" );
    else
    {
        node * pom;
        pom = tail;
        if( tail->prev != NULL )
        {
            tail = tail->prev;
            tail->next = NULL;
        }
        else
        {
            tail = NULL;
            head = NULL;
        }
        pom = NULL;
    }
}
void delete_head()
{
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        node * pom;
        pom = head;
        if( head->next != NULL )
        {
            head = head->next;
            head->prev = NULL;
        }
        else
        {
            tail = NULL;
            head = NULL;
        }
        pom = NULL;
    }
}
void save()
{
    FILE * pf = fopen( "sss.bin", "wb" );
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        node * pom;
        pom = head;
        while( pom->next != NULL )
        {
            pom = pom->next;
            fprintf( pf, "%d", & pom->val );
        }
        fprintf( pf, "%d", & pom->val );
    }
}
void addhead_read()
{
    FILE * pf = fopen( "sss.bin", "rb" );
    if( head == NULL )
    {
        head =( struct node * ) malloc( sizeof( struct node ) );
        fscanf( pf, "%d", & head->val );
        head->next = NULL;
        head->prev = NULL;
        tail = head;
    }
    else
    {
        node * pom =( struct node * ) malloc( sizeof( struct node ) );
        fscanf( pf, "%d", & head->val );
        pom->next = head;
        pom->prev = NULL;
        head->prev = pom;
        head = pom;
        pom = NULL;
    } fclose( pf );
}
P-101115
pekfos
» 2014-01-04 16:30:23
C/C++
while( pom->next != NULL )
{
    pom = pom->next;
    fprintf( pf, "%d", & pom->val );
}
fprintf( pf, "%d", & pom->val );
fprintf() przyjmuje wartość, a nie wskaźnik. Ponadto, nie zapisujesz pierwszego elementu, a ostatni 2 razy.
P-101119
marcelpan
Temat założony przez niniejszego użytkownika
» 2014-01-04 18:11:13
Chodziło ci o którąś z tych wersji ?? Czy ja cie nie rozumiem ?? Jeśli tak to nadal to samo, albo error.
C/C++
void save0()
{
    FILE * pf = fopen( "sss.bin", "wb" );
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        node * pom;
        pom = head;
        while( pom->next != NULL )
        {
            fprintf( pf, "%d", pom->val );
            pom = pom->next;
        }
        fprintf( pf, "%d", pom->val );
    }
}

void save1()
{
    FILE * pf = fopen( "sss.bin", "wb" );
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        int * a = 0;
        node * pom;
        pom = head;
        while( pom->next != NULL )
        {
            a =& pom->val;
            fprintf( pf, "%d", a );
            printf( "%d\n", a );
            pom = pom->next;
        } a =& pom->val;
        printf( "%d\n", a );
        fprintf( pf, "%d", a );
    }
}

void save2()
{
    FILE * pf = fopen( "sss.bin", "wb" );
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        int * a = 0;
        node * pom;
        pom = head;
        while( pom->next != NULL )
        {
            * a = pom->val;
            fprintf( pf, "%d", a );
            printf( "%d\n", a );
            pom = pom->next;
        } * a = pom->val;
        printf( "%d\n", a );
        fprintf( pf, "%d", a );
    }
}
void save3()
{
    FILE * pf = fopen( "sss.bin", "wb" );
    if( head == NULL ) printf( "Pustak!" );
    else
    {
        int a = 0;
        node * pom;
        pom = head;
        while( pom->next != NULL )
        {
            a = pom->val;
            fprintf( pf, "%d", a );
            printf( "%d\n", a );
            pom = pom->next;
        } a = pom->val;
        printf( "%d\n", a );
        fprintf( pf, "%d", a );
    }
}
P-101142
pekfos
» 2014-01-04 18:18:40
Większość nie ma sensu. Myśl nad tym, co robisz, zamiast produkować n wariantów.
C/C++
node * pom = head;

while( pom )
{
    fprintf( pf, "%d", pom->val );
    pom = pom->next;
}
P-101145
marcelpan
Temat założony przez niniejszego użytkownika
» 2014-01-04 18:50:30
C/C++
while( pom->next != NULL )
{
    fprintf( pf, "%d", pom->val );
    pom = pom->next;
}
fprintf( pf, "%d", pom->val );
Efekt jest ten sam co przy użyciu. Z tym ,że przy obu wersjach plik ma 2 bajty, czyli źle ,bo powinno być 8 bajtów, bo zapisuje dwa typy int. Więc co ja zapisuje do pliku tak w ogóle ?? U mnie wyświetla liczbę 3998688 w konsoli po dodaniu do listy.
C/C++
node * pom = head;

while( pom )
{
    fprintf( pf, "%d", pom->val );
    pom = pom->next;
}

 
P-101150
pekfos
» 2014-01-04 18:52:11
plik ma 2 bajty, czyli źle ,bo powinno być 8 bajtów, bo zapisuje dwa typy int.
Czyli dobrze. Nie tak się zapisuje dane binarnie.
P-101151
marcelpan
Temat założony przez niniejszego użytkownika
» 2014-01-04 18:54:45
No to wniosek skopana funkcja.
C/C++
void addhead_read()
{
    FILE * pf = fopen( "sss.bin", "rb" );
    if( head == NULL )
    {
        head =( struct node * ) malloc( sizeof( struct node ) );
        fscanf( pf, "%d", & head->val );
        head->next = NULL;
        head->prev = NULL;
        tail = head;
    }
    else
    {
        node * pom =( struct node * ) malloc( sizeof( struct node ) );
        fscanf( pf, "%d", & head->val );
        pom->next = head;
        pom->prev = NULL;
        head->prev = pom;
        head = pom;
        pom = NULL;
    } fclose( pf );
}
P-101152
« 1 » 2
  Strona 1 z 2 Następna strona