[C++]Edition de lien pour template

template <typename T>
Exemple<T>::Exemple(){
std::cout << "ceci est un exemple" << std::endl;
}

#include <vector> // dans ce header se trouve la classe template std::vector

int main(){
  std::vector<int> v; // => compilation de std::vector<int>
  std::vector<double> w; // => compilation de std::vector<double>
  return 0;
}

#ifndef PLOP  //verrou pour n'inclure ce fichier qu'une fois... par .o !
#define PLOP

#include <iostream>
#include <vector>

// 1er exemple : une fonction template

// Recherche le maximum dans un vector
template <typename T>
std::pair<T,bool> max(const std::vector<T> & v){
  // je vérifie que le vector est non vide pour pouvoir utiliser v[0] ensuite
  if (v.empty()) return std::make_pair(res,false);

  T res = v[0];
  typename std::vector<T>::const_iterator vit = v.begin(), vend = v.end();
  // Le typename est important car on accède (::) à un champ (const_iterator)
  // de la classe std::vector<T> qui dépend d'un paramètre template.


  // je parcours le vector pour trouver le maximum
  for(;vit!=vend;++vit){
    if(*vit > res) res = *vit;
  }
  return std::make_pair(res,true);
}

// 2eme exemple : une classe/structure template

template <typename T>
struct ma_classe(){
  T t;

  ma_classe(){}

  void print() const{
    std::cout << t << std::endl;
  }
};

// 3eme exemple : une méthode template

class plop{
  protected
  int x;
  
  // Le constructeur
  plop(int x0=0):x(x0){};

  // Cette méthode est implémentée dans le .hpp il faut donc la mettre inline
  // En général on ne met que des méthodes "triviales" et courtes en inline car
  // concrètement le inline recopie le code de la fonction inline à chaque appel
  // de cette méthode. Si tu ne mets pas le inline et que ce fichier est inclu
  // par a.cpp et b.cpp, le code de la fonction serait présent dans a.o et b.o,
  // et au moment de linker tu aurais une multidéfinition de cette méthode.
  inline int get_x() const{
    return x;
  }

  // Méthode template
  template <Tstream> 
  Tstream & operator << (Tstream & out) const{
    out << x;
    return out;
  }

  // Méthode déclarée dans le .hpp, implémentées dans le .cpp
  void set_x(int x0);
};

// Comme toute fonction déclarée et implémentée dans un .hpp, je dois mettre
// un inline car sinon j'aurais une multidéfinition de cette fonction si plop.hpp
// est inclu à plusieurs endroits
inline void ecrire_tapir(){
  std::cout << "tapir" << std::endl;
}

#endif

void plop::set_x(int x0){
  x = x0;
}