J'essaie de compiler mon programme mais ces erreurs apparaîssent :  
 
error C2668: 'CGroupe::CGroupe' : ambiguous call to overloaded function  
La ligne d'erreur est : CGroupe oGroupe1;
 
error C2228: left of '.SetPonderations' must have class/struct/union type
        type is 'CEleve *'
        did you intend to use '->' instead?
La ligne d'erreur est : m_oEleves.SetPonderations(iPond, iNbPond);
 
 
Qu'est-ce que ca veut dire exactement ??

"did you intend to use '->' instead?"
 
ca me parait clair.
pour la premiere c pas clair, fait voir le code

Quelle page ??
main.cpp, Groupe.cpp, Eleve.cpp??
Pis c'est pas plus clair pour moi, vu que j'ai jamais vu "->" de ma vie... Je commence en C++.

1) quel est ton compilateur
2) peut on avoir l'integralité du rapport d'erreur
3) pis le code ca peut aider aussi

Ok ben je vais tout mettre, on va pas niaiser des heures :
 
1) Visual Studio 2003
2) warning C4520: 'CGroupe' : multiple default constructors specified
error C2228: left of '.SetPonderations' must have class/struct/union type
        type is 'CEleve *'
        did you intend to use '->' instead?
warning C4520: 'CGroupe' : multiple default constructors specified
 
3) Groupe.cpp
~~~~
#include ".\groupe.h"
 
CGroupe::CGroupe(void)
: m_iNbEleves(0)
, m_iNbNotes(0)
{
 m_iNbEleves = 10;
 m_oEleves = new CEleve[m_iNbEleves];
 m_sNomGroupe = "Groupe";
}
 
CGroupe::~CGroupe(void)
{
}
 
CGroupe::CGroupe(string sNom, int iNbEleves)
{
 m_sNomGroupe = sNom;
 m_iNbEleves = iNbEleves;
 m_oEleves = new CEleve[m_iNbEleves];
}
 
 
void CGroupe::SetNbEleves(int iNbEleves)
{
 if (iNbEleves > 0)
 {
  m_iNbEleves = iNbEleves;
 }
}
 
int CGroupe::GetNbEleves(void)
{
 return m_iNbEleves;
}
 
int CGroupe::GetNbNotes(void)
{
 return m_iNbNotes;
}
 
void CGroupe::SetNbNotes(int iNbNotes)
{
 if (iNbNotes > 0)
 {
  m_iNbNotes = iNbNotes;
 }
}
 
void CGroupe::SetPonderations(int iPond[], int iNbPond)
{
 m_oEleves.SetPonderations(iPond, iNbPond);
}
 
void CGroupe::SetPonderationAvantage(void)
{
}
 
bool CGroupe::AjouterNoteEleve(int iEleve, int iNote)
{
 return false;
}
 
bool CGroupe::SetNomEleve(int iEleve, string iNom)
{
 return false;
}
 
bool CGroupe::SetPrenomEleve(int iEleve, string iPrenom)
{
 return false;
}
 
double CGroupe::GetMoyenneGroupe(void)
{
 return 0;
}
 
void CGroupe::AfficherRapport(void)
{
}
------------------------------------------------------------
Eleve.cpp
~~~~
#include ".\eleve.h"
#include ".\CONSTANTES.h"
 
CEleve::CEleve(void)
: m_iNbPonderations(0)
, m_iNbNotes(0)
, m_bBonnePonderation(false)
, m_bPonderationAvantage(false)
, m_sNom("" )
, m_sPrenom("" )
{
 m_iNbNotes = INIT; //Déclaration du nombre de notes par défaut
 m_iTabNotes = new int [m_iNbNotes];  //Nouveau tableau de notes
 m_iTabPonderations = new int [m_iNbPonderations]; //Nouveau tableau de pondérations
 InitialiserTab(m_iTabNotes,m_iNbNotes, -1); //Initialisation du tableau de notes
 InitialiserTab(m_iTabPonderations,m_iNbPonderations, -1); //Initialisation du tableau de pondérations
}//CEleve::CEleve(void)
 
