Newsgroup: it.comp.lang.c
Titolo: HELP ME!!! non so come fare!

Sono iscritto alla facoltà di Ingegneria di Bari e devo dare l'esame di
Informatica 2. Il prof.. ha chiesto il seguente programma da portargli fra
circa un mese ma le conoscenze di C del corso in toto sono scarse per varie
ragioni, sarei grato se qualcuno potesse aiutarmi:
    "Realizzare l'archivio dei nastri di una videoteca tramite una struttura
con le seguenti informazioni:
Titolo, Protagonista, Regista, data di produzione, numero di copie, numero
di copie affittate e relativi numeri di tessera di coloro che le hanno
affittate e data di inizio nolo (si consiglia l'uso di una lista
concatenata).
    Il tutto deve essere gestito utilizzando l'allocazione dinamica in RAM.
    Deve essere permessa una efficiente gestione dei dati stessi
(inserimento, modifica, salvataggio, visualizzazione della scheda di un dato
film per titolo, nome del protagonista o del regista). Realizzare quindi una
funzione che in fase di richiesta di affitto o di resa di un film tramite
titolo o protagonista, verifichi la possibilità del nolo e lo effettui
aggiornando i campi da modificare"
Grazie

concatenata).
Puoi prendere spunto dal sorgente seguente :
/****************** 
 * DBMS.C 
 * 09/02/2000
 * ---------------
 * Andrea Laforgia 
 ******************/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define FALSE   0
#define TRUE    1
#define DBFILE  "rubrica.db"
typedef FILE*  DBFilePtr ;
typedef int    bool ;
/* definisco la struttura del record */
typedef struct {
           bool deleted  ;
           char firstname[15] ;
           char lastname [15] ;
           char address  [20] ;
           char tel      [10] ;
        } record_t ;
void Message( const char * s )
{
     printf( "\n---> %s <--\n", s ) ;
}
bool GotoRecord( DBFilePtr P, long RecIdx )
{
     return fseek( P, RecIdx * sizeof( record_t ), SEEK_SET ) == 0 ;
}
bool OpenDatabase( char *DBName, DBFilePtr *P )
{
     return (( *P = fopen( DBName, "b+" ) ) != NULL ) ;
}
bool CreateDatabase( char *DBName, DBFilePtr *P )
{
     return (( *P = fopen( DBName, "wb+" ) ) != NULL ) ;
}
bool DatabaseExists( char *DBName )
{
     bool RetVal = FALSE ;
     FILE *fp ;
     if ( ( fp = fopen( DBName, "r" ) ) )
     {
        fclose( fp ) ;
        RetVal = TRUE ;
     }
     return RetVal ;
}
bool CloseDatabase( DBFilePtr P )
{
     return ( fclose( P ) != EOF ) ;
}
bool RewindDatabase( DBFilePtr P )
{
     return GotoRecord( P, 0L ) ;
}
bool GetRecord( DBFilePtr P, long RecIdx, record_t *RecBuffPtr )
{
     bool RetVal = FALSE ;
     if ( GotoRecord( P, RecIdx ) &&
          fread( RecBuffPtr, sizeof( record_t ), 1L, P ) > 0 )
        RetVal = TRUE ;
     return RetVal ;
}
bool PostRecord( DBFilePtr P, long RecIdx, record_t *RecBuffPtr )
{
     bool RetVal = FALSE ;
     if ( GotoRecord( P, RecIdx ) &&
          fwrite( RecBuffPtr, sizeof( record_t ), 1L, P ) > 0 )
        RetVal = TRUE ;
     return RetVal ;
}
bool AppendNewRecord( DBFilePtr P, record_t *RecBuffPtr )
{
     bool RetVal = FALSE ;
     if ( fseek( P, 0L, SEEK_END ) == 0 &&
          fwrite( RecBuffPtr, sizeof( record_t ), 1L, P ) > 0 )
     RetVal = TRUE ;
     return RetVal ;
}
bool ReadString( char *s, int max )
{
     bool RetVal = fgets( s, max, stdin ) != NULL ;
     if ( RetVal )
     {
        s[ strlen( s ) - 1] = NULL ;
     }
     return RetVal ;
}
char GetCh( void )
{
     int d, c = getchar() ;
     d = c ;
     while ( ( d != -1 ) && ( d != '\n' ) )
     {
           d = getchar() ;
     }
     return c ;
}
void ShowMainMenu()
{
     printf( "\nEsempio di gestione di database\n\n" ) ;
     printf( "Opzioni :\n\n" ) ;
     printf( "1 - Inserimento record\n" ) ;
     printf( "2 - Visualizzazione record\n" ) ;
     printf( "3 - Modifica record\n" ) ;
     printf( "4 - Cancellazione record\n" ) ;
     printf( "9 - Fine operazioni\n\n" ) ;
     printf( ">" ) ;
}
void ShowRecords( DBFilePtr P )
{
     long RecIdx = 0L ;
     record_t MyRec ;
     printf( "\n" ) ;
     printf( "num canc nome cognome    indirizzo       telefono\n" ) ;
     printf( "---|----|---------------|---------------"\
             "|--------------------|----------|\n" ) ;
     while ( GetRecord( P, RecIdx, &MyRec ) )
     {
         printf( "%3ld|%-4s|%-15s|%-15s|%-20s|%-10s|\n",
                                                 RecIdx,
                                                 MyRec.deleted ? "*":
"",
                                                 MyRec.firstname,
                                                 MyRec.lastname,
                                                 MyRec.address,
                                                 MyRec.tel ) ;
         RecIdx++ ;
     }
     if ( RecIdx == 0L )
        Message( "il database e' vuoto !" ) ;
}
void AskNewRecord( record_t *RecBuffPtr )
{
     RecBuffPtr->deleted = FALSE ;
     printf( "Nome      : " ) ; ReadString( RecBuffPtr->firstname,
                                       sizeof RecBuffPtr->firstname )
;
     printf( "Cognome   : " ) ; ReadString( RecBuffPtr->lastname,
                                       sizeof RecBuffPtr->lastname ) ;
     printf( "Indirizzo : " ) ; ReadString( RecBuffPtr->address,
                                       sizeof RecBuffPtr->address ) ;
     printf( "Telefono  : " ) ; ReadString( RecBuffPtr->tel,
                                  sizeof RecBuffPtr->tel ) ;
}
void InsertNewRecord( DBFilePtr P )
{
     record_t MyRec ;
     AskNewRecord( &MyRec ) ;
     if ( AppendNewRecord( P, &MyRec ) )
        Message( "record inserito con successo !" ) ;
     else
        Message( "errore nell'aggiunta del record !" ) ;
}
void ModifyRecords( DBFilePtr P, bool MustDelete )
{
     record_t MyRec ;
     long RecIdx ;
     char num[10] ;
     ShowRecords( P ) ;
     printf( "inserire l'indice del record :" ) ;
     ReadString( num, 5 ) ;
     RecIdx = atol( num ) ;
     if ( MustDelete &&
          GetRecord( P, RecIdx, &MyRec ) )
     {
        MyRec.deleted = TRUE ;
     }
     else AskNewRecord( &MyRec ) ;
     if ( PostRecord( P, RecIdx, &MyRec ) )
     {
        Message( "record modificato con successo !" ) ;
     }
     else Message( "impossibile modificare il record !" ) ;
}
void DeleteRecords( DBFilePtr P )
{
     ModifyRecords( P, TRUE ) ;
}
int main()
{
    DBFilePtr DataPtr ;
    char scelta ;
    if ( DatabaseExists( DBFILE ) &&
         OpenDatabase( DBFILE, &DataPtr ) )
    {
       Message( "file database aperto con successo !" ) ;
    }
    else
    if ( !CreateDatabase( DBFILE, &DataPtr ) )
    {
       Message( "errore nell'apertura del file database !" ) ;
       exit( 1 ) ;
    }
    else Message( "file database creato e aperto con successo !" ) ;
    do
    {
       ShowMainMenu() ;
       scelta = GetCh() ;
       switch( scelta )
       {
             case '1' : InsertNewRecord( DataPtr ) ; break ;
             case '2' : ShowRecords( DataPtr ) ; break ;
             case '3' : ModifyRecords( DataPtr, FALSE ) ; break ;
             case '4' : DeleteRecords( DataPtr ) ; break ;
       }
    } while ( scelta != '9' ) ;
    if ( !CloseDatabase( DataPtr )  )
    {
       Message( "errore nella chiusura del file database !" ) ;
       exit( 1 ) ;
    }
    return 0 ;
}
--
Andrea Laforgia (
andrea_...@bigfoot.com
)
---------------------------------------------

 ..... sarei grato se qualcuno potesse aiutarmi.....
