Simplification - Page 2

Tu devrais vraiment regarder les iostream. C'est la façon standard de manipuler des flux en C++.
Ca ferait moins bricolage que ton truc

zofstream fichier("truc.gz");
fichier <<"Salut" <<endl;

ou encore

void compresse(const string & apres, const string & avant)
{
    ifstream normal(avant);
    zofstream reduit(apres);
    reduit <<normal.rdbuf();
}

Evidemment, la classe zofstream, c'est à toi de l'implémenter (ou d'en trouver une existante... perso j'ai la mienne mais il en existe pas mal...même si elles sont toutes fonctionnellement quasi identiques).

C'est pas plutôt le streambuf, qu'il faudrait redéfinir ?

Sisi, mais tu crées aussi un stream autour. Très simple en réalité, il se contente d'encapsuler le stream standard, en lui passant un streambuf différent.
Mais si tu crées pas un stream qui va bien, t'es obligé de laisser cette opération à l'utilisateur de ton code, et c'est franchement moche.

je comprends pas trop ce que tu veux dire quand tu dis que mon truc ça fait bricolage?
Je reprend quasiment la même façon de procéder qu'avec les FILE et gzFile classiques.
L'utilisateur n'a qu'à préciser FILEIO_normal, FILEIO_gzip ou FILEIO_bzip selon ce qu'il désire au moment d'ouvrir le fichier. Il peut décider du niveau de compression (w-1 pour choix auto, w0 pour aucune compression et w9 pour le max)
il utilise ensuite "read", "write", "tell" et seek" pour les entrées et sorties.

je viens de rajouter l'opérateur >>, il suffit de faire
*fichier >> "un truc";pour écrire dans le fichier ce qui simplifie
fichier->wrtie("un truc",strlen("un truc"));Quoi de plus simple???

Je parle pas d'avoir un opérateur >>
Je parle de suivre les conventions normales d'entrées-sorties du C++.

T'as déjà dû entendre parler de ifstream, ofstream et compagnie non ?


Un autre exemple où ce que t'as fait ne va pas marcher (j'en ai déjà donné un dans mon post précédent mais t'en as pas tenu compte ) :

class Bidule {
           ostream & sortie;
    static unsigned compteur;

public:
    Bidule(ostream & s) : sortie(s) {compteur = 0;}
    void fairequelquechose() {
        machin();
        sortie <<"je viens de faire machin " <<width(3) <<++compteur <<" fois" <<endl;
    }
};
unsigned Bidule::compteur = 0;

int main() {
    Bidule a(cout);                   // Un bidule qui écrit sur la sortie standard
    a.machin();

    ofstream fichier("truc");         // Un bidule qui écrit dans le fichier truc
    Bidule b(fichier);
    b.machin();

    ostringstream chaine;             // Un bidule qui écrit dans une chaine de caractères
    Bidule c(chaine);
    c.machin();

    zofstream compresse("truc.gz");   // Un bidule qui écrit compressé dans le fichier truc.gz
    Bidule d(compresse);
    d.machin();
}

spectras :
Je parle pas d'avoir un opérateur >>
Je parle de suivre les conventions normales d'entrées-sorties du C++.

T'as déjà dû entendre parler de ifstream, ofstream et compagnie non ?

Oui j'ai déjà vu les fstream. Mais quels avantages ai-je à les utiliser? je ne veux écrire que dans des fichiers
fopen (ou gzopen) me suffit pour l'ouverture en lecture ou écriture des fichiers. En plus par rapport à ce que je veux faire c'est plus pratique : j'utilise un void *fichier; et je le passe en argument avec (FILE*)fichier ou (gzFile)fichier selon le cas.
Ton exemple propose d'écrire dans cout, une chaine ou des fichiers. Les 2 premiers ne m'interressent pas. Je vois mal des données binaires sortir avec cout.

Avantage des fstream ?
Bah vu que c'est la facon de gerer des fichiers en C++, t'as tout ce qui est exception etc. (et la surcharge d'operateurs est quand mm pas mal sympa).

Enfin, c'est quand mm vachement plus simple de faire: myFile << myClass; plutot que de se faire chier avec fopen/fwrite/fclose et dans tous les cas, comme dit Spectras, c'est la facon normale de le faire en C++.
Une classe c'est pas pour faire joli ou un simple conteneur... y'a les structures de C pour ca, c'est quand meme avant tout pour *simplifier* le developpement en adoptant une structure objet.

Vu que s'est pour être utilisé dans une fonction répétée des milliers de fois, ça ne risque pas d'être "moins performant" que les fopen & co?
Par contre je suis d'accord sur le fait que les << sont pratiques. Mais pour des données binaires?

Considerablement moins performant, ca m'etonnerait pas mal.

OK je vais me remettre dessus alors

Les performances sont équivalentes. C'est juste que le C présente un jeu de fonctions, alors que le C++ présente un jeu d'objets.
A mon avis, les fonctions C auraient dû être supprimées du C++ ça aurait sûrement évité pas mal de programmes "hybrides".
Je pense notamment à fopen/fread/fwrite/strlen/strcpy/strcat/printf....

Pour les données binaires, les flux C++ sont génériques. Autrement dit, toi tu t'occupes d'implémenter le flux qui compresse. La gestion des <<, du binaire / caractère / etc c'est pas toi qui la fait, c'est un autre objet standard C++ qui va s'interfacer avec le tien.

OK je m'amuse un peu avec les stream et c'est vrai que ça simplifie énormément les tâches.
Par contre j'avoue que je n'ai pas percuté comment les utiliser avec la lib tar (le but étant de lire/écrire des fichiers .tar.gz)
Mon IA avance à grands pas, il me reste encore 2,3 trucs dont le format de fichier et là je bloque...

Y'a pas un wrapper C++ qui existe pour la lib tar ? Ca te faciliterait grandement la vie (quoique ca doit pas etre bien dur a faire...)

Je n'en ai pas trouvé pour les fichiers TAR, seulement pour les GZ : gzstream (encore que je ne comprends pas pourquoi j'ai les erreur "référence indéfinie vers ..." alors que la lib est bien incluse, je compile sans pb les exemples mais pas mon projet?!??)
Pour le moment je n'utilise que les ofstream et ifstream, j'ai viré tous les FILE fopen, fclose et autres

J'en avais fait un mais je l'utilise plus, et il ne compile plus avec gcc4. Je devais utiliser par mégarde un des problèmes de protection de gcc.
Faudrait que je le refasse, surtout qu'il était assez élégant. Il était construit sous forme d'un conteneur de flux. Tu énumerais les flux avec un itérateur.

En utilisation ça donnait qqc comme

itarstream foo("bar.tar");
for (itarstream::const_iterator it = foo.begin(); it != foo.end(); ++it)
{
    istream & file = it->stream();
    cout <<"Fichier " <<it->name() <<" :\n" <<file.rdbuf() <<endl;
}

(remarque : l'iterator de itarstream est de type input_iterator)

Ton code m'interresse, je veux bien tenter de le porter sur gcc4 (si les sources sont dispo)
J'ai les sources de gzstream pour m'aider à comprendre comment faire (j'en ai jamais fait) mais un petit coup de pouce est toujours le bienvenue!