CEleve::~CEleve(void) //Supprime les tableaux dynamiques
{
 delete []m_iTabPonderations;
 delete []m_iTabNotes;
}//CEleve::~CEleve(void)
 
CEleve::CEleve(int iNbNote)
{
 m_iNbPonderations=0;
 m_iNbNotes = 0;
 m_bBonnePonderation = false;
 m_bPonderationAvantage = false;
 m_sNom = "";
 m_sPrenom = "";
 m_iNbNotes = iNbNote;
 m_iTabNotes = new int [m_iNbNotes]; //Initialisation du tableau de notes
 m_iTabPonderations = new int [m_iNbPonderations]; //Initialisation du tableau de pondérations
 InitialiserTab(m_iTabNotes,m_iNbNotes, -1);
 InitialiserTab(m_iTabPonderations,m_iNbPonderations, -1);
}//CEleve::CEleve(int iNbNote)
 
CEleve::CEleve(const CEleve &oACopier) //Copiage de toutes les données
{
 m_bBonnePonderation = oACopier.m_bBonnePonderation;
 m_bPonderationAvantage = oACopier.m_bPonderationAvantage;
 m_iNbNotes = oACopier.m_iNbNotes;
 m_iNbPonderations = oACopier.m_iNbPonderations;
 m_iTabNotes = oACopier.m_iTabNotes;
 m_iTabPonderations = oACopier.m_iTabPonderations;
 m_sNom = oACopier.m_sNom;
 m_sPrenom = oACopier.m_sPrenom;
 CopierTab(m_iTabNotes, oACopier.m_iTabNotes);
 m_iTabPonderations = new int[oACopier.m_iNbNotes]; //Initialisation du tableau de pondérations
 CopierTab(m_iTabPonderations, oACopier.m_iTabPonderations);
}//CEleve::CEleve(const CEleve &oACopier)
 
void CEleve::SetPonderations(int iTabPonderations[], int iNbPonderations)
{
 if (iNbPonderations > VIDE) //Si iNbPonderations est plus grand que 0...
 {
  if (m_iTabPonderations != VIDE) //Si m_iTabPonderations n'est pas vide...
  {
   delete []m_iTabPonderations; //Supprime l'ancien tableau
  }//if (m_iTabPonderations != VIDE)
  m_iNbPonderations = iNbPonderations;
  m_iTabPonderations = new int [m_iNbPonderations]; //Crée un nouveau tableau de pondérations
  for (int i=0; i < iNbPonderations; i++)
  {
   m_iTabPonderations[i] = iTabPonderations[i]; //Transfert les notes
  }//for (int i=0; i < iNbPonderations; i++)
 }//if (iNbPonderations > VIDE)
}//void CEleve::SetPonderations(int iTabPonderations[], int iNbPonderations)
 
bool CEleve::IsBonnePonderation(void)
{
 bool bBonne = true;
 int iTotal=VIDE;
 
 for (int i=0; i < m_iNbNotes; i++)
 {
  iTotal = iTotal + m_iTabPonderations[i]; //Calcul de la somme des pondérations
 }//for (int i=0; i < m_iNbNotes; i++)
 
 if (iTotal == MAX_NOTE) //Si le Total est égal à 100
 {
        bBonne = true;
 }//if (Total == BONNE_PONDERATION)
 else
 {
  bBonne = false;
 }//if (Total == BONNE_PONDERATION)
 m_bBonnePonderation = bBonne;
 return bBonne;
}//bool CEleve::IsBonnePonderation(void)
 
void CEleve::SetPonderationAvantage()
{
 m_bPonderationAvantage = true;
}//void CEleve::SetPonderationAvantage()
 
void CEleve::TrierTableaux(int iNb, int m_iTab[])
{
 int iEchange;
 
 for (int i=0; i < iNb - 1; i++)
 {
  for (int j=0; j < iNb - i - 1; j++)
  {
   if (m_iTab[j] > m_iTab[j+1])
   {
    iEchange = m_iTab[j];
    m_iTab[j] = m_iTab[j+1];
    m_iTab[j+1] = iEchange;
   }//if (m_iTab[j] > m_iTab[j+1])
  }//for (int j=0; j < iNb - i - 1; j++)
 }//for (int i=0; i < iNb - 1; i++)
}//void CEleve::TrierTableaux(int iNb, int m_iTab[])
 
