Bonjour tout le monde,

Sur cette ligne de code :

CProduit& ReferenceProduit = m_Produits.Element(m_Produits.Indice(UnPrix));

J'obtiens ce message d'erreur :

Citation : mon compilo

UnPrix' : undeclared identifier

il est pourtant déclaré.

Dans le .h :

long Indice(const int UnPrix) const;

et dans le cpp :

long CTabProduits::Indice(const int UnPrix) const
{
	return CTableauGenerique::Indice(CProduit(NULL,UnPrix));
}

Je vous laisse mon .h :

#ifndef CARAMBOUILLE_H
#define CARAMBOUILLE_H

#include "chaine.h"
#include "generique.h"


class CProduit;
class CTabProduits;
class CTraitementProduits;
class CPrix;
class CTabPrix;

class CProduit : public CGenerique
{
public:
	//constructeur
	CProduit();
	CProduit(const CProduit& Source);
	CProduit(const char* UnNom, int UnPrix);
	//Destructeur
	~CProduit();

	//Les modificatuers
	bool			SetNomProduit(const char* UnNom);
	bool			SetPrixProduit(int UnPrix);

	// Les accesseurs
	const char*		GetNomProduit() const;
	int				GetPrixProduit() const;

	CGenerique*		Cloner()const;
	bool			EstValide() const;
	bool			GereUnicite()const;
	int				Comparer(const CGenerique& Autre, long TypeComparaison) const;
	long			NombreClesDeTri() const;


//les membres
private:
	CChaine			m_NomProduit;
	int				m_PP;

};


class CTabProduits : public CTableauGenerique
{
public:
	CTabProduits();
	CTabProduits(const CTabProduits& Source);
	~CTabProduits();

	CGenerique*		Cloner() const;

	CProduit&		Element(long Indice) const;
	long			Indice(const int UnPrix) const;
	bool			Ajouter(const CProduit& Source);
	void			Trier(int CleDeTri);
};

class CPrix : public CGenerique
{
public:
	CPrix();
	CPrix(const CPrix& Source);
	CPrix(int UnPrix, CProduit& UnPrixProduit);
	~CPrix();

	CGenerique*		Cloner() const;
	bool			EstValide() const;

	//accesseur
	int				Prix() const;
	CProduit&		ReferenceProduit() const;
	//modificateur
	bool			Prix(int UnPrix);

private:
	int				m_Prix;
	CProduit&		m_ReferenceProduit;
};

class CTabPrix : public CTableauGenerique
{
public:
	CTabPrix();
	CTabPrix(const CTabPrix& Source);
	~CTabPrix();

	CGenerique*		Cloner() const;
	CProduit&		Element(long Indice) const;
	long			Indice(const int UnPrix) const;

	bool			Ajouter(CPrix& Modele);

};

class CTraitementProduits
{
public:
	CTraitementProduits();
	~CTraitementProduits();

	bool			Charger(const char* NomFichier_Produits,const char* NomFichier_Combinaisons);

private:
	CTabProduits	m_Produits;

private:

	static bool	FctnTraiterLigne_Produits(const CChargeurFichierTexte& Chargeur, void* Contexte);
	bool		TraiterLigne_Produits(const CChargeurFichierTexte& Chargeur);
	static bool	FctnTraiterLigne_Combinaisons(const CChargeurFichierTexte& Chargeur, void* Contexte);
	bool		TraiterLigne_Combinaisons(const CChargeurFichierTexte& Chargeur);
};



#endif

et mon .cpp :

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

//////////////
// CProduit //
/////////////

CProduit::CProduit()
:m_PP(0)
{
}

CProduit::CProduit(const CProduit& Source)
:CGenerique(Source),m_NomProduit(Source.m_NomProduit),m_PP(Source.m_PP)
{
}

CProduit::CProduit(const char* UnNom, int UnPrix)
:m_PP(0) //on recopie la même chose que dans le constructeur spécifique
{	
	SetNomProduit(UnNom);
	SetPrixProduit(UnPrix);
}

CProduit::~CProduit()
{
}

bool CProduit::SetNomProduit(const char* UnNom)
{
	if((strlen(UnNom)<1)&&(UnNom==NULL))return false;
	return m_NomProduit.Chaine(UnNom);
}

bool CProduit::SetPrixProduit(int UnPrix)
{
	if(UnPrix<1)return false;
	m_PP = UnPrix;
	return true;
}

const char* CProduit::GetNomProduit() const
{
	return m_NomProduit.Chaine();
}

int CProduit::GetPrixProduit() const
{
	return m_PP;
}

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

bool CProduit::EstValide() const
{
	return(strlen(GetNomProduit())>1)&&(GetPrixProduit()>1);
}

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


int CProduit::Comparer(const CGenerique& Autre, long TypeComparaison) const
{
	if(TypeComparaison == 0) return m_NomProduit.Comparer(((const CProduit&)Autre).m_NomProduit,Comparaison_TriCroissantNonStrict);
	if(TypeComparaison == 1) return m_NomProduit.Comparer(((const CProduit&)Autre).m_NomProduit,Comparaison_TriCroissantNonStrict);	
	return 0;
}

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

//////////////////
// CTabProduits //
//////////////////

CTabProduits::CTabProduits()
:CTableauGenerique(CProduit())
{
}

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

CTabProduits::~CTabProduits()
{
}

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

