Concaténation de 2 fichiers txt

Version imprimable

bonjour,
je voudrais savoir comment lire 2 fichiers txt avec ofstream ou autre méthode
et concatener les 2 en un seul fichier txt

j'ai trouvé ça

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
int main()
{
int a;
double b;
char c;
int t1[6];
string s;
int i;
ifstream f("toto.txt");
 
if(!f.is_open())cout<<"Impossible d'ouvrir le fichier en lecture !"<<endl;
else
   {
   f>>a>>b>>c;
   for(i=0;i<6;i++)f>>t1[i];
   f>>s;
   }
f.close();
cout<<"a="<<a<<endl;
cout<<"b="<<b<<endl;
cout<<"c="<<c<<endl;
for(i=0;i<6;i++)cout<<t1[i]<<endl;
cout<<s<<endl;
return 0;
}

mais ça marche pas
merci

28/05/2008, 16h20
homeostasie

Citation:

je voudrais savoir comment lire 2 fichiers txt avec ofstream ou autre méthode
et concatener les 2 en un seul fichier txt

Tu veux le faire en C ou en C++? Car là, tu es partie sur du C++ et si c'est bien ton choix, ce n'est pas le bon forum!

c pas grave, en c ou c++
les deux me convient
j'ai trouvé aussi cette fonction:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
//une fonction qui recopie un fichier dans un autre :
 
int copiefichier(char *dest, char *srce)
// copie le fichier srce dans dest
// renvoie 1 si ok, 0 sinon
{
     ifstream fi(srce, ios::in|ios::binary);
     if (!fi) return 0;        // srce impossible à lire
     ofstream fo(dest, ios::out|ios::binary);
     if (!fo) return 0;
     char tampon;
     while ( fo && fi.get(tampon) )
           fo.put(tampon);
     return fo.good() && fi.eof();
}

mais je sais pas encore comment faire!!

28/05/2008, 16h29
JeromeBcx

Même si ce n'est pas le bon forum (fais déplacer le sujet dans la rubrique appropriée) :

L'exemple présenté ne fait pas de concaténation, il lit simplement un fichier et réalise l'affichage dans la sortie standard.

Pour concaténer 2 fichiers dans un 3ème, il faut trois flux :
2 flux pour les fichiers sources en mode lecture, et un flux en mode écriture pour le fichier de destination.
Après tout dépend de la stratégie de concaténation et du type de donnés à manipuler.

Mais si le but et de faire fichier3 = fichier1 puis fichier 2, il y a surement plus efficace que les flux (on a pas forcément besoin de "lire" le contenu des fichiers mais seulement de copier les datas brutes (pas besoins de les intépréter suivant leur type))

[EDIT] Ma réponse arrive avec un message de retard ... [/EDIT]

Qu'est ce qui ne va pas avec cette nouvelle fonction ?
Elle copie le contenu du fichier 1 à la suite du contenu du fichier 2.
28/05/2008, 16h33
fatjoe

1- je le déplace ou?
2- en fait je veux juste copier le contenu de mes fichiers(2 ou plus) dans un autre fichier
merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
//une fonction qui recopie 2 fichiers dans un 3ème (nouveau) :
 
int copiefichier(char *dest, char *srce1, char *srce2)
// copie le fichier srce dans dest
// renvoie 1 si ok, 0 sinon
{
     ifstream fi1(srce1, ios::in|ios::binary);
     if (!fi1) return 0;        // srce1 impossible à lire
 
     ifstream fi2(srce2, ios::in|ios::binary);
     if (!fi2) return 0;        // srce2 impossible à lire
 
     ofstream fo(dest, ios::out|ios::binary);
     if (!fo) return 0;
 
     char tampon;
     while ( fo && fi1.get(tampon) )
           fo.put(tampon);
 
     while ( fo && fi2.get(tampon) )
           fo.put(tampon);
 
 
 
     return fo.good() && fi1.eof() && fi2.eof();
}

Quelques chose du genre devrait marcher...

et j'écrit ou les nom de fichiers?
en plus j'ai beaucoup de fichiers et non pas seulement 2
j'ai juste dit 2 comme exemple.
mes fichiers dans des repertoire différents mais je connais les noms de répertoire et les noms de fichiers sont tous nommé f1.txt