void CEleve::SetNbNotes(int iNbNotes)
{
 if (iNbNotes >= VIDE) //Si iNbNotes est plus grand que 0...
 {
  if (m_iTabNotes != VIDE) //Si m_iTabNotes n'est pas vide...
  {
   delete []m_iTabNotes; //Supprime l'ancien tableau
  }//if (m_iTabNotes != VIDE)
  m_iNbNotes = iNbNotes;
  m_iTabNotes = new int [m_iNbNotes]; //Crée un nouveau tableau de notes
  InitialiserTab(m_iTabNotes,m_iNbNotes, -1); //Initialise le tableau
 }//if (iNbNotes >= VIDE)
}//void CEleve::SetNbNotes(int iNbNotes)
 
bool CEleve::AjouterNote(int iNote)
{
 bool bOk = false;
 int i=VIDE;
 
 if (iNote >= VIDE && iNote <= MAX_NOTE) //Si la note est entre 0 et 100...
 {
        for (i=0;i < iNote; i++)
  {
   if (m_iTabNotes[i] == INIT_TAB) //Si m_iTabNotes[i] n'a pas de valeur...
   {
    m_iTabNotes[i] = iNote;
    i = iNote; //Pour sortir de la boucle
    bOk = true;
   }//if (m_iTabNotes[i] == INIT_TAB)
  }//for (i=0;i < iNote; i++)
 }//if (iNote >= VIDE && iNote <= MAX_NOTE)
 else
 {
  bOk = false;
 }//if (iNote >= VIDE && iNote <= MAX_NOTE)
 return bOk;
}//bool CEleve::AjouterNote(int iNote)
 
int CEleve::GetNote(int iPosition)
{
 int iRetour;
 
 if (iPosition >= MIN_POS && iPosition <= GetNbNotes()) //Si la position est entre 1 et GetNbNotes()...
 {
        iRetour = m_iTabNotes[iPosition-1];
 }//if (iPosition >= MIN_POS && iPosition <= GetNbNotes())
 else
 {
  iRetour = INIT_TAB;
 }//if (iPosition >= MIN_POS && iPosition <= GetNbNotes())
 return iRetour;  
}//int CEleve::GetNote(int iPosition)
 
int CEleve::GetNbNotes(void)
{
 return m_iNbNotes;
}//int CEleve::GetNbNotes(void)
 
double CEleve::CalculerNoteFinale(void)
{
 double dTotal=0;
 
 if (IsBonnePonderation()) //Si c'est une bonne ponderation...
 {
  if(m_bPonderationAvantage) //S'il y a pondération avantageuse...
  {
   TrierTableaux(m_iNbPonderations, m_iTabPonderations);
   TrierTableaux(m_iNbNotes, m_iTabNotes);
  }//if(m_bPonderationAvantage)
 
  for (int i=0; i < m_iNbNotes; i++)
  {
   if(m_iTabNotes[i] >= VIDE && m_iTabNotes[i] <= MAX_NOTE) //Si la note est entre 0 et 100...
   {
    dTotal = dTotal + (m_iTabNotes[i] * m_iTabPonderations[i]/100.0);
    cout << "dTotal : "<< dTotal << " -- " << m_iTabNotes[i] << " -- " <<m_iTabPonderations[i] << endl;
   }//if(m_iTabNotes[i] >= VIDE && m_iTabNotes[i] <= MAX_NOTE)
   else
   {
    dTotal = -1;
    i = m_iNbNotes; //pour sortir de la boucle
   }//if(m_iTabNotes[i] >= VIDE && m_iTabNotes[i] <= MAX_NOTE)
  }//for (int i=0; i < m_iNbNotes; i++)
 }//if (IsBonnePonderation())
 else
 {
  dTotal = -1;
 }//if (IsBonnePonderation())
 return dTotal;
}
 
void CEleve::SetNom(string sNom)
{
 m_sNom = sNom;
}//void CEleve::SetNom(string sNom)
 
string CEleve::GetNom(void)
{
 return m_sNom;
}//string CEleve::GetNom(void)
 