#include<stdio.h>
#include<stdlib.h>
Questo e' il mio contributo.
E' piu' forte di me, non so mai tirarmi indietro davanti ad una richiesta
d'aiuto.
Ivan Molella

...



Direi che è più corretto così:
int main(void) {
    returno 0;
}
Per quanto riguarda l'allocamento dinamico dovrai imparare a usare le malloc
e le calloc.
Che tipo di compilatore usi?
La classica struttura di una lista è questa:
typedef struct lista {
                tipo_campo1 campo1;
                tipo_campo2 campo2;
                ...................................
               tipo_campoN campoN;
                struct lista *prossimo
                } lista;
In questo modo definisco un tipo lista e posso creare variabili di tipo
lista.
Per esempio posso fare:
lista *testadilista;
La variabile testadilista è definita come un puntatore ad un elemento di
tipo lista.
La prima operazione sarà allocare il primo elemento della lista:
testadilista=(lista*)malloc(sizeof(lista));
In questo modo testadilista punta ad un elemento di tipo lista
effettivamente allocato.
Ora posso variare i campi del primo elemento della lista:
(*testadilista).campo1=xxxxxx;
(*testadilista).campoN=ggggggg;
(*testadilista).prossimo=NULL;
Se devo allocare un nuovo elemento nella lista farò semplicemente:
(*testadilista).prossimo=(lista*)malloc(sizeof(lista));
Se devi scorrere gli elementi ti conviene tenere testadilista fisso sul
primo elemento e usare un altro puntatore a lista:
lista *scorrilista;
Il classico ciclo è questo:
for(scorrilista=testadilista;scorrilista!=NULL;scorrilista=(*scorrilista).pr
ossimo)
 {
esegui le operazioni sugli elementi
}
Direi che non c'è nulla di complicato.
Ricordati che un puntatore a un tipo NON è quel tipo. Così testadilista o
scorrilista NON sono elementi di tipo lista ma sono semplicemente dei
puntatori a un tipo lista.
Il tipo lista può esistere o meno, però testadilista e scorrilista sono lì
buoni buoni pronti per contenere nella loro cella di memoria l'indirizzo
dell'elemento lista che andranno a puntare. L'elemento lista va allocato e
il suo riferimento in memoria va posto nel puntatore.
Buon lavoro,
giovann...@libero.it


Ma prima potrebbe anche servire qualcosa tipo:
#include <string.h>
e poi suggerirei piuttosto un bel:
int main (void)
{
}
Va beh, stiamo degenerando.
Ciao,
Zeppe