Se connecter avec
S'enregistrer | Connectez-vous

[C++] Boucle folle

Dernière réponse : dans Programmation

Bonjour,

Le but de mon programme est de tester la présence d'une ligne d'un fichier dans un autre.
Si celle-ci n'existe pas dans le second fichier, je l'écrit dans un troisième fichier.

Apparemment, mon programme ne s'arrête pas à la fin du fichier, d'où une boucle folle qui m'écrit toutes les lignes dans mon troisième fichier.


Toute aide est la bien venue.


PS: J'ai essayer de remplacer les
  1. tabcli[1]==tabcli2[1]


par
  1. (strcmp(tabcli[1], tabcli2[1])=0)
  2.  
  3. ou
  4.  
  5. !strcmp(tabcli[1], tabcli2[1])



Mais ça ne marche pas.

Autres pages sur : boucle folle

Lassé par la pub ? Créez un compte

J'ai modifier mon code, parce qu'il y avait pas mal d'erreur, mais j'ai toujours le même problème.
Donc à votre demande je le poste sur le forum.

  1. //##########Bibliothèques##########
  2.  
  3. #include<iostream>
  4. #include<fstream>
  5. #include<io.h>
  6. #include<string>
  7. #include<cstring>
  8. #include<sstream>
  9.  
  10. using namespace std;
  11. //##########Types##########
  12.  
  13. typedef char chaine[1000];
  14.  
  15. std::fstream fic;
  16.  
  17. std::fstream fic2;
  18.  
  19. std::fstream fic3;
  20.  
  21. typedef string tclient[62];
  22.  
  23. //##########Prototypage##########
  24.  
  25. void decoupage(tclient, chaine);
  26.  
  27. void ecriture(tclient);
  28.  
  29.  
  30. //##########Programme principal##########
  31.  
  32. void main(void)
  33. {
  34. 	bool trouve;
  35. 	int k = 0;
  36. 	int m = 0;
  37. 	tclient tabcli;
  38. 	tclient tabcli2;
  39. 	chaine cli, cli2;
  40. 	int i;
  41.  
  42. 	fic.open("mmlcomplet.csv",ios::in);
  43. 	if(!fic)
  44. 	{
  45. 		std::cout<<"ouverture mmlcomplet impossible";
  46. 	}
  47. 	else
  48. 	{
  49. 		if(!fic.eof())
  50. 		{
  51. 			fic3.open("extraction.csv",ios::out); 
  52. //ya un problème avec idn  c'est "out"  normalement
  53. 			if(!fic3)
  54. 			{
  55. 				std::cout<<"ouverture extraction impossible";
  56. 			}
  57. 			else
  58. 			{
  59. 				do
  60. 				{
  61. 					trouve = false;
  62. 					fic.getline(cli,sizeof(chaine));
  63. 					decoupage(tabcli, cli);
  64. 					fic2.open("mmlmauvais.csv",ios::in);
  65. 					do
  66. 					{
  67. 							fic2.getline(cli2,sizeof(chaine));
  68. 							m++;
  69. 							std::cout<<"lecture de l'enregistrement "<<m<<"\n";
  70. 							decoupage(tabcli2, cli2);
  71. 							if(tabcli[1]==tabcli2[1] && tabcli[3]==tabcli2[3] && 
  72. 								  tabcli[6]==tabcli2[6] && tabcli[7]==tabcli2[7])
  73. 							{
  74. 								std::cout<<"enregistrement trouvé"<<"\n";
  75. 								trouve = true;
  76. 							}
  77. 					}while(!fic2.eof());
  78. 					fic2.close();
  79. 					if(!trouve)
  80. 					{
  81. 						ecriture(tabcli);
  82. 						k++;
  83. 						std::cout<<k<<" enregistrement écrit!!!!!!!!!!!!!!!!!!!"<<"\n";
  84. 					}
  85. 				}while(!fic.eof());	
  86. 				fic.close();
  87. 				fic3.close();
  88. 			}
  89. 		}
  90. 		else
  91. 		{
  92. 			std::cout<<"mmfcomplet vide";
  93. 		}
  94. 	}
  95. 	fic.close();
  96. 	fic2.close();
  97. 	std::cin>>i;
  98. }
  99.  
  100.  
  101.  
  102.  
  103.  
  104. //##########sous-programmes##########
  105.  
  106. void decoupage(tclient tab, chaine cli)
  107. {
  108.  
  109. 	int i;
  110. 	std::string string1 = cli;
  111.     std::string string2;
  112.  
  113.     for(i=0;i<61;i++)
  114.     {
  115.         string2 = string1.substr(0, string1.find(';'));
  116.         string1 = string1.substr(string1.find(';')+1);
  117. 		tab[i]=string2;
  118. 		//std::cout<<string2;
  119.  
  120.     }
  121. }
  122.  
  123.  
  124. void ecriture(tclient tab)
  125. {
  126. 	int i;
  127. 	std::string concat = "";
  128.  
  129. 	for(i=0;i<57;i++)
  130. 	{
  131. 		concat=concat+tab[i]+';';
  132. 	}
  133. 	concat=concat+"\n";
  134. 	//std::cout<<concat;
  135. 	fic3<<concat;
  136.  
  137. }




  1. string cli, cli2;
  2. .....
  3.  
  4. do
  5. {
  6. 	trouve = false;
  7. 	getline(fic, cli);							
  8. 	decoupage(tabcli, cli);
  9. 	fic2.seekp(0);
  10. 	do
  11. 	{
  12. 			getline(fic2, cli2);
  13. 			m++;
  14. 			std::cout<<"lecture de l'enregistrement "<<m<<"\n";
  15. 			decoupage(tabcli2, cli2);
  16. 			if(tabcli[1]==tabcli2[1] && tabcli[3]==tabcli2[3] && tabcli[6]==tabcli2[6] && tabcli[7]==tabcli2[7])
  17. 			{
  18. 				std::cout<<"enregistrement trouvé"<<"\n";
  19. 				trouve = true;
  20. 				break;
  21. 			}
  22. 	}while(!fic2.eof());
  23. 	if(trouve)
  24. 	{
  25. 		ecriture(tabcli);
  26. 		k++;
  27. 		std::cout<<k<<" enregistrements écrit!!!!!!!!!!!!!!!!!!!"<<"\n";
  28. 	}


Adapte ton code aux cli1 et 2 qui sont en string, pas besoin de char[1000] qui peut poser probleme si trop court.

Pour la boucle tu oublie de revenir au debut du fichier fic2.

J'ai remis le code plus ou moins comme il était parce que les getline(fic, cli) ne remplissait pas les variables.

Donc je résume, avec ce code : 
  1. //##########Bibliothèques##########
  2.  
  3. #include<iostream>
  4. #include<fstream>
  5. #include<io.h>
  6. #include<string>
  7. #include<cstring>
  8. #include<sstream>
  9.  
  10. using namespace std;
  11. //##########Types##########
  12.  
  13. typedef char chaine[1000];
  14.  
  15. std::fstream fic;
  16.  
  17. std::fstream fic2;
  18.  
  19. std::fstream fic3;
  20.  
  21. typedef string tclient[62];
  22.  
  23. //##########Prototypage##########
  24.  
  25. void decoupage(tclient, string);
  26.  
  27. void ecriture(tclient);
  28.  
  29.  
  30. //##########Programme principal##########
  31.  
  32. void main(void)
  33. {
  34. 	bool trouve;
  35. 	int k = 0;
  36. 	int m = 0;
  37. 	tclient tabcli;
  38. 	tclient tabcli2;
  39. 	chaine cli, cli2;
  40. 	int i;
  41.  
  42. 	fic.open("mmlcomplet.csv",ios::in);
  43. 	fic2.open("mmlmauvais.csv",ios::in);
  44. 	if(!fic || !fic2)
  45. 	{
  46. 		std::cout<<"ouverture de mmlcomplet ou de mmlmauvais impossible";
  47. 	}
  48. 	else
  49. 	{
  50. 		if(!fic.eof() || !fic2.eof())
  51. 		{
  52. 			fic3.open("extraction.csv",ios::out);
  53. 			if(!fic3)
  54. 			{
  55. 				std::cout<<"ouverture extraction impossible";
  56. 			}
  57. 			else
  58. 			{
  59. 				do
  60. 				{
  61. 					trouve = false;
  62. 					fic.getline(cli, sizeof(chaine));
  63. 					decoupage(tabcli, cli);
  64. 					fic2.seekp(0);
  65. 					m = 0;
  66. 					do
  67. 					{
  68. 							fic2.getline(cli2, sizeof(chaine));
  69. 							m++;
  70. 							std::cout<<"lecture de l'enregistrement "<<m<<"\n";
  71. 							decoupage(tabcli2, cli2);
  72. 							if(tabcli[1] == tabcli2[1] && tabcli[3]==tabcli2[3] && 
  73. 								  tabcli[6]==tabcli2[6] && tabcli[7]==tabcli2[7])
  74. 							{
  75. 								std::cout<<"enregistrement trouvé"<<"\n";
  76. 								trouve = true;
  77. 							}
  78. 					}while(!fic2.eof() && !trouve);
  79. 					if(!trouve)
  80. 					{
  81. 						ecriture(tabcli);
  82. 						k++;
  83. 						std::cout<<k<<" enregistrement écrit!!!!!!!!!!!!!!!!!!!"<<"\n";
  84. 					}
  85. 				}while(!fic.eof());	
  86. 				fic.close();
  87. 				fic2.close();
  88. 				fic3.close();
  89. 			}
  90. 		}
  91. 		else
  92. 		{
  93. 			std::cout<<"mmfcomplet ou mmlmauvais vide";
  94. 		}
  95. 	}
  96. 	fic.close();
  97. 	fic2.close();
  98. 	std::cin>>i;
  99. }
  100.  
  101.  
  102.  
  103.  
  104.  
  105. //##########sous-programmes##########
  106.  
  107. void decoupage(tclient tab, string cli)
  108. {
  109.  
  110. 	int i;
  111. 	std::string string1 = cli;
  112.     std::string string2;
  113.  
  114.     for(i=0;i<61;i++)
  115.     {
  116.         string2 = string1.substr(0, string1.find(';'));
  117.         string1 = string1.substr(string1.find(';')+1);
  118. 		tab[i]=string2;
  119. 		//std::cout<<string2;
  120.  
  121.     }
  122. }
  123.  
  124.  
  125. void ecriture(tclient tab)
  126. {
  127. 	int i;
  128. 	std::string concat = "";
  129.  
  130. 	for(i=0;i<57;i++)
  131. 	{
  132. 		concat=concat+tab[i]+';';
  133. 	}
  134. 	concat=concat+"\n";
  135. 	//std::cout<<concat;
  136. 	fic3<<concat;
  137.  
  138. }


Je ne sort pas du 2ième "do", et le booléen se met à vrai lorsque que je dépasse le nombre de ligne du fichier.(Le fichier comporte 10390 lignes).

En attente d'une solution...



Pour le getline fallait comme j'avais mis adapter les cli a des string.

  1. //##########Bibliothèques##########
  2.  
  3. #include<iostream>
  4. #include<fstream>
  5. #include<ios>
  6. #include<string>
  7.  
  8. using namespace std;
  9. //##########Types##########
  10.  
  11. std::fstream fic;
  12.  
  13. std::fstream fic2;
  14.  
  15. std::fstream fic3;
  16.  
  17. typedef string tclient[62];
  18.  
  19. //##########Prototypage##########
  20.  
  21. void decoupage(tclient, string);
  22.  
  23. void ecriture(tclient);
  24.  
  25. void main()
  26. {
  27. 	bool trouve;
  28. 	int k = 0;
  29. 	int m = 0;
  30. 	tclient tabcli;
  31. 	tclient tabcli2;
  32. 	string cli, cli2;
  33. 	int i;
  34.  
  35. 	fic.open("mmlcomplet.csv",ios::in);
  36. 	if(!fic)
  37. 	{
  38. 		std::cout<<"ouverture mmlcomplet impossible";
  39. 	}
  40. 	else
  41. 	{
  42. 		fic2.open("mmlmauvais.csv",ios::in);
  43. 		if(!fic2)
  44. 		{
  45. 			std::cout<<"ouverture mmlmauvais impossible";
  46. 		}
  47. 		else
  48. 		{
  49. 			fic3.open("extraction.csv",ios::out);
  50. 			if(!fic3)
  51. 			{
  52. 				std::cout<<"ouverture extraction impossible";
  53. 			}
  54. 			else
  55. 			{
  56. 				do
  57. 				{
  58. 					trouve = false;
  59. 					getline(fic, cli);
  60. 					if (!cli.length())
  61. 						continue;
  62.  
  63. 					decoupage(tabcli, cli);
  64. 					fic2.seekp(0);
  65. 					m = 0;
  66. 					do
  67. 					{
  68. 						getline(fic2, cli2);									
  69. 						m++;
  70. 						if (!cli2.length())
  71. 							continue;
  72.  
  73. 						decoupage(tabcli2, cli2);
  74. 						if(tabcli[1]==tabcli2[1] && tabcli[3]==tabcli2[3] && 
  75. 							tabcli[6]==tabcli2[6] && tabcli[7]==tabcli2[7])
  76. 						{
  77. 							std::cout<<"enregistrement valide trouve ligne Num : "<<m<<std::endl;
  78. 							trouve = true;
  79. 							break;
  80. 						}									
  81. 					}while(!fic2.eof());
  82. 					if(trouve)
  83. 					{
  84. 						ecriture(tabcli);
  85. 						k++;
  86. 						std::cout<<k<<" enregistrements ecrit!"<<std::endl;
  87. 					}
  88. 					//Controle d'avancement dans le fichier1
  89. 					std::cout<<"Position dans le fichier 1 : "<<fic.tellp()<<std::endl;
  90. 				}while(!fic.eof());
  91.  
  92. 				std::cout<<"Sortie Fichier1"<<std::endl;
  93. 			}			
  94. 		}
  95. 	}
  96.  
  97. 	fic.close();
  98. 	fic2.close();
  99. 	fic3.close();
  100. 	std::cin>>i;
  101. }
  102.  
  103.  
  104.  
  105. //##########sous-programmes##########
  106.  
  107. void decoupage(tclient tab, string cli)
  108. {
  109. 	int i;
  110. 	std::string string1 = cli;
  111. 	std::string string2;
  112.  
  113. 	for(i=0;i<61;i++)
  114. 	{
  115. 		string2 = string1.substr(0, string1.find(';'));
  116. 		string1 = string1.substr(string1.find(';')+1);
  117. 		tab[i]=string2;
  118. 	}
  119. }
  120.  
  121.  
  122. void ecriture(tclient tab)
  123. {
  124. 	int i;
  125. 	std::string concat = "";
  126.  
  127. 	for(i=0;i<57;i++)
  128. 	{
  129. 		concat += tab[i] + ';';
  130. 	}
  131. 	concat += "\n";
  132. 	fic3<<concat;
  133. }



Si la ca marche pas, le probleme est ailleurs.

heu... je te donne l'affichage de la console :

...
Position dans la fichier 1 : 2903232
Position dans la fichier 1 : 2904523
...
...
...
Position dans la fichier 1 : 2903232
Sortie fichier1

Voila ça en gros c'est ce qu'affiche la console, avec beaucoup moins de ligne évidemment.
Et le résultat c'est que ça ma ouvert un fichier extraction.csv qui ne contient rien...

Tu peux m'expliquer?

Citation :

Position dans la fichier 1 : 2903232
Position dans la fichier 1 : 2904523
...
...
...
Position dans la fichier 1 : 2903232
Sortie fichier1


Ca, c'est mathematiquement impossible, si tu regarde l'algo tu comprendra par toi meme qu'a aucun moment tu ne reviens en arriere dans le fichier1, tu ne fais qu'avancer en lecture.

Si tu n'as rien dans le fichier3 c'est que ton if qui doit mettre le booleen a true a trouver false a la condition d'entree a chaque fois.

Essaie de mettre fic3.flush(); avant de faire le fic3.close() mais ca c'est dans le cas d'un compilo buggué.

As tu vraiment fais un copier/coller de ce que j'ai mis?
Avec quoi compiles tu le programme?

J'ai bien fais un copier coller de ce que tu avais mis. Par contre dans l'affichage de la console que je t'ai donné, c'est moi qui me suis trompé...
Mais c'est le genre d'affichage que ça me donne, tout en restant croissant...
Enfin tout pour dir que je ne vois aucun rapport avec le but du programme...

Sinon je compile avec Visual C++ 2005 Express.
Lassé par la pub ? Créez un compte

Répondre Créer un nouveau sujet

Tom's guide dans le monde