void CEleve::SetPrenom(string sPrenom)
{
 m_sPrenom = sPrenom;
}//void CEleve::SetPrenom(string sPrenom)
 
string CEleve::GetPrenom(void)
{
 return m_sPrenom;
}//string CEleve::GetPrenom(void)
 
 
void CEleve::ModifierTailleTableau(int iTableau[])
{
 int *iTabTemp;
 int iTailleTemp = m_iNbNotes;
 iTabTemp = new int[iTailleTemp];
 CopierTab(iTabTemp,iTableau);
 delete [] iTableau;
 m_iTabNotes = iTabTemp;
}//void CEleve::ModifierTailleTableau(int iTableau[])
 
void CEleve::CopierTab(int iNewTab[], int iOldTab[])
{
 for (int i=0; i < m_iNbNotes; i++)
 {
  iNewTab[i] = iOldTab[i];
 }//for (int i=0; i < m_iNbNotes; i++)
}//void CEleve::CopierTab(int iNewTab[], int iOldTab[])
 
void CEleve::InitialiserTab(int Tab[],int iTaille, int init)
{
 for (int i=0; i < iTaille;i++)
 {
  Tab[i]=init;
 }//for (int i=0; i < iTaille;i++)
}//void CEleve::InitialiserTab(int Tab[],int iTaille, int init)
 
int CEleve::GetPonderation(int iPosition)
{
 int iRetour;
 
 if (iPosition >= MIN_POS && iPosition <= GetNbNotes())
 {
        iRetour = m_iTabPonderations[iPosition-1];
 }//if (iPosition >= MIN_POS && iPosition <= GetNbNotes())
 else
 {
  iRetour = INIT_TAB;
 }//if (iPosition >= MIN_POS && iPosition <= GetNbNotes())
 return iRetour;  
}//int CEleve::GetPonderation(int iPosition)
---------------------------------------------------------
 
main.cpp
~~~~
// fichier : main.cpp
// fait par : josée lefebvre, Pier-Antoine Giguère et Jonathan Melo
//
// but : test la classe eleve seulement (début de groupe)
//
// dernières modifications faites : tests de setnom, setprenom et ajouternote eleve
//
//      A AMÉLIORER CAR LE TEST EST CUCU
//  
// v1.4.2
//
// derniere modification : 12 mars 2004
 
// bibliothèques
//////////////////////////////////////////////////////////////////////////////////////////////
#include "Eleve.h"
#include "Groupe.h"
//#include "Groupe.h"
#include <iostream>
using namespace std;
 
// constantes globales
//////////////////////////////////////////////////////////////////////////////////////////////
const int iNBNOTES = 5;
const int NBELEM = 5;
 
// variables globales (illégal, je saiiiiis)
//////////////////////////////////////////////////////////////////////////////////////////////
int ScorePrecedent=0;
int iResultatTest = 0;
 
// PROTOTYPES DE FONCTIONS
char VerifierErreur();
void Afficher(string sMessage);
 
// début du programme principale
//////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
 // Tableaux de ponderations et de notes
 int iBonnePonderation[ iNBNOTES ]  = { 25, 10, 40, 5, 20 }; // moyenne 67.5 et 77.5 avec ponderation avantage
 int iBonnePonderation2[ iNBNOTES ]  = { 20, 20, 20, 20, 20 };
 int iMauvaisePonderation[ iNBNOTES ] = { 20, 20, 25, 25, 30 };
 int iTabNotes[ iNBNOTES ] = { 90, 30, 60, 80, 70 };
 int iTabNotesMauvais[ iNBNOTES ] = { 900, 30, -60, 80, 70 };
 
 int iBonneNote = 5;
 int iMauvaiseNote = -5;
 
 // Deux objets servants aux tests
 CEleve oPersonne;      // informations contenu dans la classe
 CEleve oPersonne2;      // donnée mauvaise
 
 string sNom;             // sert a lire le nom
 string sPrenom;
 int iNo = 0;
 int iNbNoteEleve = 0;
 int iNote = 0;
 int iNbTestTotal = 0;
   
 cout << "Vous etes dans le Main () et on verifie CEleve" << endl << endl;