CProduit& CTabProduits::Element(long Indice) const
{
	return (CProduit&)CTableauGenerique::Element(Indice);
}

long CTabProduits::Indice(const int UnPrix) const
{
	return CTableauGenerique::Indice(CProduit(NULL,UnPrix));
}

bool CTabProduits::Ajouter(const CProduit& Modele)
{
	return CTableauGenerique::Ajouter(Modele);
}

/////////////////////////
// CTraitementProduits //
/////////////////////////

CTraitementProduits::CTraitementProduits()
{
}

CTraitementProduits::~CTraitementProduits()
{
}

bool CTraitementProduits::Charger(const char* NomFichier_Produits,const char* NomFichier_Combinaisons)
{
	CChargeurFichierTexte	Chargeur;

	if (!Chargeur.Charger(NomFichier_Produits,'\t',FctnTraiterLigne_Produits,this)) return false;
	if (!Chargeur.Charger(NomFichier_Combinaisons,'\t',FctnTraiterLigne_Combinaisons,this)) return false;
	m_Produits.Trier(1);
	
/*	// Affichage des deux tableaux*/
	for (long n=0; n < m_Produits.Nombre(); n++)
	{
		CProduit& P = m_Produits.Element(n);
		printf("%s \t\t  %ld\n",P.GetNomProduit(),P.GetPrixProduit());
	}
	
	return true;
}

/*Static*/ bool CTraitementProduits::FctnTraiterLigne_Produits(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTraitementProduits*)Contexte)->TraiterLigne_Produits(Chargeur);
}

/*Static*/ bool CTraitementProduits::FctnTraiterLigne_Combinaisons(const CChargeurFichierTexte& Chargeur, void* Contexte)
{
	return ((CTraitementProduits*)Contexte)->TraiterLigne_Combinaisons(Chargeur);
}

bool CTraitementProduits::TraiterLigne_Produits(const CChargeurFichierTexte& Chargeur)
{
	if(!Chargeur.NombreChamps() == 2) return true;
	const char* NomProduit = Chargeur.Champs(0);
	int PrixProduit = atol(Chargeur.Champs(1));
	if (!m_Produits.Ajouter(CProduit(NomProduit,PrixProduit))) return true;
	CProduit& ReferenceProduit = m_Produits.Element(m_Produits.Indice(UnPrix));
	return true;
}

/*bool CTraitementProduits::TraiterLigne_Combinaisons(const CChargeurFichierTexte& Chargeur)
{
	if(Chargeur.NombreChamps() == 5) m_Produits.Ajouter(CProduit atol((Chargeur.Champs(0)),atol((Chargeur.Champs(1)),atol((Chargeur.Champs(3)),atol((Chargeur.Champs(4)))));
	return true;
}*/

void CTabProduits::Trier(int CleDeTri)
{
	CTableauGenerique::Trier(CleDeTri);
}

//////////////////
// Class CPrix //
/////////////////
CProduit	g_ReferencePoubelle;

CPrix::CPrix()
:m_ReferenceProduit(g_ReferencePoubelle)
{
}

CPrix::CPrix(const CPrix& Source)
:CGenerique(Source),m_Prix(Source.m_Prix),m_ReferenceProduit(Source.m_ReferenceProduit)
{
}

CPrix::CPrix(int UnPrix, CProduit& UnPrixProduit)
:m_Prix(0),m_ReferenceProduit(UnPrixProduit)
{
	Prix(UnPrix);
}

CPrix::~CPrix()
{
}

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

bool CPrix::EstValide() const
{
	return (Prix()>0);
}

int CPrix::Prix() const
{
	return m_Prix;
}

bool CPrix::Prix(int UnPrix)
{
	if(UnPrix<0)return false;
	m_Prix = UnPrix;
	return true;
}

CProduit& CPrix::ReferenceProduit() const
{
	return m_ReferenceProduit;
}

/////////////////////
// class CTabPrix //
/////////////////////

CTabPrix::CTabPrix()
:CTableauGenerique(CPrix())
{
}

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

CTabPrix::~CTabPrix()
{
}

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

CProduit& CTabPrix::Element(long Indice) const
{
	return (CProduit&)CTableauGenerique::Element(Indice);
}

long CTabPrix::Indice(const int UnPrix) const
{
	return CTableauGenerique::Indice(CPrix(UnPrix,g_ReferencePoubelle));
}

bool CTabPrix::Ajouter(CPrix& Modele)
{
	return CTableauGenerique::Ajouter(Modele);

}

Voici plus d'info :

Citation : Pas de titre

Donc là j'ai défini le Produit, maintenant je vais en prendre la référence, s'est une
référence de Produit, je sais qu'il existe parce que "Ajouter" m'a renvoyé VRAI, donc je
vais rechercher un élément en fonction de l'indice que j'aurai trouvé via une recherche sur le
Prix donc j'appelle Indice qui me renvoie l'indice par rapport au prix et avec cet indice
j'accède à un élément et je note cette référence dans cette variable locale que j'appelle
ReferenceProduit

Merci d'avance pour l'aide.

beegees

Franchement je peu pa t aider mai juste te prévenir ke ton sujet est indiqué comme résolu donc tu ora pa bcp d aide!

merci pour ta réponse

J'ai trouvé la réponse (appel du monvais constructeur) merci encore