Newsgroup: it.comp.lang.c++
Titolo: Problemi con i file...

Qualcuno saprebbe darmi delucidazioni sulla gestione di file in c++ (
fopen(), fclose(), ecc. ) mi basterebbe sapere cosa gli devo passare e
un po' come funzionanao. Inoltre vorrei sapere come funziona memcpy() e
se è rischioso creare dei buffer con dei puntatori, non sapendo dove
puntano ( se si come fanno a fare tali buffer??? ).
Forse chiedo un po' troppo, ho cercato un po' ovunque, tranne in un
libro da 80.000 £.
Ringrazio e chiedo scusa. CiozZ!!!

Ringrazio e chiedo scusa. CiozZ!!!
Non basta di certo questo post per rispondere alle tue domande...
Il mio consiglio e' quello di comprarti un libro sul C/C++ e cominciare
da quello.
Come in linea di massima per usare i file hai due possibilita'
1) attraverso le funzioni fopen, fclose, fwrite e compagnia bella
2) attraverso l'oggetto fstream (solo C++)
Le prestazioni dovrebbero essere equivalenti (entrambi usano la cache)
il secondo e' preferibile (ma non obbligatorio) se sviluppi una classe.
**********************************************
NAME
       memcpy - copy memory area
SYNOPSIS
       #include <string.h>
       void *memcpy(void *dest, const void *src, size_t n);
DESCRIPTION
       The  memcpy() function copies n bytes from memory area src
       to memory area dest.  The memory areas  may  not  overlap.
       Use memmove(3) if the memory areas do overlap.
RETURN VALUE
       The memcpy() function returns a pointer to dest.
*************************************************
Non e' assolutamente rischioso utilizzare i puntatori, la potenza del C
sta proprio nei puntatori, richiedono solamente un po' di pratica.
Ciao

 libro da 80.000 £.
Forse è il caso che tu dia una letta a quel libro... :-)
EMG

 puntano ( se si come fanno a fare tali buffer??? ).
Intendi con malloc?  Di nuovo, it.comp.lang.c.
Alex

puntatori in C++ richiede spesso l'uso di strumenti ausiliari (se
Ok, Ok scusa, sono conscio anchio della complessita' dei puntatori
e mi sono espresso male....
cambio da "richiedono solamente un po' di pratica"
in "richiedono solamente qualche annetto di pratica" :)
Certo che cosi' suona diverso!
Ciao David

in "richiedono solamente qualche annetto di pratica" :)
Non esageriamo... ci vuole pratica e attenzione, ma non
sono chissa` cosa.
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

 sono chissa` cosa.
Sono "soltanto" la causa piu` frequente di errori di codifica
in C e C++... che altro vorresti?-)
Alex

in C e C++... che altro vorresti?-)
Non lo metto in dubbio... lo noto anche dai messaggi sul NG...
ma non ritengo ci vogliano anni per imparare a usarli, magari
diverse settimane, al piu` qualche mese.
Poi con  qualche sana abitudine (compreso evitare di riscoprire
l'acqua calda) molti di questi errori spariscono...


 l'acqua calda) molti di questi errori spariscono...
Spariscono se ed in quanto i puntatori non si usano (se non
come codice a bassissimo livello, parte di componenti di piu`
alto livello semantico, sviluppato e testato con 10-20 volte
piu` tempo-per-riga del codice applicativo "normale": esempi
cruciali, std::string, std::vector, std::list, e compagnia).
Purtroppo, questo obbiettivo in C++ non si puo` raggiungere
al 100%; restano sempre molti casi in cui i puntatori vanno
usati, magari con un 'incapsulamento sottile sottile' come
quelli offerti da std::auto_ptr o std::vector::iterator.
Questi usi (_relativamente_ rari, _molto_ cauti, e con tutte le
buone abitudini che vuoi) restano nella mia esperienza la
piu` frequente causa di errori di codifica in C++, anche per
programmatori C++ espertissimi e bravissimi; anche perche`
i compilatori al giorno d'oggi ti avvertono di tante altre cosette
che potrebbero altrimenti candidarsi al titolo poco ambito di
"piu` frequente causa di errori di codifica", come if(a=b)
invece di if(a==b), variabili non inizializzate, et similia.
L'unica causa di errore che ho visto _avvicinarsi_ (senza
raggiungerlo) all'uso (anche limitatissimo...) dei puntatori,
e` l'uso "garibaldino" degli overload (soprattutto in unione
alle conversioni automatiche): ma quest'ultimo e` una
"malattia infantile", dovuta all'entusiasmo iniziale per queste
cose che SEMBRANO tanto belle -- con l'esperienza si viene
a capire che gli overload e le conversioni implicite sono dei
MALI NECESSARI e si impara quindi a MINIMIZZARNE l'uso
nei propri progetti (usando explicit per ogni costruttore che
ha un singolo parametro, usando nomi diversi come
getPippo e putPippo per accessori e mutatori invece del
brutto vezzo di farne due overload del singolo metodo
pippo, eccetera, eccetera); e a questo punto gli errori
di codifica dovuti ad overload e conversioni calano molto.
Gli errori dovuti all'uso dei puntatori non calano sotto una
certa soglia X; in effetti, la principale causa dell'aumento
di produttivita` che si osserva passando da C++ a Java e`
proprio l'aver tolto DEL TUTTO di mezzo i puntatori.
Se non sei d'accordo sulla mia osservazione che l'uso dei
puntatori e` la principale causa di errori di codifica in C++
(anche nell'uso di programmatori esperti e scafatissimi), ti
chiedo con curiosita` QUALE caratteristica del linguaggio
tu hai invece osservato essere questa "principale causa".
Alex

tu hai invece osservato essere questa "principale causa".
Attualmente sono in guerra con del codice (C) in cui si e`
fatto un massiccio uso di macro e che interagisce male
con gli header di windows...
Ho inoltre 134 warning sparse del tipo "comparing signed
with unsigned value", e un massicio uso di cast.


 di disporre di una discreta libreria di contenitori.
...ed _incapsulamenti_ dei puntatori per altri casi, sia
standard (std::auto_ptr) sia custom -- tutti questi strumenti,
e la determinazione di usare puntatori solo quando nessuna
alternativa e` preferibile (che secondo me viene proprio
dal "timore" *necessario*:-) aiuta a minimizzarne l'uso, e
quindi gli errori che ne conseguono.
Alex