///////////////////////////////////////////////////////////////////////////////////
//    TESTS CONSTRUCTEURS             //
///////////////////////////////////////////////////////////////////////////////////
 // Tester la construction par défaut
 CEleve oPersonne4;
 
 if (oPersonne4.GetNbNotes() == 5)
 {
  iResultatTest++;
 }
 Afficher("Test Constructeur par defaut : " );
 iNbTestTotal++;
 
 // Tester la construction avec paramètre
 CEleve oPersonne5(6);
 
 if (oPersonne5.GetNbNotes() == 6)
 {
  iResultatTest++;
 }
 Afficher("Test Constructeur avec parametre : " );
 iNbTestTotal++;
 
 // Tester la construction de copie
 CEleve oPersonne6;
 oPersonne6.AjouterNote(45);
 oPersonne6.AjouterNote(99);
 
 CEleve oPersonne3(oPersonne6);
 
 cout << "Note a Copier: 45, 99" << endl;
 cout << "Note Copier: " << oPersonne3.GetNote(1) << ", " << oPersonne3.GetNote(2)<< endl << endl;
 
 if (oPersonne3.GetNote(1) == 45 && oPersonne3.GetNote(2)== 99)
 {
  iResultatTest++;
 }
 Afficher("Test Constructeur par copie : " );
 iNbTestTotal++;
 
 // Tester la construction si on ne donne pas de notes
 CEleve oPersonne7;
 
 if (oPersonne7.CalculerNoteFinale() < 0)
 {
  iResultatTest++;
 }
 Afficher("Test Constructeur sans notes : " );
 iNbTestTotal++;
///////////////////////////////////////////////////////////////////////////////////
 // Vérification de SetNom et SetPrenom
 
 sNom = "Lefebvre";
 oPersonne.SetNom(sNom);
 
 sPrenom = "Josee";
 oPersonne.SetPrenom(sPrenom);  
 
 if(oPersonne.GetNom() == "Lefebvre" )
 {
  iResultatTest++;
 }
 Afficher("Test SetNom : " );
 iNbTestTotal++;
 
 if(oPersonne.GetPrenom() == "Josee" )
 {
  iResultatTest++;
 }
 Afficher("Test SetPrenom : " );
 iNbTestTotal++;
 
///////////////////////////////////////////////////////////////////////////////////
 // Vérification de SetNbNotes
 iNbNoteEleve = NBELEM;
 
 // entrée avec de mauvaise nombre de note
 oPersonne2.SetNbNotes(iMauvaiseNote);
 
 if(oPersonne2.GetNbNotes() != iMauvaiseNote)
 {
  iResultatTest++;
 }
 Afficher("Test SetNbNotes # 1 : " );
 iNbTestTotal++;
 
 oPersonne.SetNbNotes(iBonneNote);
 
 for (int j = 0; j < iBonneNote; j++)// tableau de note : 90, 30, 60, 80, 70  
 {
  iNote = iTabNotes[j];
  oPersonne.AjouterNote(iNote);
 }
 
 if(oPersonne.GetNbNotes() == iBonneNote)
 {
  iResultatTest++;
 }
 Afficher("Test SetNbNotes # 2 : " );
 iNbTestTotal++;
 
 
///////////////////////////////////////////////////////////////////////////////////
 // Vérification de SetPonderations
 
 int iTabPondBonne[NBELEM] = { 25, 10, 40, 5, 20 }; //moyenne de 67.5 sans ponderation avantage
             //moyenne de 77.5 avec ponderation avantage
 int iNbPonderation = 5;
 
 oPersonne.SetPonderations(iBonnePonderation, iNbPonderation);
 if(oPersonne.IsBonnePonderation() == true )
 {
  iResultatTest++;
 }
 Afficher("Test SetPonderations # 1 : " );
 iNbTestTotal++;
 
 oPersonne2.SetPonderations(iMauvaisePonderation, iNbPonderation);
 if(oPersonne2.IsBonnePonderation() == false )
 {
  iResultatTest++;
 }
 Afficher("Test SetPonderations # 2 : " );
 iNbTestTotal++;
 
 
 