j'ai trouvé ça mais ça marche pas je sais pas pourquoi
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 #include <fstream> // std::ifstream, std::ofstream #include <string> // std::string, std::getline() #include <iostream> // std::endl int main () { std::ifstream ifs ("toto.txt"); std::ofstream ofs ("t.txt"); std::string s; // la lecture d'une std::string dans un flux avec std::getline() s'arrête au premier // changement de ligne, mais ne conserve pas ce caractère dans la chaîne lue; cela // explique pourquoi on insère changement de ligne «artificiel» entre chaque // chaîne en sortie. while (std::getline (ifs, s)) ofs << s << std::endl; }
ya plein de code mais ça marche pas
http://h-deb.clg.qc.ca/Sujets/AuSeco...#copier-lignes

28/05/2008, 17h03
JeromeBcx

Si, les exemples présentés marchent... ce sont juste des méthodes différentes...
qu'il faut évidement adapter à ton problème.

Tu as le mécanisme pour lire un fichier, un pour écrire dans un fichier, il faut juste trouver l'enchainement pour réaliser la concaténation de tous tes fichiers.

Le principe :
tant que fichiers à concaténés,
copier le contenu dans fichier destination.

Essaie de trouver l'architecture qui va bien, présente la nous et on te guidera le cas échéant.

Bonne chance.
28/05/2008, 17h10
fatjoe

mais les exemples ne marche pas chez moi
28/05/2008, 17h24
JeromeBcx

Heum.... Effectivement ils ne marchent pas, ils fonctionnent ou ne fonctionnent pas... Comment veux tu que l'on t'aide avec un post comme ça

Citation:

ça marche pô...

Si tu ne donnes pas plus de détails, on pourrais y passer des heures.
Choisi d'abord une des techniques que tu as trouvé et essaie de comprendre ce qu'elle fait. Après tu pourras revenir, et on pourra surement t'aider.

Fais du pas à pas, en mode débug, détecte ce qui ne va pas (le nom des fichiers par exemple, ...)

Bon courage...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
#include <fstream>   // std::ifstream, std::ofstream
#include <string>    // std::string, std::getline()
#include <iostream>  // std::endl
int main ()
{
   std::ifstream ifs ("In.txt");
   std::ofstream ofs ("Out.txt");
   std::string s;
   // la lecture d'une std::string dans un flux avec std::getline() s'arrête au premier
   // changement de ligne, mais ne conserve pas ce caractère dans la chaîne lue; cela
   // explique pourquoi on insère changement de ligne «artificiel» entre chaque
   // chaîne en sortie.
   while (std::getline (ifs, s))
      ofs << s << std::endl;
}

ça marche
mais comment je fait pour copier plusieurs fichiers?
la boucle se fait comment?
merci

Citation:

Envoyé par fatjoe

ça marche
mais comment je fait pour copier plusieurs fichiers?
la boucle se fait comment?
merci

;) Ah, On avance....
Bon pour la partie copie de plusieurs fichiers.
D'après les messages précédent, tu veux copier plusieurs fichiers avec le même nom mais dans un répertoire différent du style :
[Moncheminversmondossierprincipal]/MondossierX/f1.txt
Avec MondossierX variant.
2 possibilités pour MondossierX : soit ils sont construits suivant une règle simple et il est possible de les retrouver dynamiquement (ce qui serait le mieux !!!) soit ils ont des noms à la :traine: et la il va falloir fournir au soft la liste (dans un fichier ?, en dur ? mais là c'est :fessee:) ...

Maintenant, détectons les choses qui sont redondantes dans le système :
La copie d'un fichier dans un autre :
Il faut donc créer une fonction, qui à partir d'un nom de fichier d'entré (les fichiers à concaténer et d'un flux de fichier de sortie (le fichier de destination), copie le contenu du fichier d'entré dans le fichier de destination.

Donc voici une idée pour l'algorithme :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 //PSEUDOCODE main() { std::ofstream ofs("NomDuFluxDeSortie"); Tantque desfichiersacopier faire { lefichieracopier = Creationdunomfichier(); // Ici modification du nom du répertoire //Appel de la fonction de copie LafonctionDeCopie( lefichieracopier, ofs); } }; // LA fonction de copie LafonctionDeCopie( std::string lefichieracopier, std::ofstream& outputf) { std::ifstream ifs (lefichieracopier); while (std::getline (ifs, s)) outputf<< s << std::endl; }
REMARQUE : Le code tel quel ne marche pas hein ! il faut que tu t'en serves de trame. Penches toi un peu dessus puis revient si tu as des points bloquants.

Bonne chance