Problème de surcharge d'opérateur <<

template

<<

Stack_gene<T>

T template

T

int

template

T

template

template

template

template

Stack_gene<int>

template

   template<class U> friend std::ostream& operator<<(std::ostream&, Stack_gene<U>const&);

new/delete

Stack_gene<int>  tab2 = tab1;

std::vector<T>

const

const

cout << Stack_gene<int>{9};

template<class T> friend std::ostream & operator << (std::ostream &flot, Stack_gene<T>  &tab);

D:\Fichiers_applications\C++\Projets_QtCreator\Test\Revis_gnrle\Exercices\Exercice_148\Exercice_148\stack_gene.h:15: erreur : Declaration of 'T' shadows template parameter

new 

delete

vector

const 

operator <<

U

T

const

T

template

friend template

const

const

new

delete

<<

#ifndef STACK_GENE_H
#define STACK_GENE_H
#include <iostream>
#include <vector>
#include <stdexcept>

// déclare l'opérateur<< (nécessaire pour le déclarer en ami plus loin)
template<class T> class Stack_gene;
template<class T> std::ostream&  operator<<(std::ostream&, Stack_gene<T>const&);

template<class T>
class Stack_gene
{
public:
   Stack_gene(std::size_t nmax) : adv(nmax) {}
   ~Stack_gene() = default;
   Stack_gene&  operator<<(T const& n) {
      if ( nelmt < adv.size() )
         adv[nelmt++] = n;
      else
         throw std::overflow_error{"débordement de Stack_gene"};
      return  *this;
   }
   Stack_gene& operator>>(T& n) {
      if ( nelmt > 0u )
         n = adv[--nelmt];
      else
         throw std::underflow_error{"dépilage d'un Stack_gene vide"};
      return  *this;
   }
   bool  operator++()const {  // mauvaise idée de sortir un opérateur de sa sémantique
      return  (nelmt==adv.size());
   }
   bool  operator--()const {
      return  (nelmt==0u);
   }
   // template<class U> friend std::ostream& operator<<(std::ostream&, Stack_gene<U>const&);
   // mais on peut plutôt considérer en ami que l'opérateur<< pour le T actuel
   // à condition d'avoir préalablement déclaré le template d'operateur<<
   friend std::ostream& ::operator<< <>(std::ostream&, Stack_gene const&);

private:
   std::size_t  nelmt{};
   std::vector<T>  adv;
};

template<class T>  std::ostream& operator<<(std::ostream &flot, Stack_gene<T>const& tab) {
   flot << "// ";
   std::size_t  max = tab.nelmt;
   for ( auto const& item : tab.adv ) {
      if ( !max-- )
         break;
      flot << item << "  ";
   }
   flot << "//";
   return  flot;
}

#endif // STACK_GENE_H

#include "stack_gene.h"
// ne jamais utiliser : using namespace std;

int main(){
   Stack_gene<int> tab1(9);

   std::cout << std::boolalpha << "tab1 pleine = " << ++tab1 << "\t tab1 vide = " << --tab1 << std::endl;
   tab1 << 2 << 4 << 6 << 9;
   std::cout << "tab1 pleine = " << ++tab1 << "\t tab1 vide = " << --tab1 << std::endl;
   std::cout << "tab1 = " << tab1 << std::endl;
   int  x;
   tab1 >> x;
   std::cout << "sortie de dernier élément : " << x << std::endl;
}

template

using namespace std;

.h

.cpp

for ( auto const& item : tab.adv ) {
      if ( !max-- )
         break;
      flot << item << "  ";
   }

item

const

namespace

using namespace ...;

namespace

vector

namespace

namespace

namespace

• vector

  désigne

  ::vector

  (donc ta classe) ;

• std::vector

  désigne la classe de la STL.

using namespace std

vector

::vector

std::vector

using namespace std;

void f(){
    using namespace std;
    //...
}

using namespace std;

.cpp

<<

<<

friend

#include <ostream>
#include <vector>

template <typename T>
std::ostream & operator << (std::ostream & out, const std::vector<T> & v) {
    out << '[':
    for (auto x : v) out << ' ' << x;
    out << " ]";
    return out;
}

const

const

const int x:
int const x;

const int * px;
int const * px;

const int * px1;
int * const px2;
const int * const px3;

• l'entier pointé par

  px1

  qui est maintenu constant (i.e.,

  *px1

  ) - mais pas l'adresse ;
• l'adresse

  px2

  est maintenue constante, mais pas

  *px2

  ;

• px3

  et

  *px3

  sont tout deux maintenus constants (on aurait aussi pu écrire

  int const * const px3

  ).

const int & x

px3

px3

const