///////////////////////////////////////////////////////////////////////////////////
 // vérification de GetPonderation
 
 int iPosition = 2;
 int iLaPonderation;
    int iNombrePonderation = 5;
 int iLaNote;
 
 CEleve oPersonne9;    
 oPersonne9.SetPonderations(iBonnePonderation, iNombrePonderation);
 oPersonne9.SetNbNotes(iBonneNote);
 
 for (int j = 0; j < iBonneNote; j++) // le tableau de note est : 90, 30, 60, 80, 70
 {
  iNote = iTabNotes[j];
  oPersonne9.AjouterNote(iNote);
 }
 
 iPosition = 4;
 iLaNote = oPersonne9.GetNote(iPosition);
 if(iLaNote == 80)
 {
  iResultatTest++;
 }
 Afficher("Test GetPonderations # 1 : " );
 iNbTestTotal++;
 
 cout << "tableau de notes: ";
 for (int y = 1; y <= iNombrePonderation; y++)
 {
  iLaNote = oPersonne9.GetNote(y);
  cout << iLaNote << " , ";
 }
  cout << endl;
 
 // le tableau ponderation est : 25, 10, 40, 5, 20  
 iLaPonderation = oPersonne9.GetPonderation(iPosition);
 if(iLaPonderation == 5)
 {
  iResultatTest++;
 }
 Afficher("Test GetPonderations # 2 : " );
 iNbTestTotal++;
 
 cout << "tableau de ponderation : ";
 for (int z = 1; z <= iNombrePonderation; z ++)
 {
  iLaPonderation = oPersonne9.GetPonderation(z);
  cout << iLaPonderation << " , ";
 }
//////////////////////////////////////////////////////////////////////////////////////////
 
 // Vérification de SetPonderationAvantage désenvatageuse
 
 //bool bAvantage = false;
 double dMoyenneEtudiant = 0.00;
 
 cout << endl << "la note finale de " << oPersonne.GetNom() << " " << oPersonne.GetPrenom()  << " est : " << oPersonne.CalculerNoteFinale() << endl << endl;
 
 // Vérification de CalculerNoteFinale
 dMoyenneEtudiant = oPersonne.CalculerNoteFinale();
 
 if(dMoyenneEtudiant == 67.5)
 {
  iResultatTest++;
 }
 Afficher("Test SetPonderationAvantage # 1 : " );
 iNbTestTotal++;
 
 // Vérification de SetPonderationAvantage avantageuse
 oPersonne.SetPonderationAvantage();
 cout << endl << "la note finale avantageuse de " << oPersonne.GetNom() << " " << oPersonne.GetPrenom()  << " est : " << oPersonne.CalculerNoteFinale() << endl << endl;
 
 dMoyenneEtudiant = oPersonne.CalculerNoteFinale();
 
 if(dMoyenneEtudiant == 77.5)
 {
  iResultatTest++;
 }
 Afficher("Test SetPonderationAvantage # 2 : " );
 iNbTestTotal++;
 
 // ****a faire une condition pour vérifier si calculernote renvoi note négative
 oPersonne2.SetPonderationAvantage();
 oPersonne2.SetNbNotes(iBonneNote);
 oPersonne2.SetPonderations(iBonnePonderation, iNbPonderation);
 
 iNote = 0;
 int iMauvaiseReponse = 0;
 
 for (int k = 0; k < iBonneNote; k++)
 {
  iNote = iTabNotesMauvais[k];
  oPersonne2.AjouterNote(iNote);
 }
 
 //pe manque ponderation et note ???
 dMoyenneEtudiant = oPersonne2.CalculerNoteFinale();
 
 // calculernote doit retourné une valeur négative
 if(dMoyenneEtudiant < 0)
 {
  iResultatTest++;
 }
 Afficher("Test SetPonderationAvantage # 3 : " );
 iNbTestTotal++;
 
