Re: templates variadiques

Si tu veux parler de nouvelles fonctionnalités, alors parlons en de mes préférées :

• Pointeurs intelligents (ceux de Boost).
  

  {
   std::scoped_ptr<monobjet> e(new monobjet);
   
   if (pas_content())
   return;
   faire_des_autres_trucs(e);
   if (vraiment_pas_content())
   throw PasContentException();
   return;
  }
  

  
  e sera automatiquement détruit si on sort de la paire d'accolade. Il n'y a plus aucune raison d'utiliser delete, et on va éliminer quasiment tout les leaks avec ça. Existe aussi en version avec transfert de propriété (unique_ptr, pour remplacer auto_ptr) et en version avec un compteur de référence (shared_ptr)
  Et après vous comprendrez pourquoi les C++eux vous disent qu'ils n'ont pas besoin de GC.

• Initialisation de membres dans une classe
  

  class A{
   int i = 42;
  };
  

  
  i prendra comme valeur 42 par défaut, sauf si redéfini par un constructeur.

• Utilisation de classes locales comme classe template :
  

  void oh_une_func(std::vector<int>& i) {
   class compare_last_decimal {
   operator () (int a, int b) {
   return (a%10) < (a%10);
   }
   };
   std::sort(i.begin(), i.end(), compare_last_decimal());
  }
  

• Move semantics :
  

  std::vector<int> ma_fonction();
  ...
  std::vector<int> mon_resultat = ma_fonction();
  

  
  Avant, ce code pouvait impliquer une copie du vecteur. Maintenant, ça n'est qu'une affectation de pointeur. En gros, il y a un constructeur A::A(A&& old) et un opérateur d'affectation A& A::operator=(A&& old) qui peut être utilisé quand on sait que "old" va être prochainement détruit.

• Suppressions et définitions par défaut :
  

  class A{
   A() = default;
   A(int i);
   A(const A& ) = delete;
   A(A&&) = delete;
  };
  

  
  Le constructeur par défaut sera synthétisé automatiquement (ça fera une erreur si ça échoue, pas comme avant) et sans avoir à le faire à la main si on en défini un autre.
  La construction par copie est supprimée (elle est automatique sinon) tout comme la construction par déplacement.