Affichage tableau avec surcharge d'operateur d'Affichage!

/*
J'ai toujours l'erreur ''afficher'' was not declared in this scope

À compléter pour le numéro A du TP3, automne 2020 (10 points)
tâches à faire :
1. afficher le tableau des cercles en utilisant, entre
autres, la surcharge de l'opérateur d'affichage <<
2. permuter c[0] et c[2] , c[1] et c[4]
réafficher le tableau après ces deux permutations;
3. déterminer et afficher :
a) le cercle le plus petit rayon
b) le cercle le plus grand rayon
en utilisant, entre autres :
- une seule fonction template
- la surcharge des opérateurs > et <

Critères de correction :
tâche 1. 3 points
tâche 2. 3 points
tâche 3. 4 points

*/

#include <iostream> // entrée-sortie standard
#include <iomanip>  // formatage (présentation)
#include <string>   // chaîne de caractères (détails : plus tard)
#include <fstream> 
#include <stdlib.h>
#include <string.h>


using namespace std;

const float PI = 3.14159;
class Cercle
{
 private :
  float rayon; // l'accès au champ rayon est privé

 public :
  // un constructeur : conflit entre nom de paramètre et nom de champ
     // => on utilise le pointeur this où *this est l'objet courant

     Cercle(float rayon = 5.7)
     {
      this->rayon = rayon ;// c'est même chose que (*this).rayon;
  }

  // fonction membre
  float perimetre()
  {
   return 2 * PI * rayon;
  }

  // fonction membre : définition reportée
  float surface();

 
  
        float getRayon(); // définition reportée
  void setRayon(float nouvRayon);
template <class T>
    void afficher(T tableau[], int nbElem, string mess)
 {
  cout << "\nContenu du tableau " << mess << " :\n";
  for (int i = 0; i < nbElem; i++)
     cout << setw(2) << i << ") " << tableau[i] << endl;
    
  cout << endl ;

 }
      
  // surcharger de l'opérateur d'affichage :

  friend std::ostream& operator<< (std::ostream&, const Cercle&);
   // afficher un cercle avec un message pertinent

 };



 float Cercle::surface()
 {
  return PI * rayon * rayon;
 }

 float Cercle::getRayon()
 {
  return rayon;
 }

 void Cercle::setRayon(float nouvRayon)
 {
     rayon = nouvRayon;
 }
 template <class T>
 void permuter(T & a, T &b)
 {
  T tempo = a;
  a = b;
  b = tempo;
 }
  template <class T>
 void trier(T tableau[], int nbElem)
 {
  for (int i = 0 ; i < nbElem-1; i++)
  { int indMin = i;
    for (int j = i+1; j < nbElem; j++)
     if (tableau[j] < tableau[indMin])
        indMin = j;

    if ( indMin != i)
       permuter(tableau[i], tableau[indMin]);     
  }
 }
 

 int main()
 {

   Cercle cercle[] = { Cercle(6.1), Cercle(), Cercle(7.3), Cercle (6.9),
                  Cercle(4.5), Cercle(7.1) };
   int nbCercle = sizeof(cercle) / sizeof(Cercle);

   // 1. afficher le tableau des cercles en utilisant, entre
       //autres, la surcharge de l'opérateur d'affichage <<
       afficher(cercle, nbCercle, "Cercle");
    
  return 0;
}
/* Exécution :


*/