///////////////////////////////////////////////////////////////////////////////////
 //Verification de Ajouter Note
 //Si il empêche le débordement (trop de valeurs)
 
 CEleve oPersonne8(3);
 
 oPersonne8.AjouterNote(7);
 oPersonne8.AjouterNote(70);
 oPersonne8.AjouterNote(64);
 oPersonne8.AjouterNote(90);
 oPersonne8.AjouterNote(99);
 
 if( oPersonne8.GetNote(4) != 90 )
 {
  iResultatTest++;
 }
 Afficher("Test AjouterNote : " );
 iNbTestTotal++;
 
///////////////////////////////////////////////////////////////////////////////////
 // Vérification de GetNote
 
 // attention vérifier si c'est avant le triage ou après.. car le résultat peut différé
 // non = 60 mais pe autre chose
 
 int iIemeNote = 1;
 int iLaNote2;
 
 //======================================================
 // Le tableau a été trié plus haut avec ponderation avantageuse
 iLaNote2 = oPersonne.GetNote(iIemeNote);// le tableau de note est : 90, 30, 60, 80, 70
 cout << endl << "La note de oPersonne a la position " << iIemeNote << " est (30): " << iLaNote2 << endl << endl;
 
 //======================================================
 // getnote doit retourné une valeur négative
 iMauvaiseReponse = oPersonne2.GetNote(iMauvaiseNote);
 
 if(iMauvaiseReponse < 0)
 {
  iResultatTest++;
 }
 Afficher("Test GetNote # 1 : " );
 iNbTestTotal++;
 
/////////////////////////////////////////////////////////////////////////////////////////
 // écriture à l'écran des résultats de la classe CEleve
 
 cout << "La moyenne de oPersonne2 (doit-etre negative ) est de : " << dMoyenneEtudiant;
 cout << endl << endl << endl << "Le Resultat des tests est de : " << '\t' << '\t' << '\t'<< '\t' << iResultatTest << " / " << iNbTestTotal << endl << endl;
 
 
 
 
 
 
 
 
 
 system("pause" );     // <----- par Melo
 system("cls" );
 ScorePrecedent=0;
 iResultatTest = 0;
 cout << "Vous etes dans le Main () et on verifie CGroupe" << endl << endl;
/////////////////////////////////////////////////////////////////////////////////////////
//      TESTS DE LA CLASSE GROUPE
/////////////////////////////////////////////////////////////////////////////////////////
 
 
 // Tester la construction par défaut
/* CGroupe oGroupe1;
 
 if (oGroupe1.GetNbEleves() == 10)
 {
  iResultatTest++;
 }
 Afficher("Test Constructeur par defaut : " );
 iNbTestTotal++;*/
 
 // Tester la construction avec paramètre
 CGroupe oGroupe2("Bobben", 6);
 
 if (oGroupe2.GetNbEleves() == 6)
 {
  iResultatTest++;
 }
 Afficher("Test Constructeur avec parametre : " );
 iNbTestTotal++;
 
 // Tester la construction de copie
/* CGroupe oGroupe3("Bobette",2);
 
 oGroupe3.AjouterNoteEleve(1,50);
 oGroupe3.AjouterNoteEleve(1,50);
 oGroupe3.AjouterNoteEleve(1,75);
 oGroupe3.AjouterNoteEleve(1,100);
 oGroupe3.AjouterNoteEleve(1,100);
 
 oGroupe3.AjouterNoteEleve(2,50);
 oGroupe3.AjouterNoteEleve(2,50);
 oGroupe3.AjouterNoteEleve(2,75);
 oGroupe3.AjouterNoteEleve(2,100);
 oGroupe3.AjouterNoteEleve(2,100);
 
 oGroupe3.SetPonderations(iBonnePonderation2,5);
 
 CGroupe oGroupe4(oGroupe3);  
 
 cout << oGroupe3.GetMoyenneGroupe() << " ";
 cout << oGroupe4.GetMoyenneGroupe() << " ";
 if (oGroupe4.GetMoyenneGroupe() == 75)
 {
  iResultatTest++;
 }
 Afficher("Test Constructeur par copie : " );
 iNbTestTotal++;
 
 /////////////////////////////////////////////////////////////////////////////
 // Test SetNomEleve
 
 CGroupe oGroupe5;
 
 oGroupe5.SetNomEleve(3, "BobestBeau" );
 
 system("pause" );
 return 0;*/
}
 
 
 
 
 
 
 
 
char VerifierErreur()  
{
 char cRetour=' ';
 
 if (iResultatTest == ScorePrecedent)
 {
  cRetour = '*';
 }
 else
 {
  ScorePrecedent = iResultatTest;
 }
 return cRetour;
}
 
