Bonjour tout le monde,

J'essaie à partir de code existant de faire un exercice.

Mon programme tourne fou, j'ai mis des points d'arrêt et alors qui'l ne doit lire qu'une seule ligne d'un fichier txt, après plus de 150 clic sur F5, ça continue.

Voici la ligne sur lequel le programme tourne fou :

TabClassifications.Ajouter(Classifications);

L'appel ci-dessus va sur cette méthode :

bool CTableauGenerique::Ajouter(const CGenerique& ModeleAAjouter, bool RetourEnCasDeDoublon)
{
	if (!ModeleAAjouter.EstValide()) return false;
	if ( (m_Poubelle->GereUnicite()) && (Indice(ModeleAAjouter) >= 0) ) return RetourEnCasDeDoublon;
	void* Nouveau = realloc(m_Tableau,(m_Nombre+1)*sizeof(CGenerique*));
	if (Nouveau == NULL) return false;
	m_Tableau = (CGenerique**)Nouveau;
	CGenerique* AAjouter = ModeleAAjouter.Cloner();
	if (!AAjouter->EstValide())
	{
		delete AAjouter;
		return false;
	}
	m_Tableau[m_Nombre] = AAjouter;
	m_Tableau[m_Nombre]->DefinirConteneur(this);
	m_Nombre++;
	return true;
}

donc il n'arrive jamais ici :

for (n=0; n < TabClassifications.Nombre(); n++)

Voici le code de mon main :

include <BasicConsole.h>
#include "vehicule.h"

void main()
{
	long	n;

	CTableauGenerique	TabVehicules((const CGenerique&)CTabVehicules());
	for (n=1; true; n++)
	{
		CTabVehicules	Vehicules;
		char			NomFichier[26];
		sprintf(NomFichier,"vehicules.%ld.txt",n);
		if (!Vehicules.Charger(NomFichier)) break;
		Vehicules.Trier();
		TabVehicules.Ajouter(Vehicules);
	}
	for (n=0; n < TabVehicules.Nombre(); n++)
	{
		printf("\n\nTableau des véhicules de \"vehicules.%ld.txt\"\n",n+1);
		((CTabVehicules&)TabVehicules.Element(n)).Afficher();
	}
}

Voici aussi mon fichier cpp :

#include <BasicConsole.h>
#include <search.h>
#include "chiens.h"

//il faut donc encore créer les classes origines et utilisations

/////////////////
//Class CChiens//
////////////////

CChiens::CChiens()
{
}

CChiens::CChiens(const CChiens& Source) 
:CGenerique(Source),m_Nom(Source.m_Nom)
{
}

CChiens::CChiens(const char* UnNom)//OK
{
	Nom(UnNom);
}


CTabClassifications::~CTabClassifications()
{
}

bool CChiens::Nom(const char* UnNom) //ok
{
	if ( (UnNom == NULL) || (strlen(UnNom) < 2) ) return false;
	return m_Nom.Chaine(UnNom);
		
}

void CChiens::Afficher()const
{
	printf("- Classifications : %s\n",Nom());
}

CTabClassifications::CTabClassifications(const CTabClassifications& Source)
:CTableauGenerique(Source)
{
}


void CTabClassifications::Afficher(const char* FiltreSurType) const
{	long ordre = 0;
	for (long n=0; n < 10; n++)
	{
		if ( (FiltreSurType == NULL) || (strcmp(Element(n).Type(),FiltreSurType) == 0) )
		{
			ordre++;
			printf("%s n°%ld :\n",Element(n).Type(),ordre);
			Element(n).Afficher();
		}
	}

}

const char* CChiens::Type() const
{
	return null;
}

int CChiens::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	return 0;
}

bool CChiens::EstValide() const
{
	return true;
}

CGenerique* CChiens::Cloner() const
{
	return new CChiens(*this);
}

long CChiens::NombreClesDeTri() const
{
	return 1;
}

bool CChiens::GereUnicite() const
{
	return true;
}

CChiens::~CChiens()
{

}

const char* CChiens::Nom() const
{
	return m_Nom.Chaine();
}


CChiens& CTabClassifications::Element(long UnIndice) const
{
	return (CChiens&)CTableauGenerique::Element(UnIndice);
}
///////////////////////////////
//Class CTabClassifications////
///////////////////////////////

CTabClassifications::CTabClassifications()
:CTableauGenerique(CChiens("POUBELLE"))
{
}

long CTabClassifications::Indice(const char* UnNom) const
{
	//ici je ne passe que le nom et pas le compteur, on travaille ici avec le constructeur spécifique
	//de la classe CChiens ! donc je ne passe qu'un paramètre contrairement aux véhicules
	//donc je vérifie le nom dans le tableau, si il existe déjà j'incrémente le compteur
	//autrement je l'ajoute et j'incrémente le compteur.


	//dans les tableaux il ne faut pas remettre les membres !!!!
	return CTableauGenerique::Indice(CChiens(UnNom));
	
}

bool CTabClassifications::Ajouter(const CChiens& Modele)
{
	return CTableauGenerique::Ajouter(Modele);
}

void CTabClassifications::Trier()
{
	CTableauGenerique::Trier(ComparaisonPourTri);
}

bool CTabClassifications::Charger(const char* NomFichier)
{
	CChargeurFichierTexte	Chargeur;

	return Chargeur.Charger(NomFichier,'\t',CTabClassifications::FctnTraiterLigne,this);
}

/*static*/ bool CTabClassifications::FctnTraiterLigne(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTabClassifications*)Contexte)->TraiterLigne(Chargeur);
}


bool CTabClassifications::TraiterLigne(const CChargeurFichierTexte& Chargeur)

//le chargeur ouvre le fichier, lit ligne par ligne et éclate la ligne, il n'y a donc plus rien à faire
{
	if (Chargeur.NombreChamps() == 4)
	{
		Ajouter(CChiens(Chargeur.Champs(1)));
	}
	return true;
}

Si vous avez besoin d'autre info n'héistez pas à me le dire.

Un tout grand merci d'avance pour votre aide.

beegees