void Afficher(string sMessage)
{
 //EXEMPLE : Afficher("Le Resultat des tests est de : ",iResultatTest);
 if ((int)sMessage.size() >= 72)
 {
  sMessage.erase(72);
 }
 int iNbTab = 8 - (int)(sMessage.size()/8);
 int iNbSpace = 71 - (int)sMessage.size() - (iNbTab*8);
 
 for (int i=0; i < iNbTab; i++)
 {
  cout << '\t';
 }
 for (int i=0; i < iNbSpace; i++)
 {
  cout << " ";
 }
 cout << sMessage << '\t' << iResultatTest << VerifierErreur() << endl;
}

c'est quoi qui a pondu ceci ?
 
-> c 'est pour acceder à une méthode, donnée membre accessible par pointeur (remplace le .)
 
pourquoi utilise-tu la notation hongroise ?

La notation hongroise ?? Moi je suis au Québec, on me l'a montré comme ca.... je peux pas dire que la notation hongroise est meilleure ou pire qu'une autre, c'est la seule que je connais...

TP1 fatal error LNK1201: error writing to program database 'c:\PROJET VisualStudio\TP1mailhiot\Debug\TP1.pdb'; check for insufficient disk space, invalid path, or insufficient privilege
 
Là ca c'est quoi ca ???
 
Pas assez de place disque ?? Je devrais etre corret avec 931Mb.
Chemin d'accès invalide ?? C'est le meme depuis le début et il compilait très bien avant.
Privilèges insuffisants ?? N'importe quoi, j'ai les mêmes...

la notation hongroise consiste à nommer tes variables avec en première lettre, le type de données.
 
string sNom
int iNbCouleurs,
 
etc...  
 
pour ton problème de linking, c'est un problème de droit d'écritures sur le rép. apparement.

Oh mouais, si c'est juste ca la notation hongroise, c'est pratique des fois... En tout cas, c'est plus clair...
 
C'est mon ordinateur à moi, j'ai donc tous les droits dessus, il n'est pas supposé me bloquer l'accès à quoi que ce soit... Qu'est-ce qui justifirait un blocage de privilèges ??

mets les droits NTFS à tout le monde pour ce sous-rép.

Comment on fait ca ?

J'ai toujours mon probleme de  
 
TP1 fatal error LNK1201: error writing to program database 'c:\PROJET VisualStudio\TP1mailhiot\Debug\TP1.pdb'; check for insufficient disk space, invalid path, or insufficient privilege
 
qqun peu m'aider ??

ferme VS, supprimer le rep Debug et recommence.

.... Vous aidez pas la !! hahaha
 
J'ai décidé de laisser faire les erreurs que je ne connais pas dans le genre que j'ai posté et continuer à programmer comme si ca marchait...
 
Je sais pas s'il compile, je sais pas si ca fonctionne, mais tant pis, ca donnera ce que ca donnera... Si jamais vous voulez voir ce que ca donne, je peux remettre un pâté du nouveau Groupe.cpp (c'est le seul qui a changé)... Vous pourrez alors surement me dire "C'est de la merde, ca marchera pas!!".... Je déteste ne pas comprendre...
 
Merci tout de même à tout ceux et celles qui ont essayé de m'aider, vous avez fait votre possible...

déjà que lire du code d'un autre c'est pénible mais alors en plus quand il est moche, mal indenté ....
 
sinon donne tout ce que sort le compilo (je te le redemande car entre les erreurs de ton premier post et celui ou on te demande tout y a pas mal de differences ....)
 
dis merci à ceux qui ont si intelligement coté ton message ca rends plus lisible le post.
 
Ps: prochaine fois ca serais cool que tu mette ton code sur un ftp et que tu fasse un lien dessus

Ca m'a tellement fait rire que je les ai envoyés la bas ( ) direct.
A+,

ah oui tu peux montré group.h aussi